diff --git a/.github/workflows/e2e-cache-dependency-path.yml b/.github/workflows/e2e-cache-dependency-path.yml
index 6d92629..8b40e99 100644
--- a/.github/workflows/e2e-cache-dependency-path.yml
+++ b/.github/workflows/e2e-cache-dependency-path.yml
@@ -24,7 +24,7 @@ jobs:
         os: [macos-latest, windows-latest, ubuntu-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Run setup-java with the cache for gradle
         uses: ./
         id: setup-java
@@ -51,7 +51,7 @@ jobs:
     needs: gradle1-save
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Run setup-java with the cache for gradle
         uses: ./
         id: setup-java
@@ -76,7 +76,7 @@ jobs:
     needs: gradle1-save
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Run setup-java with the cache for gradle
         uses: ./
         id: setup-java
diff --git a/.github/workflows/e2e-cache.yml b/.github/workflows/e2e-cache.yml
index 9f6835d..6df10b5 100644
--- a/.github/workflows/e2e-cache.yml
+++ b/.github/workflows/e2e-cache.yml
@@ -24,7 +24,7 @@ jobs:
         os: [macos-15-intel, windows-latest, ubuntu-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Run setup-java with the cache for gradle
         uses: ./
         id: setup-java
@@ -50,7 +50,7 @@ jobs:
     needs: gradle-save
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Run setup-java with the cache for gradle
         uses: ./
         id: setup-java
@@ -73,7 +73,7 @@ jobs:
         os: [macos-15-intel, windows-latest, ubuntu-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Run setup-java with the cache for maven
         uses: ./
         id: setup-java
@@ -97,7 +97,7 @@ jobs:
     needs: maven-save
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Run setup-java with the cache for maven
         uses: ./
         id: setup-java
@@ -124,7 +124,7 @@ jobs:
         os: [macos-15-intel, windows-latest, ubuntu-22.04]
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Run setup-java with the cache for sbt
         uses: ./
         id: setup-java
@@ -174,7 +174,7 @@ jobs:
     needs: sbt-save
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Run setup-java with the cache for sbt
         uses: ./
         id: setup-java
diff --git a/.github/workflows/e2e-local-file.yml b/.github/workflows/e2e-local-file.yml
index 45d7912..92fdf75 100644
--- a/.github/workflows/e2e-local-file.yml
+++ b/.github/workflows/e2e-local-file.yml
@@ -21,7 +21,7 @@ jobs:
         os: [macos-latest, windows-latest, ubuntu-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Download Adopt OpenJDK file
         run: |
           if ($IsLinux) {
@@ -58,7 +58,7 @@ jobs:
         os: [macos-latest, windows-latest, ubuntu-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Download Zulu OpenJDK file
         run: |
           if ($IsLinux) {
@@ -95,7 +95,7 @@ jobs:
         os: [macos-latest, windows-latest, ubuntu-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Download Eclipse Temurin file
         run: |
           if ($IsLinux) {
diff --git a/.github/workflows/e2e-publishing.yml b/.github/workflows/e2e-publishing.yml
index d3163a9..0c0aaaf 100644
--- a/.github/workflows/e2e-publishing.yml
+++ b/.github/workflows/e2e-publishing.yml
@@ -25,7 +25,7 @@ jobs:
         os: [macos-latest, windows-latest, ubuntu-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: setup-java
         uses: ./
         id: setup-java
@@ -60,7 +60,7 @@ jobs:
         os: [macos-latest, windows-latest, ubuntu-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Create fake settings.xml
         run: |
           $xmlDirectory = Join-Path $HOME ".m2"
@@ -96,7 +96,7 @@ jobs:
         os: [macos-latest, windows-latest, ubuntu-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Create fake settings.xml
         run: |
           $xmlDirectory = Join-Path $HOME ".m2"
@@ -133,7 +133,7 @@ jobs:
         os: [macos-latest, windows-latest, ubuntu-latest]
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: setup-java
         uses: ./
         id: setup-java
diff --git a/.github/workflows/e2e-versions.yml b/.github/workflows/e2e-versions.yml
index e172949..845fce1 100644
--- a/.github/workflows/e2e-versions.yml
+++ b/.github/workflows/e2e-versions.yml
@@ -73,7 +73,7 @@ jobs:
             version: '24-ea'
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: setup-java
         uses: ./
         id: setup-java
@@ -123,7 +123,7 @@ jobs:
             version: '17.0.7'
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: setup-java
         uses: ./
         id: setup-java
@@ -158,7 +158,7 @@ jobs:
             os: macos-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: setup-java
         uses: ./
         id: setup-java
@@ -194,7 +194,7 @@ jobs:
             os: macos-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: setup-java
         uses: ./
         id: setup-java
@@ -233,7 +233,7 @@ jobs:
         version: ['17-ea', '15.0.0-ea.14']
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: setup-java
         uses: ./
         id: setup-java
@@ -255,7 +255,7 @@ jobs:
         version: ['17-ea']
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: setup-java
         uses: ./
         id: setup-java
@@ -277,7 +277,7 @@ jobs:
         version: ['17-ea', '21-ea']
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: setup-java
         uses: ./
         id: setup-java
@@ -364,7 +364,7 @@ jobs:
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: setup-java
         uses: ./
         id: setup-java
@@ -392,7 +392,7 @@ jobs:
         version: ['11']
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: setup-java
         uses: ./
         id: setup-java
@@ -415,7 +415,7 @@ jobs:
         java-version-file: ['.java-version', '.tool-versions']
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Create .java-version file
         shell: bash
         run: echo "17" > .java-version
@@ -444,7 +444,7 @@ jobs:
         java-version-file: ['.java-version', '.tool-versions']
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Create .java-version file
         shell: bash
         run: echo "11" > .java-version
@@ -472,7 +472,7 @@ jobs:
         java-version-file: ['.java-version', '.tool-versions']
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Create .java-version file
         shell: bash
         run: echo "17.0.10" > .java-version
@@ -500,7 +500,7 @@ jobs:
         java-version-file: ['.java-version', '.tool-versions', '.sdkmanrc']
     steps:
       - name: Checkout
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Create .java-version file
         shell: bash
         run: echo "openjdk64-17.0.10" > .java-version
diff --git a/.github/workflows/publish-immutable-actions.yml b/.github/workflows/publish-immutable-actions.yml
index ba3ffde..bfe5920 100644
--- a/.github/workflows/publish-immutable-actions.yml
+++ b/.github/workflows/publish-immutable-actions.yml
@@ -15,7 +15,7 @@ jobs:
 
     steps:
       - name: Checking out
-        uses: actions/checkout@v5
+        uses: actions/checkout@v6
       - name: Publish
         id: publish
         uses: actions/publish-immutable-action@v0.0.4
diff --git a/.licenses/npm/@actions/http-client-3.0.0.dep.yml b/.licenses/npm/@actions/http-client-3.0.2.dep.yml
similarity index 98%
rename from .licenses/npm/@actions/http-client-3.0.0.dep.yml
rename to .licenses/npm/@actions/http-client-3.0.2.dep.yml
index 52aa453..dd1f80d 100644
Binary files a/.licenses/npm/@actions/http-client-3.0.0.dep.yml and b/.licenses/npm/@actions/http-client-3.0.2.dep.yml differ
diff --git a/.licenses/npm/fast-xml-builder.dep.yml b/.licenses/npm/fast-xml-builder.dep.yml
new file mode 100644
index 0000000..c08d698
Binary files /dev/null and b/.licenses/npm/fast-xml-builder.dep.yml differ
diff --git a/.licenses/npm/fast-xml-parser.dep.yml b/.licenses/npm/fast-xml-parser.dep.yml
index 77eec1e..0aba3a2 100644
Binary files a/.licenses/npm/fast-xml-parser.dep.yml and b/.licenses/npm/fast-xml-parser.dep.yml differ
diff --git a/.licenses/npm/minimatch.dep.yml b/.licenses/npm/minimatch.dep.yml
index 869816f..81a9735 100644
Binary files a/.licenses/npm/minimatch.dep.yml and b/.licenses/npm/minimatch.dep.yml differ
diff --git a/.licenses/npm/undici.dep.yml b/.licenses/npm/undici-5.29.0.dep.yml
similarity index 100%
rename from .licenses/npm/undici.dep.yml
rename to .licenses/npm/undici-5.29.0.dep.yml
diff --git a/.licenses/npm/undici-6.23.0.dep.yml b/.licenses/npm/undici-6.23.0.dep.yml
new file mode 100644
index 0000000..8876000
Binary files /dev/null and b/.licenses/npm/undici-6.23.0.dep.yml differ
diff --git a/README.md b/README.md
index 8e21cd9..35c6ce3 100644
--- a/README.md
+++ b/README.md
@@ -78,28 +78,28 @@ For information about the latest releases, recent updates, and newly supported d
 #### Eclipse Temurin
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'temurin' # See 'Supported distributions' for available options
-    java-version: '21'
+    java-version: '25'
 - run: java HelloWorldApp.java
 ```
 
 #### Azul Zulu OpenJDK
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'zulu' # See 'Supported distributions' for available options
-    java-version: '21'
+    java-version: '25'
 - run: java HelloWorldApp.java
 ```
 
 #### Supported version syntax
 The `java-version` input supports an exact version or a version range using [SemVer](https://semver.org/) notation:
-- major versions: `8`, `11`, `16`, `17`, `21`
+- major versions: `8`, `11`, `16`, `17`, `21`, `25`
 - more specific versions: `8.0.282+8`, `8.0.232`, `11.0`, `11.0.4`, `17.0`
 - early access (EA) versions: `15-ea`, `15.0.0-ea`
 
@@ -145,11 +145,11 @@ The cache input is optional, and caching is turned off by default.
 #### Caching gradle dependencies
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'temurin'
-    java-version: '21'
+    java-version: '25'
     cache: 'gradle'
     cache-dependency-path: | # optional
       sub-project/*.gradle*
@@ -165,11 +165,11 @@ For setup details and a comprehensive overview of all available features, visit
 #### Caching maven dependencies
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'temurin'
-    java-version: '21'
+    java-version: '25'
     cache: 'maven'
     cache-dependency-path: 'sub-project/pom.xml' # optional
 - name: Build with Maven
@@ -179,11 +179,11 @@ steps:
 #### Caching sbt dependencies
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'temurin'
-    java-version: '21'
+    java-version: '25'
     cache: 'sbt'
     cache-dependency-path: | # optional
       sub-project/build.sbt
@@ -199,11 +199,11 @@ Usually, cache gets downloaded in multiple segments of fixed sizes. Sometimes, a
 env:
   SEGMENT_DOWNLOAD_TIMEOUT_MINS: '5'
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'temurin'
-    java-version: '21'
+    java-version: '25'
     cache: 'gradle'
 - run: ./gradlew build --no-daemon
 ```
@@ -219,11 +219,11 @@ For Java distributions that are not cached on Hosted images, `check-latest` alwa
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'temurin'
-    java-version: '21'
+    java-version: '25'
     check-latest: true
 - run: java HelloWorldApp.java
 ```
@@ -235,10 +235,10 @@ jobs:
     runs-on: ubuntu-20.04
     strategy:
       matrix:
-        java: [ '8', '11', '17', '21' ]
+        java: [ '8', '11', '17', '21', '25' ]
     name: Java ${{ matrix.Java }} sample
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Setup java
         uses: actions/setup-java@v5
         with:
diff --git a/dist/cleanup/index.js b/dist/cleanup/index.js
index b9e1cd9..7cb0210 100644
--- a/dist/cleanup/index.js
+++ b/dist/cleanup/index.js
@@ -5357,7 +5357,7 @@ const http = __importStar(__nccwpck_require__(13685));
 const https = __importStar(__nccwpck_require__(95687));
 const pm = __importStar(__nccwpck_require__(4977));
 const tunnel = __importStar(__nccwpck_require__(74294));
-const undici_1 = __nccwpck_require__(41773);
+const undici_1 = __nccwpck_require__(88498);
 var HttpCodes;
 (function (HttpCodes) {
     HttpCodes[HttpCodes["OK"] = 200] = "OK";
@@ -5475,7 +5475,7 @@ class HttpClient {
         this._maxRetries = 1;
         this._keepAlive = false;
         this._disposed = false;
-        this.userAgent = userAgent;
+        this.userAgent = this._getUserAgentWithOrchestrationId(userAgent);
         this.handlers = handlers || [];
         this.requestOptions = requestOptions;
         if (requestOptions) {
@@ -5955,6 +5955,17 @@ class HttpClient {
         }
         return proxyAgent;
     }
+    _getUserAgentWithOrchestrationId(userAgent) {
+        const baseUserAgent = userAgent || 'actions/http-client';
+        const orchId = process.env['ACTIONS_ORCHESTRATION_ID'];
+        if (orchId) {
+            // Sanitize the orchestration ID to ensure it contains only valid characters
+            // Valid characters: 0-9, a-z, _, -, .
+            const sanitizedId = orchId.replace(/[^a-z0-9_.-]/gi, '_');
+            return `${baseUserAgent} actions_orchestration_id/${sanitizedId}`;
+        }
+        return baseUserAgent;
+    }
     _performExponentialBackoff(retryNumber) {
         return __awaiter(this, void 0, void 0, function* () {
             retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
@@ -8333,6 +8344,27409 @@ function coerce (version, options) {
 }
 
 
+/***/ }),
+
+/***/ 88498:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const Client = __nccwpck_require__(6655)
+const Dispatcher = __nccwpck_require__(51927)
+const Pool = __nccwpck_require__(11795)
+const BalancedPool = __nccwpck_require__(74086)
+const Agent = __nccwpck_require__(83421)
+const ProxyAgent = __nccwpck_require__(54372)
+const EnvHttpProxyAgent = __nccwpck_require__(4803)
+const RetryAgent = __nccwpck_require__(46811)
+const errors = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { InvalidArgumentError } = errors
+const api = __nccwpck_require__(24575)
+const buildConnector = __nccwpck_require__(20123)
+const MockClient = __nccwpck_require__(32144)
+const MockAgent = __nccwpck_require__(56549)
+const MockPool = __nccwpck_require__(92565)
+const mockErrors = __nccwpck_require__(54331)
+const RetryHandler = __nccwpck_require__(61465)
+const { getGlobalDispatcher, setGlobalDispatcher } = __nccwpck_require__(72354)
+const DecoratorHandler = __nccwpck_require__(7004)
+const RedirectHandler = __nccwpck_require__(59470)
+const createRedirectInterceptor = __nccwpck_require__(11115)
+
+Object.assign(Dispatcher.prototype, api)
+
+module.exports.Dispatcher = Dispatcher
+module.exports.Client = Client
+module.exports.Pool = Pool
+module.exports.BalancedPool = BalancedPool
+module.exports.Agent = Agent
+module.exports.ProxyAgent = ProxyAgent
+module.exports.EnvHttpProxyAgent = EnvHttpProxyAgent
+module.exports.RetryAgent = RetryAgent
+module.exports.RetryHandler = RetryHandler
+
+module.exports.DecoratorHandler = DecoratorHandler
+module.exports.RedirectHandler = RedirectHandler
+module.exports.createRedirectInterceptor = createRedirectInterceptor
+module.exports.interceptors = {
+  redirect: __nccwpck_require__(42370),
+  retry: __nccwpck_require__(66080),
+  dump: __nccwpck_require__(3199),
+  dns: __nccwpck_require__(42462)
+}
+
+module.exports.buildConnector = buildConnector
+module.exports.errors = errors
+module.exports.util = {
+  parseHeaders: util.parseHeaders,
+  headerNameToString: util.headerNameToString
+}
+
+function makeDispatcher (fn) {
+  return (url, opts, handler) => {
+    if (typeof opts === 'function') {
+      handler = opts
+      opts = null
+    }
+
+    if (!url || (typeof url !== 'string' && typeof url !== 'object' && !(url instanceof URL))) {
+      throw new InvalidArgumentError('invalid url')
+    }
+
+    if (opts != null && typeof opts !== 'object') {
+      throw new InvalidArgumentError('invalid opts')
+    }
+
+    if (opts && opts.path != null) {
+      if (typeof opts.path !== 'string') {
+        throw new InvalidArgumentError('invalid opts.path')
+      }
+
+      let path = opts.path
+      if (!opts.path.startsWith('/')) {
+        path = `/${path}`
+      }
+
+      url = new URL(util.parseOrigin(url).origin + path)
+    } else {
+      if (!opts) {
+        opts = typeof url === 'object' ? url : {}
+      }
+
+      url = util.parseURL(url)
+    }
+
+    const { agent, dispatcher = getGlobalDispatcher() } = opts
+
+    if (agent) {
+      throw new InvalidArgumentError('unsupported opts.agent. Did you mean opts.client?')
+    }
+
+    return fn.call(dispatcher, {
+      ...opts,
+      origin: url.origin,
+      path: url.search ? `${url.pathname}${url.search}` : url.pathname,
+      method: opts.method || (opts.body ? 'PUT' : 'GET')
+    }, handler)
+  }
+}
+
+module.exports.setGlobalDispatcher = setGlobalDispatcher
+module.exports.getGlobalDispatcher = getGlobalDispatcher
+
+const fetchImpl = (__nccwpck_require__(31158).fetch)
+module.exports.fetch = async function fetch (init, options = undefined) {
+  try {
+    return await fetchImpl(init, options)
+  } catch (err) {
+    if (err && typeof err === 'object') {
+      Error.captureStackTrace(err)
+    }
+
+    throw err
+  }
+}
+module.exports.Headers = __nccwpck_require__(24997).Headers
+module.exports.Response = __nccwpck_require__(33139).Response
+module.exports.Request = __nccwpck_require__(13925).Request
+module.exports.FormData = __nccwpck_require__(4923).FormData
+module.exports.File = globalThis.File ?? (__nccwpck_require__(72254).File)
+module.exports.FileReader = __nccwpck_require__(70923).FileReader
+
+const { setGlobalOrigin, getGlobalOrigin } = __nccwpck_require__(71332)
+
+module.exports.setGlobalOrigin = setGlobalOrigin
+module.exports.getGlobalOrigin = getGlobalOrigin
+
+const { CacheStorage } = __nccwpck_require__(12130)
+const { kConstruct } = __nccwpck_require__(90053)
+
+// Cache & CacheStorage are tightly coupled with fetch. Even if it may run
+// in an older version of Node, it doesn't have any use without fetch.
+module.exports.caches = new CacheStorage(kConstruct)
+
+const { deleteCookie, getCookies, getSetCookies, setCookie } = __nccwpck_require__(57705)
+
+module.exports.deleteCookie = deleteCookie
+module.exports.getCookies = getCookies
+module.exports.getSetCookies = getSetCookies
+module.exports.setCookie = setCookie
+
+const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(86954)
+
+module.exports.parseMIMEType = parseMIMEType
+module.exports.serializeAMimeType = serializeAMimeType
+
+const { CloseEvent, ErrorEvent, MessageEvent } = __nccwpck_require__(15135)
+module.exports.WebSocket = __nccwpck_require__(75860).WebSocket
+module.exports.CloseEvent = CloseEvent
+module.exports.ErrorEvent = ErrorEvent
+module.exports.MessageEvent = MessageEvent
+
+module.exports.request = makeDispatcher(api.request)
+module.exports.stream = makeDispatcher(api.stream)
+module.exports.pipeline = makeDispatcher(api.pipeline)
+module.exports.connect = makeDispatcher(api.connect)
+module.exports.upgrade = makeDispatcher(api.upgrade)
+
+module.exports.MockClient = MockClient
+module.exports.MockPool = MockPool
+module.exports.MockAgent = MockAgent
+module.exports.mockErrors = mockErrors
+
+const { EventSource } = __nccwpck_require__(62205)
+
+module.exports.EventSource = EventSource
+
+
+/***/ }),
+
+/***/ 30703:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+const { addAbortListener } = __nccwpck_require__(94407)
+const { RequestAbortedError } = __nccwpck_require__(22174)
+
+const kListener = Symbol('kListener')
+const kSignal = Symbol('kSignal')
+
+function abort (self) {
+  if (self.abort) {
+    self.abort(self[kSignal]?.reason)
+  } else {
+    self.reason = self[kSignal]?.reason ?? new RequestAbortedError()
+  }
+  removeSignal(self)
+}
+
+function addSignal (self, signal) {
+  self.reason = null
+
+  self[kSignal] = null
+  self[kListener] = null
+
+  if (!signal) {
+    return
+  }
+
+  if (signal.aborted) {
+    abort(self)
+    return
+  }
+
+  self[kSignal] = signal
+  self[kListener] = () => {
+    abort(self)
+  }
+
+  addAbortListener(self[kSignal], self[kListener])
+}
+
+function removeSignal (self) {
+  if (!self[kSignal]) {
+    return
+  }
+
+  if ('removeEventListener' in self[kSignal]) {
+    self[kSignal].removeEventListener('abort', self[kListener])
+  } else {
+    self[kSignal].removeListener('abort', self[kListener])
+  }
+
+  self[kSignal] = null
+  self[kListener] = null
+}
+
+module.exports = {
+  addSignal,
+  removeSignal
+}
+
+
+/***/ }),
+
+/***/ 7636:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+const { AsyncResource } = __nccwpck_require__(92761)
+const { InvalidArgumentError, SocketError } = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { addSignal, removeSignal } = __nccwpck_require__(30703)
+
+class ConnectHandler extends AsyncResource {
+  constructor (opts, callback) {
+    if (!opts || typeof opts !== 'object') {
+      throw new InvalidArgumentError('invalid opts')
+    }
+
+    if (typeof callback !== 'function') {
+      throw new InvalidArgumentError('invalid callback')
+    }
+
+    const { signal, opaque, responseHeaders } = opts
+
+    if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
+      throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
+    }
+
+    super('UNDICI_CONNECT')
+
+    this.opaque = opaque || null
+    this.responseHeaders = responseHeaders || null
+    this.callback = callback
+    this.abort = null
+
+    addSignal(this, signal)
+  }
+
+  onConnect (abort, context) {
+    if (this.reason) {
+      abort(this.reason)
+      return
+    }
+
+    assert(this.callback)
+
+    this.abort = abort
+    this.context = context
+  }
+
+  onHeaders () {
+    throw new SocketError('bad connect', null)
+  }
+
+  onUpgrade (statusCode, rawHeaders, socket) {
+    const { callback, opaque, context } = this
+
+    removeSignal(this)
+
+    this.callback = null
+
+    let headers = rawHeaders
+    // Indicates is an HTTP2Session
+    if (headers != null) {
+      headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+    }
+
+    this.runInAsyncScope(callback, null, null, {
+      statusCode,
+      headers,
+      socket,
+      opaque,
+      context
+    })
+  }
+
+  onError (err) {
+    const { callback, opaque } = this
+
+    removeSignal(this)
+
+    if (callback) {
+      this.callback = null
+      queueMicrotask(() => {
+        this.runInAsyncScope(callback, null, err, { opaque })
+      })
+    }
+  }
+}
+
+function connect (opts, callback) {
+  if (callback === undefined) {
+    return new Promise((resolve, reject) => {
+      connect.call(this, opts, (err, data) => {
+        return err ? reject(err) : resolve(data)
+      })
+    })
+  }
+
+  try {
+    const connectHandler = new ConnectHandler(opts, callback)
+    this.dispatch({ ...opts, method: 'CONNECT' }, connectHandler)
+  } catch (err) {
+    if (typeof callback !== 'function') {
+      throw err
+    }
+    const opaque = opts?.opaque
+    queueMicrotask(() => callback(err, { opaque }))
+  }
+}
+
+module.exports = connect
+
+
+/***/ }),
+
+/***/ 94375:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  Readable,
+  Duplex,
+  PassThrough
+} = __nccwpck_require__(84492)
+const {
+  InvalidArgumentError,
+  InvalidReturnValueError,
+  RequestAbortedError
+} = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { AsyncResource } = __nccwpck_require__(92761)
+const { addSignal, removeSignal } = __nccwpck_require__(30703)
+const assert = __nccwpck_require__(98061)
+
+const kResume = Symbol('resume')
+
+class PipelineRequest extends Readable {
+  constructor () {
+    super({ autoDestroy: true })
+
+    this[kResume] = null
+  }
+
+  _read () {
+    const { [kResume]: resume } = this
+
+    if (resume) {
+      this[kResume] = null
+      resume()
+    }
+  }
+
+  _destroy (err, callback) {
+    this._read()
+
+    callback(err)
+  }
+}
+
+class PipelineResponse extends Readable {
+  constructor (resume) {
+    super({ autoDestroy: true })
+    this[kResume] = resume
+  }
+
+  _read () {
+    this[kResume]()
+  }
+
+  _destroy (err, callback) {
+    if (!err && !this._readableState.endEmitted) {
+      err = new RequestAbortedError()
+    }
+
+    callback(err)
+  }
+}
+
+class PipelineHandler extends AsyncResource {
+  constructor (opts, handler) {
+    if (!opts || typeof opts !== 'object') {
+      throw new InvalidArgumentError('invalid opts')
+    }
+
+    if (typeof handler !== 'function') {
+      throw new InvalidArgumentError('invalid handler')
+    }
+
+    const { signal, method, opaque, onInfo, responseHeaders } = opts
+
+    if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
+      throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
+    }
+
+    if (method === 'CONNECT') {
+      throw new InvalidArgumentError('invalid method')
+    }
+
+    if (onInfo && typeof onInfo !== 'function') {
+      throw new InvalidArgumentError('invalid onInfo callback')
+    }
+
+    super('UNDICI_PIPELINE')
+
+    this.opaque = opaque || null
+    this.responseHeaders = responseHeaders || null
+    this.handler = handler
+    this.abort = null
+    this.context = null
+    this.onInfo = onInfo || null
+
+    this.req = new PipelineRequest().on('error', util.nop)
+
+    this.ret = new Duplex({
+      readableObjectMode: opts.objectMode,
+      autoDestroy: true,
+      read: () => {
+        const { body } = this
+
+        if (body?.resume) {
+          body.resume()
+        }
+      },
+      write: (chunk, encoding, callback) => {
+        const { req } = this
+
+        if (req.push(chunk, encoding) || req._readableState.destroyed) {
+          callback()
+        } else {
+          req[kResume] = callback
+        }
+      },
+      destroy: (err, callback) => {
+        const { body, req, res, ret, abort } = this
+
+        if (!err && !ret._readableState.endEmitted) {
+          err = new RequestAbortedError()
+        }
+
+        if (abort && err) {
+          abort()
+        }
+
+        util.destroy(body, err)
+        util.destroy(req, err)
+        util.destroy(res, err)
+
+        removeSignal(this)
+
+        callback(err)
+      }
+    }).on('prefinish', () => {
+      const { req } = this
+
+      // Node < 15 does not call _final in same tick.
+      req.push(null)
+    })
+
+    this.res = null
+
+    addSignal(this, signal)
+  }
+
+  onConnect (abort, context) {
+    const { ret, res } = this
+
+    if (this.reason) {
+      abort(this.reason)
+      return
+    }
+
+    assert(!res, 'pipeline cannot be retried')
+    assert(!ret.destroyed)
+
+    this.abort = abort
+    this.context = context
+  }
+
+  onHeaders (statusCode, rawHeaders, resume) {
+    const { opaque, handler, context } = this
+
+    if (statusCode < 200) {
+      if (this.onInfo) {
+        const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+        this.onInfo({ statusCode, headers })
+      }
+      return
+    }
+
+    this.res = new PipelineResponse(resume)
+
+    let body
+    try {
+      this.handler = null
+      const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+      body = this.runInAsyncScope(handler, null, {
+        statusCode,
+        headers,
+        opaque,
+        body: this.res,
+        context
+      })
+    } catch (err) {
+      this.res.on('error', util.nop)
+      throw err
+    }
+
+    if (!body || typeof body.on !== 'function') {
+      throw new InvalidReturnValueError('expected Readable')
+    }
+
+    body
+      .on('data', (chunk) => {
+        const { ret, body } = this
+
+        if (!ret.push(chunk) && body.pause) {
+          body.pause()
+        }
+      })
+      .on('error', (err) => {
+        const { ret } = this
+
+        util.destroy(ret, err)
+      })
+      .on('end', () => {
+        const { ret } = this
+
+        ret.push(null)
+      })
+      .on('close', () => {
+        const { ret } = this
+
+        if (!ret._readableState.ended) {
+          util.destroy(ret, new RequestAbortedError())
+        }
+      })
+
+    this.body = body
+  }
+
+  onData (chunk) {
+    const { res } = this
+    return res.push(chunk)
+  }
+
+  onComplete (trailers) {
+    const { res } = this
+    res.push(null)
+  }
+
+  onError (err) {
+    const { ret } = this
+    this.handler = null
+    util.destroy(ret, err)
+  }
+}
+
+function pipeline (opts, handler) {
+  try {
+    const pipelineHandler = new PipelineHandler(opts, handler)
+    this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler)
+    return pipelineHandler.ret
+  } catch (err) {
+    return new PassThrough().destroy(err)
+  }
+}
+
+module.exports = pipeline
+
+
+/***/ }),
+
+/***/ 20310:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+const { Readable } = __nccwpck_require__(64054)
+const { InvalidArgumentError, RequestAbortedError } = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { getResolveErrorBodyCallback } = __nccwpck_require__(45141)
+const { AsyncResource } = __nccwpck_require__(92761)
+
+class RequestHandler extends AsyncResource {
+  constructor (opts, callback) {
+    if (!opts || typeof opts !== 'object') {
+      throw new InvalidArgumentError('invalid opts')
+    }
+
+    const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts
+
+    try {
+      if (typeof callback !== 'function') {
+        throw new InvalidArgumentError('invalid callback')
+      }
+
+      if (highWaterMark && (typeof highWaterMark !== 'number' || highWaterMark < 0)) {
+        throw new InvalidArgumentError('invalid highWaterMark')
+      }
+
+      if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
+        throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
+      }
+
+      if (method === 'CONNECT') {
+        throw new InvalidArgumentError('invalid method')
+      }
+
+      if (onInfo && typeof onInfo !== 'function') {
+        throw new InvalidArgumentError('invalid onInfo callback')
+      }
+
+      super('UNDICI_REQUEST')
+    } catch (err) {
+      if (util.isStream(body)) {
+        util.destroy(body.on('error', util.nop), err)
+      }
+      throw err
+    }
+
+    this.method = method
+    this.responseHeaders = responseHeaders || null
+    this.opaque = opaque || null
+    this.callback = callback
+    this.res = null
+    this.abort = null
+    this.body = body
+    this.trailers = {}
+    this.context = null
+    this.onInfo = onInfo || null
+    this.throwOnError = throwOnError
+    this.highWaterMark = highWaterMark
+    this.signal = signal
+    this.reason = null
+    this.removeAbortListener = null
+
+    if (util.isStream(body)) {
+      body.on('error', (err) => {
+        this.onError(err)
+      })
+    }
+
+    if (this.signal) {
+      if (this.signal.aborted) {
+        this.reason = this.signal.reason ?? new RequestAbortedError()
+      } else {
+        this.removeAbortListener = util.addAbortListener(this.signal, () => {
+          this.reason = this.signal.reason ?? new RequestAbortedError()
+          if (this.res) {
+            util.destroy(this.res.on('error', util.nop), this.reason)
+          } else if (this.abort) {
+            this.abort(this.reason)
+          }
+
+          if (this.removeAbortListener) {
+            this.res?.off('close', this.removeAbortListener)
+            this.removeAbortListener()
+            this.removeAbortListener = null
+          }
+        })
+      }
+    }
+  }
+
+  onConnect (abort, context) {
+    if (this.reason) {
+      abort(this.reason)
+      return
+    }
+
+    assert(this.callback)
+
+    this.abort = abort
+    this.context = context
+  }
+
+  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
+    const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this
+
+    const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+
+    if (statusCode < 200) {
+      if (this.onInfo) {
+        this.onInfo({ statusCode, headers })
+      }
+      return
+    }
+
+    const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers
+    const contentType = parsedHeaders['content-type']
+    const contentLength = parsedHeaders['content-length']
+    const res = new Readable({
+      resume,
+      abort,
+      contentType,
+      contentLength: this.method !== 'HEAD' && contentLength
+        ? Number(contentLength)
+        : null,
+      highWaterMark
+    })
+
+    if (this.removeAbortListener) {
+      res.on('close', this.removeAbortListener)
+    }
+
+    this.callback = null
+    this.res = res
+    if (callback !== null) {
+      if (this.throwOnError && statusCode >= 400) {
+        this.runInAsyncScope(getResolveErrorBodyCallback, null,
+          { callback, body: res, contentType, statusCode, statusMessage, headers }
+        )
+      } else {
+        this.runInAsyncScope(callback, null, null, {
+          statusCode,
+          headers,
+          trailers: this.trailers,
+          opaque,
+          body: res,
+          context
+        })
+      }
+    }
+  }
+
+  onData (chunk) {
+    return this.res.push(chunk)
+  }
+
+  onComplete (trailers) {
+    util.parseHeaders(trailers, this.trailers)
+    this.res.push(null)
+  }
+
+  onError (err) {
+    const { res, callback, body, opaque } = this
+
+    if (callback) {
+      // TODO: Does this need queueMicrotask?
+      this.callback = null
+      queueMicrotask(() => {
+        this.runInAsyncScope(callback, null, err, { opaque })
+      })
+    }
+
+    if (res) {
+      this.res = null
+      // Ensure all queued handlers are invoked before destroying res.
+      queueMicrotask(() => {
+        util.destroy(res, err)
+      })
+    }
+
+    if (body) {
+      this.body = null
+      util.destroy(body, err)
+    }
+
+    if (this.removeAbortListener) {
+      res?.off('close', this.removeAbortListener)
+      this.removeAbortListener()
+      this.removeAbortListener = null
+    }
+  }
+}
+
+function request (opts, callback) {
+  if (callback === undefined) {
+    return new Promise((resolve, reject) => {
+      request.call(this, opts, (err, data) => {
+        return err ? reject(err) : resolve(data)
+      })
+    })
+  }
+
+  try {
+    this.dispatch(opts, new RequestHandler(opts, callback))
+  } catch (err) {
+    if (typeof callback !== 'function') {
+      throw err
+    }
+    const opaque = opts?.opaque
+    queueMicrotask(() => callback(err, { opaque }))
+  }
+}
+
+module.exports = request
+module.exports.RequestHandler = RequestHandler
+
+
+/***/ }),
+
+/***/ 55784:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+const { finished, PassThrough } = __nccwpck_require__(84492)
+const { InvalidArgumentError, InvalidReturnValueError } = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { getResolveErrorBodyCallback } = __nccwpck_require__(45141)
+const { AsyncResource } = __nccwpck_require__(92761)
+const { addSignal, removeSignal } = __nccwpck_require__(30703)
+
+class StreamHandler extends AsyncResource {
+  constructor (opts, factory, callback) {
+    if (!opts || typeof opts !== 'object') {
+      throw new InvalidArgumentError('invalid opts')
+    }
+
+    const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts
+
+    try {
+      if (typeof callback !== 'function') {
+        throw new InvalidArgumentError('invalid callback')
+      }
+
+      if (typeof factory !== 'function') {
+        throw new InvalidArgumentError('invalid factory')
+      }
+
+      if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
+        throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
+      }
+
+      if (method === 'CONNECT') {
+        throw new InvalidArgumentError('invalid method')
+      }
+
+      if (onInfo && typeof onInfo !== 'function') {
+        throw new InvalidArgumentError('invalid onInfo callback')
+      }
+
+      super('UNDICI_STREAM')
+    } catch (err) {
+      if (util.isStream(body)) {
+        util.destroy(body.on('error', util.nop), err)
+      }
+      throw err
+    }
+
+    this.responseHeaders = responseHeaders || null
+    this.opaque = opaque || null
+    this.factory = factory
+    this.callback = callback
+    this.res = null
+    this.abort = null
+    this.context = null
+    this.trailers = null
+    this.body = body
+    this.onInfo = onInfo || null
+    this.throwOnError = throwOnError || false
+
+    if (util.isStream(body)) {
+      body.on('error', (err) => {
+        this.onError(err)
+      })
+    }
+
+    addSignal(this, signal)
+  }
+
+  onConnect (abort, context) {
+    if (this.reason) {
+      abort(this.reason)
+      return
+    }
+
+    assert(this.callback)
+
+    this.abort = abort
+    this.context = context
+  }
+
+  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
+    const { factory, opaque, context, callback, responseHeaders } = this
+
+    const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+
+    if (statusCode < 200) {
+      if (this.onInfo) {
+        this.onInfo({ statusCode, headers })
+      }
+      return
+    }
+
+    this.factory = null
+
+    let res
+
+    if (this.throwOnError && statusCode >= 400) {
+      const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers
+      const contentType = parsedHeaders['content-type']
+      res = new PassThrough()
+
+      this.callback = null
+      this.runInAsyncScope(getResolveErrorBodyCallback, null,
+        { callback, body: res, contentType, statusCode, statusMessage, headers }
+      )
+    } else {
+      if (factory === null) {
+        return
+      }
+
+      res = this.runInAsyncScope(factory, null, {
+        statusCode,
+        headers,
+        opaque,
+        context
+      })
+
+      if (
+        !res ||
+        typeof res.write !== 'function' ||
+        typeof res.end !== 'function' ||
+        typeof res.on !== 'function'
+      ) {
+        throw new InvalidReturnValueError('expected Writable')
+      }
+
+      // TODO: Avoid finished. It registers an unnecessary amount of listeners.
+      finished(res, { readable: false }, (err) => {
+        const { callback, res, opaque, trailers, abort } = this
+
+        this.res = null
+        if (err || !res.readable) {
+          util.destroy(res, err)
+        }
+
+        this.callback = null
+        this.runInAsyncScope(callback, null, err || null, { opaque, trailers })
+
+        if (err) {
+          abort()
+        }
+      })
+    }
+
+    res.on('drain', resume)
+
+    this.res = res
+
+    const needDrain = res.writableNeedDrain !== undefined
+      ? res.writableNeedDrain
+      : res._writableState?.needDrain
+
+    return needDrain !== true
+  }
+
+  onData (chunk) {
+    const { res } = this
+
+    return res ? res.write(chunk) : true
+  }
+
+  onComplete (trailers) {
+    const { res } = this
+
+    removeSignal(this)
+
+    if (!res) {
+      return
+    }
+
+    this.trailers = util.parseHeaders(trailers)
+
+    res.end()
+  }
+
+  onError (err) {
+    const { res, callback, opaque, body } = this
+
+    removeSignal(this)
+
+    this.factory = null
+
+    if (res) {
+      this.res = null
+      util.destroy(res, err)
+    } else if (callback) {
+      this.callback = null
+      queueMicrotask(() => {
+        this.runInAsyncScope(callback, null, err, { opaque })
+      })
+    }
+
+    if (body) {
+      this.body = null
+      util.destroy(body, err)
+    }
+  }
+}
+
+function stream (opts, factory, callback) {
+  if (callback === undefined) {
+    return new Promise((resolve, reject) => {
+      stream.call(this, opts, factory, (err, data) => {
+        return err ? reject(err) : resolve(data)
+      })
+    })
+  }
+
+  try {
+    this.dispatch(opts, new StreamHandler(opts, factory, callback))
+  } catch (err) {
+    if (typeof callback !== 'function') {
+      throw err
+    }
+    const opaque = opts?.opaque
+    queueMicrotask(() => callback(err, { opaque }))
+  }
+}
+
+module.exports = stream
+
+
+/***/ }),
+
+/***/ 73629:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { InvalidArgumentError, SocketError } = __nccwpck_require__(22174)
+const { AsyncResource } = __nccwpck_require__(92761)
+const util = __nccwpck_require__(94407)
+const { addSignal, removeSignal } = __nccwpck_require__(30703)
+const assert = __nccwpck_require__(98061)
+
+class UpgradeHandler extends AsyncResource {
+  constructor (opts, callback) {
+    if (!opts || typeof opts !== 'object') {
+      throw new InvalidArgumentError('invalid opts')
+    }
+
+    if (typeof callback !== 'function') {
+      throw new InvalidArgumentError('invalid callback')
+    }
+
+    const { signal, opaque, responseHeaders } = opts
+
+    if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
+      throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
+    }
+
+    super('UNDICI_UPGRADE')
+
+    this.responseHeaders = responseHeaders || null
+    this.opaque = opaque || null
+    this.callback = callback
+    this.abort = null
+    this.context = null
+
+    addSignal(this, signal)
+  }
+
+  onConnect (abort, context) {
+    if (this.reason) {
+      abort(this.reason)
+      return
+    }
+
+    assert(this.callback)
+
+    this.abort = abort
+    this.context = null
+  }
+
+  onHeaders () {
+    throw new SocketError('bad upgrade', null)
+  }
+
+  onUpgrade (statusCode, rawHeaders, socket) {
+    assert(statusCode === 101)
+
+    const { callback, opaque, context } = this
+
+    removeSignal(this)
+
+    this.callback = null
+    const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+    this.runInAsyncScope(callback, null, null, {
+      headers,
+      socket,
+      opaque,
+      context
+    })
+  }
+
+  onError (err) {
+    const { callback, opaque } = this
+
+    removeSignal(this)
+
+    if (callback) {
+      this.callback = null
+      queueMicrotask(() => {
+        this.runInAsyncScope(callback, null, err, { opaque })
+      })
+    }
+  }
+}
+
+function upgrade (opts, callback) {
+  if (callback === undefined) {
+    return new Promise((resolve, reject) => {
+      upgrade.call(this, opts, (err, data) => {
+        return err ? reject(err) : resolve(data)
+      })
+    })
+  }
+
+  try {
+    const upgradeHandler = new UpgradeHandler(opts, callback)
+    this.dispatch({
+      ...opts,
+      method: opts.method || 'GET',
+      upgrade: opts.protocol || 'Websocket'
+    }, upgradeHandler)
+  } catch (err) {
+    if (typeof callback !== 'function') {
+      throw err
+    }
+    const opaque = opts?.opaque
+    queueMicrotask(() => callback(err, { opaque }))
+  }
+}
+
+module.exports = upgrade
+
+
+/***/ }),
+
+/***/ 24575:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+module.exports.request = __nccwpck_require__(20310)
+module.exports.stream = __nccwpck_require__(55784)
+module.exports.pipeline = __nccwpck_require__(94375)
+module.exports.upgrade = __nccwpck_require__(73629)
+module.exports.connect = __nccwpck_require__(7636)
+
+
+/***/ }),
+
+/***/ 64054:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// Ported from https://github.com/nodejs/undici/pull/907
+
+
+
+const assert = __nccwpck_require__(98061)
+const { Readable } = __nccwpck_require__(84492)
+const { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { ReadableStreamFrom } = __nccwpck_require__(94407)
+
+const kConsume = Symbol('kConsume')
+const kReading = Symbol('kReading')
+const kBody = Symbol('kBody')
+const kAbort = Symbol('kAbort')
+const kContentType = Symbol('kContentType')
+const kContentLength = Symbol('kContentLength')
+
+const noop = () => {}
+
+class BodyReadable extends Readable {
+  constructor ({
+    resume,
+    abort,
+    contentType = '',
+    contentLength,
+    highWaterMark = 64 * 1024 // Same as nodejs fs streams.
+  }) {
+    super({
+      autoDestroy: true,
+      read: resume,
+      highWaterMark
+    })
+
+    this._readableState.dataEmitted = false
+
+    this[kAbort] = abort
+    this[kConsume] = null
+    this[kBody] = null
+    this[kContentType] = contentType
+    this[kContentLength] = contentLength
+
+    // Is stream being consumed through Readable API?
+    // This is an optimization so that we avoid checking
+    // for 'data' and 'readable' listeners in the hot path
+    // inside push().
+    this[kReading] = false
+  }
+
+  destroy (err) {
+    if (!err && !this._readableState.endEmitted) {
+      err = new RequestAbortedError()
+    }
+
+    if (err) {
+      this[kAbort]()
+    }
+
+    return super.destroy(err)
+  }
+
+  _destroy (err, callback) {
+    // Workaround for Node "bug". If the stream is destroyed in same
+    // tick as it is created, then a user who is waiting for a
+    // promise (i.e micro tick) for installing a 'error' listener will
+    // never get a chance and will always encounter an unhandled exception.
+    if (!this[kReading]) {
+      setImmediate(() => {
+        callback(err)
+      })
+    } else {
+      callback(err)
+    }
+  }
+
+  on (ev, ...args) {
+    if (ev === 'data' || ev === 'readable') {
+      this[kReading] = true
+    }
+    return super.on(ev, ...args)
+  }
+
+  addListener (ev, ...args) {
+    return this.on(ev, ...args)
+  }
+
+  off (ev, ...args) {
+    const ret = super.off(ev, ...args)
+    if (ev === 'data' || ev === 'readable') {
+      this[kReading] = (
+        this.listenerCount('data') > 0 ||
+        this.listenerCount('readable') > 0
+      )
+    }
+    return ret
+  }
+
+  removeListener (ev, ...args) {
+    return this.off(ev, ...args)
+  }
+
+  push (chunk) {
+    if (this[kConsume] && chunk !== null) {
+      consumePush(this[kConsume], chunk)
+      return this[kReading] ? super.push(chunk) : true
+    }
+    return super.push(chunk)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-text
+  async text () {
+    return consume(this, 'text')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-json
+  async json () {
+    return consume(this, 'json')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-blob
+  async blob () {
+    return consume(this, 'blob')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-bytes
+  async bytes () {
+    return consume(this, 'bytes')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+  async arrayBuffer () {
+    return consume(this, 'arrayBuffer')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-formdata
+  async formData () {
+    // TODO: Implement.
+    throw new NotSupportedError()
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-bodyused
+  get bodyUsed () {
+    return util.isDisturbed(this)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-body
+  get body () {
+    if (!this[kBody]) {
+      this[kBody] = ReadableStreamFrom(this)
+      if (this[kConsume]) {
+        // TODO: Is this the best way to force a lock?
+        this[kBody].getReader() // Ensure stream is locked.
+        assert(this[kBody].locked)
+      }
+    }
+    return this[kBody]
+  }
+
+  async dump (opts) {
+    let limit = Number.isFinite(opts?.limit) ? opts.limit : 128 * 1024
+    const signal = opts?.signal
+
+    if (signal != null && (typeof signal !== 'object' || !('aborted' in signal))) {
+      throw new InvalidArgumentError('signal must be an AbortSignal')
+    }
+
+    signal?.throwIfAborted()
+
+    if (this._readableState.closeEmitted) {
+      return null
+    }
+
+    return await new Promise((resolve, reject) => {
+      if (this[kContentLength] > limit) {
+        this.destroy(new AbortError())
+      }
+
+      const onAbort = () => {
+        this.destroy(signal.reason ?? new AbortError())
+      }
+      signal?.addEventListener('abort', onAbort)
+
+      this
+        .on('close', function () {
+          signal?.removeEventListener('abort', onAbort)
+          if (signal?.aborted) {
+            reject(signal.reason ?? new AbortError())
+          } else {
+            resolve(null)
+          }
+        })
+        .on('error', noop)
+        .on('data', function (chunk) {
+          limit -= chunk.length
+          if (limit <= 0) {
+            this.destroy()
+          }
+        })
+        .resume()
+    })
+  }
+}
+
+// https://streams.spec.whatwg.org/#readablestream-locked
+function isLocked (self) {
+  // Consume is an implicit lock.
+  return (self[kBody] && self[kBody].locked === true) || self[kConsume]
+}
+
+// https://fetch.spec.whatwg.org/#body-unusable
+function isUnusable (self) {
+  return util.isDisturbed(self) || isLocked(self)
+}
+
+async function consume (stream, type) {
+  assert(!stream[kConsume])
+
+  return new Promise((resolve, reject) => {
+    if (isUnusable(stream)) {
+      const rState = stream._readableState
+      if (rState.destroyed && rState.closeEmitted === false) {
+        stream
+          .on('error', err => {
+            reject(err)
+          })
+          .on('close', () => {
+            reject(new TypeError('unusable'))
+          })
+      } else {
+        reject(rState.errored ?? new TypeError('unusable'))
+      }
+    } else {
+      queueMicrotask(() => {
+        stream[kConsume] = {
+          type,
+          stream,
+          resolve,
+          reject,
+          length: 0,
+          body: []
+        }
+
+        stream
+          .on('error', function (err) {
+            consumeFinish(this[kConsume], err)
+          })
+          .on('close', function () {
+            if (this[kConsume].body !== null) {
+              consumeFinish(this[kConsume], new RequestAbortedError())
+            }
+          })
+
+        consumeStart(stream[kConsume])
+      })
+    }
+  })
+}
+
+function consumeStart (consume) {
+  if (consume.body === null) {
+    return
+  }
+
+  const { _readableState: state } = consume.stream
+
+  if (state.bufferIndex) {
+    const start = state.bufferIndex
+    const end = state.buffer.length
+    for (let n = start; n < end; n++) {
+      consumePush(consume, state.buffer[n])
+    }
+  } else {
+    for (const chunk of state.buffer) {
+      consumePush(consume, chunk)
+    }
+  }
+
+  if (state.endEmitted) {
+    consumeEnd(this[kConsume])
+  } else {
+    consume.stream.on('end', function () {
+      consumeEnd(this[kConsume])
+    })
+  }
+
+  consume.stream.resume()
+
+  while (consume.stream.read() != null) {
+    // Loop
+  }
+}
+
+/**
+ * @param {Buffer[]} chunks
+ * @param {number} length
+ */
+function chunksDecode (chunks, length) {
+  if (chunks.length === 0 || length === 0) {
+    return ''
+  }
+  const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, length)
+  const bufferLength = buffer.length
+
+  // Skip BOM.
+  const start =
+    bufferLength > 2 &&
+    buffer[0] === 0xef &&
+    buffer[1] === 0xbb &&
+    buffer[2] === 0xbf
+      ? 3
+      : 0
+  return buffer.utf8Slice(start, bufferLength)
+}
+
+/**
+ * @param {Buffer[]} chunks
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+function chunksConcat (chunks, length) {
+  if (chunks.length === 0 || length === 0) {
+    return new Uint8Array(0)
+  }
+  if (chunks.length === 1) {
+    // fast-path
+    return new Uint8Array(chunks[0])
+  }
+  const buffer = new Uint8Array(Buffer.allocUnsafeSlow(length).buffer)
+
+  let offset = 0
+  for (let i = 0; i < chunks.length; ++i) {
+    const chunk = chunks[i]
+    buffer.set(chunk, offset)
+    offset += chunk.length
+  }
+
+  return buffer
+}
+
+function consumeEnd (consume) {
+  const { type, body, resolve, stream, length } = consume
+
+  try {
+    if (type === 'text') {
+      resolve(chunksDecode(body, length))
+    } else if (type === 'json') {
+      resolve(JSON.parse(chunksDecode(body, length)))
+    } else if (type === 'arrayBuffer') {
+      resolve(chunksConcat(body, length).buffer)
+    } else if (type === 'blob') {
+      resolve(new Blob(body, { type: stream[kContentType] }))
+    } else if (type === 'bytes') {
+      resolve(chunksConcat(body, length))
+    }
+
+    consumeFinish(consume)
+  } catch (err) {
+    stream.destroy(err)
+  }
+}
+
+function consumePush (consume, chunk) {
+  consume.length += chunk.length
+  consume.body.push(chunk)
+}
+
+function consumeFinish (consume, err) {
+  if (consume.body === null) {
+    return
+  }
+
+  if (err) {
+    consume.reject(err)
+  } else {
+    consume.resolve()
+  }
+
+  consume.type = null
+  consume.stream = null
+  consume.resolve = null
+  consume.reject = null
+  consume.length = 0
+  consume.body = null
+}
+
+module.exports = { Readable: BodyReadable, chunksDecode }
+
+
+/***/ }),
+
+/***/ 45141:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+const assert = __nccwpck_require__(98061)
+const {
+  ResponseStatusCodeError
+} = __nccwpck_require__(22174)
+
+const { chunksDecode } = __nccwpck_require__(64054)
+const CHUNK_LIMIT = 128 * 1024
+
+async function getResolveErrorBodyCallback ({ callback, body, contentType, statusCode, statusMessage, headers }) {
+  assert(body)
+
+  let chunks = []
+  let length = 0
+
+  try {
+    for await (const chunk of body) {
+      chunks.push(chunk)
+      length += chunk.length
+      if (length > CHUNK_LIMIT) {
+        chunks = []
+        length = 0
+        break
+      }
+    }
+  } catch {
+    chunks = []
+    length = 0
+    // Do nothing....
+  }
+
+  const message = `Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`
+
+  if (statusCode === 204 || !contentType || !length) {
+    queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers)))
+    return
+  }
+
+  const stackTraceLimit = Error.stackTraceLimit
+  Error.stackTraceLimit = 0
+  let payload
+
+  try {
+    if (isContentTypeApplicationJson(contentType)) {
+      payload = JSON.parse(chunksDecode(chunks, length))
+    } else if (isContentTypeText(contentType)) {
+      payload = chunksDecode(chunks, length)
+    }
+  } catch {
+    // process in a callback to avoid throwing in the microtask queue
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit
+  }
+  queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers, payload)))
+}
+
+const isContentTypeApplicationJson = (contentType) => {
+  return (
+    contentType.length > 15 &&
+    contentType[11] === '/' &&
+    contentType[0] === 'a' &&
+    contentType[1] === 'p' &&
+    contentType[2] === 'p' &&
+    contentType[3] === 'l' &&
+    contentType[4] === 'i' &&
+    contentType[5] === 'c' &&
+    contentType[6] === 'a' &&
+    contentType[7] === 't' &&
+    contentType[8] === 'i' &&
+    contentType[9] === 'o' &&
+    contentType[10] === 'n' &&
+    contentType[12] === 'j' &&
+    contentType[13] === 's' &&
+    contentType[14] === 'o' &&
+    contentType[15] === 'n'
+  )
+}
+
+const isContentTypeText = (contentType) => {
+  return (
+    contentType.length > 4 &&
+    contentType[4] === '/' &&
+    contentType[0] === 't' &&
+    contentType[1] === 'e' &&
+    contentType[2] === 'x' &&
+    contentType[3] === 't'
+  )
+}
+
+module.exports = {
+  getResolveErrorBodyCallback,
+  isContentTypeApplicationJson,
+  isContentTypeText
+}
+
+
+/***/ }),
+
+/***/ 20123:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const net = __nccwpck_require__(87503)
+const assert = __nccwpck_require__(98061)
+const util = __nccwpck_require__(94407)
+const { InvalidArgumentError, ConnectTimeoutError } = __nccwpck_require__(22174)
+const timers = __nccwpck_require__(48413)
+
+function noop () {}
+
+let tls // include tls conditionally since it is not always available
+
+// TODO: session re-use does not wait for the first
+// connection to resolve the session and might therefore
+// resolve the same servername multiple times even when
+// re-use is enabled.
+
+let SessionCache
+// FIXME: remove workaround when the Node bug is fixed
+// https://github.com/nodejs/node/issues/49344#issuecomment-1741776308
+if (global.FinalizationRegistry && !(process.env.NODE_V8_COVERAGE || process.env.UNDICI_NO_FG)) {
+  SessionCache = class WeakSessionCache {
+    constructor (maxCachedSessions) {
+      this._maxCachedSessions = maxCachedSessions
+      this._sessionCache = new Map()
+      this._sessionRegistry = new global.FinalizationRegistry((key) => {
+        if (this._sessionCache.size < this._maxCachedSessions) {
+          return
+        }
+
+        const ref = this._sessionCache.get(key)
+        if (ref !== undefined && ref.deref() === undefined) {
+          this._sessionCache.delete(key)
+        }
+      })
+    }
+
+    get (sessionKey) {
+      const ref = this._sessionCache.get(sessionKey)
+      return ref ? ref.deref() : null
+    }
+
+    set (sessionKey, session) {
+      if (this._maxCachedSessions === 0) {
+        return
+      }
+
+      this._sessionCache.set(sessionKey, new WeakRef(session))
+      this._sessionRegistry.register(session, sessionKey)
+    }
+  }
+} else {
+  SessionCache = class SimpleSessionCache {
+    constructor (maxCachedSessions) {
+      this._maxCachedSessions = maxCachedSessions
+      this._sessionCache = new Map()
+    }
+
+    get (sessionKey) {
+      return this._sessionCache.get(sessionKey)
+    }
+
+    set (sessionKey, session) {
+      if (this._maxCachedSessions === 0) {
+        return
+      }
+
+      if (this._sessionCache.size >= this._maxCachedSessions) {
+        // remove the oldest session
+        const { value: oldestKey } = this._sessionCache.keys().next()
+        this._sessionCache.delete(oldestKey)
+      }
+
+      this._sessionCache.set(sessionKey, session)
+    }
+  }
+}
+
+function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
+  if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
+    throw new InvalidArgumentError('maxCachedSessions must be a positive integer or zero')
+  }
+
+  const options = { path: socketPath, ...opts }
+  const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions)
+  timeout = timeout == null ? 10e3 : timeout
+  allowH2 = allowH2 != null ? allowH2 : false
+  return function connect ({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
+    let socket
+    if (protocol === 'https:') {
+      if (!tls) {
+        tls = __nccwpck_require__(31764)
+      }
+      servername = servername || options.servername || util.getServerName(host) || null
+
+      const sessionKey = servername || hostname
+      assert(sessionKey)
+
+      const session = customSession || sessionCache.get(sessionKey) || null
+
+      port = port || 443
+
+      socket = tls.connect({
+        highWaterMark: 16384, // TLS in node can't have bigger HWM anyway...
+        ...options,
+        servername,
+        session,
+        localAddress,
+        // TODO(HTTP/2): Add support for h2c
+        ALPNProtocols: allowH2 ? ['http/1.1', 'h2'] : ['http/1.1'],
+        socket: httpSocket, // upgrade socket connection
+        port,
+        host: hostname
+      })
+
+      socket
+        .on('session', function (session) {
+          // TODO (fix): Can a session become invalid once established? Don't think so?
+          sessionCache.set(sessionKey, session)
+        })
+    } else {
+      assert(!httpSocket, 'httpSocket can only be sent on TLS update')
+
+      port = port || 80
+
+      socket = net.connect({
+        highWaterMark: 64 * 1024, // Same as nodejs fs streams.
+        ...options,
+        localAddress,
+        port,
+        host: hostname
+      })
+    }
+
+    // Set TCP keep alive options on the socket here instead of in connect() for the case of assigning the socket
+    if (options.keepAlive == null || options.keepAlive) {
+      const keepAliveInitialDelay = options.keepAliveInitialDelay === undefined ? 60e3 : options.keepAliveInitialDelay
+      socket.setKeepAlive(true, keepAliveInitialDelay)
+    }
+
+    const clearConnectTimeout = setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port })
+
+    socket
+      .setNoDelay(true)
+      .once(protocol === 'https:' ? 'secureConnect' : 'connect', function () {
+        queueMicrotask(clearConnectTimeout)
+
+        if (callback) {
+          const cb = callback
+          callback = null
+          cb(null, this)
+        }
+      })
+      .on('error', function (err) {
+        queueMicrotask(clearConnectTimeout)
+
+        if (callback) {
+          const cb = callback
+          callback = null
+          cb(err)
+        }
+      })
+
+    return socket
+  }
+}
+
+/**
+ * @param {WeakRef<net.Socket>} socketWeakRef
+ * @param {object} opts
+ * @param {number} opts.timeout
+ * @param {string} opts.hostname
+ * @param {number} opts.port
+ * @returns {() => void}
+ */
+const setupConnectTimeout = process.platform === 'win32'
+  ? (socketWeakRef, opts) => {
+      if (!opts.timeout) {
+        return noop
+      }
+
+      let s1 = null
+      let s2 = null
+      const fastTimer = timers.setFastTimeout(() => {
+      // setImmediate is added to make sure that we prioritize socket error events over timeouts
+        s1 = setImmediate(() => {
+        // Windows needs an extra setImmediate probably due to implementation differences in the socket logic
+          s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts))
+        })
+      }, opts.timeout)
+      return () => {
+        timers.clearFastTimeout(fastTimer)
+        clearImmediate(s1)
+        clearImmediate(s2)
+      }
+    }
+  : (socketWeakRef, opts) => {
+      if (!opts.timeout) {
+        return noop
+      }
+
+      let s1 = null
+      const fastTimer = timers.setFastTimeout(() => {
+      // setImmediate is added to make sure that we prioritize socket error events over timeouts
+        s1 = setImmediate(() => {
+          onConnectTimeout(socketWeakRef.deref(), opts)
+        })
+      }, opts.timeout)
+      return () => {
+        timers.clearFastTimeout(fastTimer)
+        clearImmediate(s1)
+      }
+    }
+
+/**
+ * @param {net.Socket} socket
+ * @param {object} opts
+ * @param {number} opts.timeout
+ * @param {string} opts.hostname
+ * @param {number} opts.port
+ */
+function onConnectTimeout (socket, opts) {
+  // The socket could be already garbage collected
+  if (socket == null) {
+    return
+  }
+
+  let message = 'Connect Timeout Error'
+  if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
+    message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(', ')},`
+  } else {
+    message += ` (attempted address: ${opts.hostname}:${opts.port},`
+  }
+
+  message += ` timeout: ${opts.timeout}ms)`
+
+  util.destroy(socket, new ConnectTimeoutError(message))
+}
+
+module.exports = buildConnector
+
+
+/***/ }),
+
+/***/ 2029:
+/***/ ((module) => {
+
+"use strict";
+
+
+/** @type {Record<string, string | undefined>} */
+const headerNameLowerCasedRecord = {}
+
+// https://developer.mozilla.org/docs/Web/HTTP/Headers
+const wellknownHeaderNames = [
+  'Accept',
+  'Accept-Encoding',
+  'Accept-Language',
+  'Accept-Ranges',
+  'Access-Control-Allow-Credentials',
+  'Access-Control-Allow-Headers',
+  'Access-Control-Allow-Methods',
+  'Access-Control-Allow-Origin',
+  'Access-Control-Expose-Headers',
+  'Access-Control-Max-Age',
+  'Access-Control-Request-Headers',
+  'Access-Control-Request-Method',
+  'Age',
+  'Allow',
+  'Alt-Svc',
+  'Alt-Used',
+  'Authorization',
+  'Cache-Control',
+  'Clear-Site-Data',
+  'Connection',
+  'Content-Disposition',
+  'Content-Encoding',
+  'Content-Language',
+  'Content-Length',
+  'Content-Location',
+  'Content-Range',
+  'Content-Security-Policy',
+  'Content-Security-Policy-Report-Only',
+  'Content-Type',
+  'Cookie',
+  'Cross-Origin-Embedder-Policy',
+  'Cross-Origin-Opener-Policy',
+  'Cross-Origin-Resource-Policy',
+  'Date',
+  'Device-Memory',
+  'Downlink',
+  'ECT',
+  'ETag',
+  'Expect',
+  'Expect-CT',
+  'Expires',
+  'Forwarded',
+  'From',
+  'Host',
+  'If-Match',
+  'If-Modified-Since',
+  'If-None-Match',
+  'If-Range',
+  'If-Unmodified-Since',
+  'Keep-Alive',
+  'Last-Modified',
+  'Link',
+  'Location',
+  'Max-Forwards',
+  'Origin',
+  'Permissions-Policy',
+  'Pragma',
+  'Proxy-Authenticate',
+  'Proxy-Authorization',
+  'RTT',
+  'Range',
+  'Referer',
+  'Referrer-Policy',
+  'Refresh',
+  'Retry-After',
+  'Sec-WebSocket-Accept',
+  'Sec-WebSocket-Extensions',
+  'Sec-WebSocket-Key',
+  'Sec-WebSocket-Protocol',
+  'Sec-WebSocket-Version',
+  'Server',
+  'Server-Timing',
+  'Service-Worker-Allowed',
+  'Service-Worker-Navigation-Preload',
+  'Set-Cookie',
+  'SourceMap',
+  'Strict-Transport-Security',
+  'Supports-Loading-Mode',
+  'TE',
+  'Timing-Allow-Origin',
+  'Trailer',
+  'Transfer-Encoding',
+  'Upgrade',
+  'Upgrade-Insecure-Requests',
+  'User-Agent',
+  'Vary',
+  'Via',
+  'WWW-Authenticate',
+  'X-Content-Type-Options',
+  'X-DNS-Prefetch-Control',
+  'X-Frame-Options',
+  'X-Permitted-Cross-Domain-Policies',
+  'X-Powered-By',
+  'X-Requested-With',
+  'X-XSS-Protection'
+]
+
+for (let i = 0; i < wellknownHeaderNames.length; ++i) {
+  const key = wellknownHeaderNames[i]
+  const lowerCasedKey = key.toLowerCase()
+  headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] =
+    lowerCasedKey
+}
+
+// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
+Object.setPrototypeOf(headerNameLowerCasedRecord, null)
+
+module.exports = {
+  wellknownHeaderNames,
+  headerNameLowerCasedRecord
+}
+
+
+/***/ }),
+
+/***/ 8627:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const diagnosticsChannel = __nccwpck_require__(65714)
+const util = __nccwpck_require__(47261)
+
+const undiciDebugLog = util.debuglog('undici')
+const fetchDebuglog = util.debuglog('fetch')
+const websocketDebuglog = util.debuglog('websocket')
+let isClientSet = false
+const channels = {
+  // Client
+  beforeConnect: diagnosticsChannel.channel('undici:client:beforeConnect'),
+  connected: diagnosticsChannel.channel('undici:client:connected'),
+  connectError: diagnosticsChannel.channel('undici:client:connectError'),
+  sendHeaders: diagnosticsChannel.channel('undici:client:sendHeaders'),
+  // Request
+  create: diagnosticsChannel.channel('undici:request:create'),
+  bodySent: diagnosticsChannel.channel('undici:request:bodySent'),
+  headers: diagnosticsChannel.channel('undici:request:headers'),
+  trailers: diagnosticsChannel.channel('undici:request:trailers'),
+  error: diagnosticsChannel.channel('undici:request:error'),
+  // WebSocket
+  open: diagnosticsChannel.channel('undici:websocket:open'),
+  close: diagnosticsChannel.channel('undici:websocket:close'),
+  socketError: diagnosticsChannel.channel('undici:websocket:socket_error'),
+  ping: diagnosticsChannel.channel('undici:websocket:ping'),
+  pong: diagnosticsChannel.channel('undici:websocket:pong')
+}
+
+if (undiciDebugLog.enabled || fetchDebuglog.enabled) {
+  const debuglog = fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog
+
+  // Track all Client events
+  diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(evt => {
+    const {
+      connectParams: { version, protocol, port, host }
+    } = evt
+    debuglog(
+      'connecting to %s using %s%s',
+      `${host}${port ? `:${port}` : ''}`,
+      protocol,
+      version
+    )
+  })
+
+  diagnosticsChannel.channel('undici:client:connected').subscribe(evt => {
+    const {
+      connectParams: { version, protocol, port, host }
+    } = evt
+    debuglog(
+      'connected to %s using %s%s',
+      `${host}${port ? `:${port}` : ''}`,
+      protocol,
+      version
+    )
+  })
+
+  diagnosticsChannel.channel('undici:client:connectError').subscribe(evt => {
+    const {
+      connectParams: { version, protocol, port, host },
+      error
+    } = evt
+    debuglog(
+      'connection to %s using %s%s errored - %s',
+      `${host}${port ? `:${port}` : ''}`,
+      protocol,
+      version,
+      error.message
+    )
+  })
+
+  diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(evt => {
+    const {
+      request: { method, path, origin }
+    } = evt
+    debuglog('sending request to %s %s/%s', method, origin, path)
+  })
+
+  // Track Request events
+  diagnosticsChannel.channel('undici:request:headers').subscribe(evt => {
+    const {
+      request: { method, path, origin },
+      response: { statusCode }
+    } = evt
+    debuglog(
+      'received response to %s %s/%s - HTTP %d',
+      method,
+      origin,
+      path,
+      statusCode
+    )
+  })
+
+  diagnosticsChannel.channel('undici:request:trailers').subscribe(evt => {
+    const {
+      request: { method, path, origin }
+    } = evt
+    debuglog('trailers received from %s %s/%s', method, origin, path)
+  })
+
+  diagnosticsChannel.channel('undici:request:error').subscribe(evt => {
+    const {
+      request: { method, path, origin },
+      error
+    } = evt
+    debuglog(
+      'request to %s %s/%s errored - %s',
+      method,
+      origin,
+      path,
+      error.message
+    )
+  })
+
+  isClientSet = true
+}
+
+if (websocketDebuglog.enabled) {
+  if (!isClientSet) {
+    const debuglog = undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog
+    diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(evt => {
+      const {
+        connectParams: { version, protocol, port, host }
+      } = evt
+      debuglog(
+        'connecting to %s%s using %s%s',
+        host,
+        port ? `:${port}` : '',
+        protocol,
+        version
+      )
+    })
+
+    diagnosticsChannel.channel('undici:client:connected').subscribe(evt => {
+      const {
+        connectParams: { version, protocol, port, host }
+      } = evt
+      debuglog(
+        'connected to %s%s using %s%s',
+        host,
+        port ? `:${port}` : '',
+        protocol,
+        version
+      )
+    })
+
+    diagnosticsChannel.channel('undici:client:connectError').subscribe(evt => {
+      const {
+        connectParams: { version, protocol, port, host },
+        error
+      } = evt
+      debuglog(
+        'connection to %s%s using %s%s errored - %s',
+        host,
+        port ? `:${port}` : '',
+        protocol,
+        version,
+        error.message
+      )
+    })
+
+    diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(evt => {
+      const {
+        request: { method, path, origin }
+      } = evt
+      debuglog('sending request to %s %s/%s', method, origin, path)
+    })
+  }
+
+  // Track all WebSocket events
+  diagnosticsChannel.channel('undici:websocket:open').subscribe(evt => {
+    const {
+      address: { address, port }
+    } = evt
+    websocketDebuglog('connection opened %s%s', address, port ? `:${port}` : '')
+  })
+
+  diagnosticsChannel.channel('undici:websocket:close').subscribe(evt => {
+    const { websocket, code, reason } = evt
+    websocketDebuglog(
+      'closed connection to %s - %s %s',
+      websocket.url,
+      code,
+      reason
+    )
+  })
+
+  diagnosticsChannel.channel('undici:websocket:socket_error').subscribe(err => {
+    websocketDebuglog('connection errored - %s', err.message)
+  })
+
+  diagnosticsChannel.channel('undici:websocket:ping').subscribe(evt => {
+    websocketDebuglog('ping received')
+  })
+
+  diagnosticsChannel.channel('undici:websocket:pong').subscribe(evt => {
+    websocketDebuglog('pong received')
+  })
+}
+
+module.exports = {
+  channels
+}
+
+
+/***/ }),
+
+/***/ 22174:
+/***/ ((module) => {
+
+"use strict";
+
+
+const kUndiciError = Symbol.for('undici.error.UND_ERR')
+class UndiciError extends Error {
+  constructor (message) {
+    super(message)
+    this.name = 'UndiciError'
+    this.code = 'UND_ERR'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kUndiciError] === true
+  }
+
+  [kUndiciError] = true
+}
+
+const kConnectTimeoutError = Symbol.for('undici.error.UND_ERR_CONNECT_TIMEOUT')
+class ConnectTimeoutError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'ConnectTimeoutError'
+    this.message = message || 'Connect Timeout Error'
+    this.code = 'UND_ERR_CONNECT_TIMEOUT'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kConnectTimeoutError] === true
+  }
+
+  [kConnectTimeoutError] = true
+}
+
+const kHeadersTimeoutError = Symbol.for('undici.error.UND_ERR_HEADERS_TIMEOUT')
+class HeadersTimeoutError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'HeadersTimeoutError'
+    this.message = message || 'Headers Timeout Error'
+    this.code = 'UND_ERR_HEADERS_TIMEOUT'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kHeadersTimeoutError] === true
+  }
+
+  [kHeadersTimeoutError] = true
+}
+
+const kHeadersOverflowError = Symbol.for('undici.error.UND_ERR_HEADERS_OVERFLOW')
+class HeadersOverflowError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'HeadersOverflowError'
+    this.message = message || 'Headers Overflow Error'
+    this.code = 'UND_ERR_HEADERS_OVERFLOW'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kHeadersOverflowError] === true
+  }
+
+  [kHeadersOverflowError] = true
+}
+
+const kBodyTimeoutError = Symbol.for('undici.error.UND_ERR_BODY_TIMEOUT')
+class BodyTimeoutError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'BodyTimeoutError'
+    this.message = message || 'Body Timeout Error'
+    this.code = 'UND_ERR_BODY_TIMEOUT'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kBodyTimeoutError] === true
+  }
+
+  [kBodyTimeoutError] = true
+}
+
+const kResponseStatusCodeError = Symbol.for('undici.error.UND_ERR_RESPONSE_STATUS_CODE')
+class ResponseStatusCodeError extends UndiciError {
+  constructor (message, statusCode, headers, body) {
+    super(message)
+    this.name = 'ResponseStatusCodeError'
+    this.message = message || 'Response Status Code Error'
+    this.code = 'UND_ERR_RESPONSE_STATUS_CODE'
+    this.body = body
+    this.status = statusCode
+    this.statusCode = statusCode
+    this.headers = headers
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kResponseStatusCodeError] === true
+  }
+
+  [kResponseStatusCodeError] = true
+}
+
+const kInvalidArgumentError = Symbol.for('undici.error.UND_ERR_INVALID_ARG')
+class InvalidArgumentError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'InvalidArgumentError'
+    this.message = message || 'Invalid Argument Error'
+    this.code = 'UND_ERR_INVALID_ARG'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kInvalidArgumentError] === true
+  }
+
+  [kInvalidArgumentError] = true
+}
+
+const kInvalidReturnValueError = Symbol.for('undici.error.UND_ERR_INVALID_RETURN_VALUE')
+class InvalidReturnValueError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'InvalidReturnValueError'
+    this.message = message || 'Invalid Return Value Error'
+    this.code = 'UND_ERR_INVALID_RETURN_VALUE'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kInvalidReturnValueError] === true
+  }
+
+  [kInvalidReturnValueError] = true
+}
+
+const kAbortError = Symbol.for('undici.error.UND_ERR_ABORT')
+class AbortError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'AbortError'
+    this.message = message || 'The operation was aborted'
+    this.code = 'UND_ERR_ABORT'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kAbortError] === true
+  }
+
+  [kAbortError] = true
+}
+
+const kRequestAbortedError = Symbol.for('undici.error.UND_ERR_ABORTED')
+class RequestAbortedError extends AbortError {
+  constructor (message) {
+    super(message)
+    this.name = 'AbortError'
+    this.message = message || 'Request aborted'
+    this.code = 'UND_ERR_ABORTED'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kRequestAbortedError] === true
+  }
+
+  [kRequestAbortedError] = true
+}
+
+const kInformationalError = Symbol.for('undici.error.UND_ERR_INFO')
+class InformationalError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'InformationalError'
+    this.message = message || 'Request information'
+    this.code = 'UND_ERR_INFO'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kInformationalError] === true
+  }
+
+  [kInformationalError] = true
+}
+
+const kRequestContentLengthMismatchError = Symbol.for('undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH')
+class RequestContentLengthMismatchError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'RequestContentLengthMismatchError'
+    this.message = message || 'Request body length does not match content-length header'
+    this.code = 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kRequestContentLengthMismatchError] === true
+  }
+
+  [kRequestContentLengthMismatchError] = true
+}
+
+const kResponseContentLengthMismatchError = Symbol.for('undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH')
+class ResponseContentLengthMismatchError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'ResponseContentLengthMismatchError'
+    this.message = message || 'Response body length does not match content-length header'
+    this.code = 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kResponseContentLengthMismatchError] === true
+  }
+
+  [kResponseContentLengthMismatchError] = true
+}
+
+const kClientDestroyedError = Symbol.for('undici.error.UND_ERR_DESTROYED')
+class ClientDestroyedError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'ClientDestroyedError'
+    this.message = message || 'The client is destroyed'
+    this.code = 'UND_ERR_DESTROYED'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kClientDestroyedError] === true
+  }
+
+  [kClientDestroyedError] = true
+}
+
+const kClientClosedError = Symbol.for('undici.error.UND_ERR_CLOSED')
+class ClientClosedError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'ClientClosedError'
+    this.message = message || 'The client is closed'
+    this.code = 'UND_ERR_CLOSED'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kClientClosedError] === true
+  }
+
+  [kClientClosedError] = true
+}
+
+const kSocketError = Symbol.for('undici.error.UND_ERR_SOCKET')
+class SocketError extends UndiciError {
+  constructor (message, socket) {
+    super(message)
+    this.name = 'SocketError'
+    this.message = message || 'Socket error'
+    this.code = 'UND_ERR_SOCKET'
+    this.socket = socket
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kSocketError] === true
+  }
+
+  [kSocketError] = true
+}
+
+const kNotSupportedError = Symbol.for('undici.error.UND_ERR_NOT_SUPPORTED')
+class NotSupportedError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'NotSupportedError'
+    this.message = message || 'Not supported error'
+    this.code = 'UND_ERR_NOT_SUPPORTED'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kNotSupportedError] === true
+  }
+
+  [kNotSupportedError] = true
+}
+
+const kBalancedPoolMissingUpstreamError = Symbol.for('undici.error.UND_ERR_BPL_MISSING_UPSTREAM')
+class BalancedPoolMissingUpstreamError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'MissingUpstreamError'
+    this.message = message || 'No upstream has been added to the BalancedPool'
+    this.code = 'UND_ERR_BPL_MISSING_UPSTREAM'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kBalancedPoolMissingUpstreamError] === true
+  }
+
+  [kBalancedPoolMissingUpstreamError] = true
+}
+
+const kHTTPParserError = Symbol.for('undici.error.UND_ERR_HTTP_PARSER')
+class HTTPParserError extends Error {
+  constructor (message, code, data) {
+    super(message)
+    this.name = 'HTTPParserError'
+    this.code = code ? `HPE_${code}` : undefined
+    this.data = data ? data.toString() : undefined
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kHTTPParserError] === true
+  }
+
+  [kHTTPParserError] = true
+}
+
+const kResponseExceededMaxSizeError = Symbol.for('undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE')
+class ResponseExceededMaxSizeError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'ResponseExceededMaxSizeError'
+    this.message = message || 'Response content exceeded max size'
+    this.code = 'UND_ERR_RES_EXCEEDED_MAX_SIZE'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kResponseExceededMaxSizeError] === true
+  }
+
+  [kResponseExceededMaxSizeError] = true
+}
+
+const kRequestRetryError = Symbol.for('undici.error.UND_ERR_REQ_RETRY')
+class RequestRetryError extends UndiciError {
+  constructor (message, code, { headers, data }) {
+    super(message)
+    this.name = 'RequestRetryError'
+    this.message = message || 'Request retry error'
+    this.code = 'UND_ERR_REQ_RETRY'
+    this.statusCode = code
+    this.data = data
+    this.headers = headers
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kRequestRetryError] === true
+  }
+
+  [kRequestRetryError] = true
+}
+
+const kResponseError = Symbol.for('undici.error.UND_ERR_RESPONSE')
+class ResponseError extends UndiciError {
+  constructor (message, code, { headers, data }) {
+    super(message)
+    this.name = 'ResponseError'
+    this.message = message || 'Response error'
+    this.code = 'UND_ERR_RESPONSE'
+    this.statusCode = code
+    this.data = data
+    this.headers = headers
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kResponseError] === true
+  }
+
+  [kResponseError] = true
+}
+
+const kSecureProxyConnectionError = Symbol.for('undici.error.UND_ERR_PRX_TLS')
+class SecureProxyConnectionError extends UndiciError {
+  constructor (cause, message, options) {
+    super(message, { cause, ...(options ?? {}) })
+    this.name = 'SecureProxyConnectionError'
+    this.message = message || 'Secure Proxy Connection failed'
+    this.code = 'UND_ERR_PRX_TLS'
+    this.cause = cause
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kSecureProxyConnectionError] === true
+  }
+
+  [kSecureProxyConnectionError] = true
+}
+
+module.exports = {
+  AbortError,
+  HTTPParserError,
+  UndiciError,
+  HeadersTimeoutError,
+  HeadersOverflowError,
+  BodyTimeoutError,
+  RequestContentLengthMismatchError,
+  ConnectTimeoutError,
+  ResponseStatusCodeError,
+  InvalidArgumentError,
+  InvalidReturnValueError,
+  RequestAbortedError,
+  ClientDestroyedError,
+  ClientClosedError,
+  InformationalError,
+  SocketError,
+  NotSupportedError,
+  ResponseContentLengthMismatchError,
+  BalancedPoolMissingUpstreamError,
+  ResponseExceededMaxSizeError,
+  RequestRetryError,
+  ResponseError,
+  SecureProxyConnectionError
+}
+
+
+/***/ }),
+
+/***/ 25829:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  InvalidArgumentError,
+  NotSupportedError
+} = __nccwpck_require__(22174)
+const assert = __nccwpck_require__(98061)
+const {
+  isValidHTTPToken,
+  isValidHeaderValue,
+  isStream,
+  destroy,
+  isBuffer,
+  isFormDataLike,
+  isIterable,
+  isBlobLike,
+  buildURL,
+  validateHandler,
+  getServerName,
+  normalizedMethodRecords
+} = __nccwpck_require__(94407)
+const { channels } = __nccwpck_require__(8627)
+const { headerNameLowerCasedRecord } = __nccwpck_require__(2029)
+
+// Verifies that a given path is valid does not contain control chars \x00 to \x20
+const invalidPathRegex = /[^\u0021-\u00ff]/
+
+const kHandler = Symbol('handler')
+
+class Request {
+  constructor (origin, {
+    path,
+    method,
+    body,
+    headers,
+    query,
+    idempotent,
+    blocking,
+    upgrade,
+    headersTimeout,
+    bodyTimeout,
+    reset,
+    throwOnError,
+    expectContinue,
+    servername
+  }, handler) {
+    if (typeof path !== 'string') {
+      throw new InvalidArgumentError('path must be a string')
+    } else if (
+      path[0] !== '/' &&
+      !(path.startsWith('http://') || path.startsWith('https://')) &&
+      method !== 'CONNECT'
+    ) {
+      throw new InvalidArgumentError('path must be an absolute URL or start with a slash')
+    } else if (invalidPathRegex.test(path)) {
+      throw new InvalidArgumentError('invalid request path')
+    }
+
+    if (typeof method !== 'string') {
+      throw new InvalidArgumentError('method must be a string')
+    } else if (normalizedMethodRecords[method] === undefined && !isValidHTTPToken(method)) {
+      throw new InvalidArgumentError('invalid request method')
+    }
+
+    if (upgrade && typeof upgrade !== 'string') {
+      throw new InvalidArgumentError('upgrade must be a string')
+    }
+
+    if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
+      throw new InvalidArgumentError('invalid headersTimeout')
+    }
+
+    if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
+      throw new InvalidArgumentError('invalid bodyTimeout')
+    }
+
+    if (reset != null && typeof reset !== 'boolean') {
+      throw new InvalidArgumentError('invalid reset')
+    }
+
+    if (expectContinue != null && typeof expectContinue !== 'boolean') {
+      throw new InvalidArgumentError('invalid expectContinue')
+    }
+
+    this.headersTimeout = headersTimeout
+
+    this.bodyTimeout = bodyTimeout
+
+    this.throwOnError = throwOnError === true
+
+    this.method = method
+
+    this.abort = null
+
+    if (body == null) {
+      this.body = null
+    } else if (isStream(body)) {
+      this.body = body
+
+      const rState = this.body._readableState
+      if (!rState || !rState.autoDestroy) {
+        this.endHandler = function autoDestroy () {
+          destroy(this)
+        }
+        this.body.on('end', this.endHandler)
+      }
+
+      this.errorHandler = err => {
+        if (this.abort) {
+          this.abort(err)
+        } else {
+          this.error = err
+        }
+      }
+      this.body.on('error', this.errorHandler)
+    } else if (isBuffer(body)) {
+      this.body = body.byteLength ? body : null
+    } else if (ArrayBuffer.isView(body)) {
+      this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null
+    } else if (body instanceof ArrayBuffer) {
+      this.body = body.byteLength ? Buffer.from(body) : null
+    } else if (typeof body === 'string') {
+      this.body = body.length ? Buffer.from(body) : null
+    } else if (isFormDataLike(body) || isIterable(body) || isBlobLike(body)) {
+      this.body = body
+    } else {
+      throw new InvalidArgumentError('body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable')
+    }
+
+    this.completed = false
+
+    this.aborted = false
+
+    this.upgrade = upgrade || null
+
+    this.path = query ? buildURL(path, query) : path
+
+    this.origin = origin
+
+    this.idempotent = idempotent == null
+      ? method === 'HEAD' || method === 'GET'
+      : idempotent
+
+    this.blocking = blocking == null ? false : blocking
+
+    this.reset = reset == null ? null : reset
+
+    this.host = null
+
+    this.contentLength = null
+
+    this.contentType = null
+
+    this.headers = []
+
+    // Only for H2
+    this.expectContinue = expectContinue != null ? expectContinue : false
+
+    if (Array.isArray(headers)) {
+      if (headers.length % 2 !== 0) {
+        throw new InvalidArgumentError('headers array must be even')
+      }
+      for (let i = 0; i < headers.length; i += 2) {
+        processHeader(this, headers[i], headers[i + 1])
+      }
+    } else if (headers && typeof headers === 'object') {
+      if (headers[Symbol.iterator]) {
+        for (const header of headers) {
+          if (!Array.isArray(header) || header.length !== 2) {
+            throw new InvalidArgumentError('headers must be in key-value pair format')
+          }
+          processHeader(this, header[0], header[1])
+        }
+      } else {
+        const keys = Object.keys(headers)
+        for (let i = 0; i < keys.length; ++i) {
+          processHeader(this, keys[i], headers[keys[i]])
+        }
+      }
+    } else if (headers != null) {
+      throw new InvalidArgumentError('headers must be an object or an array')
+    }
+
+    validateHandler(handler, method, upgrade)
+
+    this.servername = servername || getServerName(this.host)
+
+    this[kHandler] = handler
+
+    if (channels.create.hasSubscribers) {
+      channels.create.publish({ request: this })
+    }
+  }
+
+  onBodySent (chunk) {
+    if (this[kHandler].onBodySent) {
+      try {
+        return this[kHandler].onBodySent(chunk)
+      } catch (err) {
+        this.abort(err)
+      }
+    }
+  }
+
+  onRequestSent () {
+    if (channels.bodySent.hasSubscribers) {
+      channels.bodySent.publish({ request: this })
+    }
+
+    if (this[kHandler].onRequestSent) {
+      try {
+        return this[kHandler].onRequestSent()
+      } catch (err) {
+        this.abort(err)
+      }
+    }
+  }
+
+  onConnect (abort) {
+    assert(!this.aborted)
+    assert(!this.completed)
+
+    if (this.error) {
+      abort(this.error)
+    } else {
+      this.abort = abort
+      return this[kHandler].onConnect(abort)
+    }
+  }
+
+  onResponseStarted () {
+    return this[kHandler].onResponseStarted?.()
+  }
+
+  onHeaders (statusCode, headers, resume, statusText) {
+    assert(!this.aborted)
+    assert(!this.completed)
+
+    if (channels.headers.hasSubscribers) {
+      channels.headers.publish({ request: this, response: { statusCode, headers, statusText } })
+    }
+
+    try {
+      return this[kHandler].onHeaders(statusCode, headers, resume, statusText)
+    } catch (err) {
+      this.abort(err)
+    }
+  }
+
+  onData (chunk) {
+    assert(!this.aborted)
+    assert(!this.completed)
+
+    try {
+      return this[kHandler].onData(chunk)
+    } catch (err) {
+      this.abort(err)
+      return false
+    }
+  }
+
+  onUpgrade (statusCode, headers, socket) {
+    assert(!this.aborted)
+    assert(!this.completed)
+
+    return this[kHandler].onUpgrade(statusCode, headers, socket)
+  }
+
+  onComplete (trailers) {
+    this.onFinally()
+
+    assert(!this.aborted)
+
+    this.completed = true
+    if (channels.trailers.hasSubscribers) {
+      channels.trailers.publish({ request: this, trailers })
+    }
+
+    try {
+      return this[kHandler].onComplete(trailers)
+    } catch (err) {
+      // TODO (fix): This might be a bad idea?
+      this.onError(err)
+    }
+  }
+
+  onError (error) {
+    this.onFinally()
+
+    if (channels.error.hasSubscribers) {
+      channels.error.publish({ request: this, error })
+    }
+
+    if (this.aborted) {
+      return
+    }
+    this.aborted = true
+
+    return this[kHandler].onError(error)
+  }
+
+  onFinally () {
+    if (this.errorHandler) {
+      this.body.off('error', this.errorHandler)
+      this.errorHandler = null
+    }
+
+    if (this.endHandler) {
+      this.body.off('end', this.endHandler)
+      this.endHandler = null
+    }
+  }
+
+  addHeader (key, value) {
+    processHeader(this, key, value)
+    return this
+  }
+}
+
+function processHeader (request, key, val) {
+  if (val && (typeof val === 'object' && !Array.isArray(val))) {
+    throw new InvalidArgumentError(`invalid ${key} header`)
+  } else if (val === undefined) {
+    return
+  }
+
+  let headerName = headerNameLowerCasedRecord[key]
+
+  if (headerName === undefined) {
+    headerName = key.toLowerCase()
+    if (headerNameLowerCasedRecord[headerName] === undefined && !isValidHTTPToken(headerName)) {
+      throw new InvalidArgumentError('invalid header key')
+    }
+  }
+
+  if (Array.isArray(val)) {
+    const arr = []
+    for (let i = 0; i < val.length; i++) {
+      if (typeof val[i] === 'string') {
+        if (!isValidHeaderValue(val[i])) {
+          throw new InvalidArgumentError(`invalid ${key} header`)
+        }
+        arr.push(val[i])
+      } else if (val[i] === null) {
+        arr.push('')
+      } else if (typeof val[i] === 'object') {
+        throw new InvalidArgumentError(`invalid ${key} header`)
+      } else {
+        arr.push(`${val[i]}`)
+      }
+    }
+    val = arr
+  } else if (typeof val === 'string') {
+    if (!isValidHeaderValue(val)) {
+      throw new InvalidArgumentError(`invalid ${key} header`)
+    }
+  } else if (val === null) {
+    val = ''
+  } else {
+    val = `${val}`
+  }
+
+  if (request.host === null && headerName === 'host') {
+    if (typeof val !== 'string') {
+      throw new InvalidArgumentError('invalid host header')
+    }
+    // Consumed by Client
+    request.host = val
+  } else if (request.contentLength === null && headerName === 'content-length') {
+    request.contentLength = parseInt(val, 10)
+    if (!Number.isFinite(request.contentLength)) {
+      throw new InvalidArgumentError('invalid content-length header')
+    }
+  } else if (request.contentType === null && headerName === 'content-type') {
+    request.contentType = val
+    request.headers.push(key, val)
+  } else if (headerName === 'transfer-encoding' || headerName === 'keep-alive' || headerName === 'upgrade') {
+    throw new InvalidArgumentError(`invalid ${headerName} header`)
+  } else if (headerName === 'connection') {
+    const value = typeof val === 'string' ? val.toLowerCase() : null
+    if (value !== 'close' && value !== 'keep-alive') {
+      throw new InvalidArgumentError('invalid connection header')
+    }
+
+    if (value === 'close') {
+      request.reset = true
+    }
+  } else if (headerName === 'expect') {
+    throw new NotSupportedError('expect header not supported')
+  } else {
+    request.headers.push(key, val)
+  }
+}
+
+module.exports = Request
+
+
+/***/ }),
+
+/***/ 5392:
+/***/ ((module) => {
+
+module.exports = {
+  kClose: Symbol('close'),
+  kDestroy: Symbol('destroy'),
+  kDispatch: Symbol('dispatch'),
+  kUrl: Symbol('url'),
+  kWriting: Symbol('writing'),
+  kResuming: Symbol('resuming'),
+  kQueue: Symbol('queue'),
+  kConnect: Symbol('connect'),
+  kConnecting: Symbol('connecting'),
+  kKeepAliveDefaultTimeout: Symbol('default keep alive timeout'),
+  kKeepAliveMaxTimeout: Symbol('max keep alive timeout'),
+  kKeepAliveTimeoutThreshold: Symbol('keep alive timeout threshold'),
+  kKeepAliveTimeoutValue: Symbol('keep alive timeout'),
+  kKeepAlive: Symbol('keep alive'),
+  kHeadersTimeout: Symbol('headers timeout'),
+  kBodyTimeout: Symbol('body timeout'),
+  kServerName: Symbol('server name'),
+  kLocalAddress: Symbol('local address'),
+  kHost: Symbol('host'),
+  kNoRef: Symbol('no ref'),
+  kBodyUsed: Symbol('used'),
+  kBody: Symbol('abstracted request body'),
+  kRunning: Symbol('running'),
+  kBlocking: Symbol('blocking'),
+  kPending: Symbol('pending'),
+  kSize: Symbol('size'),
+  kBusy: Symbol('busy'),
+  kQueued: Symbol('queued'),
+  kFree: Symbol('free'),
+  kConnected: Symbol('connected'),
+  kClosed: Symbol('closed'),
+  kNeedDrain: Symbol('need drain'),
+  kReset: Symbol('reset'),
+  kDestroyed: Symbol.for('nodejs.stream.destroyed'),
+  kResume: Symbol('resume'),
+  kOnError: Symbol('on error'),
+  kMaxHeadersSize: Symbol('max headers size'),
+  kRunningIdx: Symbol('running index'),
+  kPendingIdx: Symbol('pending index'),
+  kError: Symbol('error'),
+  kClients: Symbol('clients'),
+  kClient: Symbol('client'),
+  kParser: Symbol('parser'),
+  kOnDestroyed: Symbol('destroy callbacks'),
+  kPipelining: Symbol('pipelining'),
+  kSocket: Symbol('socket'),
+  kHostHeader: Symbol('host header'),
+  kConnector: Symbol('connector'),
+  kStrictContentLength: Symbol('strict content length'),
+  kMaxRedirections: Symbol('maxRedirections'),
+  kMaxRequests: Symbol('maxRequestsPerClient'),
+  kProxy: Symbol('proxy agent options'),
+  kCounter: Symbol('socket request counter'),
+  kInterceptors: Symbol('dispatch interceptors'),
+  kMaxResponseSize: Symbol('max response size'),
+  kHTTP2Session: Symbol('http2Session'),
+  kHTTP2SessionState: Symbol('http2Session state'),
+  kRetryHandlerDefaultRetry: Symbol('retry agent default retry'),
+  kConstruct: Symbol('constructable'),
+  kListeners: Symbol('listeners'),
+  kHTTPContext: Symbol('http context'),
+  kMaxConcurrentStreams: Symbol('max concurrent streams'),
+  kNoProxyAgent: Symbol('no proxy agent'),
+  kHttpProxyAgent: Symbol('http proxy agent'),
+  kHttpsProxyAgent: Symbol('https proxy agent')
+}
+
+
+/***/ }),
+
+/***/ 69574:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  wellknownHeaderNames,
+  headerNameLowerCasedRecord
+} = __nccwpck_require__(2029)
+
+class TstNode {
+  /** @type {any} */
+  value = null
+  /** @type {null | TstNode} */
+  left = null
+  /** @type {null | TstNode} */
+  middle = null
+  /** @type {null | TstNode} */
+  right = null
+  /** @type {number} */
+  code
+  /**
+   * @param {string} key
+   * @param {any} value
+   * @param {number} index
+   */
+  constructor (key, value, index) {
+    if (index === undefined || index >= key.length) {
+      throw new TypeError('Unreachable')
+    }
+    const code = this.code = key.charCodeAt(index)
+    // check code is ascii string
+    if (code > 0x7F) {
+      throw new TypeError('key must be ascii string')
+    }
+    if (key.length !== ++index) {
+      this.middle = new TstNode(key, value, index)
+    } else {
+      this.value = value
+    }
+  }
+
+  /**
+   * @param {string} key
+   * @param {any} value
+   */
+  add (key, value) {
+    const length = key.length
+    if (length === 0) {
+      throw new TypeError('Unreachable')
+    }
+    let index = 0
+    let node = this
+    while (true) {
+      const code = key.charCodeAt(index)
+      // check code is ascii string
+      if (code > 0x7F) {
+        throw new TypeError('key must be ascii string')
+      }
+      if (node.code === code) {
+        if (length === ++index) {
+          node.value = value
+          break
+        } else if (node.middle !== null) {
+          node = node.middle
+        } else {
+          node.middle = new TstNode(key, value, index)
+          break
+        }
+      } else if (node.code < code) {
+        if (node.left !== null) {
+          node = node.left
+        } else {
+          node.left = new TstNode(key, value, index)
+          break
+        }
+      } else if (node.right !== null) {
+        node = node.right
+      } else {
+        node.right = new TstNode(key, value, index)
+        break
+      }
+    }
+  }
+
+  /**
+   * @param {Uint8Array} key
+   * @return {TstNode | null}
+   */
+  search (key) {
+    const keylength = key.length
+    let index = 0
+    let node = this
+    while (node !== null && index < keylength) {
+      let code = key[index]
+      // A-Z
+      // First check if it is bigger than 0x5a.
+      // Lowercase letters have higher char codes than uppercase ones.
+      // Also we assume that headers will mostly contain lowercase characters.
+      if (code <= 0x5a && code >= 0x41) {
+        // Lowercase for uppercase.
+        code |= 32
+      }
+      while (node !== null) {
+        if (code === node.code) {
+          if (keylength === ++index) {
+            // Returns Node since it is the last key.
+            return node
+          }
+          node = node.middle
+          break
+        }
+        node = node.code < code ? node.left : node.right
+      }
+    }
+    return null
+  }
+}
+
+class TernarySearchTree {
+  /** @type {TstNode | null} */
+  node = null
+
+  /**
+   * @param {string} key
+   * @param {any} value
+   * */
+  insert (key, value) {
+    if (this.node === null) {
+      this.node = new TstNode(key, value, 0)
+    } else {
+      this.node.add(key, value)
+    }
+  }
+
+  /**
+   * @param {Uint8Array} key
+   * @return {any}
+   */
+  lookup (key) {
+    return this.node?.search(key)?.value ?? null
+  }
+}
+
+const tree = new TernarySearchTree()
+
+for (let i = 0; i < wellknownHeaderNames.length; ++i) {
+  const key = headerNameLowerCasedRecord[wellknownHeaderNames[i]]
+  tree.insert(key, key)
+}
+
+module.exports = {
+  TernarySearchTree,
+  tree
+}
+
+
+/***/ }),
+
+/***/ 94407:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+const { kDestroyed, kBodyUsed, kListeners, kBody } = __nccwpck_require__(5392)
+const { IncomingMessage } = __nccwpck_require__(88849)
+const stream = __nccwpck_require__(84492)
+const net = __nccwpck_require__(87503)
+const { Blob } = __nccwpck_require__(72254)
+const nodeUtil = __nccwpck_require__(47261)
+const { stringify } = __nccwpck_require__(39630)
+const { EventEmitter: EE } = __nccwpck_require__(15673)
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+const { headerNameLowerCasedRecord } = __nccwpck_require__(2029)
+const { tree } = __nccwpck_require__(69574)
+
+const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(v => Number(v))
+
+class BodyAsyncIterable {
+  constructor (body) {
+    this[kBody] = body
+    this[kBodyUsed] = false
+  }
+
+  async * [Symbol.asyncIterator] () {
+    assert(!this[kBodyUsed], 'disturbed')
+    this[kBodyUsed] = true
+    yield * this[kBody]
+  }
+}
+
+function wrapRequestBody (body) {
+  if (isStream(body)) {
+    // TODO (fix): Provide some way for the user to cache the file to e.g. /tmp
+    // so that it can be dispatched again?
+    // TODO (fix): Do we need 100-expect support to provide a way to do this properly?
+    if (bodyLength(body) === 0) {
+      body
+        .on('data', function () {
+          assert(false)
+        })
+    }
+
+    if (typeof body.readableDidRead !== 'boolean') {
+      body[kBodyUsed] = false
+      EE.prototype.on.call(body, 'data', function () {
+        this[kBodyUsed] = true
+      })
+    }
+
+    return body
+  } else if (body && typeof body.pipeTo === 'function') {
+    // TODO (fix): We can't access ReadableStream internal state
+    // to determine whether or not it has been disturbed. This is just
+    // a workaround.
+    return new BodyAsyncIterable(body)
+  } else if (
+    body &&
+    typeof body !== 'string' &&
+    !ArrayBuffer.isView(body) &&
+    isIterable(body)
+  ) {
+    // TODO: Should we allow re-using iterable if !this.opts.idempotent
+    // or through some other flag?
+    return new BodyAsyncIterable(body)
+  } else {
+    return body
+  }
+}
+
+function nop () {}
+
+function isStream (obj) {
+  return obj && typeof obj === 'object' && typeof obj.pipe === 'function' && typeof obj.on === 'function'
+}
+
+// based on https://github.com/node-fetch/fetch-blob/blob/8ab587d34080de94140b54f07168451e7d0b655e/index.js#L229-L241 (MIT License)
+function isBlobLike (object) {
+  if (object === null) {
+    return false
+  } else if (object instanceof Blob) {
+    return true
+  } else if (typeof object !== 'object') {
+    return false
+  } else {
+    const sTag = object[Symbol.toStringTag]
+
+    return (sTag === 'Blob' || sTag === 'File') && (
+      ('stream' in object && typeof object.stream === 'function') ||
+      ('arrayBuffer' in object && typeof object.arrayBuffer === 'function')
+    )
+  }
+}
+
+function buildURL (url, queryParams) {
+  if (url.includes('?') || url.includes('#')) {
+    throw new Error('Query params cannot be passed when url already contains "?" or "#".')
+  }
+
+  const stringified = stringify(queryParams)
+
+  if (stringified) {
+    url += '?' + stringified
+  }
+
+  return url
+}
+
+function isValidPort (port) {
+  const value = parseInt(port, 10)
+  return (
+    value === Number(port) &&
+    value >= 0 &&
+    value <= 65535
+  )
+}
+
+function isHttpOrHttpsPrefixed (value) {
+  return (
+    value != null &&
+    value[0] === 'h' &&
+    value[1] === 't' &&
+    value[2] === 't' &&
+    value[3] === 'p' &&
+    (
+      value[4] === ':' ||
+      (
+        value[4] === 's' &&
+        value[5] === ':'
+      )
+    )
+  )
+}
+
+function parseURL (url) {
+  if (typeof url === 'string') {
+    url = new URL(url)
+
+    if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
+      throw new InvalidArgumentError('Invalid URL protocol: the URL must start with `http:` or `https:`.')
+    }
+
+    return url
+  }
+
+  if (!url || typeof url !== 'object') {
+    throw new InvalidArgumentError('Invalid URL: The URL argument must be a non-null object.')
+  }
+
+  if (!(url instanceof URL)) {
+    if (url.port != null && url.port !== '' && isValidPort(url.port) === false) {
+      throw new InvalidArgumentError('Invalid URL: port must be a valid integer or a string representation of an integer.')
+    }
+
+    if (url.path != null && typeof url.path !== 'string') {
+      throw new InvalidArgumentError('Invalid URL path: the path must be a string or null/undefined.')
+    }
+
+    if (url.pathname != null && typeof url.pathname !== 'string') {
+      throw new InvalidArgumentError('Invalid URL pathname: the pathname must be a string or null/undefined.')
+    }
+
+    if (url.hostname != null && typeof url.hostname !== 'string') {
+      throw new InvalidArgumentError('Invalid URL hostname: the hostname must be a string or null/undefined.')
+    }
+
+    if (url.origin != null && typeof url.origin !== 'string') {
+      throw new InvalidArgumentError('Invalid URL origin: the origin must be a string or null/undefined.')
+    }
+
+    if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
+      throw new InvalidArgumentError('Invalid URL protocol: the URL must start with `http:` or `https:`.')
+    }
+
+    const port = url.port != null
+      ? url.port
+      : (url.protocol === 'https:' ? 443 : 80)
+    let origin = url.origin != null
+      ? url.origin
+      : `${url.protocol || ''}//${url.hostname || ''}:${port}`
+    let path = url.path != null
+      ? url.path
+      : `${url.pathname || ''}${url.search || ''}`
+
+    if (origin[origin.length - 1] === '/') {
+      origin = origin.slice(0, origin.length - 1)
+    }
+
+    if (path && path[0] !== '/') {
+      path = `/${path}`
+    }
+    // new URL(path, origin) is unsafe when `path` contains an absolute URL
+    // From https://developer.mozilla.org/en-US/docs/Web/API/URL/URL:
+    // If first parameter is a relative URL, second param is required, and will be used as the base URL.
+    // If first parameter is an absolute URL, a given second param will be ignored.
+    return new URL(`${origin}${path}`)
+  }
+
+  if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
+    throw new InvalidArgumentError('Invalid URL protocol: the URL must start with `http:` or `https:`.')
+  }
+
+  return url
+}
+
+function parseOrigin (url) {
+  url = parseURL(url)
+
+  if (url.pathname !== '/' || url.search || url.hash) {
+    throw new InvalidArgumentError('invalid url')
+  }
+
+  return url
+}
+
+function getHostname (host) {
+  if (host[0] === '[') {
+    const idx = host.indexOf(']')
+
+    assert(idx !== -1)
+    return host.substring(1, idx)
+  }
+
+  const idx = host.indexOf(':')
+  if (idx === -1) return host
+
+  return host.substring(0, idx)
+}
+
+// IP addresses are not valid server names per RFC6066
+// > Currently, the only server names supported are DNS hostnames
+function getServerName (host) {
+  if (!host) {
+    return null
+  }
+
+  assert(typeof host === 'string')
+
+  const servername = getHostname(host)
+  if (net.isIP(servername)) {
+    return ''
+  }
+
+  return servername
+}
+
+function deepClone (obj) {
+  return JSON.parse(JSON.stringify(obj))
+}
+
+function isAsyncIterable (obj) {
+  return !!(obj != null && typeof obj[Symbol.asyncIterator] === 'function')
+}
+
+function isIterable (obj) {
+  return !!(obj != null && (typeof obj[Symbol.iterator] === 'function' || typeof obj[Symbol.asyncIterator] === 'function'))
+}
+
+function bodyLength (body) {
+  if (body == null) {
+    return 0
+  } else if (isStream(body)) {
+    const state = body._readableState
+    return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length)
+      ? state.length
+      : null
+  } else if (isBlobLike(body)) {
+    return body.size != null ? body.size : null
+  } else if (isBuffer(body)) {
+    return body.byteLength
+  }
+
+  return null
+}
+
+function isDestroyed (body) {
+  return body && !!(body.destroyed || body[kDestroyed] || (stream.isDestroyed?.(body)))
+}
+
+function destroy (stream, err) {
+  if (stream == null || !isStream(stream) || isDestroyed(stream)) {
+    return
+  }
+
+  if (typeof stream.destroy === 'function') {
+    if (Object.getPrototypeOf(stream).constructor === IncomingMessage) {
+      // See: https://github.com/nodejs/node/pull/38505/files
+      stream.socket = null
+    }
+
+    stream.destroy(err)
+  } else if (err) {
+    queueMicrotask(() => {
+      stream.emit('error', err)
+    })
+  }
+
+  if (stream.destroyed !== true) {
+    stream[kDestroyed] = true
+  }
+}
+
+const KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/
+function parseKeepAliveTimeout (val) {
+  const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR)
+  return m ? parseInt(m[1], 10) * 1000 : null
+}
+
+/**
+ * Retrieves a header name and returns its lowercase value.
+ * @param {string | Buffer} value Header name
+ * @returns {string}
+ */
+function headerNameToString (value) {
+  return typeof value === 'string'
+    ? headerNameLowerCasedRecord[value] ?? value.toLowerCase()
+    : tree.lookup(value) ?? value.toString('latin1').toLowerCase()
+}
+
+/**
+ * Receive the buffer as a string and return its lowercase value.
+ * @param {Buffer} value Header name
+ * @returns {string}
+ */
+function bufferToLowerCasedHeaderName (value) {
+  return tree.lookup(value) ?? value.toString('latin1').toLowerCase()
+}
+
+/**
+ * @param {Record<string, string | string[]> | (Buffer | string | (Buffer | string)[])[]} headers
+ * @param {Record<string, string | string[]>} [obj]
+ * @returns {Record<string, string | string[]>}
+ */
+function parseHeaders (headers, obj) {
+  if (obj === undefined) obj = {}
+  for (let i = 0; i < headers.length; i += 2) {
+    const key = headerNameToString(headers[i])
+    let val = obj[key]
+
+    if (val) {
+      if (typeof val === 'string') {
+        val = [val]
+        obj[key] = val
+      }
+      val.push(headers[i + 1].toString('utf8'))
+    } else {
+      const headersValue = headers[i + 1]
+      if (typeof headersValue === 'string') {
+        obj[key] = headersValue
+      } else {
+        obj[key] = Array.isArray(headersValue) ? headersValue.map(x => x.toString('utf8')) : headersValue.toString('utf8')
+      }
+    }
+  }
+
+  // See https://github.com/nodejs/node/pull/46528
+  if ('content-length' in obj && 'content-disposition' in obj) {
+    obj['content-disposition'] = Buffer.from(obj['content-disposition']).toString('latin1')
+  }
+
+  return obj
+}
+
+function parseRawHeaders (headers) {
+  const len = headers.length
+  const ret = new Array(len)
+
+  let hasContentLength = false
+  let contentDispositionIdx = -1
+  let key
+  let val
+  let kLen = 0
+
+  for (let n = 0; n < headers.length; n += 2) {
+    key = headers[n]
+    val = headers[n + 1]
+
+    typeof key !== 'string' && (key = key.toString())
+    typeof val !== 'string' && (val = val.toString('utf8'))
+
+    kLen = key.length
+    if (kLen === 14 && key[7] === '-' && (key === 'content-length' || key.toLowerCase() === 'content-length')) {
+      hasContentLength = true
+    } else if (kLen === 19 && key[7] === '-' && (key === 'content-disposition' || key.toLowerCase() === 'content-disposition')) {
+      contentDispositionIdx = n + 1
+    }
+    ret[n] = key
+    ret[n + 1] = val
+  }
+
+  // See https://github.com/nodejs/node/pull/46528
+  if (hasContentLength && contentDispositionIdx !== -1) {
+    ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString('latin1')
+  }
+
+  return ret
+}
+
+function isBuffer (buffer) {
+  // See, https://github.com/mcollina/undici/pull/319
+  return buffer instanceof Uint8Array || Buffer.isBuffer(buffer)
+}
+
+function validateHandler (handler, method, upgrade) {
+  if (!handler || typeof handler !== 'object') {
+    throw new InvalidArgumentError('handler must be an object')
+  }
+
+  if (typeof handler.onConnect !== 'function') {
+    throw new InvalidArgumentError('invalid onConnect method')
+  }
+
+  if (typeof handler.onError !== 'function') {
+    throw new InvalidArgumentError('invalid onError method')
+  }
+
+  if (typeof handler.onBodySent !== 'function' && handler.onBodySent !== undefined) {
+    throw new InvalidArgumentError('invalid onBodySent method')
+  }
+
+  if (upgrade || method === 'CONNECT') {
+    if (typeof handler.onUpgrade !== 'function') {
+      throw new InvalidArgumentError('invalid onUpgrade method')
+    }
+  } else {
+    if (typeof handler.onHeaders !== 'function') {
+      throw new InvalidArgumentError('invalid onHeaders method')
+    }
+
+    if (typeof handler.onData !== 'function') {
+      throw new InvalidArgumentError('invalid onData method')
+    }
+
+    if (typeof handler.onComplete !== 'function') {
+      throw new InvalidArgumentError('invalid onComplete method')
+    }
+  }
+}
+
+// A body is disturbed if it has been read from and it cannot
+// be re-used without losing state or data.
+function isDisturbed (body) {
+  // TODO (fix): Why is body[kBodyUsed] needed?
+  return !!(body && (stream.isDisturbed(body) || body[kBodyUsed]))
+}
+
+function isErrored (body) {
+  return !!(body && stream.isErrored(body))
+}
+
+function isReadable (body) {
+  return !!(body && stream.isReadable(body))
+}
+
+function getSocketInfo (socket) {
+  return {
+    localAddress: socket.localAddress,
+    localPort: socket.localPort,
+    remoteAddress: socket.remoteAddress,
+    remotePort: socket.remotePort,
+    remoteFamily: socket.remoteFamily,
+    timeout: socket.timeout,
+    bytesWritten: socket.bytesWritten,
+    bytesRead: socket.bytesRead
+  }
+}
+
+/** @type {globalThis['ReadableStream']} */
+function ReadableStreamFrom (iterable) {
+  // We cannot use ReadableStream.from here because it does not return a byte stream.
+
+  let iterator
+  return new ReadableStream(
+    {
+      async start () {
+        iterator = iterable[Symbol.asyncIterator]()
+      },
+      async pull (controller) {
+        const { done, value } = await iterator.next()
+        if (done) {
+          queueMicrotask(() => {
+            controller.close()
+            controller.byobRequest?.respond(0)
+          })
+        } else {
+          const buf = Buffer.isBuffer(value) ? value : Buffer.from(value)
+          if (buf.byteLength) {
+            controller.enqueue(new Uint8Array(buf))
+          }
+        }
+        return controller.desiredSize > 0
+      },
+      async cancel (reason) {
+        await iterator.return()
+      },
+      type: 'bytes'
+    }
+  )
+}
+
+// The chunk should be a FormData instance and contains
+// all the required methods.
+function isFormDataLike (object) {
+  return (
+    object &&
+    typeof object === 'object' &&
+    typeof object.append === 'function' &&
+    typeof object.delete === 'function' &&
+    typeof object.get === 'function' &&
+    typeof object.getAll === 'function' &&
+    typeof object.has === 'function' &&
+    typeof object.set === 'function' &&
+    object[Symbol.toStringTag] === 'FormData'
+  )
+}
+
+function addAbortListener (signal, listener) {
+  if ('addEventListener' in signal) {
+    signal.addEventListener('abort', listener, { once: true })
+    return () => signal.removeEventListener('abort', listener)
+  }
+  signal.addListener('abort', listener)
+  return () => signal.removeListener('abort', listener)
+}
+
+const hasToWellFormed = typeof String.prototype.toWellFormed === 'function'
+const hasIsWellFormed = typeof String.prototype.isWellFormed === 'function'
+
+/**
+ * @param {string} val
+ */
+function toUSVString (val) {
+  return hasToWellFormed ? `${val}`.toWellFormed() : nodeUtil.toUSVString(val)
+}
+
+/**
+ * @param {string} val
+ */
+// TODO: move this to webidl
+function isUSVString (val) {
+  return hasIsWellFormed ? `${val}`.isWellFormed() : toUSVString(val) === `${val}`
+}
+
+/**
+ * @see https://tools.ietf.org/html/rfc7230#section-3.2.6
+ * @param {number} c
+ */
+function isTokenCharCode (c) {
+  switch (c) {
+    case 0x22:
+    case 0x28:
+    case 0x29:
+    case 0x2c:
+    case 0x2f:
+    case 0x3a:
+    case 0x3b:
+    case 0x3c:
+    case 0x3d:
+    case 0x3e:
+    case 0x3f:
+    case 0x40:
+    case 0x5b:
+    case 0x5c:
+    case 0x5d:
+    case 0x7b:
+    case 0x7d:
+      // DQUOTE and "(),/:;<=>?@[\]{}"
+      return false
+    default:
+      // VCHAR %x21-7E
+      return c >= 0x21 && c <= 0x7e
+  }
+}
+
+/**
+ * @param {string} characters
+ */
+function isValidHTTPToken (characters) {
+  if (characters.length === 0) {
+    return false
+  }
+  for (let i = 0; i < characters.length; ++i) {
+    if (!isTokenCharCode(characters.charCodeAt(i))) {
+      return false
+    }
+  }
+  return true
+}
+
+// headerCharRegex have been lifted from
+// https://github.com/nodejs/node/blob/main/lib/_http_common.js
+
+/**
+ * Matches if val contains an invalid field-vchar
+ *  field-value    = *( field-content / obs-fold )
+ *  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+ *  field-vchar    = VCHAR / obs-text
+ */
+const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/
+
+/**
+ * @param {string} characters
+ */
+function isValidHeaderValue (characters) {
+  return !headerCharRegex.test(characters)
+}
+
+// Parsed accordingly to RFC 9110
+// https://www.rfc-editor.org/rfc/rfc9110#field.content-range
+function parseRangeHeader (range) {
+  if (range == null || range === '') return { start: 0, end: null, size: null }
+
+  const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null
+  return m
+    ? {
+        start: parseInt(m[1]),
+        end: m[2] ? parseInt(m[2]) : null,
+        size: m[3] ? parseInt(m[3]) : null
+      }
+    : null
+}
+
+function addListener (obj, name, listener) {
+  const listeners = (obj[kListeners] ??= [])
+  listeners.push([name, listener])
+  obj.on(name, listener)
+  return obj
+}
+
+function removeAllListeners (obj) {
+  for (const [name, listener] of obj[kListeners] ?? []) {
+    obj.removeListener(name, listener)
+  }
+  obj[kListeners] = null
+}
+
+function errorRequest (client, request, err) {
+  try {
+    request.onError(err)
+    assert(request.aborted)
+  } catch (err) {
+    client.emit('error', err)
+  }
+}
+
+const kEnumerableProperty = Object.create(null)
+kEnumerableProperty.enumerable = true
+
+const normalizedMethodRecordsBase = {
+  delete: 'DELETE',
+  DELETE: 'DELETE',
+  get: 'GET',
+  GET: 'GET',
+  head: 'HEAD',
+  HEAD: 'HEAD',
+  options: 'OPTIONS',
+  OPTIONS: 'OPTIONS',
+  post: 'POST',
+  POST: 'POST',
+  put: 'PUT',
+  PUT: 'PUT'
+}
+
+const normalizedMethodRecords = {
+  ...normalizedMethodRecordsBase,
+  patch: 'patch',
+  PATCH: 'PATCH'
+}
+
+// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
+Object.setPrototypeOf(normalizedMethodRecordsBase, null)
+Object.setPrototypeOf(normalizedMethodRecords, null)
+
+module.exports = {
+  kEnumerableProperty,
+  nop,
+  isDisturbed,
+  isErrored,
+  isReadable,
+  toUSVString,
+  isUSVString,
+  isBlobLike,
+  parseOrigin,
+  parseURL,
+  getServerName,
+  isStream,
+  isIterable,
+  isAsyncIterable,
+  isDestroyed,
+  headerNameToString,
+  bufferToLowerCasedHeaderName,
+  addListener,
+  removeAllListeners,
+  errorRequest,
+  parseRawHeaders,
+  parseHeaders,
+  parseKeepAliveTimeout,
+  destroy,
+  bodyLength,
+  deepClone,
+  ReadableStreamFrom,
+  isBuffer,
+  validateHandler,
+  getSocketInfo,
+  isFormDataLike,
+  buildURL,
+  addAbortListener,
+  isValidHTTPToken,
+  isValidHeaderValue,
+  isTokenCharCode,
+  parseRangeHeader,
+  normalizedMethodRecordsBase,
+  normalizedMethodRecords,
+  isValidPort,
+  isHttpOrHttpsPrefixed,
+  nodeMajor,
+  nodeMinor,
+  safeHTTPMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
+  wrapRequestBody
+}
+
+
+/***/ }),
+
+/***/ 83421:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+const { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = __nccwpck_require__(5392)
+const DispatcherBase = __nccwpck_require__(68838)
+const Pool = __nccwpck_require__(11795)
+const Client = __nccwpck_require__(6655)
+const util = __nccwpck_require__(94407)
+const createRedirectInterceptor = __nccwpck_require__(11115)
+
+const kOnConnect = Symbol('onConnect')
+const kOnDisconnect = Symbol('onDisconnect')
+const kOnConnectionError = Symbol('onConnectionError')
+const kMaxRedirections = Symbol('maxRedirections')
+const kOnDrain = Symbol('onDrain')
+const kFactory = Symbol('factory')
+const kOptions = Symbol('options')
+
+function defaultFactory (origin, opts) {
+  return opts && opts.connections === 1
+    ? new Client(origin, opts)
+    : new Pool(origin, opts)
+}
+
+class Agent extends DispatcherBase {
+  constructor ({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) {
+    super()
+
+    if (typeof factory !== 'function') {
+      throw new InvalidArgumentError('factory must be a function.')
+    }
+
+    if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
+      throw new InvalidArgumentError('connect must be a function or an object')
+    }
+
+    if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
+      throw new InvalidArgumentError('maxRedirections must be a positive number')
+    }
+
+    if (connect && typeof connect !== 'function') {
+      connect = { ...connect }
+    }
+
+    this[kInterceptors] = options.interceptors?.Agent && Array.isArray(options.interceptors.Agent)
+      ? options.interceptors.Agent
+      : [createRedirectInterceptor({ maxRedirections })]
+
+    this[kOptions] = { ...util.deepClone(options), connect }
+    this[kOptions].interceptors = options.interceptors
+      ? { ...options.interceptors }
+      : undefined
+    this[kMaxRedirections] = maxRedirections
+    this[kFactory] = factory
+    this[kClients] = new Map()
+
+    this[kOnDrain] = (origin, targets) => {
+      this.emit('drain', origin, [this, ...targets])
+    }
+
+    this[kOnConnect] = (origin, targets) => {
+      this.emit('connect', origin, [this, ...targets])
+    }
+
+    this[kOnDisconnect] = (origin, targets, err) => {
+      this.emit('disconnect', origin, [this, ...targets], err)
+    }
+
+    this[kOnConnectionError] = (origin, targets, err) => {
+      this.emit('connectionError', origin, [this, ...targets], err)
+    }
+  }
+
+  get [kRunning] () {
+    let ret = 0
+    for (const client of this[kClients].values()) {
+      ret += client[kRunning]
+    }
+    return ret
+  }
+
+  [kDispatch] (opts, handler) {
+    let key
+    if (opts.origin && (typeof opts.origin === 'string' || opts.origin instanceof URL)) {
+      key = String(opts.origin)
+    } else {
+      throw new InvalidArgumentError('opts.origin must be a non-empty string or URL.')
+    }
+
+    let dispatcher = this[kClients].get(key)
+
+    if (!dispatcher) {
+      dispatcher = this[kFactory](opts.origin, this[kOptions])
+        .on('drain', this[kOnDrain])
+        .on('connect', this[kOnConnect])
+        .on('disconnect', this[kOnDisconnect])
+        .on('connectionError', this[kOnConnectionError])
+
+      // This introduces a tiny memory leak, as dispatchers are never removed from the map.
+      // TODO(mcollina): remove te timer when the client/pool do not have any more
+      // active connections.
+      this[kClients].set(key, dispatcher)
+    }
+
+    return dispatcher.dispatch(opts, handler)
+  }
+
+  async [kClose] () {
+    const closePromises = []
+    for (const client of this[kClients].values()) {
+      closePromises.push(client.close())
+    }
+    this[kClients].clear()
+
+    await Promise.all(closePromises)
+  }
+
+  async [kDestroy] (err) {
+    const destroyPromises = []
+    for (const client of this[kClients].values()) {
+      destroyPromises.push(client.destroy(err))
+    }
+    this[kClients].clear()
+
+    await Promise.all(destroyPromises)
+  }
+}
+
+module.exports = Agent
+
+
+/***/ }),
+
+/***/ 74086:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  BalancedPoolMissingUpstreamError,
+  InvalidArgumentError
+} = __nccwpck_require__(22174)
+const {
+  PoolBase,
+  kClients,
+  kNeedDrain,
+  kAddClient,
+  kRemoveClient,
+  kGetDispatcher
+} = __nccwpck_require__(37128)
+const Pool = __nccwpck_require__(11795)
+const { kUrl, kInterceptors } = __nccwpck_require__(5392)
+const { parseOrigin } = __nccwpck_require__(94407)
+const kFactory = Symbol('factory')
+
+const kOptions = Symbol('options')
+const kGreatestCommonDivisor = Symbol('kGreatestCommonDivisor')
+const kCurrentWeight = Symbol('kCurrentWeight')
+const kIndex = Symbol('kIndex')
+const kWeight = Symbol('kWeight')
+const kMaxWeightPerServer = Symbol('kMaxWeightPerServer')
+const kErrorPenalty = Symbol('kErrorPenalty')
+
+/**
+ * Calculate the greatest common divisor of two numbers by
+ * using the Euclidean algorithm.
+ *
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+function getGreatestCommonDivisor (a, b) {
+  if (a === 0) return b
+
+  while (b !== 0) {
+    const t = b
+    b = a % b
+    a = t
+  }
+  return a
+}
+
+function defaultFactory (origin, opts) {
+  return new Pool(origin, opts)
+}
+
+class BalancedPool extends PoolBase {
+  constructor (upstreams = [], { factory = defaultFactory, ...opts } = {}) {
+    super()
+
+    this[kOptions] = opts
+    this[kIndex] = -1
+    this[kCurrentWeight] = 0
+
+    this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100
+    this[kErrorPenalty] = this[kOptions].errorPenalty || 15
+
+    if (!Array.isArray(upstreams)) {
+      upstreams = [upstreams]
+    }
+
+    if (typeof factory !== 'function') {
+      throw new InvalidArgumentError('factory must be a function.')
+    }
+
+    this[kInterceptors] = opts.interceptors?.BalancedPool && Array.isArray(opts.interceptors.BalancedPool)
+      ? opts.interceptors.BalancedPool
+      : []
+    this[kFactory] = factory
+
+    for (const upstream of upstreams) {
+      this.addUpstream(upstream)
+    }
+    this._updateBalancedPoolStats()
+  }
+
+  addUpstream (upstream) {
+    const upstreamOrigin = parseOrigin(upstream).origin
+
+    if (this[kClients].find((pool) => (
+      pool[kUrl].origin === upstreamOrigin &&
+      pool.closed !== true &&
+      pool.destroyed !== true
+    ))) {
+      return this
+    }
+    const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions]))
+
+    this[kAddClient](pool)
+    pool.on('connect', () => {
+      pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty])
+    })
+
+    pool.on('connectionError', () => {
+      pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty])
+      this._updateBalancedPoolStats()
+    })
+
+    pool.on('disconnect', (...args) => {
+      const err = args[2]
+      if (err && err.code === 'UND_ERR_SOCKET') {
+        // decrease the weight of the pool.
+        pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty])
+        this._updateBalancedPoolStats()
+      }
+    })
+
+    for (const client of this[kClients]) {
+      client[kWeight] = this[kMaxWeightPerServer]
+    }
+
+    this._updateBalancedPoolStats()
+
+    return this
+  }
+
+  _updateBalancedPoolStats () {
+    let result = 0
+    for (let i = 0; i < this[kClients].length; i++) {
+      result = getGreatestCommonDivisor(this[kClients][i][kWeight], result)
+    }
+
+    this[kGreatestCommonDivisor] = result
+  }
+
+  removeUpstream (upstream) {
+    const upstreamOrigin = parseOrigin(upstream).origin
+
+    const pool = this[kClients].find((pool) => (
+      pool[kUrl].origin === upstreamOrigin &&
+      pool.closed !== true &&
+      pool.destroyed !== true
+    ))
+
+    if (pool) {
+      this[kRemoveClient](pool)
+    }
+
+    return this
+  }
+
+  get upstreams () {
+    return this[kClients]
+      .filter(dispatcher => dispatcher.closed !== true && dispatcher.destroyed !== true)
+      .map((p) => p[kUrl].origin)
+  }
+
+  [kGetDispatcher] () {
+    // We validate that pools is greater than 0,
+    // otherwise we would have to wait until an upstream
+    // is added, which might never happen.
+    if (this[kClients].length === 0) {
+      throw new BalancedPoolMissingUpstreamError()
+    }
+
+    const dispatcher = this[kClients].find(dispatcher => (
+      !dispatcher[kNeedDrain] &&
+      dispatcher.closed !== true &&
+      dispatcher.destroyed !== true
+    ))
+
+    if (!dispatcher) {
+      return
+    }
+
+    const allClientsBusy = this[kClients].map(pool => pool[kNeedDrain]).reduce((a, b) => a && b, true)
+
+    if (allClientsBusy) {
+      return
+    }
+
+    let counter = 0
+
+    let maxWeightIndex = this[kClients].findIndex(pool => !pool[kNeedDrain])
+
+    while (counter++ < this[kClients].length) {
+      this[kIndex] = (this[kIndex] + 1) % this[kClients].length
+      const pool = this[kClients][this[kIndex]]
+
+      // find pool index with the largest weight
+      if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) {
+        maxWeightIndex = this[kIndex]
+      }
+
+      // decrease the current weight every `this[kClients].length`.
+      if (this[kIndex] === 0) {
+        // Set the current weight to the next lower weight.
+        this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor]
+
+        if (this[kCurrentWeight] <= 0) {
+          this[kCurrentWeight] = this[kMaxWeightPerServer]
+        }
+      }
+      if (pool[kWeight] >= this[kCurrentWeight] && (!pool[kNeedDrain])) {
+        return pool
+      }
+    }
+
+    this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight]
+    this[kIndex] = maxWeightIndex
+    return this[kClients][maxWeightIndex]
+  }
+}
+
+module.exports = BalancedPool
+
+
+/***/ }),
+
+/***/ 73619:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+/* global WebAssembly */
+
+const assert = __nccwpck_require__(98061)
+const util = __nccwpck_require__(94407)
+const { channels } = __nccwpck_require__(8627)
+const timers = __nccwpck_require__(48413)
+const {
+  RequestContentLengthMismatchError,
+  ResponseContentLengthMismatchError,
+  RequestAbortedError,
+  HeadersTimeoutError,
+  HeadersOverflowError,
+  SocketError,
+  InformationalError,
+  BodyTimeoutError,
+  HTTPParserError,
+  ResponseExceededMaxSizeError
+} = __nccwpck_require__(22174)
+const {
+  kUrl,
+  kReset,
+  kClient,
+  kParser,
+  kBlocking,
+  kRunning,
+  kPending,
+  kSize,
+  kWriting,
+  kQueue,
+  kNoRef,
+  kKeepAliveDefaultTimeout,
+  kHostHeader,
+  kPendingIdx,
+  kRunningIdx,
+  kError,
+  kPipelining,
+  kSocket,
+  kKeepAliveTimeoutValue,
+  kMaxHeadersSize,
+  kKeepAliveMaxTimeout,
+  kKeepAliveTimeoutThreshold,
+  kHeadersTimeout,
+  kBodyTimeout,
+  kStrictContentLength,
+  kMaxRequests,
+  kCounter,
+  kMaxResponseSize,
+  kOnError,
+  kResume,
+  kHTTPContext
+} = __nccwpck_require__(5392)
+
+const constants = __nccwpck_require__(59086)
+const EMPTY_BUF = Buffer.alloc(0)
+const FastBuffer = Buffer[Symbol.species]
+const addListener = util.addListener
+const removeAllListeners = util.removeAllListeners
+
+let extractBody
+
+async function lazyllhttp () {
+  const llhttpWasmData = process.env.JEST_WORKER_ID ? __nccwpck_require__(91475) : undefined
+
+  let mod
+  try {
+    mod = await WebAssembly.compile(__nccwpck_require__(27784))
+  } catch (e) {
+    /* istanbul ignore next */
+
+    // We could check if the error was caused by the simd option not
+    // being enabled, but the occurring of this other error
+    // * https://github.com/emscripten-core/emscripten/issues/11495
+    // got me to remove that check to avoid breaking Node 12.
+    mod = await WebAssembly.compile(llhttpWasmData || __nccwpck_require__(91475))
+  }
+
+  return await WebAssembly.instantiate(mod, {
+    env: {
+      /* eslint-disable camelcase */
+
+      wasm_on_url: (p, at, len) => {
+        /* istanbul ignore next */
+        return 0
+      },
+      wasm_on_status: (p, at, len) => {
+        assert(currentParser.ptr === p)
+        const start = at - currentBufferPtr + currentBufferRef.byteOffset
+        return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
+      },
+      wasm_on_message_begin: (p) => {
+        assert(currentParser.ptr === p)
+        return currentParser.onMessageBegin() || 0
+      },
+      wasm_on_header_field: (p, at, len) => {
+        assert(currentParser.ptr === p)
+        const start = at - currentBufferPtr + currentBufferRef.byteOffset
+        return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
+      },
+      wasm_on_header_value: (p, at, len) => {
+        assert(currentParser.ptr === p)
+        const start = at - currentBufferPtr + currentBufferRef.byteOffset
+        return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
+      },
+      wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
+        assert(currentParser.ptr === p)
+        return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0
+      },
+      wasm_on_body: (p, at, len) => {
+        assert(currentParser.ptr === p)
+        const start = at - currentBufferPtr + currentBufferRef.byteOffset
+        return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
+      },
+      wasm_on_message_complete: (p) => {
+        assert(currentParser.ptr === p)
+        return currentParser.onMessageComplete() || 0
+      }
+
+      /* eslint-enable camelcase */
+    }
+  })
+}
+
+let llhttpInstance = null
+let llhttpPromise = lazyllhttp()
+llhttpPromise.catch()
+
+let currentParser = null
+let currentBufferRef = null
+let currentBufferSize = 0
+let currentBufferPtr = null
+
+const USE_NATIVE_TIMER = 0
+const USE_FAST_TIMER = 1
+
+// Use fast timers for headers and body to take eventual event loop
+// latency into account.
+const TIMEOUT_HEADERS = 2 | USE_FAST_TIMER
+const TIMEOUT_BODY = 4 | USE_FAST_TIMER
+
+// Use native timers to ignore event loop latency for keep-alive
+// handling.
+const TIMEOUT_KEEP_ALIVE = 8 | USE_NATIVE_TIMER
+
+class Parser {
+  constructor (client, socket, { exports }) {
+    assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0)
+
+    this.llhttp = exports
+    this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE)
+    this.client = client
+    this.socket = socket
+    this.timeout = null
+    this.timeoutValue = null
+    this.timeoutType = null
+    this.statusCode = null
+    this.statusText = ''
+    this.upgrade = false
+    this.headers = []
+    this.headersSize = 0
+    this.headersMaxSize = client[kMaxHeadersSize]
+    this.shouldKeepAlive = false
+    this.paused = false
+    this.resume = this.resume.bind(this)
+
+    this.bytesRead = 0
+
+    this.keepAlive = ''
+    this.contentLength = ''
+    this.connection = ''
+    this.maxResponseSize = client[kMaxResponseSize]
+  }
+
+  setTimeout (delay, type) {
+    // If the existing timer and the new timer are of different timer type
+    // (fast or native) or have different delay, we need to clear the existing
+    // timer and set a new one.
+    if (
+      delay !== this.timeoutValue ||
+      (type & USE_FAST_TIMER) ^ (this.timeoutType & USE_FAST_TIMER)
+    ) {
+      // If a timeout is already set, clear it with clearTimeout of the fast
+      // timer implementation, as it can clear fast and native timers.
+      if (this.timeout) {
+        timers.clearTimeout(this.timeout)
+        this.timeout = null
+      }
+
+      if (delay) {
+        if (type & USE_FAST_TIMER) {
+          this.timeout = timers.setFastTimeout(onParserTimeout, delay, new WeakRef(this))
+        } else {
+          this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this))
+          this.timeout.unref()
+        }
+      }
+
+      this.timeoutValue = delay
+    } else if (this.timeout) {
+      // istanbul ignore else: only for jest
+      if (this.timeout.refresh) {
+        this.timeout.refresh()
+      }
+    }
+
+    this.timeoutType = type
+  }
+
+  resume () {
+    if (this.socket.destroyed || !this.paused) {
+      return
+    }
+
+    assert(this.ptr != null)
+    assert(currentParser == null)
+
+    this.llhttp.llhttp_resume(this.ptr)
+
+    assert(this.timeoutType === TIMEOUT_BODY)
+    if (this.timeout) {
+      // istanbul ignore else: only for jest
+      if (this.timeout.refresh) {
+        this.timeout.refresh()
+      }
+    }
+
+    this.paused = false
+    this.execute(this.socket.read() || EMPTY_BUF) // Flush parser.
+    this.readMore()
+  }
+
+  readMore () {
+    while (!this.paused && this.ptr) {
+      const chunk = this.socket.read()
+      if (chunk === null) {
+        break
+      }
+      this.execute(chunk)
+    }
+  }
+
+  execute (data) {
+    assert(this.ptr != null)
+    assert(currentParser == null)
+    assert(!this.paused)
+
+    const { socket, llhttp } = this
+
+    if (data.length > currentBufferSize) {
+      if (currentBufferPtr) {
+        llhttp.free(currentBufferPtr)
+      }
+      currentBufferSize = Math.ceil(data.length / 4096) * 4096
+      currentBufferPtr = llhttp.malloc(currentBufferSize)
+    }
+
+    new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data)
+
+    // Call `execute` on the wasm parser.
+    // We pass the `llhttp_parser` pointer address, the pointer address of buffer view data,
+    // and finally the length of bytes to parse.
+    // The return value is an error code or `constants.ERROR.OK`.
+    try {
+      let ret
+
+      try {
+        currentBufferRef = data
+        currentParser = this
+        ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length)
+        /* eslint-disable-next-line no-useless-catch */
+      } catch (err) {
+        /* istanbul ignore next: difficult to make a test case for */
+        throw err
+      } finally {
+        currentParser = null
+        currentBufferRef = null
+      }
+
+      const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr
+
+      if (ret === constants.ERROR.PAUSED_UPGRADE) {
+        this.onUpgrade(data.slice(offset))
+      } else if (ret === constants.ERROR.PAUSED) {
+        this.paused = true
+        socket.unshift(data.slice(offset))
+      } else if (ret !== constants.ERROR.OK) {
+        const ptr = llhttp.llhttp_get_error_reason(this.ptr)
+        let message = ''
+        /* istanbul ignore else: difficult to make a test case for */
+        if (ptr) {
+          const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0)
+          message =
+            'Response does not match the HTTP/1.1 protocol (' +
+            Buffer.from(llhttp.memory.buffer, ptr, len).toString() +
+            ')'
+        }
+        throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset))
+      }
+    } catch (err) {
+      util.destroy(socket, err)
+    }
+  }
+
+  destroy () {
+    assert(this.ptr != null)
+    assert(currentParser == null)
+
+    this.llhttp.llhttp_free(this.ptr)
+    this.ptr = null
+
+    this.timeout && timers.clearTimeout(this.timeout)
+    this.timeout = null
+    this.timeoutValue = null
+    this.timeoutType = null
+
+    this.paused = false
+  }
+
+  onStatus (buf) {
+    this.statusText = buf.toString()
+  }
+
+  onMessageBegin () {
+    const { socket, client } = this
+
+    /* istanbul ignore next: difficult to make a test case for */
+    if (socket.destroyed) {
+      return -1
+    }
+
+    const request = client[kQueue][client[kRunningIdx]]
+    if (!request) {
+      return -1
+    }
+    request.onResponseStarted()
+  }
+
+  onHeaderField (buf) {
+    const len = this.headers.length
+
+    if ((len & 1) === 0) {
+      this.headers.push(buf)
+    } else {
+      this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf])
+    }
+
+    this.trackHeader(buf.length)
+  }
+
+  onHeaderValue (buf) {
+    let len = this.headers.length
+
+    if ((len & 1) === 1) {
+      this.headers.push(buf)
+      len += 1
+    } else {
+      this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf])
+    }
+
+    const key = this.headers[len - 2]
+    if (key.length === 10) {
+      const headerName = util.bufferToLowerCasedHeaderName(key)
+      if (headerName === 'keep-alive') {
+        this.keepAlive += buf.toString()
+      } else if (headerName === 'connection') {
+        this.connection += buf.toString()
+      }
+    } else if (key.length === 14 && util.bufferToLowerCasedHeaderName(key) === 'content-length') {
+      this.contentLength += buf.toString()
+    }
+
+    this.trackHeader(buf.length)
+  }
+
+  trackHeader (len) {
+    this.headersSize += len
+    if (this.headersSize >= this.headersMaxSize) {
+      util.destroy(this.socket, new HeadersOverflowError())
+    }
+  }
+
+  onUpgrade (head) {
+    const { upgrade, client, socket, headers, statusCode } = this
+
+    assert(upgrade)
+    assert(client[kSocket] === socket)
+    assert(!socket.destroyed)
+    assert(!this.paused)
+    assert((headers.length & 1) === 0)
+
+    const request = client[kQueue][client[kRunningIdx]]
+    assert(request)
+    assert(request.upgrade || request.method === 'CONNECT')
+
+    this.statusCode = null
+    this.statusText = ''
+    this.shouldKeepAlive = null
+
+    this.headers = []
+    this.headersSize = 0
+
+    socket.unshift(head)
+
+    socket[kParser].destroy()
+    socket[kParser] = null
+
+    socket[kClient] = null
+    socket[kError] = null
+
+    removeAllListeners(socket)
+
+    client[kSocket] = null
+    client[kHTTPContext] = null // TODO (fix): This is hacky...
+    client[kQueue][client[kRunningIdx]++] = null
+    client.emit('disconnect', client[kUrl], [client], new InformationalError('upgrade'))
+
+    try {
+      request.onUpgrade(statusCode, headers, socket)
+    } catch (err) {
+      util.destroy(socket, err)
+    }
+
+    client[kResume]()
+  }
+
+  onHeadersComplete (statusCode, upgrade, shouldKeepAlive) {
+    const { client, socket, headers, statusText } = this
+
+    /* istanbul ignore next: difficult to make a test case for */
+    if (socket.destroyed) {
+      return -1
+    }
+
+    const request = client[kQueue][client[kRunningIdx]]
+
+    /* istanbul ignore next: difficult to make a test case for */
+    if (!request) {
+      return -1
+    }
+
+    assert(!this.upgrade)
+    assert(this.statusCode < 200)
+
+    if (statusCode === 100) {
+      util.destroy(socket, new SocketError('bad response', util.getSocketInfo(socket)))
+      return -1
+    }
+
+    /* this can only happen if server is misbehaving */
+    if (upgrade && !request.upgrade) {
+      util.destroy(socket, new SocketError('bad upgrade', util.getSocketInfo(socket)))
+      return -1
+    }
+
+    assert(this.timeoutType === TIMEOUT_HEADERS)
+
+    this.statusCode = statusCode
+    this.shouldKeepAlive = (
+      shouldKeepAlive ||
+      // Override llhttp value which does not allow keepAlive for HEAD.
+      (request.method === 'HEAD' && !socket[kReset] && this.connection.toLowerCase() === 'keep-alive')
+    )
+
+    if (this.statusCode >= 200) {
+      const bodyTimeout = request.bodyTimeout != null
+        ? request.bodyTimeout
+        : client[kBodyTimeout]
+      this.setTimeout(bodyTimeout, TIMEOUT_BODY)
+    } else if (this.timeout) {
+      // istanbul ignore else: only for jest
+      if (this.timeout.refresh) {
+        this.timeout.refresh()
+      }
+    }
+
+    if (request.method === 'CONNECT') {
+      assert(client[kRunning] === 1)
+      this.upgrade = true
+      return 2
+    }
+
+    if (upgrade) {
+      assert(client[kRunning] === 1)
+      this.upgrade = true
+      return 2
+    }
+
+    assert((this.headers.length & 1) === 0)
+    this.headers = []
+    this.headersSize = 0
+
+    if (this.shouldKeepAlive && client[kPipelining]) {
+      const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null
+
+      if (keepAliveTimeout != null) {
+        const timeout = Math.min(
+          keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
+          client[kKeepAliveMaxTimeout]
+        )
+        if (timeout <= 0) {
+          socket[kReset] = true
+        } else {
+          client[kKeepAliveTimeoutValue] = timeout
+        }
+      } else {
+        client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout]
+      }
+    } else {
+      // Stop more requests from being dispatched.
+      socket[kReset] = true
+    }
+
+    const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false
+
+    if (request.aborted) {
+      return -1
+    }
+
+    if (request.method === 'HEAD') {
+      return 1
+    }
+
+    if (statusCode < 200) {
+      return 1
+    }
+
+    if (socket[kBlocking]) {
+      socket[kBlocking] = false
+      client[kResume]()
+    }
+
+    return pause ? constants.ERROR.PAUSED : 0
+  }
+
+  onBody (buf) {
+    const { client, socket, statusCode, maxResponseSize } = this
+
+    if (socket.destroyed) {
+      return -1
+    }
+
+    const request = client[kQueue][client[kRunningIdx]]
+    assert(request)
+
+    assert(this.timeoutType === TIMEOUT_BODY)
+    if (this.timeout) {
+      // istanbul ignore else: only for jest
+      if (this.timeout.refresh) {
+        this.timeout.refresh()
+      }
+    }
+
+    assert(statusCode >= 200)
+
+    if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
+      util.destroy(socket, new ResponseExceededMaxSizeError())
+      return -1
+    }
+
+    this.bytesRead += buf.length
+
+    if (request.onData(buf) === false) {
+      return constants.ERROR.PAUSED
+    }
+  }
+
+  onMessageComplete () {
+    const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this
+
+    if (socket.destroyed && (!statusCode || shouldKeepAlive)) {
+      return -1
+    }
+
+    if (upgrade) {
+      return
+    }
+
+    assert(statusCode >= 100)
+    assert((this.headers.length & 1) === 0)
+
+    const request = client[kQueue][client[kRunningIdx]]
+    assert(request)
+
+    this.statusCode = null
+    this.statusText = ''
+    this.bytesRead = 0
+    this.contentLength = ''
+    this.keepAlive = ''
+    this.connection = ''
+
+    this.headers = []
+    this.headersSize = 0
+
+    if (statusCode < 200) {
+      return
+    }
+
+    /* istanbul ignore next: should be handled by llhttp? */
+    if (request.method !== 'HEAD' && contentLength && bytesRead !== parseInt(contentLength, 10)) {
+      util.destroy(socket, new ResponseContentLengthMismatchError())
+      return -1
+    }
+
+    request.onComplete(headers)
+
+    client[kQueue][client[kRunningIdx]++] = null
+
+    if (socket[kWriting]) {
+      assert(client[kRunning] === 0)
+      // Response completed before request.
+      util.destroy(socket, new InformationalError('reset'))
+      return constants.ERROR.PAUSED
+    } else if (!shouldKeepAlive) {
+      util.destroy(socket, new InformationalError('reset'))
+      return constants.ERROR.PAUSED
+    } else if (socket[kReset] && client[kRunning] === 0) {
+      // Destroy socket once all requests have completed.
+      // The request at the tail of the pipeline is the one
+      // that requested reset and no further requests should
+      // have been queued since then.
+      util.destroy(socket, new InformationalError('reset'))
+      return constants.ERROR.PAUSED
+    } else if (client[kPipelining] == null || client[kPipelining] === 1) {
+      // We must wait a full event loop cycle to reuse this socket to make sure
+      // that non-spec compliant servers are not closing the connection even if they
+      // said they won't.
+      setImmediate(() => client[kResume]())
+    } else {
+      client[kResume]()
+    }
+  }
+}
+
+function onParserTimeout (parser) {
+  const { socket, timeoutType, client, paused } = parser.deref()
+
+  /* istanbul ignore else */
+  if (timeoutType === TIMEOUT_HEADERS) {
+    if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
+      assert(!paused, 'cannot be paused while waiting for headers')
+      util.destroy(socket, new HeadersTimeoutError())
+    }
+  } else if (timeoutType === TIMEOUT_BODY) {
+    if (!paused) {
+      util.destroy(socket, new BodyTimeoutError())
+    }
+  } else if (timeoutType === TIMEOUT_KEEP_ALIVE) {
+    assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue])
+    util.destroy(socket, new InformationalError('socket idle timeout'))
+  }
+}
+
+async function connectH1 (client, socket) {
+  client[kSocket] = socket
+
+  if (!llhttpInstance) {
+    llhttpInstance = await llhttpPromise
+    llhttpPromise = null
+  }
+
+  socket[kNoRef] = false
+  socket[kWriting] = false
+  socket[kReset] = false
+  socket[kBlocking] = false
+  socket[kParser] = new Parser(client, socket, llhttpInstance)
+
+  addListener(socket, 'error', function (err) {
+    assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
+
+    const parser = this[kParser]
+
+    // On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded
+    // to the user.
+    if (err.code === 'ECONNRESET' && parser.statusCode && !parser.shouldKeepAlive) {
+      // We treat all incoming data so for as a valid response.
+      parser.onMessageComplete()
+      return
+    }
+
+    this[kError] = err
+
+    this[kClient][kOnError](err)
+  })
+  addListener(socket, 'readable', function () {
+    const parser = this[kParser]
+
+    if (parser) {
+      parser.readMore()
+    }
+  })
+  addListener(socket, 'end', function () {
+    const parser = this[kParser]
+
+    if (parser.statusCode && !parser.shouldKeepAlive) {
+      // We treat all incoming data so far as a valid response.
+      parser.onMessageComplete()
+      return
+    }
+
+    util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
+  })
+  addListener(socket, 'close', function () {
+    const client = this[kClient]
+    const parser = this[kParser]
+
+    if (parser) {
+      if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
+        // We treat all incoming data so far as a valid response.
+        parser.onMessageComplete()
+      }
+
+      this[kParser].destroy()
+      this[kParser] = null
+    }
+
+    const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
+
+    client[kSocket] = null
+    client[kHTTPContext] = null // TODO (fix): This is hacky...
+
+    if (client.destroyed) {
+      assert(client[kPending] === 0)
+
+      // Fail entire queue.
+      const requests = client[kQueue].splice(client[kRunningIdx])
+      for (let i = 0; i < requests.length; i++) {
+        const request = requests[i]
+        util.errorRequest(client, request, err)
+      }
+    } else if (client[kRunning] > 0 && err.code !== 'UND_ERR_INFO') {
+      // Fail head of pipeline.
+      const request = client[kQueue][client[kRunningIdx]]
+      client[kQueue][client[kRunningIdx]++] = null
+
+      util.errorRequest(client, request, err)
+    }
+
+    client[kPendingIdx] = client[kRunningIdx]
+
+    assert(client[kRunning] === 0)
+
+    client.emit('disconnect', client[kUrl], [client], err)
+
+    client[kResume]()
+  })
+
+  let closed = false
+  socket.on('close', () => {
+    closed = true
+  })
+
+  return {
+    version: 'h1',
+    defaultPipelining: 1,
+    write (...args) {
+      return writeH1(client, ...args)
+    },
+    resume () {
+      resumeH1(client)
+    },
+    destroy (err, callback) {
+      if (closed) {
+        queueMicrotask(callback)
+      } else {
+        socket.destroy(err).on('close', callback)
+      }
+    },
+    get destroyed () {
+      return socket.destroyed
+    },
+    busy (request) {
+      if (socket[kWriting] || socket[kReset] || socket[kBlocking]) {
+        return true
+      }
+
+      if (request) {
+        if (client[kRunning] > 0 && !request.idempotent) {
+          // Non-idempotent request cannot be retried.
+          // Ensure that no other requests are inflight and
+          // could cause failure.
+          return true
+        }
+
+        if (client[kRunning] > 0 && (request.upgrade || request.method === 'CONNECT')) {
+          // Don't dispatch an upgrade until all preceding requests have completed.
+          // A misbehaving server might upgrade the connection before all pipelined
+          // request has completed.
+          return true
+        }
+
+        if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 &&
+          (util.isStream(request.body) || util.isAsyncIterable(request.body) || util.isFormDataLike(request.body))) {
+          // Request with stream or iterator body can error while other requests
+          // are inflight and indirectly error those as well.
+          // Ensure this doesn't happen by waiting for inflight
+          // to complete before dispatching.
+
+          // Request with stream or iterator body cannot be retried.
+          // Ensure that no other requests are inflight and
+          // could cause failure.
+          return true
+        }
+      }
+
+      return false
+    }
+  }
+}
+
+function resumeH1 (client) {
+  const socket = client[kSocket]
+
+  if (socket && !socket.destroyed) {
+    if (client[kSize] === 0) {
+      if (!socket[kNoRef] && socket.unref) {
+        socket.unref()
+        socket[kNoRef] = true
+      }
+    } else if (socket[kNoRef] && socket.ref) {
+      socket.ref()
+      socket[kNoRef] = false
+    }
+
+    if (client[kSize] === 0) {
+      if (socket[kParser].timeoutType !== TIMEOUT_KEEP_ALIVE) {
+        socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_KEEP_ALIVE)
+      }
+    } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
+      if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
+        const request = client[kQueue][client[kRunningIdx]]
+        const headersTimeout = request.headersTimeout != null
+          ? request.headersTimeout
+          : client[kHeadersTimeout]
+        socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS)
+      }
+    }
+  }
+}
+
+// https://www.rfc-editor.org/rfc/rfc7230#section-3.3.2
+function shouldSendContentLength (method) {
+  return method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS' && method !== 'TRACE' && method !== 'CONNECT'
+}
+
+function writeH1 (client, request) {
+  const { method, path, host, upgrade, blocking, reset } = request
+
+  let { body, headers, contentLength } = request
+
+  // https://tools.ietf.org/html/rfc7231#section-4.3.1
+  // https://tools.ietf.org/html/rfc7231#section-4.3.2
+  // https://tools.ietf.org/html/rfc7231#section-4.3.5
+
+  // Sending a payload body on a request that does not
+  // expect it can cause undefined behavior on some
+  // servers and corrupt connection state. Do not
+  // re-use the connection for further requests.
+
+  const expectsPayload = (
+    method === 'PUT' ||
+    method === 'POST' ||
+    method === 'PATCH' ||
+    method === 'QUERY' ||
+    method === 'PROPFIND' ||
+    method === 'PROPPATCH'
+  )
+
+  if (util.isFormDataLike(body)) {
+    if (!extractBody) {
+      extractBody = (__nccwpck_require__(23291).extractBody)
+    }
+
+    const [bodyStream, contentType] = extractBody(body)
+    if (request.contentType == null) {
+      headers.push('content-type', contentType)
+    }
+    body = bodyStream.stream
+    contentLength = bodyStream.length
+  } else if (util.isBlobLike(body) && request.contentType == null && body.type) {
+    headers.push('content-type', body.type)
+  }
+
+  if (body && typeof body.read === 'function') {
+    // Try to read EOF in order to get length.
+    body.read(0)
+  }
+
+  const bodyLength = util.bodyLength(body)
+
+  contentLength = bodyLength ?? contentLength
+
+  if (contentLength === null) {
+    contentLength = request.contentLength
+  }
+
+  if (contentLength === 0 && !expectsPayload) {
+    // https://tools.ietf.org/html/rfc7230#section-3.3.2
+    // A user agent SHOULD NOT send a Content-Length header field when
+    // the request message does not contain a payload body and the method
+    // semantics do not anticipate such a body.
+
+    contentLength = null
+  }
+
+  // https://github.com/nodejs/undici/issues/2046
+  // A user agent may send a Content-Length header with 0 value, this should be allowed.
+  if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) {
+    if (client[kStrictContentLength]) {
+      util.errorRequest(client, request, new RequestContentLengthMismatchError())
+      return false
+    }
+
+    process.emitWarning(new RequestContentLengthMismatchError())
+  }
+
+  const socket = client[kSocket]
+
+  const abort = (err) => {
+    if (request.aborted || request.completed) {
+      return
+    }
+
+    util.errorRequest(client, request, err || new RequestAbortedError())
+
+    util.destroy(body)
+    util.destroy(socket, new InformationalError('aborted'))
+  }
+
+  try {
+    request.onConnect(abort)
+  } catch (err) {
+    util.errorRequest(client, request, err)
+  }
+
+  if (request.aborted) {
+    return false
+  }
+
+  if (method === 'HEAD') {
+    // https://github.com/mcollina/undici/issues/258
+    // Close after a HEAD request to interop with misbehaving servers
+    // that may send a body in the response.
+
+    socket[kReset] = true
+  }
+
+  if (upgrade || method === 'CONNECT') {
+    // On CONNECT or upgrade, block pipeline from dispatching further
+    // requests on this connection.
+
+    socket[kReset] = true
+  }
+
+  if (reset != null) {
+    socket[kReset] = reset
+  }
+
+  if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) {
+    socket[kReset] = true
+  }
+
+  if (blocking) {
+    socket[kBlocking] = true
+  }
+
+  let header = `${method} ${path} HTTP/1.1\r\n`
+
+  if (typeof host === 'string') {
+    header += `host: ${host}\r\n`
+  } else {
+    header += client[kHostHeader]
+  }
+
+  if (upgrade) {
+    header += `connection: upgrade\r\nupgrade: ${upgrade}\r\n`
+  } else if (client[kPipelining] && !socket[kReset]) {
+    header += 'connection: keep-alive\r\n'
+  } else {
+    header += 'connection: close\r\n'
+  }
+
+  if (Array.isArray(headers)) {
+    for (let n = 0; n < headers.length; n += 2) {
+      const key = headers[n + 0]
+      const val = headers[n + 1]
+
+      if (Array.isArray(val)) {
+        for (let i = 0; i < val.length; i++) {
+          header += `${key}: ${val[i]}\r\n`
+        }
+      } else {
+        header += `${key}: ${val}\r\n`
+      }
+    }
+  }
+
+  if (channels.sendHeaders.hasSubscribers) {
+    channels.sendHeaders.publish({ request, headers: header, socket })
+  }
+
+  /* istanbul ignore else: assertion */
+  if (!body || bodyLength === 0) {
+    writeBuffer(abort, null, client, request, socket, contentLength, header, expectsPayload)
+  } else if (util.isBuffer(body)) {
+    writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload)
+  } else if (util.isBlobLike(body)) {
+    if (typeof body.stream === 'function') {
+      writeIterable(abort, body.stream(), client, request, socket, contentLength, header, expectsPayload)
+    } else {
+      writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload)
+    }
+  } else if (util.isStream(body)) {
+    writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload)
+  } else if (util.isIterable(body)) {
+    writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload)
+  } else {
+    assert(false)
+  }
+
+  return true
+}
+
+function writeStream (abort, body, client, request, socket, contentLength, header, expectsPayload) {
+  assert(contentLength !== 0 || client[kRunning] === 0, 'stream body cannot be pipelined')
+
+  let finished = false
+
+  const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header })
+
+  const onData = function (chunk) {
+    if (finished) {
+      return
+    }
+
+    try {
+      if (!writer.write(chunk) && this.pause) {
+        this.pause()
+      }
+    } catch (err) {
+      util.destroy(this, err)
+    }
+  }
+  const onDrain = function () {
+    if (finished) {
+      return
+    }
+
+    if (body.resume) {
+      body.resume()
+    }
+  }
+  const onClose = function () {
+    // 'close' might be emitted *before* 'error' for
+    // broken streams. Wait a tick to avoid this case.
+    queueMicrotask(() => {
+      // It's only safe to remove 'error' listener after
+      // 'close'.
+      body.removeListener('error', onFinished)
+    })
+
+    if (!finished) {
+      const err = new RequestAbortedError()
+      queueMicrotask(() => onFinished(err))
+    }
+  }
+  const onFinished = function (err) {
+    if (finished) {
+      return
+    }
+
+    finished = true
+
+    assert(socket.destroyed || (socket[kWriting] && client[kRunning] <= 1))
+
+    socket
+      .off('drain', onDrain)
+      .off('error', onFinished)
+
+    body
+      .removeListener('data', onData)
+      .removeListener('end', onFinished)
+      .removeListener('close', onClose)
+
+    if (!err) {
+      try {
+        writer.end()
+      } catch (er) {
+        err = er
+      }
+    }
+
+    writer.destroy(err)
+
+    if (err && (err.code !== 'UND_ERR_INFO' || err.message !== 'reset')) {
+      util.destroy(body, err)
+    } else {
+      util.destroy(body)
+    }
+  }
+
+  body
+    .on('data', onData)
+    .on('end', onFinished)
+    .on('error', onFinished)
+    .on('close', onClose)
+
+  if (body.resume) {
+    body.resume()
+  }
+
+  socket
+    .on('drain', onDrain)
+    .on('error', onFinished)
+
+  if (body.errorEmitted ?? body.errored) {
+    setImmediate(() => onFinished(body.errored))
+  } else if (body.endEmitted ?? body.readableEnded) {
+    setImmediate(() => onFinished(null))
+  }
+
+  if (body.closeEmitted ?? body.closed) {
+    setImmediate(onClose)
+  }
+}
+
+function writeBuffer (abort, body, client, request, socket, contentLength, header, expectsPayload) {
+  try {
+    if (!body) {
+      if (contentLength === 0) {
+        socket.write(`${header}content-length: 0\r\n\r\n`, 'latin1')
+      } else {
+        assert(contentLength === null, 'no body must not have content length')
+        socket.write(`${header}\r\n`, 'latin1')
+      }
+    } else if (util.isBuffer(body)) {
+      assert(contentLength === body.byteLength, 'buffer body must have content length')
+
+      socket.cork()
+      socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1')
+      socket.write(body)
+      socket.uncork()
+      request.onBodySent(body)
+
+      if (!expectsPayload && request.reset !== false) {
+        socket[kReset] = true
+      }
+    }
+    request.onRequestSent()
+
+    client[kResume]()
+  } catch (err) {
+    abort(err)
+  }
+}
+
+async function writeBlob (abort, body, client, request, socket, contentLength, header, expectsPayload) {
+  assert(contentLength === body.size, 'blob body must have content length')
+
+  try {
+    if (contentLength != null && contentLength !== body.size) {
+      throw new RequestContentLengthMismatchError()
+    }
+
+    const buffer = Buffer.from(await body.arrayBuffer())
+
+    socket.cork()
+    socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1')
+    socket.write(buffer)
+    socket.uncork()
+
+    request.onBodySent(buffer)
+    request.onRequestSent()
+
+    if (!expectsPayload && request.reset !== false) {
+      socket[kReset] = true
+    }
+
+    client[kResume]()
+  } catch (err) {
+    abort(err)
+  }
+}
+
+async function writeIterable (abort, body, client, request, socket, contentLength, header, expectsPayload) {
+  assert(contentLength !== 0 || client[kRunning] === 0, 'iterator body cannot be pipelined')
+
+  let callback = null
+  function onDrain () {
+    if (callback) {
+      const cb = callback
+      callback = null
+      cb()
+    }
+  }
+
+  const waitForDrain = () => new Promise((resolve, reject) => {
+    assert(callback === null)
+
+    if (socket[kError]) {
+      reject(socket[kError])
+    } else {
+      callback = resolve
+    }
+  })
+
+  socket
+    .on('close', onDrain)
+    .on('drain', onDrain)
+
+  const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header })
+  try {
+    // It's up to the user to somehow abort the async iterable.
+    for await (const chunk of body) {
+      if (socket[kError]) {
+        throw socket[kError]
+      }
+
+      if (!writer.write(chunk)) {
+        await waitForDrain()
+      }
+    }
+
+    writer.end()
+  } catch (err) {
+    writer.destroy(err)
+  } finally {
+    socket
+      .off('close', onDrain)
+      .off('drain', onDrain)
+  }
+}
+
+class AsyncWriter {
+  constructor ({ abort, socket, request, contentLength, client, expectsPayload, header }) {
+    this.socket = socket
+    this.request = request
+    this.contentLength = contentLength
+    this.client = client
+    this.bytesWritten = 0
+    this.expectsPayload = expectsPayload
+    this.header = header
+    this.abort = abort
+
+    socket[kWriting] = true
+  }
+
+  write (chunk) {
+    const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this
+
+    if (socket[kError]) {
+      throw socket[kError]
+    }
+
+    if (socket.destroyed) {
+      return false
+    }
+
+    const len = Buffer.byteLength(chunk)
+    if (!len) {
+      return true
+    }
+
+    // We should defer writing chunks.
+    if (contentLength !== null && bytesWritten + len > contentLength) {
+      if (client[kStrictContentLength]) {
+        throw new RequestContentLengthMismatchError()
+      }
+
+      process.emitWarning(new RequestContentLengthMismatchError())
+    }
+
+    socket.cork()
+
+    if (bytesWritten === 0) {
+      if (!expectsPayload && request.reset !== false) {
+        socket[kReset] = true
+      }
+
+      if (contentLength === null) {
+        socket.write(`${header}transfer-encoding: chunked\r\n`, 'latin1')
+      } else {
+        socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1')
+      }
+    }
+
+    if (contentLength === null) {
+      socket.write(`\r\n${len.toString(16)}\r\n`, 'latin1')
+    }
+
+    this.bytesWritten += len
+
+    const ret = socket.write(chunk)
+
+    socket.uncork()
+
+    request.onBodySent(chunk)
+
+    if (!ret) {
+      if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
+        // istanbul ignore else: only for jest
+        if (socket[kParser].timeout.refresh) {
+          socket[kParser].timeout.refresh()
+        }
+      }
+    }
+
+    return ret
+  }
+
+  end () {
+    const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this
+    request.onRequestSent()
+
+    socket[kWriting] = false
+
+    if (socket[kError]) {
+      throw socket[kError]
+    }
+
+    if (socket.destroyed) {
+      return
+    }
+
+    if (bytesWritten === 0) {
+      if (expectsPayload) {
+        // https://tools.ietf.org/html/rfc7230#section-3.3.2
+        // A user agent SHOULD send a Content-Length in a request message when
+        // no Transfer-Encoding is sent and the request method defines a meaning
+        // for an enclosed payload body.
+
+        socket.write(`${header}content-length: 0\r\n\r\n`, 'latin1')
+      } else {
+        socket.write(`${header}\r\n`, 'latin1')
+      }
+    } else if (contentLength === null) {
+      socket.write('\r\n0\r\n\r\n', 'latin1')
+    }
+
+    if (contentLength !== null && bytesWritten !== contentLength) {
+      if (client[kStrictContentLength]) {
+        throw new RequestContentLengthMismatchError()
+      } else {
+        process.emitWarning(new RequestContentLengthMismatchError())
+      }
+    }
+
+    if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
+      // istanbul ignore else: only for jest
+      if (socket[kParser].timeout.refresh) {
+        socket[kParser].timeout.refresh()
+      }
+    }
+
+    client[kResume]()
+  }
+
+  destroy (err) {
+    const { socket, client, abort } = this
+
+    socket[kWriting] = false
+
+    if (err) {
+      assert(client[kRunning] <= 1, 'pipeline should only contain this request')
+      abort(err)
+    }
+  }
+}
+
+module.exports = connectH1
+
+
+/***/ }),
+
+/***/ 77162:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+const { pipeline } = __nccwpck_require__(84492)
+const util = __nccwpck_require__(94407)
+const {
+  RequestContentLengthMismatchError,
+  RequestAbortedError,
+  SocketError,
+  InformationalError
+} = __nccwpck_require__(22174)
+const {
+  kUrl,
+  kReset,
+  kClient,
+  kRunning,
+  kPending,
+  kQueue,
+  kPendingIdx,
+  kRunningIdx,
+  kError,
+  kSocket,
+  kStrictContentLength,
+  kOnError,
+  kMaxConcurrentStreams,
+  kHTTP2Session,
+  kResume,
+  kSize,
+  kHTTPContext
+} = __nccwpck_require__(5392)
+
+const kOpenStreams = Symbol('open streams')
+
+let extractBody
+
+// Experimental
+let h2ExperimentalWarned = false
+
+/** @type {import('http2')} */
+let http2
+try {
+  http2 = __nccwpck_require__(42725)
+} catch {
+  // @ts-ignore
+  http2 = { constants: {} }
+}
+
+const {
+  constants: {
+    HTTP2_HEADER_AUTHORITY,
+    HTTP2_HEADER_METHOD,
+    HTTP2_HEADER_PATH,
+    HTTP2_HEADER_SCHEME,
+    HTTP2_HEADER_CONTENT_LENGTH,
+    HTTP2_HEADER_EXPECT,
+    HTTP2_HEADER_STATUS
+  }
+} = http2
+
+function parseH2Headers (headers) {
+  const result = []
+
+  for (const [name, value] of Object.entries(headers)) {
+    // h2 may concat the header value by array
+    // e.g. Set-Cookie
+    if (Array.isArray(value)) {
+      for (const subvalue of value) {
+        // we need to provide each header value of header name
+        // because the headers handler expect name-value pair
+        result.push(Buffer.from(name), Buffer.from(subvalue))
+      }
+    } else {
+      result.push(Buffer.from(name), Buffer.from(value))
+    }
+  }
+
+  return result
+}
+
+async function connectH2 (client, socket) {
+  client[kSocket] = socket
+
+  if (!h2ExperimentalWarned) {
+    h2ExperimentalWarned = true
+    process.emitWarning('H2 support is experimental, expect them to change at any time.', {
+      code: 'UNDICI-H2'
+    })
+  }
+
+  const session = http2.connect(client[kUrl], {
+    createConnection: () => socket,
+    peerMaxConcurrentStreams: client[kMaxConcurrentStreams]
+  })
+
+  session[kOpenStreams] = 0
+  session[kClient] = client
+  session[kSocket] = socket
+
+  util.addListener(session, 'error', onHttp2SessionError)
+  util.addListener(session, 'frameError', onHttp2FrameError)
+  util.addListener(session, 'end', onHttp2SessionEnd)
+  util.addListener(session, 'goaway', onHTTP2GoAway)
+  util.addListener(session, 'close', function () {
+    const { [kClient]: client } = this
+    const { [kSocket]: socket } = client
+
+    const err = this[kSocket][kError] || this[kError] || new SocketError('closed', util.getSocketInfo(socket))
+
+    client[kHTTP2Session] = null
+
+    if (client.destroyed) {
+      assert(client[kPending] === 0)
+
+      // Fail entire queue.
+      const requests = client[kQueue].splice(client[kRunningIdx])
+      for (let i = 0; i < requests.length; i++) {
+        const request = requests[i]
+        util.errorRequest(client, request, err)
+      }
+    }
+  })
+
+  session.unref()
+
+  client[kHTTP2Session] = session
+  socket[kHTTP2Session] = session
+
+  util.addListener(socket, 'error', function (err) {
+    assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
+
+    this[kError] = err
+
+    this[kClient][kOnError](err)
+  })
+
+  util.addListener(socket, 'end', function () {
+    util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
+  })
+
+  util.addListener(socket, 'close', function () {
+    const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
+
+    client[kSocket] = null
+
+    if (this[kHTTP2Session] != null) {
+      this[kHTTP2Session].destroy(err)
+    }
+
+    client[kPendingIdx] = client[kRunningIdx]
+
+    assert(client[kRunning] === 0)
+
+    client.emit('disconnect', client[kUrl], [client], err)
+
+    client[kResume]()
+  })
+
+  let closed = false
+  socket.on('close', () => {
+    closed = true
+  })
+
+  return {
+    version: 'h2',
+    defaultPipelining: Infinity,
+    write (...args) {
+      return writeH2(client, ...args)
+    },
+    resume () {
+      resumeH2(client)
+    },
+    destroy (err, callback) {
+      if (closed) {
+        queueMicrotask(callback)
+      } else {
+        // Destroying the socket will trigger the session close
+        socket.destroy(err).on('close', callback)
+      }
+    },
+    get destroyed () {
+      return socket.destroyed
+    },
+    busy () {
+      return false
+    }
+  }
+}
+
+function resumeH2 (client) {
+  const socket = client[kSocket]
+
+  if (socket?.destroyed === false) {
+    if (client[kSize] === 0 && client[kMaxConcurrentStreams] === 0) {
+      socket.unref()
+      client[kHTTP2Session].unref()
+    } else {
+      socket.ref()
+      client[kHTTP2Session].ref()
+    }
+  }
+}
+
+function onHttp2SessionError (err) {
+  assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
+
+  this[kSocket][kError] = err
+  this[kClient][kOnError](err)
+}
+
+function onHttp2FrameError (type, code, id) {
+  if (id === 0) {
+    const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)
+    this[kSocket][kError] = err
+    this[kClient][kOnError](err)
+  }
+}
+
+function onHttp2SessionEnd () {
+  const err = new SocketError('other side closed', util.getSocketInfo(this[kSocket]))
+  this.destroy(err)
+  util.destroy(this[kSocket], err)
+}
+
+/**
+ * This is the root cause of #3011
+ * We need to handle GOAWAY frames properly, and trigger the session close
+ * along with the socket right away
+ */
+function onHTTP2GoAway (code) {
+  // We cannot recover, so best to close the session and the socket
+  const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${code}`, util.getSocketInfo(this))
+  const client = this[kClient]
+
+  client[kSocket] = null
+  client[kHTTPContext] = null
+
+  if (this[kHTTP2Session] != null) {
+    this[kHTTP2Session].destroy(err)
+    this[kHTTP2Session] = null
+  }
+
+  util.destroy(this[kSocket], err)
+
+  // Fail head of pipeline.
+  if (client[kRunningIdx] < client[kQueue].length) {
+    const request = client[kQueue][client[kRunningIdx]]
+    client[kQueue][client[kRunningIdx]++] = null
+    util.errorRequest(client, request, err)
+    client[kPendingIdx] = client[kRunningIdx]
+  }
+
+  assert(client[kRunning] === 0)
+
+  client.emit('disconnect', client[kUrl], [client], err)
+
+  client[kResume]()
+}
+
+// https://www.rfc-editor.org/rfc/rfc7230#section-3.3.2
+function shouldSendContentLength (method) {
+  return method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS' && method !== 'TRACE' && method !== 'CONNECT'
+}
+
+function writeH2 (client, request) {
+  const session = client[kHTTP2Session]
+  const { method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request
+  let { body } = request
+
+  if (upgrade) {
+    util.errorRequest(client, request, new Error('Upgrade not supported for H2'))
+    return false
+  }
+
+  const headers = {}
+  for (let n = 0; n < reqHeaders.length; n += 2) {
+    const key = reqHeaders[n + 0]
+    const val = reqHeaders[n + 1]
+
+    if (Array.isArray(val)) {
+      for (let i = 0; i < val.length; i++) {
+        if (headers[key]) {
+          headers[key] += `,${val[i]}`
+        } else {
+          headers[key] = val[i]
+        }
+      }
+    } else {
+      headers[key] = val
+    }
+  }
+
+  /** @type {import('node:http2').ClientHttp2Stream} */
+  let stream
+
+  const { hostname, port } = client[kUrl]
+
+  headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ''}`
+  headers[HTTP2_HEADER_METHOD] = method
+
+  const abort = (err) => {
+    if (request.aborted || request.completed) {
+      return
+    }
+
+    err = err || new RequestAbortedError()
+
+    util.errorRequest(client, request, err)
+
+    if (stream != null) {
+      util.destroy(stream, err)
+    }
+
+    // We do not destroy the socket as we can continue using the session
+    // the stream get's destroyed and the session remains to create new streams
+    util.destroy(body, err)
+    client[kQueue][client[kRunningIdx]++] = null
+    client[kResume]()
+  }
+
+  try {
+    // We are already connected, streams are pending.
+    // We can call on connect, and wait for abort
+    request.onConnect(abort)
+  } catch (err) {
+    util.errorRequest(client, request, err)
+  }
+
+  if (request.aborted) {
+    return false
+  }
+
+  if (method === 'CONNECT') {
+    session.ref()
+    // We are already connected, streams are pending, first request
+    // will create a new stream. We trigger a request to create the stream and wait until
+    // `ready` event is triggered
+    // We disabled endStream to allow the user to write to the stream
+    stream = session.request(headers, { endStream: false, signal })
+
+    if (stream.id && !stream.pending) {
+      request.onUpgrade(null, null, stream)
+      ++session[kOpenStreams]
+      client[kQueue][client[kRunningIdx]++] = null
+    } else {
+      stream.once('ready', () => {
+        request.onUpgrade(null, null, stream)
+        ++session[kOpenStreams]
+        client[kQueue][client[kRunningIdx]++] = null
+      })
+    }
+
+    stream.once('close', () => {
+      session[kOpenStreams] -= 1
+      if (session[kOpenStreams] === 0) session.unref()
+    })
+
+    return true
+  }
+
+  // https://tools.ietf.org/html/rfc7540#section-8.3
+  // :path and :scheme headers must be omitted when sending CONNECT
+
+  headers[HTTP2_HEADER_PATH] = path
+  headers[HTTP2_HEADER_SCHEME] = 'https'
+
+  // https://tools.ietf.org/html/rfc7231#section-4.3.1
+  // https://tools.ietf.org/html/rfc7231#section-4.3.2
+  // https://tools.ietf.org/html/rfc7231#section-4.3.5
+
+  // Sending a payload body on a request that does not
+  // expect it can cause undefined behavior on some
+  // servers and corrupt connection state. Do not
+  // re-use the connection for further requests.
+
+  const expectsPayload = (
+    method === 'PUT' ||
+    method === 'POST' ||
+    method === 'PATCH'
+  )
+
+  if (body && typeof body.read === 'function') {
+    // Try to read EOF in order to get length.
+    body.read(0)
+  }
+
+  let contentLength = util.bodyLength(body)
+
+  if (util.isFormDataLike(body)) {
+    extractBody ??= (__nccwpck_require__(23291).extractBody)
+
+    const [bodyStream, contentType] = extractBody(body)
+    headers['content-type'] = contentType
+
+    body = bodyStream.stream
+    contentLength = bodyStream.length
+  }
+
+  if (contentLength == null) {
+    contentLength = request.contentLength
+  }
+
+  if (contentLength === 0 || !expectsPayload) {
+    // https://tools.ietf.org/html/rfc7230#section-3.3.2
+    // A user agent SHOULD NOT send a Content-Length header field when
+    // the request message does not contain a payload body and the method
+    // semantics do not anticipate such a body.
+
+    contentLength = null
+  }
+
+  // https://github.com/nodejs/undici/issues/2046
+  // A user agent may send a Content-Length header with 0 value, this should be allowed.
+  if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) {
+    if (client[kStrictContentLength]) {
+      util.errorRequest(client, request, new RequestContentLengthMismatchError())
+      return false
+    }
+
+    process.emitWarning(new RequestContentLengthMismatchError())
+  }
+
+  if (contentLength != null) {
+    assert(body, 'no body must not have content length')
+    headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`
+  }
+
+  session.ref()
+
+  const shouldEndStream = method === 'GET' || method === 'HEAD' || body === null
+  if (expectContinue) {
+    headers[HTTP2_HEADER_EXPECT] = '100-continue'
+    stream = session.request(headers, { endStream: shouldEndStream, signal })
+
+    stream.once('continue', writeBodyH2)
+  } else {
+    stream = session.request(headers, {
+      endStream: shouldEndStream,
+      signal
+    })
+    writeBodyH2()
+  }
+
+  // Increment counter as we have new streams open
+  ++session[kOpenStreams]
+
+  stream.once('response', headers => {
+    const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers
+    request.onResponseStarted()
+
+    // Due to the stream nature, it is possible we face a race condition
+    // where the stream has been assigned, but the request has been aborted
+    // the request remains in-flight and headers hasn't been received yet
+    // for those scenarios, best effort is to destroy the stream immediately
+    // as there's no value to keep it open.
+    if (request.aborted) {
+      const err = new RequestAbortedError()
+      util.errorRequest(client, request, err)
+      util.destroy(stream, err)
+      return
+    }
+
+    if (request.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), '') === false) {
+      stream.pause()
+    }
+
+    stream.on('data', (chunk) => {
+      if (request.onData(chunk) === false) {
+        stream.pause()
+      }
+    })
+  })
+
+  stream.once('end', () => {
+    // When state is null, it means we haven't consumed body and the stream still do not have
+    // a state.
+    // Present specially when using pipeline or stream
+    if (stream.state?.state == null || stream.state.state < 6) {
+      request.onComplete([])
+    }
+
+    if (session[kOpenStreams] === 0) {
+      // Stream is closed or half-closed-remote (6), decrement counter and cleanup
+      // It does not have sense to continue working with the stream as we do not
+      // have yet RST_STREAM support on client-side
+
+      session.unref()
+    }
+
+    abort(new InformationalError('HTTP/2: stream half-closed (remote)'))
+    client[kQueue][client[kRunningIdx]++] = null
+    client[kPendingIdx] = client[kRunningIdx]
+    client[kResume]()
+  })
+
+  stream.once('close', () => {
+    session[kOpenStreams] -= 1
+    if (session[kOpenStreams] === 0) {
+      session.unref()
+    }
+  })
+
+  stream.once('error', function (err) {
+    abort(err)
+  })
+
+  stream.once('frameError', (type, code) => {
+    abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`))
+  })
+
+  // stream.on('aborted', () => {
+  //   // TODO(HTTP/2): Support aborted
+  // })
+
+  // stream.on('timeout', () => {
+  //   // TODO(HTTP/2): Support timeout
+  // })
+
+  // stream.on('push', headers => {
+  //   // TODO(HTTP/2): Support push
+  // })
+
+  // stream.on('trailers', headers => {
+  //   // TODO(HTTP/2): Support trailers
+  // })
+
+  return true
+
+  function writeBodyH2 () {
+    /* istanbul ignore else: assertion */
+    if (!body || contentLength === 0) {
+      writeBuffer(
+        abort,
+        stream,
+        null,
+        client,
+        request,
+        client[kSocket],
+        contentLength,
+        expectsPayload
+      )
+    } else if (util.isBuffer(body)) {
+      writeBuffer(
+        abort,
+        stream,
+        body,
+        client,
+        request,
+        client[kSocket],
+        contentLength,
+        expectsPayload
+      )
+    } else if (util.isBlobLike(body)) {
+      if (typeof body.stream === 'function') {
+        writeIterable(
+          abort,
+          stream,
+          body.stream(),
+          client,
+          request,
+          client[kSocket],
+          contentLength,
+          expectsPayload
+        )
+      } else {
+        writeBlob(
+          abort,
+          stream,
+          body,
+          client,
+          request,
+          client[kSocket],
+          contentLength,
+          expectsPayload
+        )
+      }
+    } else if (util.isStream(body)) {
+      writeStream(
+        abort,
+        client[kSocket],
+        expectsPayload,
+        stream,
+        body,
+        client,
+        request,
+        contentLength
+      )
+    } else if (util.isIterable(body)) {
+      writeIterable(
+        abort,
+        stream,
+        body,
+        client,
+        request,
+        client[kSocket],
+        contentLength,
+        expectsPayload
+      )
+    } else {
+      assert(false)
+    }
+  }
+}
+
+function writeBuffer (abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
+  try {
+    if (body != null && util.isBuffer(body)) {
+      assert(contentLength === body.byteLength, 'buffer body must have content length')
+      h2stream.cork()
+      h2stream.write(body)
+      h2stream.uncork()
+      h2stream.end()
+
+      request.onBodySent(body)
+    }
+
+    if (!expectsPayload) {
+      socket[kReset] = true
+    }
+
+    request.onRequestSent()
+    client[kResume]()
+  } catch (error) {
+    abort(error)
+  }
+}
+
+function writeStream (abort, socket, expectsPayload, h2stream, body, client, request, contentLength) {
+  assert(contentLength !== 0 || client[kRunning] === 0, 'stream body cannot be pipelined')
+
+  // For HTTP/2, is enough to pipe the stream
+  const pipe = pipeline(
+    body,
+    h2stream,
+    (err) => {
+      if (err) {
+        util.destroy(pipe, err)
+        abort(err)
+      } else {
+        util.removeAllListeners(pipe)
+        request.onRequestSent()
+
+        if (!expectsPayload) {
+          socket[kReset] = true
+        }
+
+        client[kResume]()
+      }
+    }
+  )
+
+  util.addListener(pipe, 'data', onPipeData)
+
+  function onPipeData (chunk) {
+    request.onBodySent(chunk)
+  }
+}
+
+async function writeBlob (abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
+  assert(contentLength === body.size, 'blob body must have content length')
+
+  try {
+    if (contentLength != null && contentLength !== body.size) {
+      throw new RequestContentLengthMismatchError()
+    }
+
+    const buffer = Buffer.from(await body.arrayBuffer())
+
+    h2stream.cork()
+    h2stream.write(buffer)
+    h2stream.uncork()
+    h2stream.end()
+
+    request.onBodySent(buffer)
+    request.onRequestSent()
+
+    if (!expectsPayload) {
+      socket[kReset] = true
+    }
+
+    client[kResume]()
+  } catch (err) {
+    abort(err)
+  }
+}
+
+async function writeIterable (abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
+  assert(contentLength !== 0 || client[kRunning] === 0, 'iterator body cannot be pipelined')
+
+  let callback = null
+  function onDrain () {
+    if (callback) {
+      const cb = callback
+      callback = null
+      cb()
+    }
+  }
+
+  const waitForDrain = () => new Promise((resolve, reject) => {
+    assert(callback === null)
+
+    if (socket[kError]) {
+      reject(socket[kError])
+    } else {
+      callback = resolve
+    }
+  })
+
+  h2stream
+    .on('close', onDrain)
+    .on('drain', onDrain)
+
+  try {
+    // It's up to the user to somehow abort the async iterable.
+    for await (const chunk of body) {
+      if (socket[kError]) {
+        throw socket[kError]
+      }
+
+      const res = h2stream.write(chunk)
+      request.onBodySent(chunk)
+      if (!res) {
+        await waitForDrain()
+      }
+    }
+
+    h2stream.end()
+
+    request.onRequestSent()
+
+    if (!expectsPayload) {
+      socket[kReset] = true
+    }
+
+    client[kResume]()
+  } catch (err) {
+    abort(err)
+  } finally {
+    h2stream
+      .off('close', onDrain)
+      .off('drain', onDrain)
+  }
+}
+
+module.exports = connectH2
+
+
+/***/ }),
+
+/***/ 6655:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// @ts-check
+
+
+
+const assert = __nccwpck_require__(98061)
+const net = __nccwpck_require__(87503)
+const http = __nccwpck_require__(88849)
+const util = __nccwpck_require__(94407)
+const { channels } = __nccwpck_require__(8627)
+const Request = __nccwpck_require__(25829)
+const DispatcherBase = __nccwpck_require__(68838)
+const {
+  InvalidArgumentError,
+  InformationalError,
+  ClientDestroyedError
+} = __nccwpck_require__(22174)
+const buildConnector = __nccwpck_require__(20123)
+const {
+  kUrl,
+  kServerName,
+  kClient,
+  kBusy,
+  kConnect,
+  kResuming,
+  kRunning,
+  kPending,
+  kSize,
+  kQueue,
+  kConnected,
+  kConnecting,
+  kNeedDrain,
+  kKeepAliveDefaultTimeout,
+  kHostHeader,
+  kPendingIdx,
+  kRunningIdx,
+  kError,
+  kPipelining,
+  kKeepAliveTimeoutValue,
+  kMaxHeadersSize,
+  kKeepAliveMaxTimeout,
+  kKeepAliveTimeoutThreshold,
+  kHeadersTimeout,
+  kBodyTimeout,
+  kStrictContentLength,
+  kConnector,
+  kMaxRedirections,
+  kMaxRequests,
+  kCounter,
+  kClose,
+  kDestroy,
+  kDispatch,
+  kInterceptors,
+  kLocalAddress,
+  kMaxResponseSize,
+  kOnError,
+  kHTTPContext,
+  kMaxConcurrentStreams,
+  kResume
+} = __nccwpck_require__(5392)
+const connectH1 = __nccwpck_require__(73619)
+const connectH2 = __nccwpck_require__(77162)
+let deprecatedInterceptorWarned = false
+
+const kClosedResolve = Symbol('kClosedResolve')
+
+const noop = () => {}
+
+function getPipelining (client) {
+  return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1
+}
+
+/**
+ * @type {import('../../types/client.js').default}
+ */
+class Client extends DispatcherBase {
+  /**
+   *
+   * @param {string|URL} url
+   * @param {import('../../types/client.js').Client.Options} options
+   */
+  constructor (url, {
+    interceptors,
+    maxHeaderSize,
+    headersTimeout,
+    socketTimeout,
+    requestTimeout,
+    connectTimeout,
+    bodyTimeout,
+    idleTimeout,
+    keepAlive,
+    keepAliveTimeout,
+    maxKeepAliveTimeout,
+    keepAliveMaxTimeout,
+    keepAliveTimeoutThreshold,
+    socketPath,
+    pipelining,
+    tls,
+    strictContentLength,
+    maxCachedSessions,
+    maxRedirections,
+    connect,
+    maxRequestsPerClient,
+    localAddress,
+    maxResponseSize,
+    autoSelectFamily,
+    autoSelectFamilyAttemptTimeout,
+    // h2
+    maxConcurrentStreams,
+    allowH2
+  } = {}) {
+    super()
+
+    if (keepAlive !== undefined) {
+      throw new InvalidArgumentError('unsupported keepAlive, use pipelining=0 instead')
+    }
+
+    if (socketTimeout !== undefined) {
+      throw new InvalidArgumentError('unsupported socketTimeout, use headersTimeout & bodyTimeout instead')
+    }
+
+    if (requestTimeout !== undefined) {
+      throw new InvalidArgumentError('unsupported requestTimeout, use headersTimeout & bodyTimeout instead')
+    }
+
+    if (idleTimeout !== undefined) {
+      throw new InvalidArgumentError('unsupported idleTimeout, use keepAliveTimeout instead')
+    }
+
+    if (maxKeepAliveTimeout !== undefined) {
+      throw new InvalidArgumentError('unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead')
+    }
+
+    if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) {
+      throw new InvalidArgumentError('invalid maxHeaderSize')
+    }
+
+    if (socketPath != null && typeof socketPath !== 'string') {
+      throw new InvalidArgumentError('invalid socketPath')
+    }
+
+    if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) {
+      throw new InvalidArgumentError('invalid connectTimeout')
+    }
+
+    if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) {
+      throw new InvalidArgumentError('invalid keepAliveTimeout')
+    }
+
+    if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) {
+      throw new InvalidArgumentError('invalid keepAliveMaxTimeout')
+    }
+
+    if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) {
+      throw new InvalidArgumentError('invalid keepAliveTimeoutThreshold')
+    }
+
+    if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) {
+      throw new InvalidArgumentError('headersTimeout must be a positive integer or zero')
+    }
+
+    if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) {
+      throw new InvalidArgumentError('bodyTimeout must be a positive integer or zero')
+    }
+
+    if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
+      throw new InvalidArgumentError('connect must be a function or an object')
+    }
+
+    if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
+      throw new InvalidArgumentError('maxRedirections must be a positive number')
+    }
+
+    if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
+      throw new InvalidArgumentError('maxRequestsPerClient must be a positive number')
+    }
+
+    if (localAddress != null && (typeof localAddress !== 'string' || net.isIP(localAddress) === 0)) {
+      throw new InvalidArgumentError('localAddress must be valid string IP address')
+    }
+
+    if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) {
+      throw new InvalidArgumentError('maxResponseSize must be a positive number')
+    }
+
+    if (
+      autoSelectFamilyAttemptTimeout != null &&
+      (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)
+    ) {
+      throw new InvalidArgumentError('autoSelectFamilyAttemptTimeout must be a positive number')
+    }
+
+    // h2
+    if (allowH2 != null && typeof allowH2 !== 'boolean') {
+      throw new InvalidArgumentError('allowH2 must be a valid boolean value')
+    }
+
+    if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== 'number' || maxConcurrentStreams < 1)) {
+      throw new InvalidArgumentError('maxConcurrentStreams must be a positive integer, greater than 0')
+    }
+
+    if (typeof connect !== 'function') {
+      connect = buildConnector({
+        ...tls,
+        maxCachedSessions,
+        allowH2,
+        socketPath,
+        timeout: connectTimeout,
+        ...(autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
+        ...connect
+      })
+    }
+
+    if (interceptors?.Client && Array.isArray(interceptors.Client)) {
+      this[kInterceptors] = interceptors.Client
+      if (!deprecatedInterceptorWarned) {
+        deprecatedInterceptorWarned = true
+        process.emitWarning('Client.Options#interceptor is deprecated. Use Dispatcher#compose instead.', {
+          code: 'UNDICI-CLIENT-INTERCEPTOR-DEPRECATED'
+        })
+      }
+    } else {
+      this[kInterceptors] = [createRedirectInterceptor({ maxRedirections })]
+    }
+
+    this[kUrl] = util.parseOrigin(url)
+    this[kConnector] = connect
+    this[kPipelining] = pipelining != null ? pipelining : 1
+    this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize
+    this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout
+    this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 600e3 : keepAliveMaxTimeout
+    this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 2e3 : keepAliveTimeoutThreshold
+    this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout]
+    this[kServerName] = null
+    this[kLocalAddress] = localAddress != null ? localAddress : null
+    this[kResuming] = 0 // 0, idle, 1, scheduled, 2 resuming
+    this[kNeedDrain] = 0 // 0, idle, 1, scheduled, 2 resuming
+    this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ''}\r\n`
+    this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 300e3
+    this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 300e3
+    this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength
+    this[kMaxRedirections] = maxRedirections
+    this[kMaxRequests] = maxRequestsPerClient
+    this[kClosedResolve] = null
+    this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1
+    this[kMaxConcurrentStreams] = maxConcurrentStreams != null ? maxConcurrentStreams : 100 // Max peerConcurrentStreams for a Node h2 server
+    this[kHTTPContext] = null
+
+    // kQueue is built up of 3 sections separated by
+    // the kRunningIdx and kPendingIdx indices.
+    // |   complete   |   running   |   pending   |
+    //                ^ kRunningIdx ^ kPendingIdx ^ kQueue.length
+    // kRunningIdx points to the first running element.
+    // kPendingIdx points to the first pending element.
+    // This implements a fast queue with an amortized
+    // time of O(1).
+
+    this[kQueue] = []
+    this[kRunningIdx] = 0
+    this[kPendingIdx] = 0
+
+    this[kResume] = (sync) => resume(this, sync)
+    this[kOnError] = (err) => onError(this, err)
+  }
+
+  get pipelining () {
+    return this[kPipelining]
+  }
+
+  set pipelining (value) {
+    this[kPipelining] = value
+    this[kResume](true)
+  }
+
+  get [kPending] () {
+    return this[kQueue].length - this[kPendingIdx]
+  }
+
+  get [kRunning] () {
+    return this[kPendingIdx] - this[kRunningIdx]
+  }
+
+  get [kSize] () {
+    return this[kQueue].length - this[kRunningIdx]
+  }
+
+  get [kConnected] () {
+    return !!this[kHTTPContext] && !this[kConnecting] && !this[kHTTPContext].destroyed
+  }
+
+  get [kBusy] () {
+    return Boolean(
+      this[kHTTPContext]?.busy(null) ||
+      (this[kSize] >= (getPipelining(this) || 1)) ||
+      this[kPending] > 0
+    )
+  }
+
+  /* istanbul ignore: only used for test */
+  [kConnect] (cb) {
+    connect(this)
+    this.once('connect', cb)
+  }
+
+  [kDispatch] (opts, handler) {
+    const origin = opts.origin || this[kUrl].origin
+    const request = new Request(origin, opts, handler)
+
+    this[kQueue].push(request)
+    if (this[kResuming]) {
+      // Do nothing.
+    } else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) {
+      // Wait a tick in case stream/iterator is ended in the same tick.
+      this[kResuming] = 1
+      queueMicrotask(() => resume(this))
+    } else {
+      this[kResume](true)
+    }
+
+    if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) {
+      this[kNeedDrain] = 2
+    }
+
+    return this[kNeedDrain] < 2
+  }
+
+  async [kClose] () {
+    // TODO: for H2 we need to gracefully flush the remaining enqueued
+    // request and close each stream.
+    return new Promise((resolve) => {
+      if (this[kSize]) {
+        this[kClosedResolve] = resolve
+      } else {
+        resolve(null)
+      }
+    })
+  }
+
+  async [kDestroy] (err) {
+    return new Promise((resolve) => {
+      const requests = this[kQueue].splice(this[kPendingIdx])
+      for (let i = 0; i < requests.length; i++) {
+        const request = requests[i]
+        util.errorRequest(this, request, err)
+      }
+
+      const callback = () => {
+        if (this[kClosedResolve]) {
+          // TODO (fix): Should we error here with ClientDestroyedError?
+          this[kClosedResolve]()
+          this[kClosedResolve] = null
+        }
+        resolve(null)
+      }
+
+      if (this[kHTTPContext]) {
+        this[kHTTPContext].destroy(err, callback)
+        this[kHTTPContext] = null
+      } else {
+        queueMicrotask(callback)
+      }
+
+      this[kResume]()
+    })
+  }
+}
+
+const createRedirectInterceptor = __nccwpck_require__(11115)
+
+function onError (client, err) {
+  if (
+    client[kRunning] === 0 &&
+    err.code !== 'UND_ERR_INFO' &&
+    err.code !== 'UND_ERR_SOCKET'
+  ) {
+    // Error is not caused by running request and not a recoverable
+    // socket error.
+
+    assert(client[kPendingIdx] === client[kRunningIdx])
+
+    const requests = client[kQueue].splice(client[kRunningIdx])
+
+    for (let i = 0; i < requests.length; i++) {
+      const request = requests[i]
+      util.errorRequest(client, request, err)
+    }
+    assert(client[kSize] === 0)
+  }
+}
+
+/**
+ * @param {Client} client
+ * @returns
+ */
+async function connect (client) {
+  assert(!client[kConnecting])
+  assert(!client[kHTTPContext])
+
+  let { host, hostname, protocol, port } = client[kUrl]
+
+  // Resolve ipv6
+  if (hostname[0] === '[') {
+    const idx = hostname.indexOf(']')
+
+    assert(idx !== -1)
+    const ip = hostname.substring(1, idx)
+
+    assert(net.isIP(ip))
+    hostname = ip
+  }
+
+  client[kConnecting] = true
+
+  if (channels.beforeConnect.hasSubscribers) {
+    channels.beforeConnect.publish({
+      connectParams: {
+        host,
+        hostname,
+        protocol,
+        port,
+        version: client[kHTTPContext]?.version,
+        servername: client[kServerName],
+        localAddress: client[kLocalAddress]
+      },
+      connector: client[kConnector]
+    })
+  }
+
+  try {
+    const socket = await new Promise((resolve, reject) => {
+      client[kConnector]({
+        host,
+        hostname,
+        protocol,
+        port,
+        servername: client[kServerName],
+        localAddress: client[kLocalAddress]
+      }, (err, socket) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(socket)
+        }
+      })
+    })
+
+    if (client.destroyed) {
+      util.destroy(socket.on('error', noop), new ClientDestroyedError())
+      return
+    }
+
+    assert(socket)
+
+    try {
+      client[kHTTPContext] = socket.alpnProtocol === 'h2'
+        ? await connectH2(client, socket)
+        : await connectH1(client, socket)
+    } catch (err) {
+      socket.destroy().on('error', noop)
+      throw err
+    }
+
+    client[kConnecting] = false
+
+    socket[kCounter] = 0
+    socket[kMaxRequests] = client[kMaxRequests]
+    socket[kClient] = client
+    socket[kError] = null
+
+    if (channels.connected.hasSubscribers) {
+      channels.connected.publish({
+        connectParams: {
+          host,
+          hostname,
+          protocol,
+          port,
+          version: client[kHTTPContext]?.version,
+          servername: client[kServerName],
+          localAddress: client[kLocalAddress]
+        },
+        connector: client[kConnector],
+        socket
+      })
+    }
+    client.emit('connect', client[kUrl], [client])
+  } catch (err) {
+    if (client.destroyed) {
+      return
+    }
+
+    client[kConnecting] = false
+
+    if (channels.connectError.hasSubscribers) {
+      channels.connectError.publish({
+        connectParams: {
+          host,
+          hostname,
+          protocol,
+          port,
+          version: client[kHTTPContext]?.version,
+          servername: client[kServerName],
+          localAddress: client[kLocalAddress]
+        },
+        connector: client[kConnector],
+        error: err
+      })
+    }
+
+    if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
+      assert(client[kRunning] === 0)
+      while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
+        const request = client[kQueue][client[kPendingIdx]++]
+        util.errorRequest(client, request, err)
+      }
+    } else {
+      onError(client, err)
+    }
+
+    client.emit('connectionError', client[kUrl], [client], err)
+  }
+
+  client[kResume]()
+}
+
+function emitDrain (client) {
+  client[kNeedDrain] = 0
+  client.emit('drain', client[kUrl], [client])
+}
+
+function resume (client, sync) {
+  if (client[kResuming] === 2) {
+    return
+  }
+
+  client[kResuming] = 2
+
+  _resume(client, sync)
+  client[kResuming] = 0
+
+  if (client[kRunningIdx] > 256) {
+    client[kQueue].splice(0, client[kRunningIdx])
+    client[kPendingIdx] -= client[kRunningIdx]
+    client[kRunningIdx] = 0
+  }
+}
+
+function _resume (client, sync) {
+  while (true) {
+    if (client.destroyed) {
+      assert(client[kPending] === 0)
+      return
+    }
+
+    if (client[kClosedResolve] && !client[kSize]) {
+      client[kClosedResolve]()
+      client[kClosedResolve] = null
+      return
+    }
+
+    if (client[kHTTPContext]) {
+      client[kHTTPContext].resume()
+    }
+
+    if (client[kBusy]) {
+      client[kNeedDrain] = 2
+    } else if (client[kNeedDrain] === 2) {
+      if (sync) {
+        client[kNeedDrain] = 1
+        queueMicrotask(() => emitDrain(client))
+      } else {
+        emitDrain(client)
+      }
+      continue
+    }
+
+    if (client[kPending] === 0) {
+      return
+    }
+
+    if (client[kRunning] >= (getPipelining(client) || 1)) {
+      return
+    }
+
+    const request = client[kQueue][client[kPendingIdx]]
+
+    if (client[kUrl].protocol === 'https:' && client[kServerName] !== request.servername) {
+      if (client[kRunning] > 0) {
+        return
+      }
+
+      client[kServerName] = request.servername
+      client[kHTTPContext]?.destroy(new InformationalError('servername changed'), () => {
+        client[kHTTPContext] = null
+        resume(client)
+      })
+    }
+
+    if (client[kConnecting]) {
+      return
+    }
+
+    if (!client[kHTTPContext]) {
+      connect(client)
+      return
+    }
+
+    if (client[kHTTPContext].destroyed) {
+      return
+    }
+
+    if (client[kHTTPContext].busy(request)) {
+      return
+    }
+
+    if (!request.aborted && client[kHTTPContext].write(request)) {
+      client[kPendingIdx]++
+    } else {
+      client[kQueue].splice(client[kPendingIdx], 1)
+    }
+  }
+}
+
+module.exports = Client
+
+
+/***/ }),
+
+/***/ 68838:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const Dispatcher = __nccwpck_require__(51927)
+const {
+  ClientDestroyedError,
+  ClientClosedError,
+  InvalidArgumentError
+} = __nccwpck_require__(22174)
+const { kDestroy, kClose, kClosed, kDestroyed, kDispatch, kInterceptors } = __nccwpck_require__(5392)
+
+const kOnDestroyed = Symbol('onDestroyed')
+const kOnClosed = Symbol('onClosed')
+const kInterceptedDispatch = Symbol('Intercepted Dispatch')
+
+class DispatcherBase extends Dispatcher {
+  constructor () {
+    super()
+
+    this[kDestroyed] = false
+    this[kOnDestroyed] = null
+    this[kClosed] = false
+    this[kOnClosed] = []
+  }
+
+  get destroyed () {
+    return this[kDestroyed]
+  }
+
+  get closed () {
+    return this[kClosed]
+  }
+
+  get interceptors () {
+    return this[kInterceptors]
+  }
+
+  set interceptors (newInterceptors) {
+    if (newInterceptors) {
+      for (let i = newInterceptors.length - 1; i >= 0; i--) {
+        const interceptor = this[kInterceptors][i]
+        if (typeof interceptor !== 'function') {
+          throw new InvalidArgumentError('interceptor must be an function')
+        }
+      }
+    }
+
+    this[kInterceptors] = newInterceptors
+  }
+
+  close (callback) {
+    if (callback === undefined) {
+      return new Promise((resolve, reject) => {
+        this.close((err, data) => {
+          return err ? reject(err) : resolve(data)
+        })
+      })
+    }
+
+    if (typeof callback !== 'function') {
+      throw new InvalidArgumentError('invalid callback')
+    }
+
+    if (this[kDestroyed]) {
+      queueMicrotask(() => callback(new ClientDestroyedError(), null))
+      return
+    }
+
+    if (this[kClosed]) {
+      if (this[kOnClosed]) {
+        this[kOnClosed].push(callback)
+      } else {
+        queueMicrotask(() => callback(null, null))
+      }
+      return
+    }
+
+    this[kClosed] = true
+    this[kOnClosed].push(callback)
+
+    const onClosed = () => {
+      const callbacks = this[kOnClosed]
+      this[kOnClosed] = null
+      for (let i = 0; i < callbacks.length; i++) {
+        callbacks[i](null, null)
+      }
+    }
+
+    // Should not error.
+    this[kClose]()
+      .then(() => this.destroy())
+      .then(() => {
+        queueMicrotask(onClosed)
+      })
+  }
+
+  destroy (err, callback) {
+    if (typeof err === 'function') {
+      callback = err
+      err = null
+    }
+
+    if (callback === undefined) {
+      return new Promise((resolve, reject) => {
+        this.destroy(err, (err, data) => {
+          return err ? /* istanbul ignore next: should never error */ reject(err) : resolve(data)
+        })
+      })
+    }
+
+    if (typeof callback !== 'function') {
+      throw new InvalidArgumentError('invalid callback')
+    }
+
+    if (this[kDestroyed]) {
+      if (this[kOnDestroyed]) {
+        this[kOnDestroyed].push(callback)
+      } else {
+        queueMicrotask(() => callback(null, null))
+      }
+      return
+    }
+
+    if (!err) {
+      err = new ClientDestroyedError()
+    }
+
+    this[kDestroyed] = true
+    this[kOnDestroyed] = this[kOnDestroyed] || []
+    this[kOnDestroyed].push(callback)
+
+    const onDestroyed = () => {
+      const callbacks = this[kOnDestroyed]
+      this[kOnDestroyed] = null
+      for (let i = 0; i < callbacks.length; i++) {
+        callbacks[i](null, null)
+      }
+    }
+
+    // Should not error.
+    this[kDestroy](err).then(() => {
+      queueMicrotask(onDestroyed)
+    })
+  }
+
+  [kInterceptedDispatch] (opts, handler) {
+    if (!this[kInterceptors] || this[kInterceptors].length === 0) {
+      this[kInterceptedDispatch] = this[kDispatch]
+      return this[kDispatch](opts, handler)
+    }
+
+    let dispatch = this[kDispatch].bind(this)
+    for (let i = this[kInterceptors].length - 1; i >= 0; i--) {
+      dispatch = this[kInterceptors][i](dispatch)
+    }
+    this[kInterceptedDispatch] = dispatch
+    return dispatch(opts, handler)
+  }
+
+  dispatch (opts, handler) {
+    if (!handler || typeof handler !== 'object') {
+      throw new InvalidArgumentError('handler must be an object')
+    }
+
+    try {
+      if (!opts || typeof opts !== 'object') {
+        throw new InvalidArgumentError('opts must be an object.')
+      }
+
+      if (this[kDestroyed] || this[kOnDestroyed]) {
+        throw new ClientDestroyedError()
+      }
+
+      if (this[kClosed]) {
+        throw new ClientClosedError()
+      }
+
+      return this[kInterceptedDispatch](opts, handler)
+    } catch (err) {
+      if (typeof handler.onError !== 'function') {
+        throw new InvalidArgumentError('invalid onError method')
+      }
+
+      handler.onError(err)
+
+      return false
+    }
+  }
+}
+
+module.exports = DispatcherBase
+
+
+/***/ }),
+
+/***/ 51927:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const EventEmitter = __nccwpck_require__(15673)
+
+class Dispatcher extends EventEmitter {
+  dispatch () {
+    throw new Error('not implemented')
+  }
+
+  close () {
+    throw new Error('not implemented')
+  }
+
+  destroy () {
+    throw new Error('not implemented')
+  }
+
+  compose (...args) {
+    // So we handle [interceptor1, interceptor2] or interceptor1, interceptor2, ...
+    const interceptors = Array.isArray(args[0]) ? args[0] : args
+    let dispatch = this.dispatch.bind(this)
+
+    for (const interceptor of interceptors) {
+      if (interceptor == null) {
+        continue
+      }
+
+      if (typeof interceptor !== 'function') {
+        throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`)
+      }
+
+      dispatch = interceptor(dispatch)
+
+      if (dispatch == null || typeof dispatch !== 'function' || dispatch.length !== 2) {
+        throw new TypeError('invalid interceptor')
+      }
+    }
+
+    return new ComposedDispatcher(this, dispatch)
+  }
+}
+
+class ComposedDispatcher extends Dispatcher {
+  #dispatcher = null
+  #dispatch = null
+
+  constructor (dispatcher, dispatch) {
+    super()
+    this.#dispatcher = dispatcher
+    this.#dispatch = dispatch
+  }
+
+  dispatch (...args) {
+    this.#dispatch(...args)
+  }
+
+  close (...args) {
+    return this.#dispatcher.close(...args)
+  }
+
+  destroy (...args) {
+    return this.#dispatcher.destroy(...args)
+  }
+}
+
+module.exports = Dispatcher
+
+
+/***/ }),
+
+/***/ 4803:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const DispatcherBase = __nccwpck_require__(68838)
+const { kClose, kDestroy, kClosed, kDestroyed, kDispatch, kNoProxyAgent, kHttpProxyAgent, kHttpsProxyAgent } = __nccwpck_require__(5392)
+const ProxyAgent = __nccwpck_require__(54372)
+const Agent = __nccwpck_require__(83421)
+
+const DEFAULT_PORTS = {
+  'http:': 80,
+  'https:': 443
+}
+
+let experimentalWarned = false
+
+class EnvHttpProxyAgent extends DispatcherBase {
+  #noProxyValue = null
+  #noProxyEntries = null
+  #opts = null
+
+  constructor (opts = {}) {
+    super()
+    this.#opts = opts
+
+    if (!experimentalWarned) {
+      experimentalWarned = true
+      process.emitWarning('EnvHttpProxyAgent is experimental, expect them to change at any time.', {
+        code: 'UNDICI-EHPA'
+      })
+    }
+
+    const { httpProxy, httpsProxy, noProxy, ...agentOpts } = opts
+
+    this[kNoProxyAgent] = new Agent(agentOpts)
+
+    const HTTP_PROXY = httpProxy ?? process.env.http_proxy ?? process.env.HTTP_PROXY
+    if (HTTP_PROXY) {
+      this[kHttpProxyAgent] = new ProxyAgent({ ...agentOpts, uri: HTTP_PROXY })
+    } else {
+      this[kHttpProxyAgent] = this[kNoProxyAgent]
+    }
+
+    const HTTPS_PROXY = httpsProxy ?? process.env.https_proxy ?? process.env.HTTPS_PROXY
+    if (HTTPS_PROXY) {
+      this[kHttpsProxyAgent] = new ProxyAgent({ ...agentOpts, uri: HTTPS_PROXY })
+    } else {
+      this[kHttpsProxyAgent] = this[kHttpProxyAgent]
+    }
+
+    this.#parseNoProxy()
+  }
+
+  [kDispatch] (opts, handler) {
+    const url = new URL(opts.origin)
+    const agent = this.#getProxyAgentForUrl(url)
+    return agent.dispatch(opts, handler)
+  }
+
+  async [kClose] () {
+    await this[kNoProxyAgent].close()
+    if (!this[kHttpProxyAgent][kClosed]) {
+      await this[kHttpProxyAgent].close()
+    }
+    if (!this[kHttpsProxyAgent][kClosed]) {
+      await this[kHttpsProxyAgent].close()
+    }
+  }
+
+  async [kDestroy] (err) {
+    await this[kNoProxyAgent].destroy(err)
+    if (!this[kHttpProxyAgent][kDestroyed]) {
+      await this[kHttpProxyAgent].destroy(err)
+    }
+    if (!this[kHttpsProxyAgent][kDestroyed]) {
+      await this[kHttpsProxyAgent].destroy(err)
+    }
+  }
+
+  #getProxyAgentForUrl (url) {
+    let { protocol, host: hostname, port } = url
+
+    // Stripping ports in this way instead of using parsedUrl.hostname to make
+    // sure that the brackets around IPv6 addresses are kept.
+    hostname = hostname.replace(/:\d*$/, '').toLowerCase()
+    port = Number.parseInt(port, 10) || DEFAULT_PORTS[protocol] || 0
+    if (!this.#shouldProxy(hostname, port)) {
+      return this[kNoProxyAgent]
+    }
+    if (protocol === 'https:') {
+      return this[kHttpsProxyAgent]
+    }
+    return this[kHttpProxyAgent]
+  }
+
+  #shouldProxy (hostname, port) {
+    if (this.#noProxyChanged) {
+      this.#parseNoProxy()
+    }
+
+    if (this.#noProxyEntries.length === 0) {
+      return true // Always proxy if NO_PROXY is not set or empty.
+    }
+    if (this.#noProxyValue === '*') {
+      return false // Never proxy if wildcard is set.
+    }
+
+    for (let i = 0; i < this.#noProxyEntries.length; i++) {
+      const entry = this.#noProxyEntries[i]
+      if (entry.port && entry.port !== port) {
+        continue // Skip if ports don't match.
+      }
+      if (!/^[.*]/.test(entry.hostname)) {
+        // No wildcards, so don't proxy only if there is not an exact match.
+        if (hostname === entry.hostname) {
+          return false
+        }
+      } else {
+        // Don't proxy if the hostname ends with the no_proxy host.
+        if (hostname.endsWith(entry.hostname.replace(/^\*/, ''))) {
+          return false
+        }
+      }
+    }
+
+    return true
+  }
+
+  #parseNoProxy () {
+    const noProxyValue = this.#opts.noProxy ?? this.#noProxyEnv
+    const noProxySplit = noProxyValue.split(/[,\s]/)
+    const noProxyEntries = []
+
+    for (let i = 0; i < noProxySplit.length; i++) {
+      const entry = noProxySplit[i]
+      if (!entry) {
+        continue
+      }
+      const parsed = entry.match(/^(.+):(\d+)$/)
+      noProxyEntries.push({
+        hostname: (parsed ? parsed[1] : entry).toLowerCase(),
+        port: parsed ? Number.parseInt(parsed[2], 10) : 0
+      })
+    }
+
+    this.#noProxyValue = noProxyValue
+    this.#noProxyEntries = noProxyEntries
+  }
+
+  get #noProxyChanged () {
+    if (this.#opts.noProxy !== undefined) {
+      return false
+    }
+    return this.#noProxyValue !== this.#noProxyEnv
+  }
+
+  get #noProxyEnv () {
+    return process.env.no_proxy ?? process.env.NO_PROXY ?? ''
+  }
+}
+
+module.exports = EnvHttpProxyAgent
+
+
+/***/ }),
+
+/***/ 82285:
+/***/ ((module) => {
+
+"use strict";
+/* eslint-disable */
+
+
+
+// Extracted from node/lib/internal/fixed_queue.js
+
+// Currently optimal queue size, tested on V8 6.0 - 6.6. Must be power of two.
+const kSize = 2048;
+const kMask = kSize - 1;
+
+// The FixedQueue is implemented as a singly-linked list of fixed-size
+// circular buffers. It looks something like this:
+//
+//  head                                                       tail
+//    |                                                          |
+//    v                                                          v
+// +-----------+ <-----\       +-----------+ <------\         +-----------+
+// |  [null]   |        \----- |   next    |         \------- |   next    |
+// +-----------+               +-----------+                  +-----------+
+// |   item    | <-- bottom    |   item    | <-- bottom       |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |       bottom --> |   item    |
+// |   item    |               |   item    |                  |   item    |
+// |    ...    |               |    ...    |                  |    ...    |
+// |   item    |               |   item    |                  |   item    |
+// |   item    |               |   item    |                  |   item    |
+// |  [empty]  | <-- top       |   item    |                  |   item    |
+// |  [empty]  |               |   item    |                  |   item    |
+// |  [empty]  |               |  [empty]  | <-- top  top --> |  [empty]  |
+// +-----------+               +-----------+                  +-----------+
+//
+// Or, if there is only one circular buffer, it looks something
+// like either of these:
+//
+//  head   tail                                 head   tail
+//    |     |                                     |     |
+//    v     v                                     v     v
+// +-----------+                               +-----------+
+// |  [null]   |                               |  [null]   |
+// +-----------+                               +-----------+
+// |  [empty]  |                               |   item    |
+// |  [empty]  |                               |   item    |
+// |   item    | <-- bottom            top --> |  [empty]  |
+// |   item    |                               |  [empty]  |
+// |  [empty]  | <-- top            bottom --> |   item    |
+// |  [empty]  |                               |   item    |
+// +-----------+                               +-----------+
+//
+// Adding a value means moving `top` forward by one, removing means
+// moving `bottom` forward by one. After reaching the end, the queue
+// wraps around.
+//
+// When `top === bottom` the current queue is empty and when
+// `top + 1 === bottom` it's full. This wastes a single space of storage
+// but allows much quicker checks.
+
+class FixedCircularBuffer {
+  constructor() {
+    this.bottom = 0;
+    this.top = 0;
+    this.list = new Array(kSize);
+    this.next = null;
+  }
+
+  isEmpty() {
+    return this.top === this.bottom;
+  }
+
+  isFull() {
+    return ((this.top + 1) & kMask) === this.bottom;
+  }
+
+  push(data) {
+    this.list[this.top] = data;
+    this.top = (this.top + 1) & kMask;
+  }
+
+  shift() {
+    const nextItem = this.list[this.bottom];
+    if (nextItem === undefined)
+      return null;
+    this.list[this.bottom] = undefined;
+    this.bottom = (this.bottom + 1) & kMask;
+    return nextItem;
+  }
+}
+
+module.exports = class FixedQueue {
+  constructor() {
+    this.head = this.tail = new FixedCircularBuffer();
+  }
+
+  isEmpty() {
+    return this.head.isEmpty();
+  }
+
+  push(data) {
+    if (this.head.isFull()) {
+      // Head is full: Creates a new queue, sets the old queue's `.next` to it,
+      // and sets it as the new main queue.
+      this.head = this.head.next = new FixedCircularBuffer();
+    }
+    this.head.push(data);
+  }
+
+  shift() {
+    const tail = this.tail;
+    const next = tail.shift();
+    if (tail.isEmpty() && tail.next !== null) {
+      // If there is another queue, it forms the new tail.
+      this.tail = tail.next;
+    }
+    return next;
+  }
+};
+
+
+/***/ }),
+
+/***/ 37128:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const DispatcherBase = __nccwpck_require__(68838)
+const FixedQueue = __nccwpck_require__(82285)
+const { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = __nccwpck_require__(5392)
+const PoolStats = __nccwpck_require__(28292)
+
+const kClients = Symbol('clients')
+const kNeedDrain = Symbol('needDrain')
+const kQueue = Symbol('queue')
+const kClosedResolve = Symbol('closed resolve')
+const kOnDrain = Symbol('onDrain')
+const kOnConnect = Symbol('onConnect')
+const kOnDisconnect = Symbol('onDisconnect')
+const kOnConnectionError = Symbol('onConnectionError')
+const kGetDispatcher = Symbol('get dispatcher')
+const kAddClient = Symbol('add client')
+const kRemoveClient = Symbol('remove client')
+const kStats = Symbol('stats')
+
+class PoolBase extends DispatcherBase {
+  constructor () {
+    super()
+
+    this[kQueue] = new FixedQueue()
+    this[kClients] = []
+    this[kQueued] = 0
+
+    const pool = this
+
+    this[kOnDrain] = function onDrain (origin, targets) {
+      const queue = pool[kQueue]
+
+      let needDrain = false
+
+      while (!needDrain) {
+        const item = queue.shift()
+        if (!item) {
+          break
+        }
+        pool[kQueued]--
+        needDrain = !this.dispatch(item.opts, item.handler)
+      }
+
+      this[kNeedDrain] = needDrain
+
+      if (!this[kNeedDrain] && pool[kNeedDrain]) {
+        pool[kNeedDrain] = false
+        pool.emit('drain', origin, [pool, ...targets])
+      }
+
+      if (pool[kClosedResolve] && queue.isEmpty()) {
+        Promise
+          .all(pool[kClients].map(c => c.close()))
+          .then(pool[kClosedResolve])
+      }
+    }
+
+    this[kOnConnect] = (origin, targets) => {
+      pool.emit('connect', origin, [pool, ...targets])
+    }
+
+    this[kOnDisconnect] = (origin, targets, err) => {
+      pool.emit('disconnect', origin, [pool, ...targets], err)
+    }
+
+    this[kOnConnectionError] = (origin, targets, err) => {
+      pool.emit('connectionError', origin, [pool, ...targets], err)
+    }
+
+    this[kStats] = new PoolStats(this)
+  }
+
+  get [kBusy] () {
+    return this[kNeedDrain]
+  }
+
+  get [kConnected] () {
+    return this[kClients].filter(client => client[kConnected]).length
+  }
+
+  get [kFree] () {
+    return this[kClients].filter(client => client[kConnected] && !client[kNeedDrain]).length
+  }
+
+  get [kPending] () {
+    let ret = this[kQueued]
+    for (const { [kPending]: pending } of this[kClients]) {
+      ret += pending
+    }
+    return ret
+  }
+
+  get [kRunning] () {
+    let ret = 0
+    for (const { [kRunning]: running } of this[kClients]) {
+      ret += running
+    }
+    return ret
+  }
+
+  get [kSize] () {
+    let ret = this[kQueued]
+    for (const { [kSize]: size } of this[kClients]) {
+      ret += size
+    }
+    return ret
+  }
+
+  get stats () {
+    return this[kStats]
+  }
+
+  async [kClose] () {
+    if (this[kQueue].isEmpty()) {
+      await Promise.all(this[kClients].map(c => c.close()))
+    } else {
+      await new Promise((resolve) => {
+        this[kClosedResolve] = resolve
+      })
+    }
+  }
+
+  async [kDestroy] (err) {
+    while (true) {
+      const item = this[kQueue].shift()
+      if (!item) {
+        break
+      }
+      item.handler.onError(err)
+    }
+
+    await Promise.all(this[kClients].map(c => c.destroy(err)))
+  }
+
+  [kDispatch] (opts, handler) {
+    const dispatcher = this[kGetDispatcher]()
+
+    if (!dispatcher) {
+      this[kNeedDrain] = true
+      this[kQueue].push({ opts, handler })
+      this[kQueued]++
+    } else if (!dispatcher.dispatch(opts, handler)) {
+      dispatcher[kNeedDrain] = true
+      this[kNeedDrain] = !this[kGetDispatcher]()
+    }
+
+    return !this[kNeedDrain]
+  }
+
+  [kAddClient] (client) {
+    client
+      .on('drain', this[kOnDrain])
+      .on('connect', this[kOnConnect])
+      .on('disconnect', this[kOnDisconnect])
+      .on('connectionError', this[kOnConnectionError])
+
+    this[kClients].push(client)
+
+    if (this[kNeedDrain]) {
+      queueMicrotask(() => {
+        if (this[kNeedDrain]) {
+          this[kOnDrain](client[kUrl], [this, client])
+        }
+      })
+    }
+
+    return this
+  }
+
+  [kRemoveClient] (client) {
+    client.close(() => {
+      const idx = this[kClients].indexOf(client)
+      if (idx !== -1) {
+        this[kClients].splice(idx, 1)
+      }
+    })
+
+    this[kNeedDrain] = this[kClients].some(dispatcher => (
+      !dispatcher[kNeedDrain] &&
+      dispatcher.closed !== true &&
+      dispatcher.destroyed !== true
+    ))
+  }
+}
+
+module.exports = {
+  PoolBase,
+  kClients,
+  kNeedDrain,
+  kAddClient,
+  kRemoveClient,
+  kGetDispatcher
+}
+
+
+/***/ }),
+
+/***/ 28292:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+const { kFree, kConnected, kPending, kQueued, kRunning, kSize } = __nccwpck_require__(5392)
+const kPool = Symbol('pool')
+
+class PoolStats {
+  constructor (pool) {
+    this[kPool] = pool
+  }
+
+  get connected () {
+    return this[kPool][kConnected]
+  }
+
+  get free () {
+    return this[kPool][kFree]
+  }
+
+  get pending () {
+    return this[kPool][kPending]
+  }
+
+  get queued () {
+    return this[kPool][kQueued]
+  }
+
+  get running () {
+    return this[kPool][kRunning]
+  }
+
+  get size () {
+    return this[kPool][kSize]
+  }
+}
+
+module.exports = PoolStats
+
+
+/***/ }),
+
+/***/ 11795:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  PoolBase,
+  kClients,
+  kNeedDrain,
+  kAddClient,
+  kGetDispatcher
+} = __nccwpck_require__(37128)
+const Client = __nccwpck_require__(6655)
+const {
+  InvalidArgumentError
+} = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { kUrl, kInterceptors } = __nccwpck_require__(5392)
+const buildConnector = __nccwpck_require__(20123)
+
+const kOptions = Symbol('options')
+const kConnections = Symbol('connections')
+const kFactory = Symbol('factory')
+
+function defaultFactory (origin, opts) {
+  return new Client(origin, opts)
+}
+
+class Pool extends PoolBase {
+  constructor (origin, {
+    connections,
+    factory = defaultFactory,
+    connect,
+    connectTimeout,
+    tls,
+    maxCachedSessions,
+    socketPath,
+    autoSelectFamily,
+    autoSelectFamilyAttemptTimeout,
+    allowH2,
+    ...options
+  } = {}) {
+    super()
+
+    if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
+      throw new InvalidArgumentError('invalid connections')
+    }
+
+    if (typeof factory !== 'function') {
+      throw new InvalidArgumentError('factory must be a function.')
+    }
+
+    if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
+      throw new InvalidArgumentError('connect must be a function or an object')
+    }
+
+    if (typeof connect !== 'function') {
+      connect = buildConnector({
+        ...tls,
+        maxCachedSessions,
+        allowH2,
+        socketPath,
+        timeout: connectTimeout,
+        ...(autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
+        ...connect
+      })
+    }
+
+    this[kInterceptors] = options.interceptors?.Pool && Array.isArray(options.interceptors.Pool)
+      ? options.interceptors.Pool
+      : []
+    this[kConnections] = connections || null
+    this[kUrl] = util.parseOrigin(origin)
+    this[kOptions] = { ...util.deepClone(options), connect, allowH2 }
+    this[kOptions].interceptors = options.interceptors
+      ? { ...options.interceptors }
+      : undefined
+    this[kFactory] = factory
+
+    this.on('connectionError', (origin, targets, error) => {
+      // If a connection error occurs, we remove the client from the pool,
+      // and emit a connectionError event. They will not be re-used.
+      // Fixes https://github.com/nodejs/undici/issues/3895
+      for (const target of targets) {
+        // Do not use kRemoveClient here, as it will close the client,
+        // but the client cannot be closed in this state.
+        const idx = this[kClients].indexOf(target)
+        if (idx !== -1) {
+          this[kClients].splice(idx, 1)
+        }
+      }
+    })
+  }
+
+  [kGetDispatcher] () {
+    for (const client of this[kClients]) {
+      if (!client[kNeedDrain]) {
+        return client
+      }
+    }
+
+    if (!this[kConnections] || this[kClients].length < this[kConnections]) {
+      const dispatcher = this[kFactory](this[kUrl], this[kOptions])
+      this[kAddClient](dispatcher)
+      return dispatcher
+    }
+  }
+}
+
+module.exports = Pool
+
+
+/***/ }),
+
+/***/ 54372:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kProxy, kClose, kDestroy, kDispatch, kInterceptors } = __nccwpck_require__(5392)
+const { URL } = __nccwpck_require__(41041)
+const Agent = __nccwpck_require__(83421)
+const Pool = __nccwpck_require__(11795)
+const DispatcherBase = __nccwpck_require__(68838)
+const { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = __nccwpck_require__(22174)
+const buildConnector = __nccwpck_require__(20123)
+const Client = __nccwpck_require__(6655)
+
+const kAgent = Symbol('proxy agent')
+const kClient = Symbol('proxy client')
+const kProxyHeaders = Symbol('proxy headers')
+const kRequestTls = Symbol('request tls settings')
+const kProxyTls = Symbol('proxy tls settings')
+const kConnectEndpoint = Symbol('connect endpoint function')
+const kTunnelProxy = Symbol('tunnel proxy')
+
+function defaultProtocolPort (protocol) {
+  return protocol === 'https:' ? 443 : 80
+}
+
+function defaultFactory (origin, opts) {
+  return new Pool(origin, opts)
+}
+
+const noop = () => {}
+
+function defaultAgentFactory (origin, opts) {
+  if (opts.connections === 1) {
+    return new Client(origin, opts)
+  }
+  return new Pool(origin, opts)
+}
+
+class Http1ProxyWrapper extends DispatcherBase {
+  #client
+
+  constructor (proxyUrl, { headers = {}, connect, factory }) {
+    super()
+    if (!proxyUrl) {
+      throw new InvalidArgumentError('Proxy URL is mandatory')
+    }
+
+    this[kProxyHeaders] = headers
+    if (factory) {
+      this.#client = factory(proxyUrl, { connect })
+    } else {
+      this.#client = new Client(proxyUrl, { connect })
+    }
+  }
+
+  [kDispatch] (opts, handler) {
+    const onHeaders = handler.onHeaders
+    handler.onHeaders = function (statusCode, data, resume) {
+      if (statusCode === 407) {
+        if (typeof handler.onError === 'function') {
+          handler.onError(new InvalidArgumentError('Proxy Authentication Required (407)'))
+        }
+        return
+      }
+      if (onHeaders) onHeaders.call(this, statusCode, data, resume)
+    }
+
+    // Rewrite request as an HTTP1 Proxy request, without tunneling.
+    const {
+      origin,
+      path = '/',
+      headers = {}
+    } = opts
+
+    opts.path = origin + path
+
+    if (!('host' in headers) && !('Host' in headers)) {
+      const { host } = new URL(origin)
+      headers.host = host
+    }
+    opts.headers = { ...this[kProxyHeaders], ...headers }
+
+    return this.#client[kDispatch](opts, handler)
+  }
+
+  async [kClose] () {
+    return this.#client.close()
+  }
+
+  async [kDestroy] (err) {
+    return this.#client.destroy(err)
+  }
+}
+
+class ProxyAgent extends DispatcherBase {
+  constructor (opts) {
+    super()
+
+    if (!opts || (typeof opts === 'object' && !(opts instanceof URL) && !opts.uri)) {
+      throw new InvalidArgumentError('Proxy uri is mandatory')
+    }
+
+    const { clientFactory = defaultFactory } = opts
+    if (typeof clientFactory !== 'function') {
+      throw new InvalidArgumentError('Proxy opts.clientFactory must be a function.')
+    }
+
+    const { proxyTunnel = true } = opts
+
+    const url = this.#getUrl(opts)
+    const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url
+
+    this[kProxy] = { uri: href, protocol }
+    this[kInterceptors] = opts.interceptors?.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent)
+      ? opts.interceptors.ProxyAgent
+      : []
+    this[kRequestTls] = opts.requestTls
+    this[kProxyTls] = opts.proxyTls
+    this[kProxyHeaders] = opts.headers || {}
+    this[kTunnelProxy] = proxyTunnel
+
+    if (opts.auth && opts.token) {
+      throw new InvalidArgumentError('opts.auth cannot be used in combination with opts.token')
+    } else if (opts.auth) {
+      /* @deprecated in favour of opts.token */
+      this[kProxyHeaders]['proxy-authorization'] = `Basic ${opts.auth}`
+    } else if (opts.token) {
+      this[kProxyHeaders]['proxy-authorization'] = opts.token
+    } else if (username && password) {
+      this[kProxyHeaders]['proxy-authorization'] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString('base64')}`
+    }
+
+    const connect = buildConnector({ ...opts.proxyTls })
+    this[kConnectEndpoint] = buildConnector({ ...opts.requestTls })
+
+    const agentFactory = opts.factory || defaultAgentFactory
+    const factory = (origin, options) => {
+      const { protocol } = new URL(origin)
+      if (!this[kTunnelProxy] && protocol === 'http:' && this[kProxy].protocol === 'http:') {
+        return new Http1ProxyWrapper(this[kProxy].uri, {
+          headers: this[kProxyHeaders],
+          connect,
+          factory: agentFactory
+        })
+      }
+      return agentFactory(origin, options)
+    }
+    this[kClient] = clientFactory(url, { connect })
+    this[kAgent] = new Agent({
+      ...opts,
+      factory,
+      connect: async (opts, callback) => {
+        let requestedPath = opts.host
+        if (!opts.port) {
+          requestedPath += `:${defaultProtocolPort(opts.protocol)}`
+        }
+        try {
+          const { socket, statusCode } = await this[kClient].connect({
+            origin,
+            port,
+            path: requestedPath,
+            signal: opts.signal,
+            headers: {
+              ...this[kProxyHeaders],
+              host: opts.host
+            },
+            servername: this[kProxyTls]?.servername || proxyHostname
+          })
+          if (statusCode !== 200) {
+            socket.on('error', noop).destroy()
+            callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`))
+          }
+          if (opts.protocol !== 'https:') {
+            callback(null, socket)
+            return
+          }
+          let servername
+          if (this[kRequestTls]) {
+            servername = this[kRequestTls].servername
+          } else {
+            servername = opts.servername
+          }
+          this[kConnectEndpoint]({ ...opts, servername, httpSocket: socket }, callback)
+        } catch (err) {
+          if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
+            // Throw a custom error to avoid loop in client.js#connect
+            callback(new SecureProxyConnectionError(err))
+          } else {
+            callback(err)
+          }
+        }
+      }
+    })
+  }
+
+  dispatch (opts, handler) {
+    const headers = buildHeaders(opts.headers)
+    throwIfProxyAuthIsSent(headers)
+
+    if (headers && !('host' in headers) && !('Host' in headers)) {
+      const { host } = new URL(opts.origin)
+      headers.host = host
+    }
+
+    return this[kAgent].dispatch(
+      {
+        ...opts,
+        headers
+      },
+      handler
+    )
+  }
+
+  /**
+   * @param {import('../types/proxy-agent').ProxyAgent.Options | string | URL} opts
+   * @returns {URL}
+   */
+  #getUrl (opts) {
+    if (typeof opts === 'string') {
+      return new URL(opts)
+    } else if (opts instanceof URL) {
+      return opts
+    } else {
+      return new URL(opts.uri)
+    }
+  }
+
+  async [kClose] () {
+    await this[kAgent].close()
+    await this[kClient].close()
+  }
+
+  async [kDestroy] () {
+    await this[kAgent].destroy()
+    await this[kClient].destroy()
+  }
+}
+
+/**
+ * @param {string[] | Record<string, string>} headers
+ * @returns {Record<string, string>}
+ */
+function buildHeaders (headers) {
+  // When using undici.fetch, the headers list is stored
+  // as an array.
+  if (Array.isArray(headers)) {
+    /** @type {Record<string, string>} */
+    const headersPair = {}
+
+    for (let i = 0; i < headers.length; i += 2) {
+      headersPair[headers[i]] = headers[i + 1]
+    }
+
+    return headersPair
+  }
+
+  return headers
+}
+
+/**
+ * @param {Record<string, string>} headers
+ *
+ * Previous versions of ProxyAgent suggests the Proxy-Authorization in request headers
+ * Nevertheless, it was changed and to avoid a security vulnerability by end users
+ * this check was created.
+ * It should be removed in the next major version for performance reasons
+ */
+function throwIfProxyAuthIsSent (headers) {
+  const existProxyAuth = headers && Object.keys(headers)
+    .find((key) => key.toLowerCase() === 'proxy-authorization')
+  if (existProxyAuth) {
+    throw new InvalidArgumentError('Proxy-Authorization should be sent in ProxyAgent constructor')
+  }
+}
+
+module.exports = ProxyAgent
+
+
+/***/ }),
+
+/***/ 46811:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const Dispatcher = __nccwpck_require__(51927)
+const RetryHandler = __nccwpck_require__(61465)
+
+class RetryAgent extends Dispatcher {
+  #agent = null
+  #options = null
+  constructor (agent, options = {}) {
+    super(options)
+    this.#agent = agent
+    this.#options = options
+  }
+
+  dispatch (opts, handler) {
+    const retry = new RetryHandler({
+      ...opts,
+      retryOptions: this.#options
+    }, {
+      dispatch: this.#agent.dispatch.bind(this.#agent),
+      handler
+    })
+    return this.#agent.dispatch(opts, retry)
+  }
+
+  close () {
+    return this.#agent.close()
+  }
+
+  destroy () {
+    return this.#agent.destroy()
+  }
+}
+
+module.exports = RetryAgent
+
+
+/***/ }),
+
+/***/ 72354:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+// We include a version number for the Dispatcher API. In case of breaking changes,
+// this version number must be increased to avoid conflicts.
+const globalDispatcher = Symbol.for('undici.globalDispatcher.1')
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+const Agent = __nccwpck_require__(83421)
+
+if (getGlobalDispatcher() === undefined) {
+  setGlobalDispatcher(new Agent())
+}
+
+function setGlobalDispatcher (agent) {
+  if (!agent || typeof agent.dispatch !== 'function') {
+    throw new InvalidArgumentError('Argument agent must implement Agent')
+  }
+  Object.defineProperty(globalThis, globalDispatcher, {
+    value: agent,
+    writable: true,
+    enumerable: false,
+    configurable: false
+  })
+}
+
+function getGlobalDispatcher () {
+  return globalThis[globalDispatcher]
+}
+
+module.exports = {
+  setGlobalDispatcher,
+  getGlobalDispatcher
+}
+
+
+/***/ }),
+
+/***/ 7004:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = class DecoratorHandler {
+  #handler
+
+  constructor (handler) {
+    if (typeof handler !== 'object' || handler === null) {
+      throw new TypeError('handler must be an object')
+    }
+    this.#handler = handler
+  }
+
+  onConnect (...args) {
+    return this.#handler.onConnect?.(...args)
+  }
+
+  onError (...args) {
+    return this.#handler.onError?.(...args)
+  }
+
+  onUpgrade (...args) {
+    return this.#handler.onUpgrade?.(...args)
+  }
+
+  onResponseStarted (...args) {
+    return this.#handler.onResponseStarted?.(...args)
+  }
+
+  onHeaders (...args) {
+    return this.#handler.onHeaders?.(...args)
+  }
+
+  onData (...args) {
+    return this.#handler.onData?.(...args)
+  }
+
+  onComplete (...args) {
+    return this.#handler.onComplete?.(...args)
+  }
+
+  onBodySent (...args) {
+    return this.#handler.onBodySent?.(...args)
+  }
+}
+
+
+/***/ }),
+
+/***/ 59470:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const util = __nccwpck_require__(94407)
+const { kBodyUsed } = __nccwpck_require__(5392)
+const assert = __nccwpck_require__(98061)
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+const EE = __nccwpck_require__(15673)
+
+const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
+
+const kBody = Symbol('body')
+
+class BodyAsyncIterable {
+  constructor (body) {
+    this[kBody] = body
+    this[kBodyUsed] = false
+  }
+
+  async * [Symbol.asyncIterator] () {
+    assert(!this[kBodyUsed], 'disturbed')
+    this[kBodyUsed] = true
+    yield * this[kBody]
+  }
+}
+
+class RedirectHandler {
+  constructor (dispatch, maxRedirections, opts, handler) {
+    if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
+      throw new InvalidArgumentError('maxRedirections must be a positive number')
+    }
+
+    util.validateHandler(handler, opts.method, opts.upgrade)
+
+    this.dispatch = dispatch
+    this.location = null
+    this.abort = null
+    this.opts = { ...opts, maxRedirections: 0 } // opts must be a copy
+    this.maxRedirections = maxRedirections
+    this.handler = handler
+    this.history = []
+    this.redirectionLimitReached = false
+
+    if (util.isStream(this.opts.body)) {
+      // TODO (fix): Provide some way for the user to cache the file to e.g. /tmp
+      // so that it can be dispatched again?
+      // TODO (fix): Do we need 100-expect support to provide a way to do this properly?
+      if (util.bodyLength(this.opts.body) === 0) {
+        this.opts.body
+          .on('data', function () {
+            assert(false)
+          })
+      }
+
+      if (typeof this.opts.body.readableDidRead !== 'boolean') {
+        this.opts.body[kBodyUsed] = false
+        EE.prototype.on.call(this.opts.body, 'data', function () {
+          this[kBodyUsed] = true
+        })
+      }
+    } else if (this.opts.body && typeof this.opts.body.pipeTo === 'function') {
+      // TODO (fix): We can't access ReadableStream internal state
+      // to determine whether or not it has been disturbed. This is just
+      // a workaround.
+      this.opts.body = new BodyAsyncIterable(this.opts.body)
+    } else if (
+      this.opts.body &&
+      typeof this.opts.body !== 'string' &&
+      !ArrayBuffer.isView(this.opts.body) &&
+      util.isIterable(this.opts.body)
+    ) {
+      // TODO: Should we allow re-using iterable if !this.opts.idempotent
+      // or through some other flag?
+      this.opts.body = new BodyAsyncIterable(this.opts.body)
+    }
+  }
+
+  onConnect (abort) {
+    this.abort = abort
+    this.handler.onConnect(abort, { history: this.history })
+  }
+
+  onUpgrade (statusCode, headers, socket) {
+    this.handler.onUpgrade(statusCode, headers, socket)
+  }
+
+  onError (error) {
+    this.handler.onError(error)
+  }
+
+  onHeaders (statusCode, headers, resume, statusText) {
+    this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body)
+      ? null
+      : parseLocation(statusCode, headers)
+
+    if (this.opts.throwOnMaxRedirect && this.history.length >= this.maxRedirections) {
+      if (this.request) {
+        this.request.abort(new Error('max redirects'))
+      }
+
+      this.redirectionLimitReached = true
+      this.abort(new Error('max redirects'))
+      return
+    }
+
+    if (this.opts.origin) {
+      this.history.push(new URL(this.opts.path, this.opts.origin))
+    }
+
+    if (!this.location) {
+      return this.handler.onHeaders(statusCode, headers, resume, statusText)
+    }
+
+    const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)))
+    const path = search ? `${pathname}${search}` : pathname
+
+    // Remove headers referring to the original URL.
+    // By default it is Host only, unless it's a 303 (see below), which removes also all Content-* headers.
+    // https://tools.ietf.org/html/rfc7231#section-6.4
+    this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin)
+    this.opts.path = path
+    this.opts.origin = origin
+    this.opts.maxRedirections = 0
+    this.opts.query = null
+
+    // https://tools.ietf.org/html/rfc7231#section-6.4.4
+    // In case of HTTP 303, always replace method to be either HEAD or GET
+    if (statusCode === 303 && this.opts.method !== 'HEAD') {
+      this.opts.method = 'GET'
+      this.opts.body = null
+    }
+  }
+
+  onData (chunk) {
+    if (this.location) {
+      /*
+        https://tools.ietf.org/html/rfc7231#section-6.4
+
+        TLDR: undici always ignores 3xx response bodies.
+
+        Redirection is used to serve the requested resource from another URL, so it is assumes that
+        no body is generated (and thus can be ignored). Even though generating a body is not prohibited.
+
+        For status 301, 302, 303, 307 and 308 (the latter from RFC 7238), the specs mention that the body usually
+        (which means it's optional and not mandated) contain just an hyperlink to the value of
+        the Location response header, so the body can be ignored safely.
+
+        For status 300, which is "Multiple Choices", the spec mentions both generating a Location
+        response header AND a response body with the other possible location to follow.
+        Since the spec explicitly chooses not to specify a format for such body and leave it to
+        servers and browsers implementors, we ignore the body as there is no specified way to eventually parse it.
+      */
+    } else {
+      return this.handler.onData(chunk)
+    }
+  }
+
+  onComplete (trailers) {
+    if (this.location) {
+      /*
+        https://tools.ietf.org/html/rfc7231#section-6.4
+
+        TLDR: undici always ignores 3xx response trailers as they are not expected in case of redirections
+        and neither are useful if present.
+
+        See comment on onData method above for more detailed information.
+      */
+
+      this.location = null
+      this.abort = null
+
+      this.dispatch(this.opts, this)
+    } else {
+      this.handler.onComplete(trailers)
+    }
+  }
+
+  onBodySent (chunk) {
+    if (this.handler.onBodySent) {
+      this.handler.onBodySent(chunk)
+    }
+  }
+}
+
+function parseLocation (statusCode, headers) {
+  if (redirectableStatusCodes.indexOf(statusCode) === -1) {
+    return null
+  }
+
+  for (let i = 0; i < headers.length; i += 2) {
+    if (headers[i].length === 8 && util.headerNameToString(headers[i]) === 'location') {
+      return headers[i + 1]
+    }
+  }
+}
+
+// https://tools.ietf.org/html/rfc7231#section-6.4.4
+function shouldRemoveHeader (header, removeContent, unknownOrigin) {
+  if (header.length === 4) {
+    return util.headerNameToString(header) === 'host'
+  }
+  if (removeContent && util.headerNameToString(header).startsWith('content-')) {
+    return true
+  }
+  if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) {
+    const name = util.headerNameToString(header)
+    return name === 'authorization' || name === 'cookie' || name === 'proxy-authorization'
+  }
+  return false
+}
+
+// https://tools.ietf.org/html/rfc7231#section-6.4
+function cleanRequestHeaders (headers, removeContent, unknownOrigin) {
+  const ret = []
+  if (Array.isArray(headers)) {
+    for (let i = 0; i < headers.length; i += 2) {
+      if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) {
+        ret.push(headers[i], headers[i + 1])
+      }
+    }
+  } else if (headers && typeof headers === 'object') {
+    for (const key of Object.keys(headers)) {
+      if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
+        ret.push(key, headers[key])
+      }
+    }
+  } else {
+    assert(headers == null, 'headers must be an object or an array')
+  }
+  return ret
+}
+
+module.exports = RedirectHandler
+
+
+/***/ }),
+
+/***/ 61465:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const assert = __nccwpck_require__(98061)
+
+const { kRetryHandlerDefaultRetry } = __nccwpck_require__(5392)
+const { RequestRetryError } = __nccwpck_require__(22174)
+const {
+  isDisturbed,
+  parseHeaders,
+  parseRangeHeader,
+  wrapRequestBody
+} = __nccwpck_require__(94407)
+
+function calculateRetryAfterHeader (retryAfter) {
+  const current = Date.now()
+  return new Date(retryAfter).getTime() - current
+}
+
+class RetryHandler {
+  constructor (opts, handlers) {
+    const { retryOptions, ...dispatchOpts } = opts
+    const {
+      // Retry scoped
+      retry: retryFn,
+      maxRetries,
+      maxTimeout,
+      minTimeout,
+      timeoutFactor,
+      // Response scoped
+      methods,
+      errorCodes,
+      retryAfter,
+      statusCodes
+    } = retryOptions ?? {}
+
+    this.dispatch = handlers.dispatch
+    this.handler = handlers.handler
+    this.opts = { ...dispatchOpts, body: wrapRequestBody(opts.body) }
+    this.abort = null
+    this.aborted = false
+    this.retryOpts = {
+      retry: retryFn ?? RetryHandler[kRetryHandlerDefaultRetry],
+      retryAfter: retryAfter ?? true,
+      maxTimeout: maxTimeout ?? 30 * 1000, // 30s,
+      minTimeout: minTimeout ?? 500, // .5s
+      timeoutFactor: timeoutFactor ?? 2,
+      maxRetries: maxRetries ?? 5,
+      // What errors we should retry
+      methods: methods ?? ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE'],
+      // Indicates which errors to retry
+      statusCodes: statusCodes ?? [500, 502, 503, 504, 429],
+      // List of errors to retry
+      errorCodes: errorCodes ?? [
+        'ECONNRESET',
+        'ECONNREFUSED',
+        'ENOTFOUND',
+        'ENETDOWN',
+        'ENETUNREACH',
+        'EHOSTDOWN',
+        'EHOSTUNREACH',
+        'EPIPE',
+        'UND_ERR_SOCKET'
+      ]
+    }
+
+    this.retryCount = 0
+    this.retryCountCheckpoint = 0
+    this.start = 0
+    this.end = null
+    this.etag = null
+    this.resume = null
+
+    // Handle possible onConnect duplication
+    this.handler.onConnect(reason => {
+      this.aborted = true
+      if (this.abort) {
+        this.abort(reason)
+      } else {
+        this.reason = reason
+      }
+    })
+  }
+
+  onRequestSent () {
+    if (this.handler.onRequestSent) {
+      this.handler.onRequestSent()
+    }
+  }
+
+  onUpgrade (statusCode, headers, socket) {
+    if (this.handler.onUpgrade) {
+      this.handler.onUpgrade(statusCode, headers, socket)
+    }
+  }
+
+  onConnect (abort) {
+    if (this.aborted) {
+      abort(this.reason)
+    } else {
+      this.abort = abort
+    }
+  }
+
+  onBodySent (chunk) {
+    if (this.handler.onBodySent) return this.handler.onBodySent(chunk)
+  }
+
+  static [kRetryHandlerDefaultRetry] (err, { state, opts }, cb) {
+    const { statusCode, code, headers } = err
+    const { method, retryOptions } = opts
+    const {
+      maxRetries,
+      minTimeout,
+      maxTimeout,
+      timeoutFactor,
+      statusCodes,
+      errorCodes,
+      methods
+    } = retryOptions
+    const { counter } = state
+
+    // Any code that is not a Undici's originated and allowed to retry
+    if (code && code !== 'UND_ERR_REQ_RETRY' && !errorCodes.includes(code)) {
+      cb(err)
+      return
+    }
+
+    // If a set of method are provided and the current method is not in the list
+    if (Array.isArray(methods) && !methods.includes(method)) {
+      cb(err)
+      return
+    }
+
+    // If a set of status code are provided and the current status code is not in the list
+    if (
+      statusCode != null &&
+      Array.isArray(statusCodes) &&
+      !statusCodes.includes(statusCode)
+    ) {
+      cb(err)
+      return
+    }
+
+    // If we reached the max number of retries
+    if (counter > maxRetries) {
+      cb(err)
+      return
+    }
+
+    let retryAfterHeader = headers?.['retry-after']
+    if (retryAfterHeader) {
+      retryAfterHeader = Number(retryAfterHeader)
+      retryAfterHeader = Number.isNaN(retryAfterHeader)
+        ? calculateRetryAfterHeader(retryAfterHeader)
+        : retryAfterHeader * 1e3 // Retry-After is in seconds
+    }
+
+    const retryTimeout =
+      retryAfterHeader > 0
+        ? Math.min(retryAfterHeader, maxTimeout)
+        : Math.min(minTimeout * timeoutFactor ** (counter - 1), maxTimeout)
+
+    setTimeout(() => cb(null), retryTimeout)
+  }
+
+  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
+    const headers = parseHeaders(rawHeaders)
+
+    this.retryCount += 1
+
+    if (statusCode >= 300) {
+      if (this.retryOpts.statusCodes.includes(statusCode) === false) {
+        return this.handler.onHeaders(
+          statusCode,
+          rawHeaders,
+          resume,
+          statusMessage
+        )
+      } else {
+        this.abort(
+          new RequestRetryError('Request failed', statusCode, {
+            headers,
+            data: {
+              count: this.retryCount
+            }
+          })
+        )
+        return false
+      }
+    }
+
+    // Checkpoint for resume from where we left it
+    if (this.resume != null) {
+      this.resume = null
+
+      // Only Partial Content 206 supposed to provide Content-Range,
+      // any other status code that partially consumed the payload
+      // should not be retry because it would result in downstream
+      // wrongly concatanete multiple responses.
+      if (statusCode !== 206 && (this.start > 0 || statusCode !== 200)) {
+        this.abort(
+          new RequestRetryError('server does not support the range header and the payload was partially consumed', statusCode, {
+            headers,
+            data: { count: this.retryCount }
+          })
+        )
+        return false
+      }
+
+      const contentRange = parseRangeHeader(headers['content-range'])
+      // If no content range
+      if (!contentRange) {
+        this.abort(
+          new RequestRetryError('Content-Range mismatch', statusCode, {
+            headers,
+            data: { count: this.retryCount }
+          })
+        )
+        return false
+      }
+
+      // Let's start with a weak etag check
+      if (this.etag != null && this.etag !== headers.etag) {
+        this.abort(
+          new RequestRetryError('ETag mismatch', statusCode, {
+            headers,
+            data: { count: this.retryCount }
+          })
+        )
+        return false
+      }
+
+      const { start, size, end = size - 1 } = contentRange
+
+      assert(this.start === start, 'content-range mismatch')
+      assert(this.end == null || this.end === end, 'content-range mismatch')
+
+      this.resume = resume
+      return true
+    }
+
+    if (this.end == null) {
+      if (statusCode === 206) {
+        // First time we receive 206
+        const range = parseRangeHeader(headers['content-range'])
+
+        if (range == null) {
+          return this.handler.onHeaders(
+            statusCode,
+            rawHeaders,
+            resume,
+            statusMessage
+          )
+        }
+
+        const { start, size, end = size - 1 } = range
+        assert(
+          start != null && Number.isFinite(start),
+          'content-range mismatch'
+        )
+        assert(end != null && Number.isFinite(end), 'invalid content-length')
+
+        this.start = start
+        this.end = end
+      }
+
+      // We make our best to checkpoint the body for further range headers
+      if (this.end == null) {
+        const contentLength = headers['content-length']
+        this.end = contentLength != null ? Number(contentLength) - 1 : null
+      }
+
+      assert(Number.isFinite(this.start))
+      assert(
+        this.end == null || Number.isFinite(this.end),
+        'invalid content-length'
+      )
+
+      this.resume = resume
+      this.etag = headers.etag != null ? headers.etag : null
+
+      // Weak etags are not useful for comparison nor cache
+      // for instance not safe to assume if the response is byte-per-byte
+      // equal
+      if (this.etag != null && this.etag.startsWith('W/')) {
+        this.etag = null
+      }
+
+      return this.handler.onHeaders(
+        statusCode,
+        rawHeaders,
+        resume,
+        statusMessage
+      )
+    }
+
+    const err = new RequestRetryError('Request failed', statusCode, {
+      headers,
+      data: { count: this.retryCount }
+    })
+
+    this.abort(err)
+
+    return false
+  }
+
+  onData (chunk) {
+    this.start += chunk.length
+
+    return this.handler.onData(chunk)
+  }
+
+  onComplete (rawTrailers) {
+    this.retryCount = 0
+    return this.handler.onComplete(rawTrailers)
+  }
+
+  onError (err) {
+    if (this.aborted || isDisturbed(this.opts.body)) {
+      return this.handler.onError(err)
+    }
+
+    // We reconcile in case of a mix between network errors
+    // and server error response
+    if (this.retryCount - this.retryCountCheckpoint > 0) {
+      // We count the difference between the last checkpoint and the current retry count
+      this.retryCount =
+        this.retryCountCheckpoint +
+        (this.retryCount - this.retryCountCheckpoint)
+    } else {
+      this.retryCount += 1
+    }
+
+    this.retryOpts.retry(
+      err,
+      {
+        state: { counter: this.retryCount },
+        opts: { retryOptions: this.retryOpts, ...this.opts }
+      },
+      onRetry.bind(this)
+    )
+
+    function onRetry (err) {
+      if (err != null || this.aborted || isDisturbed(this.opts.body)) {
+        return this.handler.onError(err)
+      }
+
+      if (this.start !== 0) {
+        const headers = { range: `bytes=${this.start}-${this.end ?? ''}` }
+
+        // Weak etag check - weak etags will make comparison algorithms never match
+        if (this.etag != null) {
+          headers['if-match'] = this.etag
+        }
+
+        this.opts = {
+          ...this.opts,
+          headers: {
+            ...this.opts.headers,
+            ...headers
+          }
+        }
+      }
+
+      try {
+        this.retryCountCheckpoint = this.retryCount
+        this.dispatch(this.opts, this)
+      } catch (err) {
+        this.handler.onError(err)
+      }
+    }
+  }
+}
+
+module.exports = RetryHandler
+
+
+/***/ }),
+
+/***/ 42462:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const { isIP } = __nccwpck_require__(87503)
+const { lookup } = __nccwpck_require__(30604)
+const DecoratorHandler = __nccwpck_require__(7004)
+const { InvalidArgumentError, InformationalError } = __nccwpck_require__(22174)
+const maxInt = Math.pow(2, 31) - 1
+
+class DNSInstance {
+  #maxTTL = 0
+  #maxItems = 0
+  #records = new Map()
+  dualStack = true
+  affinity = null
+  lookup = null
+  pick = null
+
+  constructor (opts) {
+    this.#maxTTL = opts.maxTTL
+    this.#maxItems = opts.maxItems
+    this.dualStack = opts.dualStack
+    this.affinity = opts.affinity
+    this.lookup = opts.lookup ?? this.#defaultLookup
+    this.pick = opts.pick ?? this.#defaultPick
+  }
+
+  get full () {
+    return this.#records.size === this.#maxItems
+  }
+
+  runLookup (origin, opts, cb) {
+    const ips = this.#records.get(origin.hostname)
+
+    // If full, we just return the origin
+    if (ips == null && this.full) {
+      cb(null, origin.origin)
+      return
+    }
+
+    const newOpts = {
+      affinity: this.affinity,
+      dualStack: this.dualStack,
+      lookup: this.lookup,
+      pick: this.pick,
+      ...opts.dns,
+      maxTTL: this.#maxTTL,
+      maxItems: this.#maxItems
+    }
+
+    // If no IPs we lookup
+    if (ips == null) {
+      this.lookup(origin, newOpts, (err, addresses) => {
+        if (err || addresses == null || addresses.length === 0) {
+          cb(err ?? new InformationalError('No DNS entries found'))
+          return
+        }
+
+        this.setRecords(origin, addresses)
+        const records = this.#records.get(origin.hostname)
+
+        const ip = this.pick(
+          origin,
+          records,
+          newOpts.affinity
+        )
+
+        let port
+        if (typeof ip.port === 'number') {
+          port = `:${ip.port}`
+        } else if (origin.port !== '') {
+          port = `:${origin.port}`
+        } else {
+          port = ''
+        }
+
+        cb(
+          null,
+          `${origin.protocol}//${
+            ip.family === 6 ? `[${ip.address}]` : ip.address
+          }${port}`
+        )
+      })
+    } else {
+      // If there's IPs we pick
+      const ip = this.pick(
+        origin,
+        ips,
+        newOpts.affinity
+      )
+
+      // If no IPs we lookup - deleting old records
+      if (ip == null) {
+        this.#records.delete(origin.hostname)
+        this.runLookup(origin, opts, cb)
+        return
+      }
+
+      let port
+      if (typeof ip.port === 'number') {
+        port = `:${ip.port}`
+      } else if (origin.port !== '') {
+        port = `:${origin.port}`
+      } else {
+        port = ''
+      }
+
+      cb(
+        null,
+        `${origin.protocol}//${
+          ip.family === 6 ? `[${ip.address}]` : ip.address
+        }${port}`
+      )
+    }
+  }
+
+  #defaultLookup (origin, opts, cb) {
+    lookup(
+      origin.hostname,
+      {
+        all: true,
+        family: this.dualStack === false ? this.affinity : 0,
+        order: 'ipv4first'
+      },
+      (err, addresses) => {
+        if (err) {
+          return cb(err)
+        }
+
+        const results = new Map()
+
+        for (const addr of addresses) {
+          // On linux we found duplicates, we attempt to remove them with
+          // the latest record
+          results.set(`${addr.address}:${addr.family}`, addr)
+        }
+
+        cb(null, results.values())
+      }
+    )
+  }
+
+  #defaultPick (origin, hostnameRecords, affinity) {
+    let ip = null
+    const { records, offset } = hostnameRecords
+
+    let family
+    if (this.dualStack) {
+      if (affinity == null) {
+        // Balance between ip families
+        if (offset == null || offset === maxInt) {
+          hostnameRecords.offset = 0
+          affinity = 4
+        } else {
+          hostnameRecords.offset++
+          affinity = (hostnameRecords.offset & 1) === 1 ? 6 : 4
+        }
+      }
+
+      if (records[affinity] != null && records[affinity].ips.length > 0) {
+        family = records[affinity]
+      } else {
+        family = records[affinity === 4 ? 6 : 4]
+      }
+    } else {
+      family = records[affinity]
+    }
+
+    // If no IPs we return null
+    if (family == null || family.ips.length === 0) {
+      return ip
+    }
+
+    if (family.offset == null || family.offset === maxInt) {
+      family.offset = 0
+    } else {
+      family.offset++
+    }
+
+    const position = family.offset % family.ips.length
+    ip = family.ips[position] ?? null
+
+    if (ip == null) {
+      return ip
+    }
+
+    if (Date.now() - ip.timestamp > ip.ttl) { // record TTL is already in ms
+      // We delete expired records
+      // It is possible that they have different TTL, so we manage them individually
+      family.ips.splice(position, 1)
+      return this.pick(origin, hostnameRecords, affinity)
+    }
+
+    return ip
+  }
+
+  setRecords (origin, addresses) {
+    const timestamp = Date.now()
+    const records = { records: { 4: null, 6: null } }
+    for (const record of addresses) {
+      record.timestamp = timestamp
+      if (typeof record.ttl === 'number') {
+        // The record TTL is expected to be in ms
+        record.ttl = Math.min(record.ttl, this.#maxTTL)
+      } else {
+        record.ttl = this.#maxTTL
+      }
+
+      const familyRecords = records.records[record.family] ?? { ips: [] }
+
+      familyRecords.ips.push(record)
+      records.records[record.family] = familyRecords
+    }
+
+    this.#records.set(origin.hostname, records)
+  }
+
+  getHandler (meta, opts) {
+    return new DNSDispatchHandler(this, meta, opts)
+  }
+}
+
+class DNSDispatchHandler extends DecoratorHandler {
+  #state = null
+  #opts = null
+  #dispatch = null
+  #handler = null
+  #origin = null
+
+  constructor (state, { origin, handler, dispatch }, opts) {
+    super(handler)
+    this.#origin = origin
+    this.#handler = handler
+    this.#opts = { ...opts }
+    this.#state = state
+    this.#dispatch = dispatch
+  }
+
+  onError (err) {
+    switch (err.code) {
+      case 'ETIMEDOUT':
+      case 'ECONNREFUSED': {
+        if (this.#state.dualStack) {
+          // We delete the record and retry
+          this.#state.runLookup(this.#origin, this.#opts, (err, newOrigin) => {
+            if (err) {
+              return this.#handler.onError(err)
+            }
+
+            const dispatchOpts = {
+              ...this.#opts,
+              origin: newOrigin
+            }
+
+            this.#dispatch(dispatchOpts, this)
+          })
+
+          // if dual-stack disabled, we error out
+          return
+        }
+
+        this.#handler.onError(err)
+        return
+      }
+      case 'ENOTFOUND':
+        this.#state.deleteRecord(this.#origin)
+      // eslint-disable-next-line no-fallthrough
+      default:
+        this.#handler.onError(err)
+        break
+    }
+  }
+}
+
+module.exports = interceptorOpts => {
+  if (
+    interceptorOpts?.maxTTL != null &&
+    (typeof interceptorOpts?.maxTTL !== 'number' || interceptorOpts?.maxTTL < 0)
+  ) {
+    throw new InvalidArgumentError('Invalid maxTTL. Must be a positive number')
+  }
+
+  if (
+    interceptorOpts?.maxItems != null &&
+    (typeof interceptorOpts?.maxItems !== 'number' ||
+      interceptorOpts?.maxItems < 1)
+  ) {
+    throw new InvalidArgumentError(
+      'Invalid maxItems. Must be a positive number and greater than zero'
+    )
+  }
+
+  if (
+    interceptorOpts?.affinity != null &&
+    interceptorOpts?.affinity !== 4 &&
+    interceptorOpts?.affinity !== 6
+  ) {
+    throw new InvalidArgumentError('Invalid affinity. Must be either 4 or 6')
+  }
+
+  if (
+    interceptorOpts?.dualStack != null &&
+    typeof interceptorOpts?.dualStack !== 'boolean'
+  ) {
+    throw new InvalidArgumentError('Invalid dualStack. Must be a boolean')
+  }
+
+  if (
+    interceptorOpts?.lookup != null &&
+    typeof interceptorOpts?.lookup !== 'function'
+  ) {
+    throw new InvalidArgumentError('Invalid lookup. Must be a function')
+  }
+
+  if (
+    interceptorOpts?.pick != null &&
+    typeof interceptorOpts?.pick !== 'function'
+  ) {
+    throw new InvalidArgumentError('Invalid pick. Must be a function')
+  }
+
+  const dualStack = interceptorOpts?.dualStack ?? true
+  let affinity
+  if (dualStack) {
+    affinity = interceptorOpts?.affinity ?? null
+  } else {
+    affinity = interceptorOpts?.affinity ?? 4
+  }
+
+  const opts = {
+    maxTTL: interceptorOpts?.maxTTL ?? 10e3, // Expressed in ms
+    lookup: interceptorOpts?.lookup ?? null,
+    pick: interceptorOpts?.pick ?? null,
+    dualStack,
+    affinity,
+    maxItems: interceptorOpts?.maxItems ?? Infinity
+  }
+
+  const instance = new DNSInstance(opts)
+
+  return dispatch => {
+    return function dnsInterceptor (origDispatchOpts, handler) {
+      const origin =
+        origDispatchOpts.origin.constructor === URL
+          ? origDispatchOpts.origin
+          : new URL(origDispatchOpts.origin)
+
+      if (isIP(origin.hostname) !== 0) {
+        return dispatch(origDispatchOpts, handler)
+      }
+
+      instance.runLookup(origin, origDispatchOpts, (err, newOrigin) => {
+        if (err) {
+          return handler.onError(err)
+        }
+
+        let dispatchOpts = null
+        dispatchOpts = {
+          ...origDispatchOpts,
+          servername: origin.hostname, // For SNI on TLS
+          origin: newOrigin,
+          headers: {
+            host: origin.hostname,
+            ...origDispatchOpts.headers
+          }
+        }
+
+        dispatch(
+          dispatchOpts,
+          instance.getHandler({ origin, dispatch, handler }, origDispatchOpts)
+        )
+      })
+
+      return true
+    }
+  }
+}
+
+
+/***/ }),
+
+/***/ 3199:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const util = __nccwpck_require__(94407)
+const { InvalidArgumentError, RequestAbortedError } = __nccwpck_require__(22174)
+const DecoratorHandler = __nccwpck_require__(7004)
+
+class DumpHandler extends DecoratorHandler {
+  #maxSize = 1024 * 1024
+  #abort = null
+  #dumped = false
+  #aborted = false
+  #size = 0
+  #reason = null
+  #handler = null
+
+  constructor ({ maxSize }, handler) {
+    super(handler)
+
+    if (maxSize != null && (!Number.isFinite(maxSize) || maxSize < 1)) {
+      throw new InvalidArgumentError('maxSize must be a number greater than 0')
+    }
+
+    this.#maxSize = maxSize ?? this.#maxSize
+    this.#handler = handler
+  }
+
+  onConnect (abort) {
+    this.#abort = abort
+
+    this.#handler.onConnect(this.#customAbort.bind(this))
+  }
+
+  #customAbort (reason) {
+    this.#aborted = true
+    this.#reason = reason
+  }
+
+  // TODO: will require adjustment after new hooks are out
+  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
+    const headers = util.parseHeaders(rawHeaders)
+    const contentLength = headers['content-length']
+
+    if (contentLength != null && contentLength > this.#maxSize) {
+      throw new RequestAbortedError(
+        `Response size (${contentLength}) larger than maxSize (${
+          this.#maxSize
+        })`
+      )
+    }
+
+    if (this.#aborted) {
+      return true
+    }
+
+    return this.#handler.onHeaders(
+      statusCode,
+      rawHeaders,
+      resume,
+      statusMessage
+    )
+  }
+
+  onError (err) {
+    if (this.#dumped) {
+      return
+    }
+
+    err = this.#reason ?? err
+
+    this.#handler.onError(err)
+  }
+
+  onData (chunk) {
+    this.#size = this.#size + chunk.length
+
+    if (this.#size >= this.#maxSize) {
+      this.#dumped = true
+
+      if (this.#aborted) {
+        this.#handler.onError(this.#reason)
+      } else {
+        this.#handler.onComplete([])
+      }
+    }
+
+    return true
+  }
+
+  onComplete (trailers) {
+    if (this.#dumped) {
+      return
+    }
+
+    if (this.#aborted) {
+      this.#handler.onError(this.reason)
+      return
+    }
+
+    this.#handler.onComplete(trailers)
+  }
+}
+
+function createDumpInterceptor (
+  { maxSize: defaultMaxSize } = {
+    maxSize: 1024 * 1024
+  }
+) {
+  return dispatch => {
+    return function Intercept (opts, handler) {
+      const { dumpMaxSize = defaultMaxSize } =
+        opts
+
+      const dumpHandler = new DumpHandler(
+        { maxSize: dumpMaxSize },
+        handler
+      )
+
+      return dispatch(opts, dumpHandler)
+    }
+  }
+}
+
+module.exports = createDumpInterceptor
+
+
+/***/ }),
+
+/***/ 11115:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const RedirectHandler = __nccwpck_require__(59470)
+
+function createRedirectInterceptor ({ maxRedirections: defaultMaxRedirections }) {
+  return (dispatch) => {
+    return function Intercept (opts, handler) {
+      const { maxRedirections = defaultMaxRedirections } = opts
+
+      if (!maxRedirections) {
+        return dispatch(opts, handler)
+      }
+
+      const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler)
+      opts = { ...opts, maxRedirections: 0 } // Stop sub dispatcher from also redirecting.
+      return dispatch(opts, redirectHandler)
+    }
+  }
+}
+
+module.exports = createRedirectInterceptor
+
+
+/***/ }),
+
+/***/ 42370:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const RedirectHandler = __nccwpck_require__(59470)
+
+module.exports = opts => {
+  const globalMaxRedirections = opts?.maxRedirections
+  return dispatch => {
+    return function redirectInterceptor (opts, handler) {
+      const { maxRedirections = globalMaxRedirections, ...baseOpts } = opts
+
+      if (!maxRedirections) {
+        return dispatch(opts, handler)
+      }
+
+      const redirectHandler = new RedirectHandler(
+        dispatch,
+        maxRedirections,
+        opts,
+        handler
+      )
+
+      return dispatch(baseOpts, redirectHandler)
+    }
+  }
+}
+
+
+/***/ }),
+
+/***/ 66080:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const RetryHandler = __nccwpck_require__(61465)
+
+module.exports = globalOpts => {
+  return dispatch => {
+    return function retryInterceptor (opts, handler) {
+      return dispatch(
+        opts,
+        new RetryHandler(
+          { ...opts, retryOptions: { ...globalOpts, ...opts.retryOptions } },
+          {
+            handler,
+            dispatch
+          }
+        )
+      )
+    }
+  }
+}
+
+
+/***/ }),
+
+/***/ 59086:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SPECIAL_HEADERS = exports.HEADER_STATE = exports.MINOR = exports.MAJOR = exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS = exports.TOKEN = exports.STRICT_TOKEN = exports.HEX = exports.URL_CHAR = exports.STRICT_URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.NUM = exports.HEX_MAP = exports.NUM_MAP = exports.ALPHA = exports.FINISH = exports.H_METHOD_MAP = exports.METHOD_MAP = exports.METHODS_RTSP = exports.METHODS_ICE = exports.METHODS_HTTP = exports.METHODS = exports.LENIENT_FLAGS = exports.FLAGS = exports.TYPE = exports.ERROR = void 0;
+const utils_1 = __nccwpck_require__(44118);
+// C headers
+var ERROR;
+(function (ERROR) {
+    ERROR[ERROR["OK"] = 0] = "OK";
+    ERROR[ERROR["INTERNAL"] = 1] = "INTERNAL";
+    ERROR[ERROR["STRICT"] = 2] = "STRICT";
+    ERROR[ERROR["LF_EXPECTED"] = 3] = "LF_EXPECTED";
+    ERROR[ERROR["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH";
+    ERROR[ERROR["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION";
+    ERROR[ERROR["INVALID_METHOD"] = 6] = "INVALID_METHOD";
+    ERROR[ERROR["INVALID_URL"] = 7] = "INVALID_URL";
+    ERROR[ERROR["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT";
+    ERROR[ERROR["INVALID_VERSION"] = 9] = "INVALID_VERSION";
+    ERROR[ERROR["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN";
+    ERROR[ERROR["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH";
+    ERROR[ERROR["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE";
+    ERROR[ERROR["INVALID_STATUS"] = 13] = "INVALID_STATUS";
+    ERROR[ERROR["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE";
+    ERROR[ERROR["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING";
+    ERROR[ERROR["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN";
+    ERROR[ERROR["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE";
+    ERROR[ERROR["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE";
+    ERROR[ERROR["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER";
+    ERROR[ERROR["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE";
+    ERROR[ERROR["PAUSED"] = 21] = "PAUSED";
+    ERROR[ERROR["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE";
+    ERROR[ERROR["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE";
+    ERROR[ERROR["USER"] = 24] = "USER";
+})(ERROR = exports.ERROR || (exports.ERROR = {}));
+var TYPE;
+(function (TYPE) {
+    TYPE[TYPE["BOTH"] = 0] = "BOTH";
+    TYPE[TYPE["REQUEST"] = 1] = "REQUEST";
+    TYPE[TYPE["RESPONSE"] = 2] = "RESPONSE";
+})(TYPE = exports.TYPE || (exports.TYPE = {}));
+var FLAGS;
+(function (FLAGS) {
+    FLAGS[FLAGS["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE";
+    FLAGS[FLAGS["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE";
+    FLAGS[FLAGS["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE";
+    FLAGS[FLAGS["CHUNKED"] = 8] = "CHUNKED";
+    FLAGS[FLAGS["UPGRADE"] = 16] = "UPGRADE";
+    FLAGS[FLAGS["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH";
+    FLAGS[FLAGS["SKIPBODY"] = 64] = "SKIPBODY";
+    FLAGS[FLAGS["TRAILING"] = 128] = "TRAILING";
+    // 1 << 8 is unused
+    FLAGS[FLAGS["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING";
+})(FLAGS = exports.FLAGS || (exports.FLAGS = {}));
+var LENIENT_FLAGS;
+(function (LENIENT_FLAGS) {
+    LENIENT_FLAGS[LENIENT_FLAGS["HEADERS"] = 1] = "HEADERS";
+    LENIENT_FLAGS[LENIENT_FLAGS["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH";
+    LENIENT_FLAGS[LENIENT_FLAGS["KEEP_ALIVE"] = 4] = "KEEP_ALIVE";
+})(LENIENT_FLAGS = exports.LENIENT_FLAGS || (exports.LENIENT_FLAGS = {}));
+var METHODS;
+(function (METHODS) {
+    METHODS[METHODS["DELETE"] = 0] = "DELETE";
+    METHODS[METHODS["GET"] = 1] = "GET";
+    METHODS[METHODS["HEAD"] = 2] = "HEAD";
+    METHODS[METHODS["POST"] = 3] = "POST";
+    METHODS[METHODS["PUT"] = 4] = "PUT";
+    /* pathological */
+    METHODS[METHODS["CONNECT"] = 5] = "CONNECT";
+    METHODS[METHODS["OPTIONS"] = 6] = "OPTIONS";
+    METHODS[METHODS["TRACE"] = 7] = "TRACE";
+    /* WebDAV */
+    METHODS[METHODS["COPY"] = 8] = "COPY";
+    METHODS[METHODS["LOCK"] = 9] = "LOCK";
+    METHODS[METHODS["MKCOL"] = 10] = "MKCOL";
+    METHODS[METHODS["MOVE"] = 11] = "MOVE";
+    METHODS[METHODS["PROPFIND"] = 12] = "PROPFIND";
+    METHODS[METHODS["PROPPATCH"] = 13] = "PROPPATCH";
+    METHODS[METHODS["SEARCH"] = 14] = "SEARCH";
+    METHODS[METHODS["UNLOCK"] = 15] = "UNLOCK";
+    METHODS[METHODS["BIND"] = 16] = "BIND";
+    METHODS[METHODS["REBIND"] = 17] = "REBIND";
+    METHODS[METHODS["UNBIND"] = 18] = "UNBIND";
+    METHODS[METHODS["ACL"] = 19] = "ACL";
+    /* subversion */
+    METHODS[METHODS["REPORT"] = 20] = "REPORT";
+    METHODS[METHODS["MKACTIVITY"] = 21] = "MKACTIVITY";
+    METHODS[METHODS["CHECKOUT"] = 22] = "CHECKOUT";
+    METHODS[METHODS["MERGE"] = 23] = "MERGE";
+    /* upnp */
+    METHODS[METHODS["M-SEARCH"] = 24] = "M-SEARCH";
+    METHODS[METHODS["NOTIFY"] = 25] = "NOTIFY";
+    METHODS[METHODS["SUBSCRIBE"] = 26] = "SUBSCRIBE";
+    METHODS[METHODS["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE";
+    /* RFC-5789 */
+    METHODS[METHODS["PATCH"] = 28] = "PATCH";
+    METHODS[METHODS["PURGE"] = 29] = "PURGE";
+    /* CalDAV */
+    METHODS[METHODS["MKCALENDAR"] = 30] = "MKCALENDAR";
+    /* RFC-2068, section 19.6.1.2 */
+    METHODS[METHODS["LINK"] = 31] = "LINK";
+    METHODS[METHODS["UNLINK"] = 32] = "UNLINK";
+    /* icecast */
+    METHODS[METHODS["SOURCE"] = 33] = "SOURCE";
+    /* RFC-7540, section 11.6 */
+    METHODS[METHODS["PRI"] = 34] = "PRI";
+    /* RFC-2326 RTSP */
+    METHODS[METHODS["DESCRIBE"] = 35] = "DESCRIBE";
+    METHODS[METHODS["ANNOUNCE"] = 36] = "ANNOUNCE";
+    METHODS[METHODS["SETUP"] = 37] = "SETUP";
+    METHODS[METHODS["PLAY"] = 38] = "PLAY";
+    METHODS[METHODS["PAUSE"] = 39] = "PAUSE";
+    METHODS[METHODS["TEARDOWN"] = 40] = "TEARDOWN";
+    METHODS[METHODS["GET_PARAMETER"] = 41] = "GET_PARAMETER";
+    METHODS[METHODS["SET_PARAMETER"] = 42] = "SET_PARAMETER";
+    METHODS[METHODS["REDIRECT"] = 43] = "REDIRECT";
+    METHODS[METHODS["RECORD"] = 44] = "RECORD";
+    /* RAOP */
+    METHODS[METHODS["FLUSH"] = 45] = "FLUSH";
+})(METHODS = exports.METHODS || (exports.METHODS = {}));
+exports.METHODS_HTTP = [
+    METHODS.DELETE,
+    METHODS.GET,
+    METHODS.HEAD,
+    METHODS.POST,
+    METHODS.PUT,
+    METHODS.CONNECT,
+    METHODS.OPTIONS,
+    METHODS.TRACE,
+    METHODS.COPY,
+    METHODS.LOCK,
+    METHODS.MKCOL,
+    METHODS.MOVE,
+    METHODS.PROPFIND,
+    METHODS.PROPPATCH,
+    METHODS.SEARCH,
+    METHODS.UNLOCK,
+    METHODS.BIND,
+    METHODS.REBIND,
+    METHODS.UNBIND,
+    METHODS.ACL,
+    METHODS.REPORT,
+    METHODS.MKACTIVITY,
+    METHODS.CHECKOUT,
+    METHODS.MERGE,
+    METHODS['M-SEARCH'],
+    METHODS.NOTIFY,
+    METHODS.SUBSCRIBE,
+    METHODS.UNSUBSCRIBE,
+    METHODS.PATCH,
+    METHODS.PURGE,
+    METHODS.MKCALENDAR,
+    METHODS.LINK,
+    METHODS.UNLINK,
+    METHODS.PRI,
+    // TODO(indutny): should we allow it with HTTP?
+    METHODS.SOURCE,
+];
+exports.METHODS_ICE = [
+    METHODS.SOURCE,
+];
+exports.METHODS_RTSP = [
+    METHODS.OPTIONS,
+    METHODS.DESCRIBE,
+    METHODS.ANNOUNCE,
+    METHODS.SETUP,
+    METHODS.PLAY,
+    METHODS.PAUSE,
+    METHODS.TEARDOWN,
+    METHODS.GET_PARAMETER,
+    METHODS.SET_PARAMETER,
+    METHODS.REDIRECT,
+    METHODS.RECORD,
+    METHODS.FLUSH,
+    // For AirPlay
+    METHODS.GET,
+    METHODS.POST,
+];
+exports.METHOD_MAP = utils_1.enumToMap(METHODS);
+exports.H_METHOD_MAP = {};
+Object.keys(exports.METHOD_MAP).forEach((key) => {
+    if (/^H/.test(key)) {
+        exports.H_METHOD_MAP[key] = exports.METHOD_MAP[key];
+    }
+});
+var FINISH;
+(function (FINISH) {
+    FINISH[FINISH["SAFE"] = 0] = "SAFE";
+    FINISH[FINISH["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB";
+    FINISH[FINISH["UNSAFE"] = 2] = "UNSAFE";
+})(FINISH = exports.FINISH || (exports.FINISH = {}));
+exports.ALPHA = [];
+for (let i = 'A'.charCodeAt(0); i <= 'Z'.charCodeAt(0); i++) {
+    // Upper case
+    exports.ALPHA.push(String.fromCharCode(i));
+    // Lower case
+    exports.ALPHA.push(String.fromCharCode(i + 0x20));
+}
+exports.NUM_MAP = {
+    0: 0, 1: 1, 2: 2, 3: 3, 4: 4,
+    5: 5, 6: 6, 7: 7, 8: 8, 9: 9,
+};
+exports.HEX_MAP = {
+    0: 0, 1: 1, 2: 2, 3: 3, 4: 4,
+    5: 5, 6: 6, 7: 7, 8: 8, 9: 9,
+    A: 0XA, B: 0XB, C: 0XC, D: 0XD, E: 0XE, F: 0XF,
+    a: 0xa, b: 0xb, c: 0xc, d: 0xd, e: 0xe, f: 0xf,
+};
+exports.NUM = [
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+];
+exports.ALPHANUM = exports.ALPHA.concat(exports.NUM);
+exports.MARK = ['-', '_', '.', '!', '~', '*', '\'', '(', ')'];
+exports.USERINFO_CHARS = exports.ALPHANUM
+    .concat(exports.MARK)
+    .concat(['%', ';', ':', '&', '=', '+', '$', ',']);
+// TODO(indutny): use RFC
+exports.STRICT_URL_CHAR = [
+    '!', '"', '$', '%', '&', '\'',
+    '(', ')', '*', '+', ',', '-', '.', '/',
+    ':', ';', '<', '=', '>',
+    '@', '[', '\\', ']', '^', '_',
+    '`',
+    '{', '|', '}', '~',
+].concat(exports.ALPHANUM);
+exports.URL_CHAR = exports.STRICT_URL_CHAR
+    .concat(['\t', '\f']);
+// All characters with 0x80 bit set to 1
+for (let i = 0x80; i <= 0xff; i++) {
+    exports.URL_CHAR.push(i);
+}
+exports.HEX = exports.NUM.concat(['a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F']);
+/* Tokens as defined by rfc 2616. Also lowercases them.
+ *        token       = 1*<any CHAR except CTLs or separators>
+ *     separators     = "(" | ")" | "<" | ">" | "@"
+ *                    | "," | ";" | ":" | "\" | <">
+ *                    | "/" | "[" | "]" | "?" | "="
+ *                    | "{" | "}" | SP | HT
+ */
+exports.STRICT_TOKEN = [
+    '!', '#', '$', '%', '&', '\'',
+    '*', '+', '-', '.',
+    '^', '_', '`',
+    '|', '~',
+].concat(exports.ALPHANUM);
+exports.TOKEN = exports.STRICT_TOKEN.concat([' ']);
+/*
+ * Verify that a char is a valid visible (printable) US-ASCII
+ * character or %x80-FF
+ */
+exports.HEADER_CHARS = ['\t'];
+for (let i = 32; i <= 255; i++) {
+    if (i !== 127) {
+        exports.HEADER_CHARS.push(i);
+    }
+}
+// ',' = \x44
+exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS.filter((c) => c !== 44);
+exports.MAJOR = exports.NUM_MAP;
+exports.MINOR = exports.MAJOR;
+var HEADER_STATE;
+(function (HEADER_STATE) {
+    HEADER_STATE[HEADER_STATE["GENERAL"] = 0] = "GENERAL";
+    HEADER_STATE[HEADER_STATE["CONNECTION"] = 1] = "CONNECTION";
+    HEADER_STATE[HEADER_STATE["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH";
+    HEADER_STATE[HEADER_STATE["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING";
+    HEADER_STATE[HEADER_STATE["UPGRADE"] = 4] = "UPGRADE";
+    HEADER_STATE[HEADER_STATE["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE";
+    HEADER_STATE[HEADER_STATE["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE";
+    HEADER_STATE[HEADER_STATE["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE";
+    HEADER_STATE[HEADER_STATE["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED";
+})(HEADER_STATE = exports.HEADER_STATE || (exports.HEADER_STATE = {}));
+exports.SPECIAL_HEADERS = {
+    'connection': HEADER_STATE.CONNECTION,
+    'content-length': HEADER_STATE.CONTENT_LENGTH,
+    'proxy-connection': HEADER_STATE.CONNECTION,
+    'transfer-encoding': HEADER_STATE.TRANSFER_ENCODING,
+    'upgrade': HEADER_STATE.UPGRADE,
+};
+//# sourceMappingURL=constants.js.map
+
+/***/ }),
+
+/***/ 91475:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Buffer } = __nccwpck_require__(72254)
+
+module.exports = Buffer.from('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', 'base64')
+
+
+/***/ }),
+
+/***/ 27784:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Buffer } = __nccwpck_require__(72254)
+
+module.exports = Buffer.from('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', 'base64')
+
+
+/***/ }),
+
+/***/ 44118:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.enumToMap = void 0;
+function enumToMap(obj) {
+    const res = {};
+    Object.keys(obj).forEach((key) => {
+        const value = obj[key];
+        if (typeof value === 'number') {
+            res[key] = value;
+        }
+    });
+    return res;
+}
+exports.enumToMap = enumToMap;
+//# sourceMappingURL=utils.js.map
+
+/***/ }),
+
+/***/ 56549:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kClients } = __nccwpck_require__(5392)
+const Agent = __nccwpck_require__(83421)
+const {
+  kAgent,
+  kMockAgentSet,
+  kMockAgentGet,
+  kDispatches,
+  kIsMockActive,
+  kNetConnect,
+  kGetNetConnect,
+  kOptions,
+  kFactory
+} = __nccwpck_require__(67296)
+const MockClient = __nccwpck_require__(32144)
+const MockPool = __nccwpck_require__(92565)
+const { matchValue, buildMockOptions } = __nccwpck_require__(94202)
+const { InvalidArgumentError, UndiciError } = __nccwpck_require__(22174)
+const Dispatcher = __nccwpck_require__(51927)
+const Pluralizer = __nccwpck_require__(77551)
+const PendingInterceptorsFormatter = __nccwpck_require__(70698)
+
+class MockAgent extends Dispatcher {
+  constructor (opts) {
+    super(opts)
+
+    this[kNetConnect] = true
+    this[kIsMockActive] = true
+
+    // Instantiate Agent and encapsulate
+    if ((opts?.agent && typeof opts.agent.dispatch !== 'function')) {
+      throw new InvalidArgumentError('Argument opts.agent must implement Agent')
+    }
+    const agent = opts?.agent ? opts.agent : new Agent(opts)
+    this[kAgent] = agent
+
+    this[kClients] = agent[kClients]
+    this[kOptions] = buildMockOptions(opts)
+  }
+
+  get (origin) {
+    let dispatcher = this[kMockAgentGet](origin)
+
+    if (!dispatcher) {
+      dispatcher = this[kFactory](origin)
+      this[kMockAgentSet](origin, dispatcher)
+    }
+    return dispatcher
+  }
+
+  dispatch (opts, handler) {
+    // Call MockAgent.get to perform additional setup before dispatching as normal
+    this.get(opts.origin)
+    return this[kAgent].dispatch(opts, handler)
+  }
+
+  async close () {
+    await this[kAgent].close()
+    this[kClients].clear()
+  }
+
+  deactivate () {
+    this[kIsMockActive] = false
+  }
+
+  activate () {
+    this[kIsMockActive] = true
+  }
+
+  enableNetConnect (matcher) {
+    if (typeof matcher === 'string' || typeof matcher === 'function' || matcher instanceof RegExp) {
+      if (Array.isArray(this[kNetConnect])) {
+        this[kNetConnect].push(matcher)
+      } else {
+        this[kNetConnect] = [matcher]
+      }
+    } else if (typeof matcher === 'undefined') {
+      this[kNetConnect] = true
+    } else {
+      throw new InvalidArgumentError('Unsupported matcher. Must be one of String|Function|RegExp.')
+    }
+  }
+
+  disableNetConnect () {
+    this[kNetConnect] = false
+  }
+
+  // This is required to bypass issues caused by using global symbols - see:
+  // https://github.com/nodejs/undici/issues/1447
+  get isMockActive () {
+    return this[kIsMockActive]
+  }
+
+  [kMockAgentSet] (origin, dispatcher) {
+    this[kClients].set(origin, dispatcher)
+  }
+
+  [kFactory] (origin) {
+    const mockOptions = Object.assign({ agent: this }, this[kOptions])
+    return this[kOptions] && this[kOptions].connections === 1
+      ? new MockClient(origin, mockOptions)
+      : new MockPool(origin, mockOptions)
+  }
+
+  [kMockAgentGet] (origin) {
+    // First check if we can immediately find it
+    const client = this[kClients].get(origin)
+    if (client) {
+      return client
+    }
+
+    // If the origin is not a string create a dummy parent pool and return to user
+    if (typeof origin !== 'string') {
+      const dispatcher = this[kFactory]('http://localhost:9999')
+      this[kMockAgentSet](origin, dispatcher)
+      return dispatcher
+    }
+
+    // If we match, create a pool and assign the same dispatches
+    for (const [keyMatcher, nonExplicitDispatcher] of Array.from(this[kClients])) {
+      if (nonExplicitDispatcher && typeof keyMatcher !== 'string' && matchValue(keyMatcher, origin)) {
+        const dispatcher = this[kFactory](origin)
+        this[kMockAgentSet](origin, dispatcher)
+        dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches]
+        return dispatcher
+      }
+    }
+  }
+
+  [kGetNetConnect] () {
+    return this[kNetConnect]
+  }
+
+  pendingInterceptors () {
+    const mockAgentClients = this[kClients]
+
+    return Array.from(mockAgentClients.entries())
+      .flatMap(([origin, scope]) => scope[kDispatches].map(dispatch => ({ ...dispatch, origin })))
+      .filter(({ pending }) => pending)
+  }
+
+  assertNoPendingInterceptors ({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) {
+    const pending = this.pendingInterceptors()
+
+    if (pending.length === 0) {
+      return
+    }
+
+    const pluralizer = new Pluralizer('interceptor', 'interceptors').pluralize(pending.length)
+
+    throw new UndiciError(`
+${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending:
+
+${pendingInterceptorsFormatter.format(pending)}
+`.trim())
+  }
+}
+
+module.exports = MockAgent
+
+
+/***/ }),
+
+/***/ 32144:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { promisify } = __nccwpck_require__(47261)
+const Client = __nccwpck_require__(6655)
+const { buildMockDispatch } = __nccwpck_require__(94202)
+const {
+  kDispatches,
+  kMockAgent,
+  kClose,
+  kOriginalClose,
+  kOrigin,
+  kOriginalDispatch,
+  kConnected
+} = __nccwpck_require__(67296)
+const { MockInterceptor } = __nccwpck_require__(34800)
+const Symbols = __nccwpck_require__(5392)
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+
+/**
+ * MockClient provides an API that extends the Client to influence the mockDispatches.
+ */
+class MockClient extends Client {
+  constructor (origin, opts) {
+    super(origin, opts)
+
+    if (!opts || !opts.agent || typeof opts.agent.dispatch !== 'function') {
+      throw new InvalidArgumentError('Argument opts.agent must implement Agent')
+    }
+
+    this[kMockAgent] = opts.agent
+    this[kOrigin] = origin
+    this[kDispatches] = []
+    this[kConnected] = 1
+    this[kOriginalDispatch] = this.dispatch
+    this[kOriginalClose] = this.close.bind(this)
+
+    this.dispatch = buildMockDispatch.call(this)
+    this.close = this[kClose]
+  }
+
+  get [Symbols.kConnected] () {
+    return this[kConnected]
+  }
+
+  /**
+   * Sets up the base interceptor for mocking replies from undici.
+   */
+  intercept (opts) {
+    return new MockInterceptor(opts, this[kDispatches])
+  }
+
+  async [kClose] () {
+    await promisify(this[kOriginalClose])()
+    this[kConnected] = 0
+    this[kMockAgent][Symbols.kClients].delete(this[kOrigin])
+  }
+}
+
+module.exports = MockClient
+
+
+/***/ }),
+
+/***/ 54331:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { UndiciError } = __nccwpck_require__(22174)
+
+const kMockNotMatchedError = Symbol.for('undici.error.UND_MOCK_ERR_MOCK_NOT_MATCHED')
+
+/**
+ * The request does not match any registered mock dispatches.
+ */
+class MockNotMatchedError extends UndiciError {
+  constructor (message) {
+    super(message)
+    Error.captureStackTrace(this, MockNotMatchedError)
+    this.name = 'MockNotMatchedError'
+    this.message = message || 'The request does not match any registered mock dispatches'
+    this.code = 'UND_MOCK_ERR_MOCK_NOT_MATCHED'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kMockNotMatchedError] === true
+  }
+
+  [kMockNotMatchedError] = true
+}
+
+module.exports = {
+  MockNotMatchedError
+}
+
+
+/***/ }),
+
+/***/ 34800:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { getResponseData, buildKey, addMockDispatch } = __nccwpck_require__(94202)
+const {
+  kDispatches,
+  kDispatchKey,
+  kDefaultHeaders,
+  kDefaultTrailers,
+  kContentLength,
+  kMockDispatch
+} = __nccwpck_require__(67296)
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+const { buildURL } = __nccwpck_require__(94407)
+
+/**
+ * Defines the scope API for an interceptor reply
+ */
+class MockScope {
+  constructor (mockDispatch) {
+    this[kMockDispatch] = mockDispatch
+  }
+
+  /**
+   * Delay a reply by a set amount in ms.
+   */
+  delay (waitInMs) {
+    if (typeof waitInMs !== 'number' || !Number.isInteger(waitInMs) || waitInMs <= 0) {
+      throw new InvalidArgumentError('waitInMs must be a valid integer > 0')
+    }
+
+    this[kMockDispatch].delay = waitInMs
+    return this
+  }
+
+  /**
+   * For a defined reply, never mark as consumed.
+   */
+  persist () {
+    this[kMockDispatch].persist = true
+    return this
+  }
+
+  /**
+   * Allow one to define a reply for a set amount of matching requests.
+   */
+  times (repeatTimes) {
+    if (typeof repeatTimes !== 'number' || !Number.isInteger(repeatTimes) || repeatTimes <= 0) {
+      throw new InvalidArgumentError('repeatTimes must be a valid integer > 0')
+    }
+
+    this[kMockDispatch].times = repeatTimes
+    return this
+  }
+}
+
+/**
+ * Defines an interceptor for a Mock
+ */
+class MockInterceptor {
+  constructor (opts, mockDispatches) {
+    if (typeof opts !== 'object') {
+      throw new InvalidArgumentError('opts must be an object')
+    }
+    if (typeof opts.path === 'undefined') {
+      throw new InvalidArgumentError('opts.path must be defined')
+    }
+    if (typeof opts.method === 'undefined') {
+      opts.method = 'GET'
+    }
+    // See https://github.com/nodejs/undici/issues/1245
+    // As per RFC 3986, clients are not supposed to send URI
+    // fragments to servers when they retrieve a document,
+    if (typeof opts.path === 'string') {
+      if (opts.query) {
+        opts.path = buildURL(opts.path, opts.query)
+      } else {
+        // Matches https://github.com/nodejs/undici/blob/main/lib/web/fetch/index.js#L1811
+        const parsedURL = new URL(opts.path, 'data://')
+        opts.path = parsedURL.pathname + parsedURL.search
+      }
+    }
+    if (typeof opts.method === 'string') {
+      opts.method = opts.method.toUpperCase()
+    }
+
+    this[kDispatchKey] = buildKey(opts)
+    this[kDispatches] = mockDispatches
+    this[kDefaultHeaders] = {}
+    this[kDefaultTrailers] = {}
+    this[kContentLength] = false
+  }
+
+  createMockScopeDispatchData ({ statusCode, data, responseOptions }) {
+    const responseData = getResponseData(data)
+    const contentLength = this[kContentLength] ? { 'content-length': responseData.length } : {}
+    const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers }
+    const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers }
+
+    return { statusCode, data, headers, trailers }
+  }
+
+  validateReplyParameters (replyParameters) {
+    if (typeof replyParameters.statusCode === 'undefined') {
+      throw new InvalidArgumentError('statusCode must be defined')
+    }
+    if (typeof replyParameters.responseOptions !== 'object' || replyParameters.responseOptions === null) {
+      throw new InvalidArgumentError('responseOptions must be an object')
+    }
+  }
+
+  /**
+   * Mock an undici request with a defined reply.
+   */
+  reply (replyOptionsCallbackOrStatusCode) {
+    // Values of reply aren't available right now as they
+    // can only be available when the reply callback is invoked.
+    if (typeof replyOptionsCallbackOrStatusCode === 'function') {
+      // We'll first wrap the provided callback in another function,
+      // this function will properly resolve the data from the callback
+      // when invoked.
+      const wrappedDefaultsCallback = (opts) => {
+        // Our reply options callback contains the parameter for statusCode, data and options.
+        const resolvedData = replyOptionsCallbackOrStatusCode(opts)
+
+        // Check if it is in the right format
+        if (typeof resolvedData !== 'object' || resolvedData === null) {
+          throw new InvalidArgumentError('reply options callback must return an object')
+        }
+
+        const replyParameters = { data: '', responseOptions: {}, ...resolvedData }
+        this.validateReplyParameters(replyParameters)
+        // Since the values can be obtained immediately we return them
+        // from this higher order function that will be resolved later.
+        return {
+          ...this.createMockScopeDispatchData(replyParameters)
+        }
+      }
+
+      // Add usual dispatch data, but this time set the data parameter to function that will eventually provide data.
+      const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback)
+      return new MockScope(newMockDispatch)
+    }
+
+    // We can have either one or three parameters, if we get here,
+    // we should have 1-3 parameters. So we spread the arguments of
+    // this function to obtain the parameters, since replyData will always
+    // just be the statusCode.
+    const replyParameters = {
+      statusCode: replyOptionsCallbackOrStatusCode,
+      data: arguments[1] === undefined ? '' : arguments[1],
+      responseOptions: arguments[2] === undefined ? {} : arguments[2]
+    }
+    this.validateReplyParameters(replyParameters)
+
+    // Send in-already provided data like usual
+    const dispatchData = this.createMockScopeDispatchData(replyParameters)
+    const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData)
+    return new MockScope(newMockDispatch)
+  }
+
+  /**
+   * Mock an undici request with a defined error.
+   */
+  replyWithError (error) {
+    if (typeof error === 'undefined') {
+      throw new InvalidArgumentError('error must be defined')
+    }
+
+    const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error })
+    return new MockScope(newMockDispatch)
+  }
+
+  /**
+   * Set default reply headers on the interceptor for subsequent replies
+   */
+  defaultReplyHeaders (headers) {
+    if (typeof headers === 'undefined') {
+      throw new InvalidArgumentError('headers must be defined')
+    }
+
+    this[kDefaultHeaders] = headers
+    return this
+  }
+
+  /**
+   * Set default reply trailers on the interceptor for subsequent replies
+   */
+  defaultReplyTrailers (trailers) {
+    if (typeof trailers === 'undefined') {
+      throw new InvalidArgumentError('trailers must be defined')
+    }
+
+    this[kDefaultTrailers] = trailers
+    return this
+  }
+
+  /**
+   * Set reply content length header for replies on the interceptor
+   */
+  replyContentLength () {
+    this[kContentLength] = true
+    return this
+  }
+}
+
+module.exports.MockInterceptor = MockInterceptor
+module.exports.MockScope = MockScope
+
+
+/***/ }),
+
+/***/ 92565:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { promisify } = __nccwpck_require__(47261)
+const Pool = __nccwpck_require__(11795)
+const { buildMockDispatch } = __nccwpck_require__(94202)
+const {
+  kDispatches,
+  kMockAgent,
+  kClose,
+  kOriginalClose,
+  kOrigin,
+  kOriginalDispatch,
+  kConnected
+} = __nccwpck_require__(67296)
+const { MockInterceptor } = __nccwpck_require__(34800)
+const Symbols = __nccwpck_require__(5392)
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+
+/**
+ * MockPool provides an API that extends the Pool to influence the mockDispatches.
+ */
+class MockPool extends Pool {
+  constructor (origin, opts) {
+    super(origin, opts)
+
+    if (!opts || !opts.agent || typeof opts.agent.dispatch !== 'function') {
+      throw new InvalidArgumentError('Argument opts.agent must implement Agent')
+    }
+
+    this[kMockAgent] = opts.agent
+    this[kOrigin] = origin
+    this[kDispatches] = []
+    this[kConnected] = 1
+    this[kOriginalDispatch] = this.dispatch
+    this[kOriginalClose] = this.close.bind(this)
+
+    this.dispatch = buildMockDispatch.call(this)
+    this.close = this[kClose]
+  }
+
+  get [Symbols.kConnected] () {
+    return this[kConnected]
+  }
+
+  /**
+   * Sets up the base interceptor for mocking replies from undici.
+   */
+  intercept (opts) {
+    return new MockInterceptor(opts, this[kDispatches])
+  }
+
+  async [kClose] () {
+    await promisify(this[kOriginalClose])()
+    this[kConnected] = 0
+    this[kMockAgent][Symbols.kClients].delete(this[kOrigin])
+  }
+}
+
+module.exports = MockPool
+
+
+/***/ }),
+
+/***/ 67296:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = {
+  kAgent: Symbol('agent'),
+  kOptions: Symbol('options'),
+  kFactory: Symbol('factory'),
+  kDispatches: Symbol('dispatches'),
+  kDispatchKey: Symbol('dispatch key'),
+  kDefaultHeaders: Symbol('default headers'),
+  kDefaultTrailers: Symbol('default trailers'),
+  kContentLength: Symbol('content length'),
+  kMockAgent: Symbol('mock agent'),
+  kMockAgentSet: Symbol('mock agent set'),
+  kMockAgentGet: Symbol('mock agent get'),
+  kMockDispatch: Symbol('mock dispatch'),
+  kClose: Symbol('close'),
+  kOriginalClose: Symbol('original agent close'),
+  kOrigin: Symbol('origin'),
+  kIsMockActive: Symbol('is mock active'),
+  kNetConnect: Symbol('net connect'),
+  kGetNetConnect: Symbol('get net connect'),
+  kConnected: Symbol('connected')
+}
+
+
+/***/ }),
+
+/***/ 94202:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { MockNotMatchedError } = __nccwpck_require__(54331)
+const {
+  kDispatches,
+  kMockAgent,
+  kOriginalDispatch,
+  kOrigin,
+  kGetNetConnect
+} = __nccwpck_require__(67296)
+const { buildURL } = __nccwpck_require__(94407)
+const { STATUS_CODES } = __nccwpck_require__(88849)
+const {
+  types: {
+    isPromise
+  }
+} = __nccwpck_require__(47261)
+
+function matchValue (match, value) {
+  if (typeof match === 'string') {
+    return match === value
+  }
+  if (match instanceof RegExp) {
+    return match.test(value)
+  }
+  if (typeof match === 'function') {
+    return match(value) === true
+  }
+  return false
+}
+
+function lowerCaseEntries (headers) {
+  return Object.fromEntries(
+    Object.entries(headers).map(([headerName, headerValue]) => {
+      return [headerName.toLocaleLowerCase(), headerValue]
+    })
+  )
+}
+
+/**
+ * @param {import('../../index').Headers|string[]|Record<string, string>} headers
+ * @param {string} key
+ */
+function getHeaderByName (headers, key) {
+  if (Array.isArray(headers)) {
+    for (let i = 0; i < headers.length; i += 2) {
+      if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) {
+        return headers[i + 1]
+      }
+    }
+
+    return undefined
+  } else if (typeof headers.get === 'function') {
+    return headers.get(key)
+  } else {
+    return lowerCaseEntries(headers)[key.toLocaleLowerCase()]
+  }
+}
+
+/** @param {string[]} headers */
+function buildHeadersFromArray (headers) { // fetch HeadersList
+  const clone = headers.slice()
+  const entries = []
+  for (let index = 0; index < clone.length; index += 2) {
+    entries.push([clone[index], clone[index + 1]])
+  }
+  return Object.fromEntries(entries)
+}
+
+function matchHeaders (mockDispatch, headers) {
+  if (typeof mockDispatch.headers === 'function') {
+    if (Array.isArray(headers)) { // fetch HeadersList
+      headers = buildHeadersFromArray(headers)
+    }
+    return mockDispatch.headers(headers ? lowerCaseEntries(headers) : {})
+  }
+  if (typeof mockDispatch.headers === 'undefined') {
+    return true
+  }
+  if (typeof headers !== 'object' || typeof mockDispatch.headers !== 'object') {
+    return false
+  }
+
+  for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch.headers)) {
+    const headerValue = getHeaderByName(headers, matchHeaderName)
+
+    if (!matchValue(matchHeaderValue, headerValue)) {
+      return false
+    }
+  }
+  return true
+}
+
+function safeUrl (path) {
+  if (typeof path !== 'string') {
+    return path
+  }
+
+  const pathSegments = path.split('?')
+
+  if (pathSegments.length !== 2) {
+    return path
+  }
+
+  const qp = new URLSearchParams(pathSegments.pop())
+  qp.sort()
+  return [...pathSegments, qp.toString()].join('?')
+}
+
+function matchKey (mockDispatch, { path, method, body, headers }) {
+  const pathMatch = matchValue(mockDispatch.path, path)
+  const methodMatch = matchValue(mockDispatch.method, method)
+  const bodyMatch = typeof mockDispatch.body !== 'undefined' ? matchValue(mockDispatch.body, body) : true
+  const headersMatch = matchHeaders(mockDispatch, headers)
+  return pathMatch && methodMatch && bodyMatch && headersMatch
+}
+
+function getResponseData (data) {
+  if (Buffer.isBuffer(data)) {
+    return data
+  } else if (data instanceof Uint8Array) {
+    return data
+  } else if (data instanceof ArrayBuffer) {
+    return data
+  } else if (typeof data === 'object') {
+    return JSON.stringify(data)
+  } else {
+    return data.toString()
+  }
+}
+
+function getMockDispatch (mockDispatches, key) {
+  const basePath = key.query ? buildURL(key.path, key.query) : key.path
+  const resolvedPath = typeof basePath === 'string' ? safeUrl(basePath) : basePath
+
+  // Match path
+  let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path }) => matchValue(safeUrl(path), resolvedPath))
+  if (matchedMockDispatches.length === 0) {
+    throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`)
+  }
+
+  // Match method
+  matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method))
+  if (matchedMockDispatches.length === 0) {
+    throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}' on path '${resolvedPath}'`)
+  }
+
+  // Match body
+  matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== 'undefined' ? matchValue(body, key.body) : true)
+  if (matchedMockDispatches.length === 0) {
+    throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}' on path '${resolvedPath}'`)
+  }
+
+  // Match headers
+  matchedMockDispatches = matchedMockDispatches.filter((mockDispatch) => matchHeaders(mockDispatch, key.headers))
+  if (matchedMockDispatches.length === 0) {
+    const headers = typeof key.headers === 'object' ? JSON.stringify(key.headers) : key.headers
+    throw new MockNotMatchedError(`Mock dispatch not matched for headers '${headers}' on path '${resolvedPath}'`)
+  }
+
+  return matchedMockDispatches[0]
+}
+
+function addMockDispatch (mockDispatches, key, data) {
+  const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false }
+  const replyData = typeof data === 'function' ? { callback: data } : { ...data }
+  const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } }
+  mockDispatches.push(newMockDispatch)
+  return newMockDispatch
+}
+
+function deleteMockDispatch (mockDispatches, key) {
+  const index = mockDispatches.findIndex(dispatch => {
+    if (!dispatch.consumed) {
+      return false
+    }
+    return matchKey(dispatch, key)
+  })
+  if (index !== -1) {
+    mockDispatches.splice(index, 1)
+  }
+}
+
+function buildKey (opts) {
+  const { path, method, body, headers, query } = opts
+  return {
+    path,
+    method,
+    body,
+    headers,
+    query
+  }
+}
+
+function generateKeyValues (data) {
+  const keys = Object.keys(data)
+  const result = []
+  for (let i = 0; i < keys.length; ++i) {
+    const key = keys[i]
+    const value = data[key]
+    const name = Buffer.from(`${key}`)
+    if (Array.isArray(value)) {
+      for (let j = 0; j < value.length; ++j) {
+        result.push(name, Buffer.from(`${value[j]}`))
+      }
+    } else {
+      result.push(name, Buffer.from(`${value}`))
+    }
+  }
+  return result
+}
+
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
+ * @param {number} statusCode
+ */
+function getStatusText (statusCode) {
+  return STATUS_CODES[statusCode] || 'unknown'
+}
+
+async function getResponse (body) {
+  const buffers = []
+  for await (const data of body) {
+    buffers.push(data)
+  }
+  return Buffer.concat(buffers).toString('utf8')
+}
+
+/**
+ * Mock dispatch function used to simulate undici dispatches
+ */
+function mockDispatch (opts, handler) {
+  // Get mock dispatch from built key
+  const key = buildKey(opts)
+  const mockDispatch = getMockDispatch(this[kDispatches], key)
+
+  mockDispatch.timesInvoked++
+
+  // Here's where we resolve a callback if a callback is present for the dispatch data.
+  if (mockDispatch.data.callback) {
+    mockDispatch.data = { ...mockDispatch.data, ...mockDispatch.data.callback(opts) }
+  }
+
+  // Parse mockDispatch data
+  const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch
+  const { timesInvoked, times } = mockDispatch
+
+  // If it's used up and not persistent, mark as consumed
+  mockDispatch.consumed = !persist && timesInvoked >= times
+  mockDispatch.pending = timesInvoked < times
+
+  // If specified, trigger dispatch error
+  if (error !== null) {
+    deleteMockDispatch(this[kDispatches], key)
+    handler.onError(error)
+    return true
+  }
+
+  // Handle the request with a delay if necessary
+  if (typeof delay === 'number' && delay > 0) {
+    setTimeout(() => {
+      handleReply(this[kDispatches])
+    }, delay)
+  } else {
+    handleReply(this[kDispatches])
+  }
+
+  function handleReply (mockDispatches, _data = data) {
+    // fetch's HeadersList is a 1D string array
+    const optsHeaders = Array.isArray(opts.headers)
+      ? buildHeadersFromArray(opts.headers)
+      : opts.headers
+    const body = typeof _data === 'function'
+      ? _data({ ...opts, headers: optsHeaders })
+      : _data
+
+    // util.types.isPromise is likely needed for jest.
+    if (isPromise(body)) {
+      // If handleReply is asynchronous, throwing an error
+      // in the callback will reject the promise, rather than
+      // synchronously throw the error, which breaks some tests.
+      // Rather, we wait for the callback to resolve if it is a
+      // promise, and then re-run handleReply with the new body.
+      body.then((newData) => handleReply(mockDispatches, newData))
+      return
+    }
+
+    const responseData = getResponseData(body)
+    const responseHeaders = generateKeyValues(headers)
+    const responseTrailers = generateKeyValues(trailers)
+
+    handler.onConnect?.(err => handler.onError(err), null)
+    handler.onHeaders?.(statusCode, responseHeaders, resume, getStatusText(statusCode))
+    handler.onData?.(Buffer.from(responseData))
+    handler.onComplete?.(responseTrailers)
+    deleteMockDispatch(mockDispatches, key)
+  }
+
+  function resume () {}
+
+  return true
+}
+
+function buildMockDispatch () {
+  const agent = this[kMockAgent]
+  const origin = this[kOrigin]
+  const originalDispatch = this[kOriginalDispatch]
+
+  return function dispatch (opts, handler) {
+    if (agent.isMockActive) {
+      try {
+        mockDispatch.call(this, opts, handler)
+      } catch (error) {
+        if (error instanceof MockNotMatchedError) {
+          const netConnect = agent[kGetNetConnect]()
+          if (netConnect === false) {
+            throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`)
+          }
+          if (checkNetConnect(netConnect, origin)) {
+            originalDispatch.call(this, opts, handler)
+          } else {
+            throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`)
+          }
+        } else {
+          throw error
+        }
+      }
+    } else {
+      originalDispatch.call(this, opts, handler)
+    }
+  }
+}
+
+function checkNetConnect (netConnect, origin) {
+  const url = new URL(origin)
+  if (netConnect === true) {
+    return true
+  } else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) {
+    return true
+  }
+  return false
+}
+
+function buildMockOptions (opts) {
+  if (opts) {
+    const { agent, ...mockOptions } = opts
+    return mockOptions
+  }
+}
+
+module.exports = {
+  getResponseData,
+  getMockDispatch,
+  addMockDispatch,
+  deleteMockDispatch,
+  buildKey,
+  generateKeyValues,
+  matchValue,
+  getResponse,
+  getStatusText,
+  mockDispatch,
+  buildMockDispatch,
+  checkNetConnect,
+  buildMockOptions,
+  getHeaderByName,
+  buildHeadersFromArray
+}
+
+
+/***/ }),
+
+/***/ 70698:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Transform } = __nccwpck_require__(84492)
+const { Console } = __nccwpck_require__(40027)
+
+const PERSISTENT = process.versions.icu ? '✅' : 'Y '
+const NOT_PERSISTENT = process.versions.icu ? '❌' : 'N '
+
+/**
+ * Gets the output of `console.table(…)` as a string.
+ */
+module.exports = class PendingInterceptorsFormatter {
+  constructor ({ disableColors } = {}) {
+    this.transform = new Transform({
+      transform (chunk, _enc, cb) {
+        cb(null, chunk)
+      }
+    })
+
+    this.logger = new Console({
+      stdout: this.transform,
+      inspectOptions: {
+        colors: !disableColors && !process.env.CI
+      }
+    })
+  }
+
+  format (pendingInterceptors) {
+    const withPrettyHeaders = pendingInterceptors.map(
+      ({ method, path, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+        Method: method,
+        Origin: origin,
+        Path: path,
+        'Status code': statusCode,
+        Persistent: persist ? PERSISTENT : NOT_PERSISTENT,
+        Invocations: timesInvoked,
+        Remaining: persist ? Infinity : times - timesInvoked
+      }))
+
+    this.logger.table(withPrettyHeaders)
+    return this.transform.read().toString()
+  }
+}
+
+
+/***/ }),
+
+/***/ 77551:
+/***/ ((module) => {
+
+"use strict";
+
+
+const singulars = {
+  pronoun: 'it',
+  is: 'is',
+  was: 'was',
+  this: 'this'
+}
+
+const plurals = {
+  pronoun: 'they',
+  is: 'are',
+  was: 'were',
+  this: 'these'
+}
+
+module.exports = class Pluralizer {
+  constructor (singular, plural) {
+    this.singular = singular
+    this.plural = plural
+  }
+
+  pluralize (count) {
+    const one = count === 1
+    const keys = one ? singulars : plurals
+    const noun = one ? this.singular : this.plural
+    return { ...keys, count, noun }
+  }
+}
+
+
+/***/ }),
+
+/***/ 48413:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * This module offers an optimized timer implementation designed for scenarios
+ * where high precision is not critical.
+ *
+ * The timer achieves faster performance by using a low-resolution approach,
+ * with an accuracy target of within 500ms. This makes it particularly useful
+ * for timers with delays of 1 second or more, where exact timing is less
+ * crucial.
+ *
+ * It's important to note that Node.js timers are inherently imprecise, as
+ * delays can occur due to the event loop being blocked by other operations.
+ * Consequently, timers may trigger later than their scheduled time.
+ */
+
+/**
+ * The fastNow variable contains the internal fast timer clock value.
+ *
+ * @type {number}
+ */
+let fastNow = 0
+
+/**
+ * RESOLUTION_MS represents the target resolution time in milliseconds.
+ *
+ * @type {number}
+ * @default 1000
+ */
+const RESOLUTION_MS = 1e3
+
+/**
+ * TICK_MS defines the desired interval in milliseconds between each tick.
+ * The target value is set to half the resolution time, minus 1 ms, to account
+ * for potential event loop overhead.
+ *
+ * @type {number}
+ * @default 499
+ */
+const TICK_MS = (RESOLUTION_MS >> 1) - 1
+
+/**
+ * fastNowTimeout is a Node.js timer used to manage and process
+ * the FastTimers stored in the `fastTimers` array.
+ *
+ * @type {NodeJS.Timeout}
+ */
+let fastNowTimeout
+
+/**
+ * The kFastTimer symbol is used to identify FastTimer instances.
+ *
+ * @type {Symbol}
+ */
+const kFastTimer = Symbol('kFastTimer')
+
+/**
+ * The fastTimers array contains all active FastTimers.
+ *
+ * @type {FastTimer[]}
+ */
+const fastTimers = []
+
+/**
+ * These constants represent the various states of a FastTimer.
+ */
+
+/**
+ * The `NOT_IN_LIST` constant indicates that the FastTimer is not included
+ * in the `fastTimers` array. Timers with this status will not be processed
+ * during the next tick by the `onTick` function.
+ *
+ * A FastTimer can be re-added to the `fastTimers` array by invoking the
+ * `refresh` method on the FastTimer instance.
+ *
+ * @type {-2}
+ */
+const NOT_IN_LIST = -2
+
+/**
+ * The `TO_BE_CLEARED` constant indicates that the FastTimer is scheduled
+ * for removal from the `fastTimers` array. A FastTimer in this state will
+ * be removed in the next tick by the `onTick` function and will no longer
+ * be processed.
+ *
+ * This status is also set when the `clear` method is called on the FastTimer instance.
+ *
+ * @type {-1}
+ */
+const TO_BE_CLEARED = -1
+
+/**
+ * The `PENDING` constant signifies that the FastTimer is awaiting processing
+ * in the next tick by the `onTick` function. Timers with this status will have
+ * their `_idleStart` value set and their status updated to `ACTIVE` in the next tick.
+ *
+ * @type {0}
+ */
+const PENDING = 0
+
+/**
+ * The `ACTIVE` constant indicates that the FastTimer is active and waiting
+ * for its timer to expire. During the next tick, the `onTick` function will
+ * check if the timer has expired, and if so, it will execute the associated callback.
+ *
+ * @type {1}
+ */
+const ACTIVE = 1
+
+/**
+ * The onTick function processes the fastTimers array.
+ *
+ * @returns {void}
+ */
+function onTick () {
+  /**
+   * Increment the fastNow value by the TICK_MS value, despite the actual time
+   * that has passed since the last tick. This approach ensures independence
+   * from the system clock and delays caused by a blocked event loop.
+   *
+   * @type {number}
+   */
+  fastNow += TICK_MS
+
+  /**
+   * The `idx` variable is used to iterate over the `fastTimers` array.
+   * Expired timers are removed by replacing them with the last element in the array.
+   * Consequently, `idx` is only incremented when the current element is not removed.
+   *
+   * @type {number}
+   */
+  let idx = 0
+
+  /**
+   * The len variable will contain the length of the fastTimers array
+   * and will be decremented when a FastTimer should be removed from the
+   * fastTimers array.
+   *
+   * @type {number}
+   */
+  let len = fastTimers.length
+
+  while (idx < len) {
+    /**
+     * @type {FastTimer}
+     */
+    const timer = fastTimers[idx]
+
+    // If the timer is in the ACTIVE state and the timer has expired, it will
+    // be processed in the next tick.
+    if (timer._state === PENDING) {
+      // Set the _idleStart value to the fastNow value minus the TICK_MS value
+      // to account for the time the timer was in the PENDING state.
+      timer._idleStart = fastNow - TICK_MS
+      timer._state = ACTIVE
+    } else if (
+      timer._state === ACTIVE &&
+      fastNow >= timer._idleStart + timer._idleTimeout
+    ) {
+      timer._state = TO_BE_CLEARED
+      timer._idleStart = -1
+      timer._onTimeout(timer._timerArg)
+    }
+
+    if (timer._state === TO_BE_CLEARED) {
+      timer._state = NOT_IN_LIST
+
+      // Move the last element to the current index and decrement len if it is
+      // not the only element in the array.
+      if (--len !== 0) {
+        fastTimers[idx] = fastTimers[len]
+      }
+    } else {
+      ++idx
+    }
+  }
+
+  // Set the length of the fastTimers array to the new length and thus
+  // removing the excess FastTimers elements from the array.
+  fastTimers.length = len
+
+  // If there are still active FastTimers in the array, refresh the Timer.
+  // If there are no active FastTimers, the timer will be refreshed again
+  // when a new FastTimer is instantiated.
+  if (fastTimers.length !== 0) {
+    refreshTimeout()
+  }
+}
+
+function refreshTimeout () {
+  // If the fastNowTimeout is already set, refresh it.
+  if (fastNowTimeout) {
+    fastNowTimeout.refresh()
+  // fastNowTimeout is not instantiated yet, create a new Timer.
+  } else {
+    clearTimeout(fastNowTimeout)
+    fastNowTimeout = setTimeout(onTick, TICK_MS)
+
+    // If the Timer has an unref method, call it to allow the process to exit if
+    // there are no other active handles.
+    if (fastNowTimeout.unref) {
+      fastNowTimeout.unref()
+    }
+  }
+}
+
+/**
+ * The `FastTimer` class is a data structure designed to store and manage
+ * timer information.
+ */
+class FastTimer {
+  [kFastTimer] = true
+
+  /**
+   * The state of the timer, which can be one of the following:
+   * - NOT_IN_LIST (-2)
+   * - TO_BE_CLEARED (-1)
+   * - PENDING (0)
+   * - ACTIVE (1)
+   *
+   * @type {-2|-1|0|1}
+   * @private
+   */
+  _state = NOT_IN_LIST
+
+  /**
+   * The number of milliseconds to wait before calling the callback.
+   *
+   * @type {number}
+   * @private
+   */
+  _idleTimeout = -1
+
+  /**
+   * The time in milliseconds when the timer was started. This value is used to
+   * calculate when the timer should expire.
+   *
+   * @type {number}
+   * @default -1
+   * @private
+   */
+  _idleStart = -1
+
+  /**
+   * The function to be executed when the timer expires.
+   * @type {Function}
+   * @private
+   */
+  _onTimeout
+
+  /**
+   * The argument to be passed to the callback when the timer expires.
+   *
+   * @type {*}
+   * @private
+   */
+  _timerArg
+
+  /**
+   * @constructor
+   * @param {Function} callback A function to be executed after the timer
+   * expires.
+   * @param {number} delay The time, in milliseconds that the timer should wait
+   * before the specified function or code is executed.
+   * @param {*} arg
+   */
+  constructor (callback, delay, arg) {
+    this._onTimeout = callback
+    this._idleTimeout = delay
+    this._timerArg = arg
+
+    this.refresh()
+  }
+
+  /**
+   * Sets the timer's start time to the current time, and reschedules the timer
+   * to call its callback at the previously specified duration adjusted to the
+   * current time.
+   * Using this on a timer that has already called its callback will reactivate
+   * the timer.
+   *
+   * @returns {void}
+   */
+  refresh () {
+    // In the special case that the timer is not in the list of active timers,
+    // add it back to the array to be processed in the next tick by the onTick
+    // function.
+    if (this._state === NOT_IN_LIST) {
+      fastTimers.push(this)
+    }
+
+    // If the timer is the only active timer, refresh the fastNowTimeout for
+    // better resolution.
+    if (!fastNowTimeout || fastTimers.length === 1) {
+      refreshTimeout()
+    }
+
+    // Setting the state to PENDING will cause the timer to be reset in the
+    // next tick by the onTick function.
+    this._state = PENDING
+  }
+
+  /**
+   * The `clear` method cancels the timer, preventing it from executing.
+   *
+   * @returns {void}
+   * @private
+   */
+  clear () {
+    // Set the state to TO_BE_CLEARED to mark the timer for removal in the next
+    // tick by the onTick function.
+    this._state = TO_BE_CLEARED
+
+    // Reset the _idleStart value to -1 to indicate that the timer is no longer
+    // active.
+    this._idleStart = -1
+  }
+}
+
+/**
+ * This module exports a setTimeout and clearTimeout function that can be
+ * used as a drop-in replacement for the native functions.
+ */
+module.exports = {
+  /**
+   * The setTimeout() method sets a timer which executes a function once the
+   * timer expires.
+   * @param {Function} callback A function to be executed after the timer
+   * expires.
+   * @param {number} delay The time, in milliseconds that the timer should
+   * wait before the specified function or code is executed.
+   * @param {*} [arg] An optional argument to be passed to the callback function
+   * when the timer expires.
+   * @returns {NodeJS.Timeout|FastTimer}
+   */
+  setTimeout (callback, delay, arg) {
+    // If the delay is less than or equal to the RESOLUTION_MS value return a
+    // native Node.js Timer instance.
+    return delay <= RESOLUTION_MS
+      ? setTimeout(callback, delay, arg)
+      : new FastTimer(callback, delay, arg)
+  },
+  /**
+   * The clearTimeout method cancels an instantiated Timer previously created
+   * by calling setTimeout.
+   *
+   * @param {NodeJS.Timeout|FastTimer} timeout
+   */
+  clearTimeout (timeout) {
+    // If the timeout is a FastTimer, call its own clear method.
+    if (timeout[kFastTimer]) {
+      /**
+       * @type {FastTimer}
+       */
+      timeout.clear()
+      // Otherwise it is an instance of a native NodeJS.Timeout, so call the
+      // Node.js native clearTimeout function.
+    } else {
+      clearTimeout(timeout)
+    }
+  },
+  /**
+   * The setFastTimeout() method sets a fastTimer which executes a function once
+   * the timer expires.
+   * @param {Function} callback A function to be executed after the timer
+   * expires.
+   * @param {number} delay The time, in milliseconds that the timer should
+   * wait before the specified function or code is executed.
+   * @param {*} [arg] An optional argument to be passed to the callback function
+   * when the timer expires.
+   * @returns {FastTimer}
+   */
+  setFastTimeout (callback, delay, arg) {
+    return new FastTimer(callback, delay, arg)
+  },
+  /**
+   * The clearTimeout method cancels an instantiated FastTimer previously
+   * created by calling setFastTimeout.
+   *
+   * @param {FastTimer} timeout
+   */
+  clearFastTimeout (timeout) {
+    timeout.clear()
+  },
+  /**
+   * The now method returns the value of the internal fast timer clock.
+   *
+   * @returns {number}
+   */
+  now () {
+    return fastNow
+  },
+  /**
+   * Trigger the onTick function to process the fastTimers array.
+   * Exported for testing purposes only.
+   * Marking as deprecated to discourage any use outside of testing.
+   * @deprecated
+   * @param {number} [delay=0] The delay in milliseconds to add to the now value.
+   */
+  tick (delay = 0) {
+    fastNow += delay - RESOLUTION_MS + 1
+    onTick()
+    onTick()
+  },
+  /**
+   * Reset FastTimers.
+   * Exported for testing purposes only.
+   * Marking as deprecated to discourage any use outside of testing.
+   * @deprecated
+   */
+  reset () {
+    fastNow = 0
+    fastTimers.length = 0
+    clearTimeout(fastNowTimeout)
+    fastNowTimeout = null
+  },
+  /**
+   * Exporting for testing purposes only.
+   * Marking as deprecated to discourage any use outside of testing.
+   * @deprecated
+   */
+  kFastTimer
+}
+
+
+/***/ }),
+
+/***/ 61821:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kConstruct } = __nccwpck_require__(90053)
+const { urlEquals, getFieldValues } = __nccwpck_require__(63166)
+const { kEnumerableProperty, isDisturbed } = __nccwpck_require__(94407)
+const { webidl } = __nccwpck_require__(37829)
+const { Response, cloneResponse, fromInnerResponse } = __nccwpck_require__(33139)
+const { Request, fromInnerRequest } = __nccwpck_require__(13925)
+const { kState } = __nccwpck_require__(78172)
+const { fetching } = __nccwpck_require__(31158)
+const { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = __nccwpck_require__(91976)
+const assert = __nccwpck_require__(98061)
+
+/**
+ * @see https://w3c.github.io/ServiceWorker/#dfn-cache-batch-operation
+ * @typedef {Object} CacheBatchOperation
+ * @property {'delete' | 'put'} type
+ * @property {any} request
+ * @property {any} response
+ * @property {import('../../types/cache').CacheQueryOptions} options
+ */
+
+/**
+ * @see https://w3c.github.io/ServiceWorker/#dfn-request-response-list
+ * @typedef {[any, any][]} requestResponseList
+ */
+
+class Cache {
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list
+   * @type {requestResponseList}
+   */
+  #relevantRequestResponseList
+
+  constructor () {
+    if (arguments[0] !== kConstruct) {
+      webidl.illegalConstructor()
+    }
+
+    webidl.util.markAsUncloneable(this)
+    this.#relevantRequestResponseList = arguments[1]
+  }
+
+  async match (request, options = {}) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.match'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    request = webidl.converters.RequestInfo(request, prefix, 'request')
+    options = webidl.converters.CacheQueryOptions(options, prefix, 'options')
+
+    const p = this.#internalMatchAll(request, options, 1)
+
+    if (p.length === 0) {
+      return
+    }
+
+    return p[0]
+  }
+
+  async matchAll (request = undefined, options = {}) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.matchAll'
+    if (request !== undefined) request = webidl.converters.RequestInfo(request, prefix, 'request')
+    options = webidl.converters.CacheQueryOptions(options, prefix, 'options')
+
+    return this.#internalMatchAll(request, options)
+  }
+
+  async add (request) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.add'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    request = webidl.converters.RequestInfo(request, prefix, 'request')
+
+    // 1.
+    const requests = [request]
+
+    // 2.
+    const responseArrayPromise = this.addAll(requests)
+
+    // 3.
+    return await responseArrayPromise
+  }
+
+  async addAll (requests) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.addAll'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    // 1.
+    const responsePromises = []
+
+    // 2.
+    const requestList = []
+
+    // 3.
+    for (let request of requests) {
+      if (request === undefined) {
+        throw webidl.errors.conversionFailed({
+          prefix,
+          argument: 'Argument 1',
+          types: ['undefined is not allowed']
+        })
+      }
+
+      request = webidl.converters.RequestInfo(request)
+
+      if (typeof request === 'string') {
+        continue
+      }
+
+      // 3.1
+      const r = request[kState]
+
+      // 3.2
+      if (!urlIsHttpHttpsScheme(r.url) || r.method !== 'GET') {
+        throw webidl.errors.exception({
+          header: prefix,
+          message: 'Expected http/s scheme when method is not GET.'
+        })
+      }
+    }
+
+    // 4.
+    /** @type {ReturnType<typeof fetching>[]} */
+    const fetchControllers = []
+
+    // 5.
+    for (const request of requests) {
+      // 5.1
+      const r = new Request(request)[kState]
+
+      // 5.2
+      if (!urlIsHttpHttpsScheme(r.url)) {
+        throw webidl.errors.exception({
+          header: prefix,
+          message: 'Expected http/s scheme.'
+        })
+      }
+
+      // 5.4
+      r.initiator = 'fetch'
+      r.destination = 'subresource'
+
+      // 5.5
+      requestList.push(r)
+
+      // 5.6
+      const responsePromise = createDeferredPromise()
+
+      // 5.7
+      fetchControllers.push(fetching({
+        request: r,
+        processResponse (response) {
+          // 1.
+          if (response.type === 'error' || response.status === 206 || response.status < 200 || response.status > 299) {
+            responsePromise.reject(webidl.errors.exception({
+              header: 'Cache.addAll',
+              message: 'Received an invalid status code or the request failed.'
+            }))
+          } else if (response.headersList.contains('vary')) { // 2.
+            // 2.1
+            const fieldValues = getFieldValues(response.headersList.get('vary'))
+
+            // 2.2
+            for (const fieldValue of fieldValues) {
+              // 2.2.1
+              if (fieldValue === '*') {
+                responsePromise.reject(webidl.errors.exception({
+                  header: 'Cache.addAll',
+                  message: 'invalid vary field value'
+                }))
+
+                for (const controller of fetchControllers) {
+                  controller.abort()
+                }
+
+                return
+              }
+            }
+          }
+        },
+        processResponseEndOfBody (response) {
+          // 1.
+          if (response.aborted) {
+            responsePromise.reject(new DOMException('aborted', 'AbortError'))
+            return
+          }
+
+          // 2.
+          responsePromise.resolve(response)
+        }
+      }))
+
+      // 5.8
+      responsePromises.push(responsePromise.promise)
+    }
+
+    // 6.
+    const p = Promise.all(responsePromises)
+
+    // 7.
+    const responses = await p
+
+    // 7.1
+    const operations = []
+
+    // 7.2
+    let index = 0
+
+    // 7.3
+    for (const response of responses) {
+      // 7.3.1
+      /** @type {CacheBatchOperation} */
+      const operation = {
+        type: 'put', // 7.3.2
+        request: requestList[index], // 7.3.3
+        response // 7.3.4
+      }
+
+      operations.push(operation) // 7.3.5
+
+      index++ // 7.3.6
+    }
+
+    // 7.5
+    const cacheJobPromise = createDeferredPromise()
+
+    // 7.6.1
+    let errorData = null
+
+    // 7.6.2
+    try {
+      this.#batchCacheOperations(operations)
+    } catch (e) {
+      errorData = e
+    }
+
+    // 7.6.3
+    queueMicrotask(() => {
+      // 7.6.3.1
+      if (errorData === null) {
+        cacheJobPromise.resolve(undefined)
+      } else {
+        // 7.6.3.2
+        cacheJobPromise.reject(errorData)
+      }
+    })
+
+    // 7.7
+    return cacheJobPromise.promise
+  }
+
+  async put (request, response) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.put'
+    webidl.argumentLengthCheck(arguments, 2, prefix)
+
+    request = webidl.converters.RequestInfo(request, prefix, 'request')
+    response = webidl.converters.Response(response, prefix, 'response')
+
+    // 1.
+    let innerRequest = null
+
+    // 2.
+    if (request instanceof Request) {
+      innerRequest = request[kState]
+    } else { // 3.
+      innerRequest = new Request(request)[kState]
+    }
+
+    // 4.
+    if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== 'GET') {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: 'Expected an http/s scheme when method is not GET'
+      })
+    }
+
+    // 5.
+    const innerResponse = response[kState]
+
+    // 6.
+    if (innerResponse.status === 206) {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: 'Got 206 status'
+      })
+    }
+
+    // 7.
+    if (innerResponse.headersList.contains('vary')) {
+      // 7.1.
+      const fieldValues = getFieldValues(innerResponse.headersList.get('vary'))
+
+      // 7.2.
+      for (const fieldValue of fieldValues) {
+        // 7.2.1
+        if (fieldValue === '*') {
+          throw webidl.errors.exception({
+            header: prefix,
+            message: 'Got * vary field value'
+          })
+        }
+      }
+    }
+
+    // 8.
+    if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: 'Response body is locked or disturbed'
+      })
+    }
+
+    // 9.
+    const clonedResponse = cloneResponse(innerResponse)
+
+    // 10.
+    const bodyReadPromise = createDeferredPromise()
+
+    // 11.
+    if (innerResponse.body != null) {
+      // 11.1
+      const stream = innerResponse.body.stream
+
+      // 11.2
+      const reader = stream.getReader()
+
+      // 11.3
+      readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject)
+    } else {
+      bodyReadPromise.resolve(undefined)
+    }
+
+    // 12.
+    /** @type {CacheBatchOperation[]} */
+    const operations = []
+
+    // 13.
+    /** @type {CacheBatchOperation} */
+    const operation = {
+      type: 'put', // 14.
+      request: innerRequest, // 15.
+      response: clonedResponse // 16.
+    }
+
+    // 17.
+    operations.push(operation)
+
+    // 19.
+    const bytes = await bodyReadPromise.promise
+
+    if (clonedResponse.body != null) {
+      clonedResponse.body.source = bytes
+    }
+
+    // 19.1
+    const cacheJobPromise = createDeferredPromise()
+
+    // 19.2.1
+    let errorData = null
+
+    // 19.2.2
+    try {
+      this.#batchCacheOperations(operations)
+    } catch (e) {
+      errorData = e
+    }
+
+    // 19.2.3
+    queueMicrotask(() => {
+      // 19.2.3.1
+      if (errorData === null) {
+        cacheJobPromise.resolve()
+      } else { // 19.2.3.2
+        cacheJobPromise.reject(errorData)
+      }
+    })
+
+    return cacheJobPromise.promise
+  }
+
+  async delete (request, options = {}) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.delete'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    request = webidl.converters.RequestInfo(request, prefix, 'request')
+    options = webidl.converters.CacheQueryOptions(options, prefix, 'options')
+
+    /**
+     * @type {Request}
+     */
+    let r = null
+
+    if (request instanceof Request) {
+      r = request[kState]
+
+      if (r.method !== 'GET' && !options.ignoreMethod) {
+        return false
+      }
+    } else {
+      assert(typeof request === 'string')
+
+      r = new Request(request)[kState]
+    }
+
+    /** @type {CacheBatchOperation[]} */
+    const operations = []
+
+    /** @type {CacheBatchOperation} */
+    const operation = {
+      type: 'delete',
+      request: r,
+      options
+    }
+
+    operations.push(operation)
+
+    const cacheJobPromise = createDeferredPromise()
+
+    let errorData = null
+    let requestResponses
+
+    try {
+      requestResponses = this.#batchCacheOperations(operations)
+    } catch (e) {
+      errorData = e
+    }
+
+    queueMicrotask(() => {
+      if (errorData === null) {
+        cacheJobPromise.resolve(!!requestResponses?.length)
+      } else {
+        cacheJobPromise.reject(errorData)
+      }
+    })
+
+    return cacheJobPromise.promise
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#dom-cache-keys
+   * @param {any} request
+   * @param {import('../../types/cache').CacheQueryOptions} options
+   * @returns {Promise<readonly Request[]>}
+   */
+  async keys (request = undefined, options = {}) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.keys'
+
+    if (request !== undefined) request = webidl.converters.RequestInfo(request, prefix, 'request')
+    options = webidl.converters.CacheQueryOptions(options, prefix, 'options')
+
+    // 1.
+    let r = null
+
+    // 2.
+    if (request !== undefined) {
+      // 2.1
+      if (request instanceof Request) {
+        // 2.1.1
+        r = request[kState]
+
+        // 2.1.2
+        if (r.method !== 'GET' && !options.ignoreMethod) {
+          return []
+        }
+      } else if (typeof request === 'string') { // 2.2
+        r = new Request(request)[kState]
+      }
+    }
+
+    // 4.
+    const promise = createDeferredPromise()
+
+    // 5.
+    // 5.1
+    const requests = []
+
+    // 5.2
+    if (request === undefined) {
+      // 5.2.1
+      for (const requestResponse of this.#relevantRequestResponseList) {
+        // 5.2.1.1
+        requests.push(requestResponse[0])
+      }
+    } else { // 5.3
+      // 5.3.1
+      const requestResponses = this.#queryCache(r, options)
+
+      // 5.3.2
+      for (const requestResponse of requestResponses) {
+        // 5.3.2.1
+        requests.push(requestResponse[0])
+      }
+    }
+
+    // 5.4
+    queueMicrotask(() => {
+      // 5.4.1
+      const requestList = []
+
+      // 5.4.2
+      for (const request of requests) {
+        const requestObject = fromInnerRequest(
+          request,
+          new AbortController().signal,
+          'immutable'
+        )
+        // 5.4.2.1
+        requestList.push(requestObject)
+      }
+
+      // 5.4.3
+      promise.resolve(Object.freeze(requestList))
+    })
+
+    return promise.promise
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm
+   * @param {CacheBatchOperation[]} operations
+   * @returns {requestResponseList}
+   */
+  #batchCacheOperations (operations) {
+    // 1.
+    const cache = this.#relevantRequestResponseList
+
+    // 2.
+    const backupCache = [...cache]
+
+    // 3.
+    const addedItems = []
+
+    // 4.1
+    const resultList = []
+
+    try {
+      // 4.2
+      for (const operation of operations) {
+        // 4.2.1
+        if (operation.type !== 'delete' && operation.type !== 'put') {
+          throw webidl.errors.exception({
+            header: 'Cache.#batchCacheOperations',
+            message: 'operation type does not match "delete" or "put"'
+          })
+        }
+
+        // 4.2.2
+        if (operation.type === 'delete' && operation.response != null) {
+          throw webidl.errors.exception({
+            header: 'Cache.#batchCacheOperations',
+            message: 'delete operation should not have an associated response'
+          })
+        }
+
+        // 4.2.3
+        if (this.#queryCache(operation.request, operation.options, addedItems).length) {
+          throw new DOMException('???', 'InvalidStateError')
+        }
+
+        // 4.2.4
+        let requestResponses
+
+        // 4.2.5
+        if (operation.type === 'delete') {
+          // 4.2.5.1
+          requestResponses = this.#queryCache(operation.request, operation.options)
+
+          // TODO: the spec is wrong, this is needed to pass WPTs
+          if (requestResponses.length === 0) {
+            return []
+          }
+
+          // 4.2.5.2
+          for (const requestResponse of requestResponses) {
+            const idx = cache.indexOf(requestResponse)
+            assert(idx !== -1)
+
+            // 4.2.5.2.1
+            cache.splice(idx, 1)
+          }
+        } else if (operation.type === 'put') { // 4.2.6
+          // 4.2.6.1
+          if (operation.response == null) {
+            throw webidl.errors.exception({
+              header: 'Cache.#batchCacheOperations',
+              message: 'put operation should have an associated response'
+            })
+          }
+
+          // 4.2.6.2
+          const r = operation.request
+
+          // 4.2.6.3
+          if (!urlIsHttpHttpsScheme(r.url)) {
+            throw webidl.errors.exception({
+              header: 'Cache.#batchCacheOperations',
+              message: 'expected http or https scheme'
+            })
+          }
+
+          // 4.2.6.4
+          if (r.method !== 'GET') {
+            throw webidl.errors.exception({
+              header: 'Cache.#batchCacheOperations',
+              message: 'not get method'
+            })
+          }
+
+          // 4.2.6.5
+          if (operation.options != null) {
+            throw webidl.errors.exception({
+              header: 'Cache.#batchCacheOperations',
+              message: 'options must not be defined'
+            })
+          }
+
+          // 4.2.6.6
+          requestResponses = this.#queryCache(operation.request)
+
+          // 4.2.6.7
+          for (const requestResponse of requestResponses) {
+            const idx = cache.indexOf(requestResponse)
+            assert(idx !== -1)
+
+            // 4.2.6.7.1
+            cache.splice(idx, 1)
+          }
+
+          // 4.2.6.8
+          cache.push([operation.request, operation.response])
+
+          // 4.2.6.10
+          addedItems.push([operation.request, operation.response])
+        }
+
+        // 4.2.7
+        resultList.push([operation.request, operation.response])
+      }
+
+      // 4.3
+      return resultList
+    } catch (e) { // 5.
+      // 5.1
+      this.#relevantRequestResponseList.length = 0
+
+      // 5.2
+      this.#relevantRequestResponseList = backupCache
+
+      // 5.3
+      throw e
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#query-cache
+   * @param {any} requestQuery
+   * @param {import('../../types/cache').CacheQueryOptions} options
+   * @param {requestResponseList} targetStorage
+   * @returns {requestResponseList}
+   */
+  #queryCache (requestQuery, options, targetStorage) {
+    /** @type {requestResponseList} */
+    const resultList = []
+
+    const storage = targetStorage ?? this.#relevantRequestResponseList
+
+    for (const requestResponse of storage) {
+      const [cachedRequest, cachedResponse] = requestResponse
+      if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options)) {
+        resultList.push(requestResponse)
+      }
+    }
+
+    return resultList
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm
+   * @param {any} requestQuery
+   * @param {any} request
+   * @param {any | null} response
+   * @param {import('../../types/cache').CacheQueryOptions | undefined} options
+   * @returns {boolean}
+   */
+  #requestMatchesCachedItem (requestQuery, request, response = null, options) {
+    // if (options?.ignoreMethod === false && request.method === 'GET') {
+    //   return false
+    // }
+
+    const queryURL = new URL(requestQuery.url)
+
+    const cachedURL = new URL(request.url)
+
+    if (options?.ignoreSearch) {
+      cachedURL.search = ''
+
+      queryURL.search = ''
+    }
+
+    if (!urlEquals(queryURL, cachedURL, true)) {
+      return false
+    }
+
+    if (
+      response == null ||
+      options?.ignoreVary ||
+      !response.headersList.contains('vary')
+    ) {
+      return true
+    }
+
+    const fieldValues = getFieldValues(response.headersList.get('vary'))
+
+    for (const fieldValue of fieldValues) {
+      if (fieldValue === '*') {
+        return false
+      }
+
+      const requestValue = request.headersList.get(fieldValue)
+      const queryValue = requestQuery.headersList.get(fieldValue)
+
+      // If one has the header and the other doesn't, or one has
+      // a different value than the other, return false
+      if (requestValue !== queryValue) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  #internalMatchAll (request, options, maxResponses = Infinity) {
+    // 1.
+    let r = null
+
+    // 2.
+    if (request !== undefined) {
+      if (request instanceof Request) {
+        // 2.1.1
+        r = request[kState]
+
+        // 2.1.2
+        if (r.method !== 'GET' && !options.ignoreMethod) {
+          return []
+        }
+      } else if (typeof request === 'string') {
+        // 2.2.1
+        r = new Request(request)[kState]
+      }
+    }
+
+    // 5.
+    // 5.1
+    const responses = []
+
+    // 5.2
+    if (request === undefined) {
+      // 5.2.1
+      for (const requestResponse of this.#relevantRequestResponseList) {
+        responses.push(requestResponse[1])
+      }
+    } else { // 5.3
+      // 5.3.1
+      const requestResponses = this.#queryCache(r, options)
+
+      // 5.3.2
+      for (const requestResponse of requestResponses) {
+        responses.push(requestResponse[1])
+      }
+    }
+
+    // 5.4
+    // We don't implement CORs so we don't need to loop over the responses, yay!
+
+    // 5.5.1
+    const responseList = []
+
+    // 5.5.2
+    for (const response of responses) {
+      // 5.5.2.1
+      const responseObject = fromInnerResponse(response, 'immutable')
+
+      responseList.push(responseObject.clone())
+
+      if (responseList.length >= maxResponses) {
+        break
+      }
+    }
+
+    // 6.
+    return Object.freeze(responseList)
+  }
+}
+
+Object.defineProperties(Cache.prototype, {
+  [Symbol.toStringTag]: {
+    value: 'Cache',
+    configurable: true
+  },
+  match: kEnumerableProperty,
+  matchAll: kEnumerableProperty,
+  add: kEnumerableProperty,
+  addAll: kEnumerableProperty,
+  put: kEnumerableProperty,
+  delete: kEnumerableProperty,
+  keys: kEnumerableProperty
+})
+
+const cacheQueryOptionConverters = [
+  {
+    key: 'ignoreSearch',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'ignoreMethod',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'ignoreVary',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  }
+]
+
+webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters)
+
+webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([
+  ...cacheQueryOptionConverters,
+  {
+    key: 'cacheName',
+    converter: webidl.converters.DOMString
+  }
+])
+
+webidl.converters.Response = webidl.interfaceConverter(Response)
+
+webidl.converters['sequence<RequestInfo>'] = webidl.sequenceConverter(
+  webidl.converters.RequestInfo
+)
+
+module.exports = {
+  Cache
+}
+
+
+/***/ }),
+
+/***/ 12130:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kConstruct } = __nccwpck_require__(90053)
+const { Cache } = __nccwpck_require__(61821)
+const { webidl } = __nccwpck_require__(37829)
+const { kEnumerableProperty } = __nccwpck_require__(94407)
+
+class CacheStorage {
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map
+   * @type {Map<string, import('./cache').requestResponseList}
+   */
+  #caches = new Map()
+
+  constructor () {
+    if (arguments[0] !== kConstruct) {
+      webidl.illegalConstructor()
+    }
+
+    webidl.util.markAsUncloneable(this)
+  }
+
+  async match (request, options = {}) {
+    webidl.brandCheck(this, CacheStorage)
+    webidl.argumentLengthCheck(arguments, 1, 'CacheStorage.match')
+
+    request = webidl.converters.RequestInfo(request)
+    options = webidl.converters.MultiCacheQueryOptions(options)
+
+    // 1.
+    if (options.cacheName != null) {
+      // 1.1.1.1
+      if (this.#caches.has(options.cacheName)) {
+        // 1.1.1.1.1
+        const cacheList = this.#caches.get(options.cacheName)
+        const cache = new Cache(kConstruct, cacheList)
+
+        return await cache.match(request, options)
+      }
+    } else { // 2.
+      // 2.2
+      for (const cacheList of this.#caches.values()) {
+        const cache = new Cache(kConstruct, cacheList)
+
+        // 2.2.1.2
+        const response = await cache.match(request, options)
+
+        if (response !== undefined) {
+          return response
+        }
+      }
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#cache-storage-has
+   * @param {string} cacheName
+   * @returns {Promise<boolean>}
+   */
+  async has (cacheName) {
+    webidl.brandCheck(this, CacheStorage)
+
+    const prefix = 'CacheStorage.has'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    cacheName = webidl.converters.DOMString(cacheName, prefix, 'cacheName')
+
+    // 2.1.1
+    // 2.2
+    return this.#caches.has(cacheName)
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open
+   * @param {string} cacheName
+   * @returns {Promise<Cache>}
+   */
+  async open (cacheName) {
+    webidl.brandCheck(this, CacheStorage)
+
+    const prefix = 'CacheStorage.open'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    cacheName = webidl.converters.DOMString(cacheName, prefix, 'cacheName')
+
+    // 2.1
+    if (this.#caches.has(cacheName)) {
+      // await caches.open('v1') !== await caches.open('v1')
+
+      // 2.1.1
+      const cache = this.#caches.get(cacheName)
+
+      // 2.1.1.1
+      return new Cache(kConstruct, cache)
+    }
+
+    // 2.2
+    const cache = []
+
+    // 2.3
+    this.#caches.set(cacheName, cache)
+
+    // 2.4
+    return new Cache(kConstruct, cache)
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#cache-storage-delete
+   * @param {string} cacheName
+   * @returns {Promise<boolean>}
+   */
+  async delete (cacheName) {
+    webidl.brandCheck(this, CacheStorage)
+
+    const prefix = 'CacheStorage.delete'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    cacheName = webidl.converters.DOMString(cacheName, prefix, 'cacheName')
+
+    return this.#caches.delete(cacheName)
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#cache-storage-keys
+   * @returns {Promise<string[]>}
+   */
+  async keys () {
+    webidl.brandCheck(this, CacheStorage)
+
+    // 2.1
+    const keys = this.#caches.keys()
+
+    // 2.2
+    return [...keys]
+  }
+}
+
+Object.defineProperties(CacheStorage.prototype, {
+  [Symbol.toStringTag]: {
+    value: 'CacheStorage',
+    configurable: true
+  },
+  match: kEnumerableProperty,
+  has: kEnumerableProperty,
+  open: kEnumerableProperty,
+  delete: kEnumerableProperty,
+  keys: kEnumerableProperty
+})
+
+module.exports = {
+  CacheStorage
+}
+
+
+/***/ }),
+
+/***/ 90053:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+module.exports = {
+  kConstruct: (__nccwpck_require__(5392).kConstruct)
+}
+
+
+/***/ }),
+
+/***/ 63166:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+const { URLSerializer } = __nccwpck_require__(86954)
+const { isValidHeaderName } = __nccwpck_require__(91976)
+
+/**
+ * @see https://url.spec.whatwg.org/#concept-url-equals
+ * @param {URL} A
+ * @param {URL} B
+ * @param {boolean | undefined} excludeFragment
+ * @returns {boolean}
+ */
+function urlEquals (A, B, excludeFragment = false) {
+  const serializedA = URLSerializer(A, excludeFragment)
+
+  const serializedB = URLSerializer(B, excludeFragment)
+
+  return serializedA === serializedB
+}
+
+/**
+ * @see https://github.com/chromium/chromium/blob/694d20d134cb553d8d89e5500b9148012b1ba299/content/browser/cache_storage/cache_storage_cache.cc#L260-L262
+ * @param {string} header
+ */
+function getFieldValues (header) {
+  assert(header !== null)
+
+  const values = []
+
+  for (let value of header.split(',')) {
+    value = value.trim()
+
+    if (isValidHeaderName(value)) {
+      values.push(value)
+    }
+  }
+
+  return values
+}
+
+module.exports = {
+  urlEquals,
+  getFieldValues
+}
+
+
+/***/ }),
+
+/***/ 67246:
+/***/ ((module) => {
+
+"use strict";
+
+
+// https://wicg.github.io/cookie-store/#cookie-maximum-attribute-value-size
+const maxAttributeValueSize = 1024
+
+// https://wicg.github.io/cookie-store/#cookie-maximum-name-value-pair-size
+const maxNameValuePairSize = 4096
+
+module.exports = {
+  maxAttributeValueSize,
+  maxNameValuePairSize
+}
+
+
+/***/ }),
+
+/***/ 57705:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { parseSetCookie } = __nccwpck_require__(45318)
+const { stringify } = __nccwpck_require__(72660)
+const { webidl } = __nccwpck_require__(37829)
+const { Headers } = __nccwpck_require__(24997)
+
+/**
+ * @typedef {Object} Cookie
+ * @property {string} name
+ * @property {string} value
+ * @property {Date|number|undefined} expires
+ * @property {number|undefined} maxAge
+ * @property {string|undefined} domain
+ * @property {string|undefined} path
+ * @property {boolean|undefined} secure
+ * @property {boolean|undefined} httpOnly
+ * @property {'Strict'|'Lax'|'None'} sameSite
+ * @property {string[]} unparsed
+ */
+
+/**
+ * @param {Headers} headers
+ * @returns {Record<string, string>}
+ */
+function getCookies (headers) {
+  webidl.argumentLengthCheck(arguments, 1, 'getCookies')
+
+  webidl.brandCheck(headers, Headers, { strict: false })
+
+  const cookie = headers.get('cookie')
+  const out = {}
+
+  if (!cookie) {
+    return out
+  }
+
+  for (const piece of cookie.split(';')) {
+    const [name, ...value] = piece.split('=')
+
+    out[name.trim()] = value.join('=')
+  }
+
+  return out
+}
+
+/**
+ * @param {Headers} headers
+ * @param {string} name
+ * @param {{ path?: string, domain?: string }|undefined} attributes
+ * @returns {void}
+ */
+function deleteCookie (headers, name, attributes) {
+  webidl.brandCheck(headers, Headers, { strict: false })
+
+  const prefix = 'deleteCookie'
+  webidl.argumentLengthCheck(arguments, 2, prefix)
+
+  name = webidl.converters.DOMString(name, prefix, 'name')
+  attributes = webidl.converters.DeleteCookieAttributes(attributes)
+
+  // Matches behavior of
+  // https://github.com/denoland/deno_std/blob/63827b16330b82489a04614027c33b7904e08be5/http/cookie.ts#L278
+  setCookie(headers, {
+    name,
+    value: '',
+    expires: new Date(0),
+    ...attributes
+  })
+}
+
+/**
+ * @param {Headers} headers
+ * @returns {Cookie[]}
+ */
+function getSetCookies (headers) {
+  webidl.argumentLengthCheck(arguments, 1, 'getSetCookies')
+
+  webidl.brandCheck(headers, Headers, { strict: false })
+
+  const cookies = headers.getSetCookie()
+
+  if (!cookies) {
+    return []
+  }
+
+  return cookies.map((pair) => parseSetCookie(pair))
+}
+
+/**
+ * @param {Headers} headers
+ * @param {Cookie} cookie
+ * @returns {void}
+ */
+function setCookie (headers, cookie) {
+  webidl.argumentLengthCheck(arguments, 2, 'setCookie')
+
+  webidl.brandCheck(headers, Headers, { strict: false })
+
+  cookie = webidl.converters.Cookie(cookie)
+
+  const str = stringify(cookie)
+
+  if (str) {
+    headers.append('Set-Cookie', str)
+  }
+}
+
+webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([
+  {
+    converter: webidl.nullableConverter(webidl.converters.DOMString),
+    key: 'path',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.nullableConverter(webidl.converters.DOMString),
+    key: 'domain',
+    defaultValue: () => null
+  }
+])
+
+webidl.converters.Cookie = webidl.dictionaryConverter([
+  {
+    converter: webidl.converters.DOMString,
+    key: 'name'
+  },
+  {
+    converter: webidl.converters.DOMString,
+    key: 'value'
+  },
+  {
+    converter: webidl.nullableConverter((value) => {
+      if (typeof value === 'number') {
+        return webidl.converters['unsigned long long'](value)
+      }
+
+      return new Date(value)
+    }),
+    key: 'expires',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.nullableConverter(webidl.converters['long long']),
+    key: 'maxAge',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.nullableConverter(webidl.converters.DOMString),
+    key: 'domain',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.nullableConverter(webidl.converters.DOMString),
+    key: 'path',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.nullableConverter(webidl.converters.boolean),
+    key: 'secure',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.nullableConverter(webidl.converters.boolean),
+    key: 'httpOnly',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.converters.USVString,
+    key: 'sameSite',
+    allowedValues: ['Strict', 'Lax', 'None']
+  },
+  {
+    converter: webidl.sequenceConverter(webidl.converters.DOMString),
+    key: 'unparsed',
+    defaultValue: () => new Array(0)
+  }
+])
+
+module.exports = {
+  getCookies,
+  deleteCookie,
+  getSetCookies,
+  setCookie
+}
+
+
+/***/ }),
+
+/***/ 45318:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { maxNameValuePairSize, maxAttributeValueSize } = __nccwpck_require__(67246)
+const { isCTLExcludingHtab } = __nccwpck_require__(72660)
+const { collectASequenceOfCodePointsFast } = __nccwpck_require__(86954)
+const assert = __nccwpck_require__(98061)
+
+/**
+ * @description Parses the field-value attributes of a set-cookie header string.
+ * @see https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4
+ * @param {string} header
+ * @returns if the header is invalid, null will be returned
+ */
+function parseSetCookie (header) {
+  // 1. If the set-cookie-string contains a %x00-08 / %x0A-1F / %x7F
+  //    character (CTL characters excluding HTAB): Abort these steps and
+  //    ignore the set-cookie-string entirely.
+  if (isCTLExcludingHtab(header)) {
+    return null
+  }
+
+  let nameValuePair = ''
+  let unparsedAttributes = ''
+  let name = ''
+  let value = ''
+
+  // 2. If the set-cookie-string contains a %x3B (";") character:
+  if (header.includes(';')) {
+    // 1. The name-value-pair string consists of the characters up to,
+    //    but not including, the first %x3B (";"), and the unparsed-
+    //    attributes consist of the remainder of the set-cookie-string
+    //    (including the %x3B (";") in question).
+    const position = { position: 0 }
+
+    nameValuePair = collectASequenceOfCodePointsFast(';', header, position)
+    unparsedAttributes = header.slice(position.position)
+  } else {
+    // Otherwise:
+
+    // 1. The name-value-pair string consists of all the characters
+    //    contained in the set-cookie-string, and the unparsed-
+    //    attributes is the empty string.
+    nameValuePair = header
+  }
+
+  // 3. If the name-value-pair string lacks a %x3D ("=") character, then
+  //    the name string is empty, and the value string is the value of
+  //    name-value-pair.
+  if (!nameValuePair.includes('=')) {
+    value = nameValuePair
+  } else {
+    //    Otherwise, the name string consists of the characters up to, but
+    //    not including, the first %x3D ("=") character, and the (possibly
+    //    empty) value string consists of the characters after the first
+    //    %x3D ("=") character.
+    const position = { position: 0 }
+    name = collectASequenceOfCodePointsFast(
+      '=',
+      nameValuePair,
+      position
+    )
+    value = nameValuePair.slice(position.position + 1)
+  }
+
+  // 4. Remove any leading or trailing WSP characters from the name
+  //    string and the value string.
+  name = name.trim()
+  value = value.trim()
+
+  // 5. If the sum of the lengths of the name string and the value string
+  //    is more than 4096 octets, abort these steps and ignore the set-
+  //    cookie-string entirely.
+  if (name.length + value.length > maxNameValuePairSize) {
+    return null
+  }
+
+  // 6. The cookie-name is the name string, and the cookie-value is the
+  //    value string.
+  return {
+    name, value, ...parseUnparsedAttributes(unparsedAttributes)
+  }
+}
+
+/**
+ * Parses the remaining attributes of a set-cookie header
+ * @see https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4
+ * @param {string} unparsedAttributes
+ * @param {[Object.<string, unknown>]={}} cookieAttributeList
+ */
+function parseUnparsedAttributes (unparsedAttributes, cookieAttributeList = {}) {
+  // 1. If the unparsed-attributes string is empty, skip the rest of
+  //    these steps.
+  if (unparsedAttributes.length === 0) {
+    return cookieAttributeList
+  }
+
+  // 2. Discard the first character of the unparsed-attributes (which
+  //    will be a %x3B (";") character).
+  assert(unparsedAttributes[0] === ';')
+  unparsedAttributes = unparsedAttributes.slice(1)
+
+  let cookieAv = ''
+
+  // 3. If the remaining unparsed-attributes contains a %x3B (";")
+  //    character:
+  if (unparsedAttributes.includes(';')) {
+    // 1. Consume the characters of the unparsed-attributes up to, but
+    //    not including, the first %x3B (";") character.
+    cookieAv = collectASequenceOfCodePointsFast(
+      ';',
+      unparsedAttributes,
+      { position: 0 }
+    )
+    unparsedAttributes = unparsedAttributes.slice(cookieAv.length)
+  } else {
+    // Otherwise:
+
+    // 1. Consume the remainder of the unparsed-attributes.
+    cookieAv = unparsedAttributes
+    unparsedAttributes = ''
+  }
+
+  // Let the cookie-av string be the characters consumed in this step.
+
+  let attributeName = ''
+  let attributeValue = ''
+
+  // 4. If the cookie-av string contains a %x3D ("=") character:
+  if (cookieAv.includes('=')) {
+    // 1. The (possibly empty) attribute-name string consists of the
+    //    characters up to, but not including, the first %x3D ("=")
+    //    character, and the (possibly empty) attribute-value string
+    //    consists of the characters after the first %x3D ("=")
+    //    character.
+    const position = { position: 0 }
+
+    attributeName = collectASequenceOfCodePointsFast(
+      '=',
+      cookieAv,
+      position
+    )
+    attributeValue = cookieAv.slice(position.position + 1)
+  } else {
+    // Otherwise:
+
+    // 1. The attribute-name string consists of the entire cookie-av
+    //    string, and the attribute-value string is empty.
+    attributeName = cookieAv
+  }
+
+  // 5. Remove any leading or trailing WSP characters from the attribute-
+  //    name string and the attribute-value string.
+  attributeName = attributeName.trim()
+  attributeValue = attributeValue.trim()
+
+  // 6. If the attribute-value is longer than 1024 octets, ignore the
+  //    cookie-av string and return to Step 1 of this algorithm.
+  if (attributeValue.length > maxAttributeValueSize) {
+    return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList)
+  }
+
+  // 7. Process the attribute-name and attribute-value according to the
+  //    requirements in the following subsections.  (Notice that
+  //    attributes with unrecognized attribute-names are ignored.)
+  const attributeNameLowercase = attributeName.toLowerCase()
+
+  // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.1
+  // If the attribute-name case-insensitively matches the string
+  // "Expires", the user agent MUST process the cookie-av as follows.
+  if (attributeNameLowercase === 'expires') {
+    // 1. Let the expiry-time be the result of parsing the attribute-value
+    //    as cookie-date (see Section 5.1.1).
+    const expiryTime = new Date(attributeValue)
+
+    // 2. If the attribute-value failed to parse as a cookie date, ignore
+    //    the cookie-av.
+
+    cookieAttributeList.expires = expiryTime
+  } else if (attributeNameLowercase === 'max-age') {
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.2
+    // If the attribute-name case-insensitively matches the string "Max-
+    // Age", the user agent MUST process the cookie-av as follows.
+
+    // 1. If the first character of the attribute-value is not a DIGIT or a
+    //    "-" character, ignore the cookie-av.
+    const charCode = attributeValue.charCodeAt(0)
+
+    if ((charCode < 48 || charCode > 57) && attributeValue[0] !== '-') {
+      return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList)
+    }
+
+    // 2. If the remainder of attribute-value contains a non-DIGIT
+    //    character, ignore the cookie-av.
+    if (!/^\d+$/.test(attributeValue)) {
+      return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList)
+    }
+
+    // 3. Let delta-seconds be the attribute-value converted to an integer.
+    const deltaSeconds = Number(attributeValue)
+
+    // 4. Let cookie-age-limit be the maximum age of the cookie (which
+    //    SHOULD be 400 days or less, see Section 4.1.2.2).
+
+    // 5. Set delta-seconds to the smaller of its present value and cookie-
+    //    age-limit.
+    // deltaSeconds = Math.min(deltaSeconds * 1000, maxExpiresMs)
+
+    // 6. If delta-seconds is less than or equal to zero (0), let expiry-
+    //    time be the earliest representable date and time.  Otherwise, let
+    //    the expiry-time be the current date and time plus delta-seconds
+    //    seconds.
+    // const expiryTime = deltaSeconds <= 0 ? Date.now() : Date.now() + deltaSeconds
+
+    // 7. Append an attribute to the cookie-attribute-list with an
+    //    attribute-name of Max-Age and an attribute-value of expiry-time.
+    cookieAttributeList.maxAge = deltaSeconds
+  } else if (attributeNameLowercase === 'domain') {
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.3
+    // If the attribute-name case-insensitively matches the string "Domain",
+    // the user agent MUST process the cookie-av as follows.
+
+    // 1. Let cookie-domain be the attribute-value.
+    let cookieDomain = attributeValue
+
+    // 2. If cookie-domain starts with %x2E ("."), let cookie-domain be
+    //    cookie-domain without its leading %x2E (".").
+    if (cookieDomain[0] === '.') {
+      cookieDomain = cookieDomain.slice(1)
+    }
+
+    // 3. Convert the cookie-domain to lower case.
+    cookieDomain = cookieDomain.toLowerCase()
+
+    // 4. Append an attribute to the cookie-attribute-list with an
+    //    attribute-name of Domain and an attribute-value of cookie-domain.
+    cookieAttributeList.domain = cookieDomain
+  } else if (attributeNameLowercase === 'path') {
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.4
+    // If the attribute-name case-insensitively matches the string "Path",
+    // the user agent MUST process the cookie-av as follows.
+
+    // 1. If the attribute-value is empty or if the first character of the
+    //    attribute-value is not %x2F ("/"):
+    let cookiePath = ''
+    if (attributeValue.length === 0 || attributeValue[0] !== '/') {
+      // 1. Let cookie-path be the default-path.
+      cookiePath = '/'
+    } else {
+      // Otherwise:
+
+      // 1. Let cookie-path be the attribute-value.
+      cookiePath = attributeValue
+    }
+
+    // 2. Append an attribute to the cookie-attribute-list with an
+    //    attribute-name of Path and an attribute-value of cookie-path.
+    cookieAttributeList.path = cookiePath
+  } else if (attributeNameLowercase === 'secure') {
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.5
+    // If the attribute-name case-insensitively matches the string "Secure",
+    // the user agent MUST append an attribute to the cookie-attribute-list
+    // with an attribute-name of Secure and an empty attribute-value.
+
+    cookieAttributeList.secure = true
+  } else if (attributeNameLowercase === 'httponly') {
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.6
+    // If the attribute-name case-insensitively matches the string
+    // "HttpOnly", the user agent MUST append an attribute to the cookie-
+    // attribute-list with an attribute-name of HttpOnly and an empty
+    // attribute-value.
+
+    cookieAttributeList.httpOnly = true
+  } else if (attributeNameLowercase === 'samesite') {
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.7
+    // If the attribute-name case-insensitively matches the string
+    // "SameSite", the user agent MUST process the cookie-av as follows:
+
+    // 1. Let enforcement be "Default".
+    let enforcement = 'Default'
+
+    const attributeValueLowercase = attributeValue.toLowerCase()
+    // 2. If cookie-av's attribute-value is a case-insensitive match for
+    //    "None", set enforcement to "None".
+    if (attributeValueLowercase.includes('none')) {
+      enforcement = 'None'
+    }
+
+    // 3. If cookie-av's attribute-value is a case-insensitive match for
+    //    "Strict", set enforcement to "Strict".
+    if (attributeValueLowercase.includes('strict')) {
+      enforcement = 'Strict'
+    }
+
+    // 4. If cookie-av's attribute-value is a case-insensitive match for
+    //    "Lax", set enforcement to "Lax".
+    if (attributeValueLowercase.includes('lax')) {
+      enforcement = 'Lax'
+    }
+
+    // 5. Append an attribute to the cookie-attribute-list with an
+    //    attribute-name of "SameSite" and an attribute-value of
+    //    enforcement.
+    cookieAttributeList.sameSite = enforcement
+  } else {
+    cookieAttributeList.unparsed ??= []
+
+    cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`)
+  }
+
+  // 8. Return to Step 1 of this algorithm.
+  return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList)
+}
+
+module.exports = {
+  parseSetCookie,
+  parseUnparsedAttributes
+}
+
+
+/***/ }),
+
+/***/ 72660:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isCTLExcludingHtab (value) {
+  for (let i = 0; i < value.length; ++i) {
+    const code = value.charCodeAt(i)
+
+    if (
+      (code >= 0x00 && code <= 0x08) ||
+      (code >= 0x0A && code <= 0x1F) ||
+      code === 0x7F
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ CHAR           = <any US-ASCII character (octets 0 - 127)>
+ token          = 1*<any CHAR except CTLs or separators>
+ separators     = "(" | ")" | "<" | ">" | "@"
+                | "," | ";" | ":" | "\" | <">
+                | "/" | "[" | "]" | "?" | "="
+                | "{" | "}" | SP | HT
+ * @param {string} name
+ */
+function validateCookieName (name) {
+  for (let i = 0; i < name.length; ++i) {
+    const code = name.charCodeAt(i)
+
+    if (
+      code < 0x21 || // exclude CTLs (0-31), SP and HT
+      code > 0x7E || // exclude non-ascii and DEL
+      code === 0x22 || // "
+      code === 0x28 || // (
+      code === 0x29 || // )
+      code === 0x3C || // <
+      code === 0x3E || // >
+      code === 0x40 || // @
+      code === 0x2C || // ,
+      code === 0x3B || // ;
+      code === 0x3A || // :
+      code === 0x5C || // \
+      code === 0x2F || // /
+      code === 0x5B || // [
+      code === 0x5D || // ]
+      code === 0x3F || // ?
+      code === 0x3D || // =
+      code === 0x7B || // {
+      code === 0x7D // }
+    ) {
+      throw new Error('Invalid cookie name')
+    }
+  }
+}
+
+/**
+ cookie-value      = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE )
+ cookie-octet      = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
+                       ; US-ASCII characters excluding CTLs,
+                       ; whitespace DQUOTE, comma, semicolon,
+                       ; and backslash
+ * @param {string} value
+ */
+function validateCookieValue (value) {
+  let len = value.length
+  let i = 0
+
+  // if the value is wrapped in DQUOTE
+  if (value[0] === '"') {
+    if (len === 1 || value[len - 1] !== '"') {
+      throw new Error('Invalid cookie value')
+    }
+    --len
+    ++i
+  }
+
+  while (i < len) {
+    const code = value.charCodeAt(i++)
+
+    if (
+      code < 0x21 || // exclude CTLs (0-31)
+      code > 0x7E || // non-ascii and DEL (127)
+      code === 0x22 || // "
+      code === 0x2C || // ,
+      code === 0x3B || // ;
+      code === 0x5C // \
+    ) {
+      throw new Error('Invalid cookie value')
+    }
+  }
+}
+
+/**
+ * path-value        = <any CHAR except CTLs or ";">
+ * @param {string} path
+ */
+function validateCookiePath (path) {
+  for (let i = 0; i < path.length; ++i) {
+    const code = path.charCodeAt(i)
+
+    if (
+      code < 0x20 || // exclude CTLs (0-31)
+      code === 0x7F || // DEL
+      code === 0x3B // ;
+    ) {
+      throw new Error('Invalid cookie path')
+    }
+  }
+}
+
+/**
+ * I have no idea why these values aren't allowed to be honest,
+ * but Deno tests these. - Khafra
+ * @param {string} domain
+ */
+function validateCookieDomain (domain) {
+  if (
+    domain.startsWith('-') ||
+    domain.endsWith('.') ||
+    domain.endsWith('-')
+  ) {
+    throw new Error('Invalid cookie domain')
+  }
+}
+
+const IMFDays = [
+  'Sun', 'Mon', 'Tue', 'Wed',
+  'Thu', 'Fri', 'Sat'
+]
+
+const IMFMonths = [
+  'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'
+]
+
+const IMFPaddedNumbers = Array(61).fill(0).map((_, i) => i.toString().padStart(2, '0'))
+
+/**
+ * @see https://www.rfc-editor.org/rfc/rfc7231#section-7.1.1.1
+ * @param {number|Date} date
+  IMF-fixdate  = day-name "," SP date1 SP time-of-day SP GMT
+  ; fixed length/zone/capitalization subset of the format
+  ; see Section 3.3 of [RFC5322]
+
+  day-name     = %x4D.6F.6E ; "Mon", case-sensitive
+              / %x54.75.65 ; "Tue", case-sensitive
+              / %x57.65.64 ; "Wed", case-sensitive
+              / %x54.68.75 ; "Thu", case-sensitive
+              / %x46.72.69 ; "Fri", case-sensitive
+              / %x53.61.74 ; "Sat", case-sensitive
+              / %x53.75.6E ; "Sun", case-sensitive
+  date1        = day SP month SP year
+                  ; e.g., 02 Jun 1982
+
+  day          = 2DIGIT
+  month        = %x4A.61.6E ; "Jan", case-sensitive
+              / %x46.65.62 ; "Feb", case-sensitive
+              / %x4D.61.72 ; "Mar", case-sensitive
+              / %x41.70.72 ; "Apr", case-sensitive
+              / %x4D.61.79 ; "May", case-sensitive
+              / %x4A.75.6E ; "Jun", case-sensitive
+              / %x4A.75.6C ; "Jul", case-sensitive
+              / %x41.75.67 ; "Aug", case-sensitive
+              / %x53.65.70 ; "Sep", case-sensitive
+              / %x4F.63.74 ; "Oct", case-sensitive
+              / %x4E.6F.76 ; "Nov", case-sensitive
+              / %x44.65.63 ; "Dec", case-sensitive
+  year         = 4DIGIT
+
+  GMT          = %x47.4D.54 ; "GMT", case-sensitive
+
+  time-of-day  = hour ":" minute ":" second
+              ; 00:00:00 - 23:59:60 (leap second)
+
+  hour         = 2DIGIT
+  minute       = 2DIGIT
+  second       = 2DIGIT
+ */
+function toIMFDate (date) {
+  if (typeof date === 'number') {
+    date = new Date(date)
+  }
+
+  return `${IMFDays[date.getUTCDay()]}, ${IMFPaddedNumbers[date.getUTCDate()]} ${IMFMonths[date.getUTCMonth()]} ${date.getUTCFullYear()} ${IMFPaddedNumbers[date.getUTCHours()]}:${IMFPaddedNumbers[date.getUTCMinutes()]}:${IMFPaddedNumbers[date.getUTCSeconds()]} GMT`
+}
+
+/**
+ max-age-av        = "Max-Age=" non-zero-digit *DIGIT
+                       ; In practice, both expires-av and max-age-av
+                       ; are limited to dates representable by the
+                       ; user agent.
+ * @param {number} maxAge
+ */
+function validateCookieMaxAge (maxAge) {
+  if (maxAge < 0) {
+    throw new Error('Invalid cookie max-age')
+  }
+}
+
+/**
+ * @see https://www.rfc-editor.org/rfc/rfc6265#section-4.1.1
+ * @param {import('./index').Cookie} cookie
+ */
+function stringify (cookie) {
+  if (cookie.name.length === 0) {
+    return null
+  }
+
+  validateCookieName(cookie.name)
+  validateCookieValue(cookie.value)
+
+  const out = [`${cookie.name}=${cookie.value}`]
+
+  // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-cookie-prefixes-00#section-3.1
+  // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-cookie-prefixes-00#section-3.2
+  if (cookie.name.startsWith('__Secure-')) {
+    cookie.secure = true
+  }
+
+  if (cookie.name.startsWith('__Host-')) {
+    cookie.secure = true
+    cookie.domain = null
+    cookie.path = '/'
+  }
+
+  if (cookie.secure) {
+    out.push('Secure')
+  }
+
+  if (cookie.httpOnly) {
+    out.push('HttpOnly')
+  }
+
+  if (typeof cookie.maxAge === 'number') {
+    validateCookieMaxAge(cookie.maxAge)
+    out.push(`Max-Age=${cookie.maxAge}`)
+  }
+
+  if (cookie.domain) {
+    validateCookieDomain(cookie.domain)
+    out.push(`Domain=${cookie.domain}`)
+  }
+
+  if (cookie.path) {
+    validateCookiePath(cookie.path)
+    out.push(`Path=${cookie.path}`)
+  }
+
+  if (cookie.expires && cookie.expires.toString() !== 'Invalid Date') {
+    out.push(`Expires=${toIMFDate(cookie.expires)}`)
+  }
+
+  if (cookie.sameSite) {
+    out.push(`SameSite=${cookie.sameSite}`)
+  }
+
+  for (const part of cookie.unparsed) {
+    if (!part.includes('=')) {
+      throw new Error('Invalid unparsed')
+    }
+
+    const [key, ...value] = part.split('=')
+
+    out.push(`${key.trim()}=${value.join('=')}`)
+  }
+
+  return out.join('; ')
+}
+
+module.exports = {
+  isCTLExcludingHtab,
+  validateCookieName,
+  validateCookiePath,
+  validateCookieValue,
+  toIMFDate,
+  stringify
+}
+
+
+/***/ }),
+
+/***/ 47882:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const { Transform } = __nccwpck_require__(84492)
+const { isASCIINumber, isValidLastEventId } = __nccwpck_require__(7793)
+
+/**
+ * @type {number[]} BOM
+ */
+const BOM = [0xEF, 0xBB, 0xBF]
+/**
+ * @type {10} LF
+ */
+const LF = 0x0A
+/**
+ * @type {13} CR
+ */
+const CR = 0x0D
+/**
+ * @type {58} COLON
+ */
+const COLON = 0x3A
+/**
+ * @type {32} SPACE
+ */
+const SPACE = 0x20
+
+/**
+ * @typedef {object} EventSourceStreamEvent
+ * @type {object}
+ * @property {string} [event] The event type.
+ * @property {string} [data] The data of the message.
+ * @property {string} [id] A unique ID for the event.
+ * @property {string} [retry] The reconnection time, in milliseconds.
+ */
+
+/**
+ * @typedef eventSourceSettings
+ * @type {object}
+ * @property {string} lastEventId The last event ID received from the server.
+ * @property {string} origin The origin of the event source.
+ * @property {number} reconnectionTime The reconnection time, in milliseconds.
+ */
+
+class EventSourceStream extends Transform {
+  /**
+   * @type {eventSourceSettings}
+   */
+  state = null
+
+  /**
+   * Leading byte-order-mark check.
+   * @type {boolean}
+   */
+  checkBOM = true
+
+  /**
+   * @type {boolean}
+   */
+  crlfCheck = false
+
+  /**
+   * @type {boolean}
+   */
+  eventEndCheck = false
+
+  /**
+   * @type {Buffer}
+   */
+  buffer = null
+
+  pos = 0
+
+  event = {
+    data: undefined,
+    event: undefined,
+    id: undefined,
+    retry: undefined
+  }
+
+  /**
+   * @param {object} options
+   * @param {eventSourceSettings} options.eventSourceSettings
+   * @param {Function} [options.push]
+   */
+  constructor (options = {}) {
+    // Enable object mode as EventSourceStream emits objects of shape
+    // EventSourceStreamEvent
+    options.readableObjectMode = true
+
+    super(options)
+
+    this.state = options.eventSourceSettings || {}
+    if (options.push) {
+      this.push = options.push
+    }
+  }
+
+  /**
+   * @param {Buffer} chunk
+   * @param {string} _encoding
+   * @param {Function} callback
+   * @returns {void}
+   */
+  _transform (chunk, _encoding, callback) {
+    if (chunk.length === 0) {
+      callback()
+      return
+    }
+
+    // Cache the chunk in the buffer, as the data might not be complete while
+    // processing it
+    // TODO: Investigate if there is a more performant way to handle
+    // incoming chunks
+    // see: https://github.com/nodejs/undici/issues/2630
+    if (this.buffer) {
+      this.buffer = Buffer.concat([this.buffer, chunk])
+    } else {
+      this.buffer = chunk
+    }
+
+    // Strip leading byte-order-mark if we opened the stream and started
+    // the processing of the incoming data
+    if (this.checkBOM) {
+      switch (this.buffer.length) {
+        case 1:
+          // Check if the first byte is the same as the first byte of the BOM
+          if (this.buffer[0] === BOM[0]) {
+            // If it is, we need to wait for more data
+            callback()
+            return
+          }
+          // Set the checkBOM flag to false as we don't need to check for the
+          // BOM anymore
+          this.checkBOM = false
+
+          // The buffer only contains one byte so we need to wait for more data
+          callback()
+          return
+        case 2:
+          // Check if the first two bytes are the same as the first two bytes
+          // of the BOM
+          if (
+            this.buffer[0] === BOM[0] &&
+            this.buffer[1] === BOM[1]
+          ) {
+            // If it is, we need to wait for more data, because the third byte
+            // is needed to determine if it is the BOM or not
+            callback()
+            return
+          }
+
+          // Set the checkBOM flag to false as we don't need to check for the
+          // BOM anymore
+          this.checkBOM = false
+          break
+        case 3:
+          // Check if the first three bytes are the same as the first three
+          // bytes of the BOM
+          if (
+            this.buffer[0] === BOM[0] &&
+            this.buffer[1] === BOM[1] &&
+            this.buffer[2] === BOM[2]
+          ) {
+            // If it is, we can drop the buffered data, as it is only the BOM
+            this.buffer = Buffer.alloc(0)
+            // Set the checkBOM flag to false as we don't need to check for the
+            // BOM anymore
+            this.checkBOM = false
+
+            // Await more data
+            callback()
+            return
+          }
+          // If it is not the BOM, we can start processing the data
+          this.checkBOM = false
+          break
+        default:
+          // The buffer is longer than 3 bytes, so we can drop the BOM if it is
+          // present
+          if (
+            this.buffer[0] === BOM[0] &&
+            this.buffer[1] === BOM[1] &&
+            this.buffer[2] === BOM[2]
+          ) {
+            // Remove the BOM from the buffer
+            this.buffer = this.buffer.subarray(3)
+          }
+
+          // Set the checkBOM flag to false as we don't need to check for the
+          this.checkBOM = false
+          break
+      }
+    }
+
+    while (this.pos < this.buffer.length) {
+      // If the previous line ended with an end-of-line, we need to check
+      // if the next character is also an end-of-line.
+      if (this.eventEndCheck) {
+        // If the the current character is an end-of-line, then the event
+        // is finished and we can process it
+
+        // If the previous line ended with a carriage return, we need to
+        // check if the current character is a line feed and remove it
+        // from the buffer.
+        if (this.crlfCheck) {
+          // If the current character is a line feed, we can remove it
+          // from the buffer and reset the crlfCheck flag
+          if (this.buffer[this.pos] === LF) {
+            this.buffer = this.buffer.subarray(this.pos + 1)
+            this.pos = 0
+            this.crlfCheck = false
+
+            // It is possible that the line feed is not the end of the
+            // event. We need to check if the next character is an
+            // end-of-line character to determine if the event is
+            // finished. We simply continue the loop to check the next
+            // character.
+
+            // As we removed the line feed from the buffer and set the
+            // crlfCheck flag to false, we basically don't make any
+            // distinction between a line feed and a carriage return.
+            continue
+          }
+          this.crlfCheck = false
+        }
+
+        if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
+          // If the current character is a carriage return, we need to
+          // set the crlfCheck flag to true, as we need to check if the
+          // next character is a line feed so we can remove it from the
+          // buffer
+          if (this.buffer[this.pos] === CR) {
+            this.crlfCheck = true
+          }
+
+          this.buffer = this.buffer.subarray(this.pos + 1)
+          this.pos = 0
+          if (
+            this.event.data !== undefined || this.event.event || this.event.id || this.event.retry) {
+            this.processEvent(this.event)
+          }
+          this.clearEvent()
+          continue
+        }
+        // If the current character is not an end-of-line, then the event
+        // is not finished and we have to reset the eventEndCheck flag
+        this.eventEndCheck = false
+        continue
+      }
+
+      // If the current character is an end-of-line, we can process the
+      // line
+      if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
+        // If the current character is a carriage return, we need to
+        // set the crlfCheck flag to true, as we need to check if the
+        // next character is a line feed
+        if (this.buffer[this.pos] === CR) {
+          this.crlfCheck = true
+        }
+
+        // In any case, we can process the line as we reached an
+        // end-of-line character
+        this.parseLine(this.buffer.subarray(0, this.pos), this.event)
+
+        // Remove the processed line from the buffer
+        this.buffer = this.buffer.subarray(this.pos + 1)
+        // Reset the position as we removed the processed line from the buffer
+        this.pos = 0
+        // A line was processed and this could be the end of the event. We need
+        // to check if the next line is empty to determine if the event is
+        // finished.
+        this.eventEndCheck = true
+        continue
+      }
+
+      this.pos++
+    }
+
+    callback()
+  }
+
+  /**
+   * @param {Buffer} line
+   * @param {EventStreamEvent} event
+   */
+  parseLine (line, event) {
+    // If the line is empty (a blank line)
+    // Dispatch the event, as defined below.
+    // This will be handled in the _transform method
+    if (line.length === 0) {
+      return
+    }
+
+    // If the line starts with a U+003A COLON character (:)
+    // Ignore the line.
+    const colonPosition = line.indexOf(COLON)
+    if (colonPosition === 0) {
+      return
+    }
+
+    let field = ''
+    let value = ''
+
+    // If the line contains a U+003A COLON character (:)
+    if (colonPosition !== -1) {
+      // Collect the characters on the line before the first U+003A COLON
+      // character (:), and let field be that string.
+      // TODO: Investigate if there is a more performant way to extract the
+      // field
+      // see: https://github.com/nodejs/undici/issues/2630
+      field = line.subarray(0, colonPosition).toString('utf8')
+
+      // Collect the characters on the line after the first U+003A COLON
+      // character (:), and let value be that string.
+      // If value starts with a U+0020 SPACE character, remove it from value.
+      let valueStart = colonPosition + 1
+      if (line[valueStart] === SPACE) {
+        ++valueStart
+      }
+      // TODO: Investigate if there is a more performant way to extract the
+      // value
+      // see: https://github.com/nodejs/undici/issues/2630
+      value = line.subarray(valueStart).toString('utf8')
+
+      // Otherwise, the string is not empty but does not contain a U+003A COLON
+      // character (:)
+    } else {
+      // Process the field using the steps described below, using the whole
+      // line as the field name, and the empty string as the field value.
+      field = line.toString('utf8')
+      value = ''
+    }
+
+    // Modify the event with the field name and value. The value is also
+    // decoded as UTF-8
+    switch (field) {
+      case 'data':
+        if (event[field] === undefined) {
+          event[field] = value
+        } else {
+          event[field] += `\n${value}`
+        }
+        break
+      case 'retry':
+        if (isASCIINumber(value)) {
+          event[field] = value
+        }
+        break
+      case 'id':
+        if (isValidLastEventId(value)) {
+          event[field] = value
+        }
+        break
+      case 'event':
+        if (value.length > 0) {
+          event[field] = value
+        }
+        break
+    }
+  }
+
+  /**
+   * @param {EventSourceStreamEvent} event
+   */
+  processEvent (event) {
+    if (event.retry && isASCIINumber(event.retry)) {
+      this.state.reconnectionTime = parseInt(event.retry, 10)
+    }
+
+    if (event.id && isValidLastEventId(event.id)) {
+      this.state.lastEventId = event.id
+    }
+
+    // only dispatch event, when data is provided
+    if (event.data !== undefined) {
+      this.push({
+        type: event.event || 'message',
+        options: {
+          data: event.data,
+          lastEventId: this.state.lastEventId,
+          origin: this.state.origin
+        }
+      })
+    }
+  }
+
+  clearEvent () {
+    this.event = {
+      data: undefined,
+      event: undefined,
+      id: undefined,
+      retry: undefined
+    }
+  }
+}
+
+module.exports = {
+  EventSourceStream
+}
+
+
+/***/ }),
+
+/***/ 62205:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { pipeline } = __nccwpck_require__(84492)
+const { fetching } = __nccwpck_require__(31158)
+const { makeRequest } = __nccwpck_require__(13925)
+const { webidl } = __nccwpck_require__(37829)
+const { EventSourceStream } = __nccwpck_require__(47882)
+const { parseMIMEType } = __nccwpck_require__(86954)
+const { createFastMessageEvent } = __nccwpck_require__(15135)
+const { isNetworkError } = __nccwpck_require__(33139)
+const { delay } = __nccwpck_require__(7793)
+const { kEnumerableProperty } = __nccwpck_require__(94407)
+const { environmentSettingsObject } = __nccwpck_require__(91976)
+
+let experimentalWarned = false
+
+/**
+ * A reconnection time, in milliseconds. This must initially be an implementation-defined value,
+ * probably in the region of a few seconds.
+ *
+ * In Comparison:
+ * - Chrome uses 3000ms.
+ * - Deno uses 5000ms.
+ *
+ * @type {3000}
+ */
+const defaultReconnectionTime = 3000
+
+/**
+ * The readyState attribute represents the state of the connection.
+ * @enum
+ * @readonly
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#dom-eventsource-readystate-dev
+ */
+
+/**
+ * The connection has not yet been established, or it was closed and the user
+ * agent is reconnecting.
+ * @type {0}
+ */
+const CONNECTING = 0
+
+/**
+ * The user agent has an open connection and is dispatching events as it
+ * receives them.
+ * @type {1}
+ */
+const OPEN = 1
+
+/**
+ * The connection is not open, and the user agent is not trying to reconnect.
+ * @type {2}
+ */
+const CLOSED = 2
+
+/**
+ * Requests for the element will have their mode set to "cors" and their credentials mode set to "same-origin".
+ * @type {'anonymous'}
+ */
+const ANONYMOUS = 'anonymous'
+
+/**
+ * Requests for the element will have their mode set to "cors" and their credentials mode set to "include".
+ * @type {'use-credentials'}
+ */
+const USE_CREDENTIALS = 'use-credentials'
+
+/**
+ * The EventSource interface is used to receive server-sent events. It
+ * connects to a server over HTTP and receives events in text/event-stream
+ * format without closing the connection.
+ * @extends {EventTarget}
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events
+ * @api public
+ */
+class EventSource extends EventTarget {
+  #events = {
+    open: null,
+    error: null,
+    message: null
+  }
+
+  #url = null
+  #withCredentials = false
+
+  #readyState = CONNECTING
+
+  #request = null
+  #controller = null
+
+  #dispatcher
+
+  /**
+   * @type {import('./eventsource-stream').eventSourceSettings}
+   */
+  #state
+
+  /**
+   * Creates a new EventSource object.
+   * @param {string} url
+   * @param {EventSourceInit} [eventSourceInitDict]
+   * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface
+   */
+  constructor (url, eventSourceInitDict = {}) {
+    // 1. Let ev be a new EventSource object.
+    super()
+
+    webidl.util.markAsUncloneable(this)
+
+    const prefix = 'EventSource constructor'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    if (!experimentalWarned) {
+      experimentalWarned = true
+      process.emitWarning('EventSource is experimental, expect them to change at any time.', {
+        code: 'UNDICI-ES'
+      })
+    }
+
+    url = webidl.converters.USVString(url, prefix, 'url')
+    eventSourceInitDict = webidl.converters.EventSourceInitDict(eventSourceInitDict, prefix, 'eventSourceInitDict')
+
+    this.#dispatcher = eventSourceInitDict.dispatcher
+    this.#state = {
+      lastEventId: '',
+      reconnectionTime: defaultReconnectionTime
+    }
+
+    // 2. Let settings be ev's relevant settings object.
+    // https://html.spec.whatwg.org/multipage/webappapis.html#environment-settings-object
+    const settings = environmentSettingsObject
+
+    let urlRecord
+
+    try {
+      // 3. Let urlRecord be the result of encoding-parsing a URL given url, relative to settings.
+      urlRecord = new URL(url, settings.settingsObject.baseUrl)
+      this.#state.origin = urlRecord.origin
+    } catch (e) {
+      // 4. If urlRecord is failure, then throw a "SyntaxError" DOMException.
+      throw new DOMException(e, 'SyntaxError')
+    }
+
+    // 5. Set ev's url to urlRecord.
+    this.#url = urlRecord.href
+
+    // 6. Let corsAttributeState be Anonymous.
+    let corsAttributeState = ANONYMOUS
+
+    // 7. If the value of eventSourceInitDict's withCredentials member is true,
+    // then set corsAttributeState to Use Credentials and set ev's
+    // withCredentials attribute to true.
+    if (eventSourceInitDict.withCredentials) {
+      corsAttributeState = USE_CREDENTIALS
+      this.#withCredentials = true
+    }
+
+    // 8. Let request be the result of creating a potential-CORS request given
+    // urlRecord, the empty string, and corsAttributeState.
+    const initRequest = {
+      redirect: 'follow',
+      keepalive: true,
+      // @see https://html.spec.whatwg.org/multipage/urls-and-fetching.html#cors-settings-attributes
+      mode: 'cors',
+      credentials: corsAttributeState === 'anonymous'
+        ? 'same-origin'
+        : 'omit',
+      referrer: 'no-referrer'
+    }
+
+    // 9. Set request's client to settings.
+    initRequest.client = environmentSettingsObject.settingsObject
+
+    // 10. User agents may set (`Accept`, `text/event-stream`) in request's header list.
+    initRequest.headersList = [['accept', { name: 'accept', value: 'text/event-stream' }]]
+
+    // 11. Set request's cache mode to "no-store".
+    initRequest.cache = 'no-store'
+
+    // 12. Set request's initiator type to "other".
+    initRequest.initiator = 'other'
+
+    initRequest.urlList = [new URL(this.#url)]
+
+    // 13. Set ev's request to request.
+    this.#request = makeRequest(initRequest)
+
+    this.#connect()
+  }
+
+  /**
+   * Returns the state of this EventSource object's connection. It can have the
+   * values described below.
+   * @returns {0|1|2}
+   * @readonly
+   */
+  get readyState () {
+    return this.#readyState
+  }
+
+  /**
+   * Returns the URL providing the event stream.
+   * @readonly
+   * @returns {string}
+   */
+  get url () {
+    return this.#url
+  }
+
+  /**
+   * Returns a boolean indicating whether the EventSource object was
+   * instantiated with CORS credentials set (true), or not (false, the default).
+   */
+  get withCredentials () {
+    return this.#withCredentials
+  }
+
+  #connect () {
+    if (this.#readyState === CLOSED) return
+
+    this.#readyState = CONNECTING
+
+    const fetchParams = {
+      request: this.#request,
+      dispatcher: this.#dispatcher
+    }
+
+    // 14. Let processEventSourceEndOfBody given response res be the following step: if res is not a network error, then reestablish the connection.
+    const processEventSourceEndOfBody = (response) => {
+      if (isNetworkError(response)) {
+        this.dispatchEvent(new Event('error'))
+        this.close()
+      }
+
+      this.#reconnect()
+    }
+
+    // 15. Fetch request, with processResponseEndOfBody set to processEventSourceEndOfBody...
+    fetchParams.processResponseEndOfBody = processEventSourceEndOfBody
+
+    // and processResponse set to the following steps given response res:
+    fetchParams.processResponse = (response) => {
+      // 1. If res is an aborted network error, then fail the connection.
+
+      if (isNetworkError(response)) {
+        // 1. When a user agent is to fail the connection, the user agent
+        // must queue a task which, if the readyState attribute is set to a
+        // value other than CLOSED, sets the readyState attribute to CLOSED
+        // and fires an event named error at the EventSource object. Once the
+        // user agent has failed the connection, it does not attempt to
+        // reconnect.
+        if (response.aborted) {
+          this.close()
+          this.dispatchEvent(new Event('error'))
+          return
+          // 2. Otherwise, if res is a network error, then reestablish the
+          // connection, unless the user agent knows that to be futile, in
+          // which case the user agent may fail the connection.
+        } else {
+          this.#reconnect()
+          return
+        }
+      }
+
+      // 3. Otherwise, if res's status is not 200, or if res's `Content-Type`
+      // is not `text/event-stream`, then fail the connection.
+      const contentType = response.headersList.get('content-type', true)
+      const mimeType = contentType !== null ? parseMIMEType(contentType) : 'failure'
+      const contentTypeValid = mimeType !== 'failure' && mimeType.essence === 'text/event-stream'
+      if (
+        response.status !== 200 ||
+        contentTypeValid === false
+      ) {
+        this.close()
+        this.dispatchEvent(new Event('error'))
+        return
+      }
+
+      // 4. Otherwise, announce the connection and interpret res's body
+      // line by line.
+
+      // When a user agent is to announce the connection, the user agent
+      // must queue a task which, if the readyState attribute is set to a
+      // value other than CLOSED, sets the readyState attribute to OPEN
+      // and fires an event named open at the EventSource object.
+      // @see https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model
+      this.#readyState = OPEN
+      this.dispatchEvent(new Event('open'))
+
+      // If redirected to a different origin, set the origin to the new origin.
+      this.#state.origin = response.urlList[response.urlList.length - 1].origin
+
+      const eventSourceStream = new EventSourceStream({
+        eventSourceSettings: this.#state,
+        push: (event) => {
+          this.dispatchEvent(createFastMessageEvent(
+            event.type,
+            event.options
+          ))
+        }
+      })
+
+      pipeline(response.body.stream,
+        eventSourceStream,
+        (error) => {
+          if (
+            error?.aborted === false
+          ) {
+            this.close()
+            this.dispatchEvent(new Event('error'))
+          }
+        })
+    }
+
+    this.#controller = fetching(fetchParams)
+  }
+
+  /**
+   * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model
+   * @returns {Promise<void>}
+   */
+  async #reconnect () {
+    // When a user agent is to reestablish the connection, the user agent must
+    // run the following steps. These steps are run in parallel, not as part of
+    // a task. (The tasks that it queues, of course, are run like normal tasks
+    // and not themselves in parallel.)
+
+    // 1. Queue a task to run the following steps:
+
+    //   1. If the readyState attribute is set to CLOSED, abort the task.
+    if (this.#readyState === CLOSED) return
+
+    //   2. Set the readyState attribute to CONNECTING.
+    this.#readyState = CONNECTING
+
+    //   3. Fire an event named error at the EventSource object.
+    this.dispatchEvent(new Event('error'))
+
+    // 2. Wait a delay equal to the reconnection time of the event source.
+    await delay(this.#state.reconnectionTime)
+
+    // 5. Queue a task to run the following steps:
+
+    //   1. If the EventSource object's readyState attribute is not set to
+    //      CONNECTING, then return.
+    if (this.#readyState !== CONNECTING) return
+
+    //   2. Let request be the EventSource object's request.
+    //   3. If the EventSource object's last event ID string is not the empty
+    //      string, then:
+    //      1. Let lastEventIDValue be the EventSource object's last event ID
+    //         string, encoded as UTF-8.
+    //      2. Set (`Last-Event-ID`, lastEventIDValue) in request's header
+    //         list.
+    if (this.#state.lastEventId.length) {
+      this.#request.headersList.set('last-event-id', this.#state.lastEventId, true)
+    }
+
+    //   4. Fetch request and process the response obtained in this fashion, if any, as described earlier in this section.
+    this.#connect()
+  }
+
+  /**
+   * Closes the connection, if any, and sets the readyState attribute to
+   * CLOSED.
+   */
+  close () {
+    webidl.brandCheck(this, EventSource)
+
+    if (this.#readyState === CLOSED) return
+    this.#readyState = CLOSED
+    this.#controller.abort()
+    this.#request = null
+  }
+
+  get onopen () {
+    return this.#events.open
+  }
+
+  set onopen (fn) {
+    if (this.#events.open) {
+      this.removeEventListener('open', this.#events.open)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.open = fn
+      this.addEventListener('open', fn)
+    } else {
+      this.#events.open = null
+    }
+  }
+
+  get onmessage () {
+    return this.#events.message
+  }
+
+  set onmessage (fn) {
+    if (this.#events.message) {
+      this.removeEventListener('message', this.#events.message)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.message = fn
+      this.addEventListener('message', fn)
+    } else {
+      this.#events.message = null
+    }
+  }
+
+  get onerror () {
+    return this.#events.error
+  }
+
+  set onerror (fn) {
+    if (this.#events.error) {
+      this.removeEventListener('error', this.#events.error)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.error = fn
+      this.addEventListener('error', fn)
+    } else {
+      this.#events.error = null
+    }
+  }
+}
+
+const constantsPropertyDescriptors = {
+  CONNECTING: {
+    __proto__: null,
+    configurable: false,
+    enumerable: true,
+    value: CONNECTING,
+    writable: false
+  },
+  OPEN: {
+    __proto__: null,
+    configurable: false,
+    enumerable: true,
+    value: OPEN,
+    writable: false
+  },
+  CLOSED: {
+    __proto__: null,
+    configurable: false,
+    enumerable: true,
+    value: CLOSED,
+    writable: false
+  }
+}
+
+Object.defineProperties(EventSource, constantsPropertyDescriptors)
+Object.defineProperties(EventSource.prototype, constantsPropertyDescriptors)
+
+Object.defineProperties(EventSource.prototype, {
+  close: kEnumerableProperty,
+  onerror: kEnumerableProperty,
+  onmessage: kEnumerableProperty,
+  onopen: kEnumerableProperty,
+  readyState: kEnumerableProperty,
+  url: kEnumerableProperty,
+  withCredentials: kEnumerableProperty
+})
+
+webidl.converters.EventSourceInitDict = webidl.dictionaryConverter([
+  {
+    key: 'withCredentials',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'dispatcher', // undici only
+    converter: webidl.converters.any
+  }
+])
+
+module.exports = {
+  EventSource,
+  defaultReconnectionTime
+}
+
+
+/***/ }),
+
+/***/ 7793:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * Checks if the given value is a valid LastEventId.
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isValidLastEventId (value) {
+  // LastEventId should not contain U+0000 NULL
+  return value.indexOf('\u0000') === -1
+}
+
+/**
+ * Checks if the given value is a base 10 digit.
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isASCIINumber (value) {
+  if (value.length === 0) return false
+  for (let i = 0; i < value.length; i++) {
+    if (value.charCodeAt(i) < 0x30 || value.charCodeAt(i) > 0x39) return false
+  }
+  return true
+}
+
+// https://github.com/nodejs/undici/issues/2664
+function delay (ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms).unref()
+  })
+}
+
+module.exports = {
+  isValidLastEventId,
+  isASCIINumber,
+  delay
+}
+
+
+/***/ }),
+
+/***/ 23291:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const util = __nccwpck_require__(94407)
+const {
+  ReadableStreamFrom,
+  isBlobLike,
+  isReadableStreamLike,
+  readableStreamClose,
+  createDeferredPromise,
+  fullyReadBody,
+  extractMimeType,
+  utf8DecodeBytes
+} = __nccwpck_require__(91976)
+const { FormData } = __nccwpck_require__(4923)
+const { kState } = __nccwpck_require__(78172)
+const { webidl } = __nccwpck_require__(37829)
+const { Blob } = __nccwpck_require__(72254)
+const assert = __nccwpck_require__(98061)
+const { isErrored, isDisturbed } = __nccwpck_require__(84492)
+const { isArrayBuffer } = __nccwpck_require__(93746)
+const { serializeAMimeType } = __nccwpck_require__(86954)
+const { multipartFormDataParser } = __nccwpck_require__(43227)
+let random
+
+try {
+  const crypto = __nccwpck_require__(6005)
+  random = (max) => crypto.randomInt(0, max)
+} catch {
+  random = (max) => Math.floor(Math.random(max))
+}
+
+const textEncoder = new TextEncoder()
+function noop () {}
+
+const hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf('v18') !== 0
+let streamRegistry
+
+if (hasFinalizationRegistry) {
+  streamRegistry = new FinalizationRegistry((weakRef) => {
+    const stream = weakRef.deref()
+    if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) {
+      stream.cancel('Response object has been garbage collected').catch(noop)
+    }
+  })
+}
+
+// https://fetch.spec.whatwg.org/#concept-bodyinit-extract
+function extractBody (object, keepalive = false) {
+  // 1. Let stream be null.
+  let stream = null
+
+  // 2. If object is a ReadableStream object, then set stream to object.
+  if (object instanceof ReadableStream) {
+    stream = object
+  } else if (isBlobLike(object)) {
+    // 3. Otherwise, if object is a Blob object, set stream to the
+    //    result of running object’s get stream.
+    stream = object.stream()
+  } else {
+    // 4. Otherwise, set stream to a new ReadableStream object, and set
+    //    up stream with byte reading support.
+    stream = new ReadableStream({
+      async pull (controller) {
+        const buffer = typeof source === 'string' ? textEncoder.encode(source) : source
+
+        if (buffer.byteLength) {
+          controller.enqueue(buffer)
+        }
+
+        queueMicrotask(() => readableStreamClose(controller))
+      },
+      start () {},
+      type: 'bytes'
+    })
+  }
+
+  // 5. Assert: stream is a ReadableStream object.
+  assert(isReadableStreamLike(stream))
+
+  // 6. Let action be null.
+  let action = null
+
+  // 7. Let source be null.
+  let source = null
+
+  // 8. Let length be null.
+  let length = null
+
+  // 9. Let type be null.
+  let type = null
+
+  // 10. Switch on object:
+  if (typeof object === 'string') {
+    // Set source to the UTF-8 encoding of object.
+    // Note: setting source to a Uint8Array here breaks some mocking assumptions.
+    source = object
+
+    // Set type to `text/plain;charset=UTF-8`.
+    type = 'text/plain;charset=UTF-8'
+  } else if (object instanceof URLSearchParams) {
+    // URLSearchParams
+
+    // spec says to run application/x-www-form-urlencoded on body.list
+    // this is implemented in Node.js as apart of an URLSearchParams instance toString method
+    // See: https://github.com/nodejs/node/blob/e46c680bf2b211bbd52cf959ca17ee98c7f657f5/lib/internal/url.js#L490
+    // and https://github.com/nodejs/node/blob/e46c680bf2b211bbd52cf959ca17ee98c7f657f5/lib/internal/url.js#L1100
+
+    // Set source to the result of running the application/x-www-form-urlencoded serializer with object’s list.
+    source = object.toString()
+
+    // Set type to `application/x-www-form-urlencoded;charset=UTF-8`.
+    type = 'application/x-www-form-urlencoded;charset=UTF-8'
+  } else if (isArrayBuffer(object)) {
+    // BufferSource/ArrayBuffer
+
+    // Set source to a copy of the bytes held by object.
+    source = new Uint8Array(object.slice())
+  } else if (ArrayBuffer.isView(object)) {
+    // BufferSource/ArrayBufferView
+
+    // Set source to a copy of the bytes held by object.
+    source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength))
+  } else if (util.isFormDataLike(object)) {
+    const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, '0')}`
+    const prefix = `--${boundary}\r\nContent-Disposition: form-data`
+
+    /*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+    const escape = (str) =>
+      str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22')
+    const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, '\r\n')
+
+    // Set action to this step: run the multipart/form-data
+    // encoding algorithm, with object’s entry list and UTF-8.
+    // - This ensures that the body is immutable and can't be changed afterwords
+    // - That the content-length is calculated in advance.
+    // - And that all parts are pre-encoded and ready to be sent.
+
+    const blobParts = []
+    const rn = new Uint8Array([13, 10]) // '\r\n'
+    length = 0
+    let hasUnknownSizeValue = false
+
+    for (const [name, value] of object) {
+      if (typeof value === 'string') {
+        const chunk = textEncoder.encode(prefix +
+          `; name="${escape(normalizeLinefeeds(name))}"` +
+          `\r\n\r\n${normalizeLinefeeds(value)}\r\n`)
+        blobParts.push(chunk)
+        length += chunk.byteLength
+      } else {
+        const chunk = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` +
+          (value.name ? `; filename="${escape(value.name)}"` : '') + '\r\n' +
+          `Content-Type: ${
+            value.type || 'application/octet-stream'
+          }\r\n\r\n`)
+        blobParts.push(chunk, value, rn)
+        if (typeof value.size === 'number') {
+          length += chunk.byteLength + value.size + rn.byteLength
+        } else {
+          hasUnknownSizeValue = true
+        }
+      }
+    }
+
+    // CRLF is appended to the body to function with legacy servers and match other implementations.
+    // https://github.com/curl/curl/blob/3434c6b46e682452973972e8313613dfa58cd690/lib/mime.c#L1029-L1030
+    // https://github.com/form-data/form-data/issues/63
+    const chunk = textEncoder.encode(`--${boundary}--\r\n`)
+    blobParts.push(chunk)
+    length += chunk.byteLength
+    if (hasUnknownSizeValue) {
+      length = null
+    }
+
+    // Set source to object.
+    source = object
+
+    action = async function * () {
+      for (const part of blobParts) {
+        if (part.stream) {
+          yield * part.stream()
+        } else {
+          yield part
+        }
+      }
+    }
+
+    // Set type to `multipart/form-data; boundary=`,
+    // followed by the multipart/form-data boundary string generated
+    // by the multipart/form-data encoding algorithm.
+    type = `multipart/form-data; boundary=${boundary}`
+  } else if (isBlobLike(object)) {
+    // Blob
+
+    // Set source to object.
+    source = object
+
+    // Set length to object’s size.
+    length = object.size
+
+    // If object’s type attribute is not the empty byte sequence, set
+    // type to its value.
+    if (object.type) {
+      type = object.type
+    }
+  } else if (typeof object[Symbol.asyncIterator] === 'function') {
+    // If keepalive is true, then throw a TypeError.
+    if (keepalive) {
+      throw new TypeError('keepalive')
+    }
+
+    // If object is disturbed or locked, then throw a TypeError.
+    if (util.isDisturbed(object) || object.locked) {
+      throw new TypeError(
+        'Response body object should not be disturbed or locked'
+      )
+    }
+
+    stream =
+      object instanceof ReadableStream ? object : ReadableStreamFrom(object)
+  }
+
+  // 11. If source is a byte sequence, then set action to a
+  // step that returns source and length to source’s length.
+  if (typeof source === 'string' || util.isBuffer(source)) {
+    length = Buffer.byteLength(source)
+  }
+
+  // 12. If action is non-null, then run these steps in in parallel:
+  if (action != null) {
+    // Run action.
+    let iterator
+    stream = new ReadableStream({
+      async start () {
+        iterator = action(object)[Symbol.asyncIterator]()
+      },
+      async pull (controller) {
+        const { value, done } = await iterator.next()
+        if (done) {
+          // When running action is done, close stream.
+          queueMicrotask(() => {
+            controller.close()
+            controller.byobRequest?.respond(0)
+          })
+        } else {
+          // Whenever one or more bytes are available and stream is not errored,
+          // enqueue a Uint8Array wrapping an ArrayBuffer containing the available
+          // bytes into stream.
+          if (!isErrored(stream)) {
+            const buffer = new Uint8Array(value)
+            if (buffer.byteLength) {
+              controller.enqueue(buffer)
+            }
+          }
+        }
+        return controller.desiredSize > 0
+      },
+      async cancel (reason) {
+        await iterator.return()
+      },
+      type: 'bytes'
+    })
+  }
+
+  // 13. Let body be a body whose stream is stream, source is source,
+  // and length is length.
+  const body = { stream, source, length }
+
+  // 14. Return (body, type).
+  return [body, type]
+}
+
+// https://fetch.spec.whatwg.org/#bodyinit-safely-extract
+function safelyExtractBody (object, keepalive = false) {
+  // To safely extract a body and a `Content-Type` value from
+  // a byte sequence or BodyInit object object, run these steps:
+
+  // 1. If object is a ReadableStream object, then:
+  if (object instanceof ReadableStream) {
+    // Assert: object is neither disturbed nor locked.
+    // istanbul ignore next
+    assert(!util.isDisturbed(object), 'The body has already been consumed.')
+    // istanbul ignore next
+    assert(!object.locked, 'The stream is locked.')
+  }
+
+  // 2. Return the results of extracting object.
+  return extractBody(object, keepalive)
+}
+
+function cloneBody (instance, body) {
+  // To clone a body body, run these steps:
+
+  // https://fetch.spec.whatwg.org/#concept-body-clone
+
+  // 1. Let « out1, out2 » be the result of teeing body’s stream.
+  const [out1, out2] = body.stream.tee()
+
+  // 2. Set body’s stream to out1.
+  body.stream = out1
+
+  // 3. Return a body whose stream is out2 and other members are copied from body.
+  return {
+    stream: out2,
+    length: body.length,
+    source: body.source
+  }
+}
+
+function throwIfAborted (state) {
+  if (state.aborted) {
+    throw new DOMException('The operation was aborted.', 'AbortError')
+  }
+}
+
+function bodyMixinMethods (instance) {
+  const methods = {
+    blob () {
+      // The blob() method steps are to return the result of
+      // running consume body with this and the following step
+      // given a byte sequence bytes: return a Blob whose
+      // contents are bytes and whose type attribute is this’s
+      // MIME type.
+      return consumeBody(this, (bytes) => {
+        let mimeType = bodyMimeType(this)
+
+        if (mimeType === null) {
+          mimeType = ''
+        } else if (mimeType) {
+          mimeType = serializeAMimeType(mimeType)
+        }
+
+        // Return a Blob whose contents are bytes and type attribute
+        // is mimeType.
+        return new Blob([bytes], { type: mimeType })
+      }, instance)
+    },
+
+    arrayBuffer () {
+      // The arrayBuffer() method steps are to return the result
+      // of running consume body with this and the following step
+      // given a byte sequence bytes: return a new ArrayBuffer
+      // whose contents are bytes.
+      return consumeBody(this, (bytes) => {
+        return new Uint8Array(bytes).buffer
+      }, instance)
+    },
+
+    text () {
+      // The text() method steps are to return the result of running
+      // consume body with this and UTF-8 decode.
+      return consumeBody(this, utf8DecodeBytes, instance)
+    },
+
+    json () {
+      // The json() method steps are to return the result of running
+      // consume body with this and parse JSON from bytes.
+      return consumeBody(this, parseJSONFromBytes, instance)
+    },
+
+    formData () {
+      // The formData() method steps are to return the result of running
+      // consume body with this and the following step given a byte sequence bytes:
+      return consumeBody(this, (value) => {
+        // 1. Let mimeType be the result of get the MIME type with this.
+        const mimeType = bodyMimeType(this)
+
+        // 2. If mimeType is non-null, then switch on mimeType’s essence and run
+        //    the corresponding steps:
+        if (mimeType !== null) {
+          switch (mimeType.essence) {
+            case 'multipart/form-data': {
+              // 1. ... [long step]
+              const parsed = multipartFormDataParser(value, mimeType)
+
+              // 2. If that fails for some reason, then throw a TypeError.
+              if (parsed === 'failure') {
+                throw new TypeError('Failed to parse body as FormData.')
+              }
+
+              // 3. Return a new FormData object, appending each entry,
+              //    resulting from the parsing operation, to its entry list.
+              const fd = new FormData()
+              fd[kState] = parsed
+
+              return fd
+            }
+            case 'application/x-www-form-urlencoded': {
+              // 1. Let entries be the result of parsing bytes.
+              const entries = new URLSearchParams(value.toString())
+
+              // 2. If entries is failure, then throw a TypeError.
+
+              // 3. Return a new FormData object whose entry list is entries.
+              const fd = new FormData()
+
+              for (const [name, value] of entries) {
+                fd.append(name, value)
+              }
+
+              return fd
+            }
+          }
+        }
+
+        // 3. Throw a TypeError.
+        throw new TypeError(
+          'Content-Type was not one of "multipart/form-data" or "application/x-www-form-urlencoded".'
+        )
+      }, instance)
+    },
+
+    bytes () {
+      // The bytes() method steps are to return the result of running consume body
+      // with this and the following step given a byte sequence bytes: return the
+      // result of creating a Uint8Array from bytes in this’s relevant realm.
+      return consumeBody(this, (bytes) => {
+        return new Uint8Array(bytes)
+      }, instance)
+    }
+  }
+
+  return methods
+}
+
+function mixinBody (prototype) {
+  Object.assign(prototype.prototype, bodyMixinMethods(prototype))
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-body-consume-body
+ * @param {Response|Request} object
+ * @param {(value: unknown) => unknown} convertBytesToJSValue
+ * @param {Response|Request} instance
+ */
+async function consumeBody (object, convertBytesToJSValue, instance) {
+  webidl.brandCheck(object, instance)
+
+  // 1. If object is unusable, then return a promise rejected
+  //    with a TypeError.
+  if (bodyUnusable(object)) {
+    throw new TypeError('Body is unusable: Body has already been read')
+  }
+
+  throwIfAborted(object[kState])
+
+  // 2. Let promise be a new promise.
+  const promise = createDeferredPromise()
+
+  // 3. Let errorSteps given error be to reject promise with error.
+  const errorSteps = (error) => promise.reject(error)
+
+  // 4. Let successSteps given a byte sequence data be to resolve
+  //    promise with the result of running convertBytesToJSValue
+  //    with data. If that threw an exception, then run errorSteps
+  //    with that exception.
+  const successSteps = (data) => {
+    try {
+      promise.resolve(convertBytesToJSValue(data))
+    } catch (e) {
+      errorSteps(e)
+    }
+  }
+
+  // 5. If object’s body is null, then run successSteps with an
+  //    empty byte sequence.
+  if (object[kState].body == null) {
+    successSteps(Buffer.allocUnsafe(0))
+    return promise.promise
+  }
+
+  // 6. Otherwise, fully read object’s body given successSteps,
+  //    errorSteps, and object’s relevant global object.
+  await fullyReadBody(object[kState].body, successSteps, errorSteps)
+
+  // 7. Return promise.
+  return promise.promise
+}
+
+// https://fetch.spec.whatwg.org/#body-unusable
+function bodyUnusable (object) {
+  const body = object[kState].body
+
+  // An object including the Body interface mixin is
+  // said to be unusable if its body is non-null and
+  // its body’s stream is disturbed or locked.
+  return body != null && (body.stream.locked || util.isDisturbed(body.stream))
+}
+
+/**
+ * @see https://infra.spec.whatwg.org/#parse-json-bytes-to-a-javascript-value
+ * @param {Uint8Array} bytes
+ */
+function parseJSONFromBytes (bytes) {
+  return JSON.parse(utf8DecodeBytes(bytes))
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-body-mime-type
+ * @param {import('./response').Response|import('./request').Request} requestOrResponse
+ */
+function bodyMimeType (requestOrResponse) {
+  // 1. Let headers be null.
+  // 2. If requestOrResponse is a Request object, then set headers to requestOrResponse’s request’s header list.
+  // 3. Otherwise, set headers to requestOrResponse’s response’s header list.
+  /** @type {import('./headers').HeadersList} */
+  const headers = requestOrResponse[kState].headersList
+
+  // 4. Let mimeType be the result of extracting a MIME type from headers.
+  const mimeType = extractMimeType(headers)
+
+  // 5. If mimeType is failure, then return null.
+  if (mimeType === 'failure') {
+    return null
+  }
+
+  // 6. Return mimeType.
+  return mimeType
+}
+
+module.exports = {
+  extractBody,
+  safelyExtractBody,
+  cloneBody,
+  mixinBody,
+  streamRegistry,
+  hasFinalizationRegistry,
+  bodyUnusable
+}
+
+
+/***/ }),
+
+/***/ 87979:
+/***/ ((module) => {
+
+"use strict";
+
+
+const corsSafeListedMethods = /** @type {const} */ (['GET', 'HEAD', 'POST'])
+const corsSafeListedMethodsSet = new Set(corsSafeListedMethods)
+
+const nullBodyStatus = /** @type {const} */ ([101, 204, 205, 304])
+
+const redirectStatus = /** @type {const} */ ([301, 302, 303, 307, 308])
+const redirectStatusSet = new Set(redirectStatus)
+
+/**
+ * @see https://fetch.spec.whatwg.org/#block-bad-port
+ */
+const badPorts = /** @type {const} */ ([
+  '1', '7', '9', '11', '13', '15', '17', '19', '20', '21', '22', '23', '25', '37', '42', '43', '53', '69', '77', '79',
+  '87', '95', '101', '102', '103', '104', '109', '110', '111', '113', '115', '117', '119', '123', '135', '137',
+  '139', '143', '161', '179', '389', '427', '465', '512', '513', '514', '515', '526', '530', '531', '532',
+  '540', '548', '554', '556', '563', '587', '601', '636', '989', '990', '993', '995', '1719', '1720', '1723',
+  '2049', '3659', '4045', '4190', '5060', '5061', '6000', '6566', '6665', '6666', '6667', '6668', '6669', '6679',
+  '6697', '10080'
+])
+const badPortsSet = new Set(badPorts)
+
+/**
+ * @see https://w3c.github.io/webappsec-referrer-policy/#referrer-policies
+ */
+const referrerPolicy = /** @type {const} */ ([
+  '',
+  'no-referrer',
+  'no-referrer-when-downgrade',
+  'same-origin',
+  'origin',
+  'strict-origin',
+  'origin-when-cross-origin',
+  'strict-origin-when-cross-origin',
+  'unsafe-url'
+])
+const referrerPolicySet = new Set(referrerPolicy)
+
+const requestRedirect = /** @type {const} */ (['follow', 'manual', 'error'])
+
+const safeMethods = /** @type {const} */ (['GET', 'HEAD', 'OPTIONS', 'TRACE'])
+const safeMethodsSet = new Set(safeMethods)
+
+const requestMode = /** @type {const} */ (['navigate', 'same-origin', 'no-cors', 'cors'])
+
+const requestCredentials = /** @type {const} */ (['omit', 'same-origin', 'include'])
+
+const requestCache = /** @type {const} */ ([
+  'default',
+  'no-store',
+  'reload',
+  'no-cache',
+  'force-cache',
+  'only-if-cached'
+])
+
+/**
+ * @see https://fetch.spec.whatwg.org/#request-body-header-name
+ */
+const requestBodyHeader = /** @type {const} */ ([
+  'content-encoding',
+  'content-language',
+  'content-location',
+  'content-type',
+  // See https://github.com/nodejs/undici/issues/2021
+  // 'Content-Length' is a forbidden header name, which is typically
+  // removed in the Headers implementation. However, undici doesn't
+  // filter out headers, so we add it here.
+  'content-length'
+])
+
+/**
+ * @see https://fetch.spec.whatwg.org/#enumdef-requestduplex
+ */
+const requestDuplex = /** @type {const} */ ([
+  'half'
+])
+
+/**
+ * @see http://fetch.spec.whatwg.org/#forbidden-method
+ */
+const forbiddenMethods = /** @type {const} */ (['CONNECT', 'TRACE', 'TRACK'])
+const forbiddenMethodsSet = new Set(forbiddenMethods)
+
+const subresource = /** @type {const} */ ([
+  'audio',
+  'audioworklet',
+  'font',
+  'image',
+  'manifest',
+  'paintworklet',
+  'script',
+  'style',
+  'track',
+  'video',
+  'xslt',
+  ''
+])
+const subresourceSet = new Set(subresource)
+
+module.exports = {
+  subresource,
+  forbiddenMethods,
+  requestBodyHeader,
+  referrerPolicy,
+  requestRedirect,
+  requestMode,
+  requestCredentials,
+  requestCache,
+  redirectStatus,
+  corsSafeListedMethods,
+  nullBodyStatus,
+  safeMethods,
+  badPorts,
+  requestDuplex,
+  subresourceSet,
+  badPortsSet,
+  redirectStatusSet,
+  corsSafeListedMethodsSet,
+  safeMethodsSet,
+  forbiddenMethodsSet,
+  referrerPolicySet
+}
+
+
+/***/ }),
+
+/***/ 86954:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+
+const encoder = new TextEncoder()
+
+/**
+ * @see https://mimesniff.spec.whatwg.org/#http-token-code-point
+ */
+const HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+\-.^_|~A-Za-z0-9]+$/
+const HTTP_WHITESPACE_REGEX = /[\u000A\u000D\u0009\u0020]/ // eslint-disable-line
+const ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g // eslint-disable-line
+/**
+ * @see https://mimesniff.spec.whatwg.org/#http-quoted-string-token-code-point
+ */
+const HTTP_QUOTED_STRING_TOKENS = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/ // eslint-disable-line
+
+// https://fetch.spec.whatwg.org/#data-url-processor
+/** @param {URL} dataURL */
+function dataURLProcessor (dataURL) {
+  // 1. Assert: dataURL’s scheme is "data".
+  assert(dataURL.protocol === 'data:')
+
+  // 2. Let input be the result of running the URL
+  // serializer on dataURL with exclude fragment
+  // set to true.
+  let input = URLSerializer(dataURL, true)
+
+  // 3. Remove the leading "data:" string from input.
+  input = input.slice(5)
+
+  // 4. Let position point at the start of input.
+  const position = { position: 0 }
+
+  // 5. Let mimeType be the result of collecting a
+  // sequence of code points that are not equal
+  // to U+002C (,), given position.
+  let mimeType = collectASequenceOfCodePointsFast(
+    ',',
+    input,
+    position
+  )
+
+  // 6. Strip leading and trailing ASCII whitespace
+  // from mimeType.
+  // Undici implementation note: we need to store the
+  // length because if the mimetype has spaces removed,
+  // the wrong amount will be sliced from the input in
+  // step #9
+  const mimeTypeLength = mimeType.length
+  mimeType = removeASCIIWhitespace(mimeType, true, true)
+
+  // 7. If position is past the end of input, then
+  // return failure
+  if (position.position >= input.length) {
+    return 'failure'
+  }
+
+  // 8. Advance position by 1.
+  position.position++
+
+  // 9. Let encodedBody be the remainder of input.
+  const encodedBody = input.slice(mimeTypeLength + 1)
+
+  // 10. Let body be the percent-decoding of encodedBody.
+  let body = stringPercentDecode(encodedBody)
+
+  // 11. If mimeType ends with U+003B (;), followed by
+  // zero or more U+0020 SPACE, followed by an ASCII
+  // case-insensitive match for "base64", then:
+  if (/;(\u0020){0,}base64$/i.test(mimeType)) {
+    // 1. Let stringBody be the isomorphic decode of body.
+    const stringBody = isomorphicDecode(body)
+
+    // 2. Set body to the forgiving-base64 decode of
+    // stringBody.
+    body = forgivingBase64(stringBody)
+
+    // 3. If body is failure, then return failure.
+    if (body === 'failure') {
+      return 'failure'
+    }
+
+    // 4. Remove the last 6 code points from mimeType.
+    mimeType = mimeType.slice(0, -6)
+
+    // 5. Remove trailing U+0020 SPACE code points from mimeType,
+    // if any.
+    mimeType = mimeType.replace(/(\u0020)+$/, '')
+
+    // 6. Remove the last U+003B (;) code point from mimeType.
+    mimeType = mimeType.slice(0, -1)
+  }
+
+  // 12. If mimeType starts with U+003B (;), then prepend
+  // "text/plain" to mimeType.
+  if (mimeType.startsWith(';')) {
+    mimeType = 'text/plain' + mimeType
+  }
+
+  // 13. Let mimeTypeRecord be the result of parsing
+  // mimeType.
+  let mimeTypeRecord = parseMIMEType(mimeType)
+
+  // 14. If mimeTypeRecord is failure, then set
+  // mimeTypeRecord to text/plain;charset=US-ASCII.
+  if (mimeTypeRecord === 'failure') {
+    mimeTypeRecord = parseMIMEType('text/plain;charset=US-ASCII')
+  }
+
+  // 15. Return a new data: URL struct whose MIME
+  // type is mimeTypeRecord and body is body.
+  // https://fetch.spec.whatwg.org/#data-url-struct
+  return { mimeType: mimeTypeRecord, body }
+}
+
+// https://url.spec.whatwg.org/#concept-url-serializer
+/**
+ * @param {URL} url
+ * @param {boolean} excludeFragment
+ */
+function URLSerializer (url, excludeFragment = false) {
+  if (!excludeFragment) {
+    return url.href
+  }
+
+  const href = url.href
+  const hashLength = url.hash.length
+
+  const serialized = hashLength === 0 ? href : href.substring(0, href.length - hashLength)
+
+  if (!hashLength && href.endsWith('#')) {
+    return serialized.slice(0, -1)
+  }
+
+  return serialized
+}
+
+// https://infra.spec.whatwg.org/#collect-a-sequence-of-code-points
+/**
+ * @param {(char: string) => boolean} condition
+ * @param {string} input
+ * @param {{ position: number }} position
+ */
+function collectASequenceOfCodePoints (condition, input, position) {
+  // 1. Let result be the empty string.
+  let result = ''
+
+  // 2. While position doesn’t point past the end of input and the
+  // code point at position within input meets the condition condition:
+  while (position.position < input.length && condition(input[position.position])) {
+    // 1. Append that code point to the end of result.
+    result += input[position.position]
+
+    // 2. Advance position by 1.
+    position.position++
+  }
+
+  // 3. Return result.
+  return result
+}
+
+/**
+ * A faster collectASequenceOfCodePoints that only works when comparing a single character.
+ * @param {string} char
+ * @param {string} input
+ * @param {{ position: number }} position
+ */
+function collectASequenceOfCodePointsFast (char, input, position) {
+  const idx = input.indexOf(char, position.position)
+  const start = position.position
+
+  if (idx === -1) {
+    position.position = input.length
+    return input.slice(start)
+  }
+
+  position.position = idx
+  return input.slice(start, position.position)
+}
+
+// https://url.spec.whatwg.org/#string-percent-decode
+/** @param {string} input */
+function stringPercentDecode (input) {
+  // 1. Let bytes be the UTF-8 encoding of input.
+  const bytes = encoder.encode(input)
+
+  // 2. Return the percent-decoding of bytes.
+  return percentDecode(bytes)
+}
+
+/**
+ * @param {number} byte
+ */
+function isHexCharByte (byte) {
+  // 0-9 A-F a-f
+  return (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x46) || (byte >= 0x61 && byte <= 0x66)
+}
+
+/**
+ * @param {number} byte
+ */
+function hexByteToNumber (byte) {
+  return (
+    // 0-9
+    byte >= 0x30 && byte <= 0x39
+      ? (byte - 48)
+    // Convert to uppercase
+    // ((byte & 0xDF) - 65) + 10
+      : ((byte & 0xDF) - 55)
+  )
+}
+
+// https://url.spec.whatwg.org/#percent-decode
+/** @param {Uint8Array} input */
+function percentDecode (input) {
+  const length = input.length
+  // 1. Let output be an empty byte sequence.
+  /** @type {Uint8Array} */
+  const output = new Uint8Array(length)
+  let j = 0
+  // 2. For each byte byte in input:
+  for (let i = 0; i < length; ++i) {
+    const byte = input[i]
+
+    // 1. If byte is not 0x25 (%), then append byte to output.
+    if (byte !== 0x25) {
+      output[j++] = byte
+
+    // 2. Otherwise, if byte is 0x25 (%) and the next two bytes
+    // after byte in input are not in the ranges
+    // 0x30 (0) to 0x39 (9), 0x41 (A) to 0x46 (F),
+    // and 0x61 (a) to 0x66 (f), all inclusive, append byte
+    // to output.
+    } else if (
+      byte === 0x25 &&
+      !(isHexCharByte(input[i + 1]) && isHexCharByte(input[i + 2]))
+    ) {
+      output[j++] = 0x25
+
+    // 3. Otherwise:
+    } else {
+      // 1. Let bytePoint be the two bytes after byte in input,
+      // decoded, and then interpreted as hexadecimal number.
+      // 2. Append a byte whose value is bytePoint to output.
+      output[j++] = (hexByteToNumber(input[i + 1]) << 4) | hexByteToNumber(input[i + 2])
+
+      // 3. Skip the next two bytes in input.
+      i += 2
+    }
+  }
+
+  // 3. Return output.
+  return length === j ? output : output.subarray(0, j)
+}
+
+// https://mimesniff.spec.whatwg.org/#parse-a-mime-type
+/** @param {string} input */
+function parseMIMEType (input) {
+  // 1. Remove any leading and trailing HTTP whitespace
+  // from input.
+  input = removeHTTPWhitespace(input, true, true)
+
+  // 2. Let position be a position variable for input,
+  // initially pointing at the start of input.
+  const position = { position: 0 }
+
+  // 3. Let type be the result of collecting a sequence
+  // of code points that are not U+002F (/) from
+  // input, given position.
+  const type = collectASequenceOfCodePointsFast(
+    '/',
+    input,
+    position
+  )
+
+  // 4. If type is the empty string or does not solely
+  // contain HTTP token code points, then return failure.
+  // https://mimesniff.spec.whatwg.org/#http-token-code-point
+  if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
+    return 'failure'
+  }
+
+  // 5. If position is past the end of input, then return
+  // failure
+  if (position.position > input.length) {
+    return 'failure'
+  }
+
+  // 6. Advance position by 1. (This skips past U+002F (/).)
+  position.position++
+
+  // 7. Let subtype be the result of collecting a sequence of
+  // code points that are not U+003B (;) from input, given
+  // position.
+  let subtype = collectASequenceOfCodePointsFast(
+    ';',
+    input,
+    position
+  )
+
+  // 8. Remove any trailing HTTP whitespace from subtype.
+  subtype = removeHTTPWhitespace(subtype, false, true)
+
+  // 9. If subtype is the empty string or does not solely
+  // contain HTTP token code points, then return failure.
+  if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
+    return 'failure'
+  }
+
+  const typeLowercase = type.toLowerCase()
+  const subtypeLowercase = subtype.toLowerCase()
+
+  // 10. Let mimeType be a new MIME type record whose type
+  // is type, in ASCII lowercase, and subtype is subtype,
+  // in ASCII lowercase.
+  // https://mimesniff.spec.whatwg.org/#mime-type
+  const mimeType = {
+    type: typeLowercase,
+    subtype: subtypeLowercase,
+    /** @type {Map<string, string>} */
+    parameters: new Map(),
+    // https://mimesniff.spec.whatwg.org/#mime-type-essence
+    essence: `${typeLowercase}/${subtypeLowercase}`
+  }
+
+  // 11. While position is not past the end of input:
+  while (position.position < input.length) {
+    // 1. Advance position by 1. (This skips past U+003B (;).)
+    position.position++
+
+    // 2. Collect a sequence of code points that are HTTP
+    // whitespace from input given position.
+    collectASequenceOfCodePoints(
+      // https://fetch.spec.whatwg.org/#http-whitespace
+      char => HTTP_WHITESPACE_REGEX.test(char),
+      input,
+      position
+    )
+
+    // 3. Let parameterName be the result of collecting a
+    // sequence of code points that are not U+003B (;)
+    // or U+003D (=) from input, given position.
+    let parameterName = collectASequenceOfCodePoints(
+      (char) => char !== ';' && char !== '=',
+      input,
+      position
+    )
+
+    // 4. Set parameterName to parameterName, in ASCII
+    // lowercase.
+    parameterName = parameterName.toLowerCase()
+
+    // 5. If position is not past the end of input, then:
+    if (position.position < input.length) {
+      // 1. If the code point at position within input is
+      // U+003B (;), then continue.
+      if (input[position.position] === ';') {
+        continue
+      }
+
+      // 2. Advance position by 1. (This skips past U+003D (=).)
+      position.position++
+    }
+
+    // 6. If position is past the end of input, then break.
+    if (position.position > input.length) {
+      break
+    }
+
+    // 7. Let parameterValue be null.
+    let parameterValue = null
+
+    // 8. If the code point at position within input is
+    // U+0022 ("), then:
+    if (input[position.position] === '"') {
+      // 1. Set parameterValue to the result of collecting
+      // an HTTP quoted string from input, given position
+      // and the extract-value flag.
+      parameterValue = collectAnHTTPQuotedString(input, position, true)
+
+      // 2. Collect a sequence of code points that are not
+      // U+003B (;) from input, given position.
+      collectASequenceOfCodePointsFast(
+        ';',
+        input,
+        position
+      )
+
+    // 9. Otherwise:
+    } else {
+      // 1. Set parameterValue to the result of collecting
+      // a sequence of code points that are not U+003B (;)
+      // from input, given position.
+      parameterValue = collectASequenceOfCodePointsFast(
+        ';',
+        input,
+        position
+      )
+
+      // 2. Remove any trailing HTTP whitespace from parameterValue.
+      parameterValue = removeHTTPWhitespace(parameterValue, false, true)
+
+      // 3. If parameterValue is the empty string, then continue.
+      if (parameterValue.length === 0) {
+        continue
+      }
+    }
+
+    // 10. If all of the following are true
+    // - parameterName is not the empty string
+    // - parameterName solely contains HTTP token code points
+    // - parameterValue solely contains HTTP quoted-string token code points
+    // - mimeType’s parameters[parameterName] does not exist
+    // then set mimeType’s parameters[parameterName] to parameterValue.
+    if (
+      parameterName.length !== 0 &&
+      HTTP_TOKEN_CODEPOINTS.test(parameterName) &&
+      (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) &&
+      !mimeType.parameters.has(parameterName)
+    ) {
+      mimeType.parameters.set(parameterName, parameterValue)
+    }
+  }
+
+  // 12. Return mimeType.
+  return mimeType
+}
+
+// https://infra.spec.whatwg.org/#forgiving-base64-decode
+/** @param {string} data */
+function forgivingBase64 (data) {
+  // 1. Remove all ASCII whitespace from data.
+  data = data.replace(ASCII_WHITESPACE_REPLACE_REGEX, '')  // eslint-disable-line
+
+  let dataLength = data.length
+  // 2. If data’s code point length divides by 4 leaving
+  // no remainder, then:
+  if (dataLength % 4 === 0) {
+    // 1. If data ends with one or two U+003D (=) code points,
+    // then remove them from data.
+    if (data.charCodeAt(dataLength - 1) === 0x003D) {
+      --dataLength
+      if (data.charCodeAt(dataLength - 1) === 0x003D) {
+        --dataLength
+      }
+    }
+  }
+
+  // 3. If data’s code point length divides by 4 leaving
+  // a remainder of 1, then return failure.
+  if (dataLength % 4 === 1) {
+    return 'failure'
+  }
+
+  // 4. If data contains a code point that is not one of
+  //  U+002B (+)
+  //  U+002F (/)
+  //  ASCII alphanumeric
+  // then return failure.
+  if (/[^+/0-9A-Za-z]/.test(data.length === dataLength ? data : data.substring(0, dataLength))) {
+    return 'failure'
+  }
+
+  const buffer = Buffer.from(data, 'base64')
+  return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+}
+
+// https://fetch.spec.whatwg.org/#collect-an-http-quoted-string
+// tests: https://fetch.spec.whatwg.org/#example-http-quoted-string
+/**
+ * @param {string} input
+ * @param {{ position: number }} position
+ * @param {boolean?} extractValue
+ */
+function collectAnHTTPQuotedString (input, position, extractValue) {
+  // 1. Let positionStart be position.
+  const positionStart = position.position
+
+  // 2. Let value be the empty string.
+  let value = ''
+
+  // 3. Assert: the code point at position within input
+  // is U+0022 (").
+  assert(input[position.position] === '"')
+
+  // 4. Advance position by 1.
+  position.position++
+
+  // 5. While true:
+  while (true) {
+    // 1. Append the result of collecting a sequence of code points
+    // that are not U+0022 (") or U+005C (\) from input, given
+    // position, to value.
+    value += collectASequenceOfCodePoints(
+      (char) => char !== '"' && char !== '\\',
+      input,
+      position
+    )
+
+    // 2. If position is past the end of input, then break.
+    if (position.position >= input.length) {
+      break
+    }
+
+    // 3. Let quoteOrBackslash be the code point at position within
+    // input.
+    const quoteOrBackslash = input[position.position]
+
+    // 4. Advance position by 1.
+    position.position++
+
+    // 5. If quoteOrBackslash is U+005C (\), then:
+    if (quoteOrBackslash === '\\') {
+      // 1. If position is past the end of input, then append
+      // U+005C (\) to value and break.
+      if (position.position >= input.length) {
+        value += '\\'
+        break
+      }
+
+      // 2. Append the code point at position within input to value.
+      value += input[position.position]
+
+      // 3. Advance position by 1.
+      position.position++
+
+    // 6. Otherwise:
+    } else {
+      // 1. Assert: quoteOrBackslash is U+0022 (").
+      assert(quoteOrBackslash === '"')
+
+      // 2. Break.
+      break
+    }
+  }
+
+  // 6. If the extract-value flag is set, then return value.
+  if (extractValue) {
+    return value
+  }
+
+  // 7. Return the code points from positionStart to position,
+  // inclusive, within input.
+  return input.slice(positionStart, position.position)
+}
+
+/**
+ * @see https://mimesniff.spec.whatwg.org/#serialize-a-mime-type
+ */
+function serializeAMimeType (mimeType) {
+  assert(mimeType !== 'failure')
+  const { parameters, essence } = mimeType
+
+  // 1. Let serialization be the concatenation of mimeType’s
+  //    type, U+002F (/), and mimeType’s subtype.
+  let serialization = essence
+
+  // 2. For each name → value of mimeType’s parameters:
+  for (let [name, value] of parameters.entries()) {
+    // 1. Append U+003B (;) to serialization.
+    serialization += ';'
+
+    // 2. Append name to serialization.
+    serialization += name
+
+    // 3. Append U+003D (=) to serialization.
+    serialization += '='
+
+    // 4. If value does not solely contain HTTP token code
+    //    points or value is the empty string, then:
+    if (!HTTP_TOKEN_CODEPOINTS.test(value)) {
+      // 1. Precede each occurrence of U+0022 (") or
+      //    U+005C (\) in value with U+005C (\).
+      value = value.replace(/(\\|")/g, '\\$1')
+
+      // 2. Prepend U+0022 (") to value.
+      value = '"' + value
+
+      // 3. Append U+0022 (") to value.
+      value += '"'
+    }
+
+    // 5. Append value to serialization.
+    serialization += value
+  }
+
+  // 3. Return serialization.
+  return serialization
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#http-whitespace
+ * @param {number} char
+ */
+function isHTTPWhiteSpace (char) {
+  // "\r\n\t "
+  return char === 0x00d || char === 0x00a || char === 0x009 || char === 0x020
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#http-whitespace
+ * @param {string} str
+ * @param {boolean} [leading=true]
+ * @param {boolean} [trailing=true]
+ */
+function removeHTTPWhitespace (str, leading = true, trailing = true) {
+  return removeChars(str, leading, trailing, isHTTPWhiteSpace)
+}
+
+/**
+ * @see https://infra.spec.whatwg.org/#ascii-whitespace
+ * @param {number} char
+ */
+function isASCIIWhitespace (char) {
+  // "\r\n\t\f "
+  return char === 0x00d || char === 0x00a || char === 0x009 || char === 0x00c || char === 0x020
+}
+
+/**
+ * @see https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace
+ * @param {string} str
+ * @param {boolean} [leading=true]
+ * @param {boolean} [trailing=true]
+ */
+function removeASCIIWhitespace (str, leading = true, trailing = true) {
+  return removeChars(str, leading, trailing, isASCIIWhitespace)
+}
+
+/**
+ * @param {string} str
+ * @param {boolean} leading
+ * @param {boolean} trailing
+ * @param {(charCode: number) => boolean} predicate
+ * @returns
+ */
+function removeChars (str, leading, trailing, predicate) {
+  let lead = 0
+  let trail = str.length - 1
+
+  if (leading) {
+    while (lead < str.length && predicate(str.charCodeAt(lead))) lead++
+  }
+
+  if (trailing) {
+    while (trail > 0 && predicate(str.charCodeAt(trail))) trail--
+  }
+
+  return lead === 0 && trail === str.length - 1 ? str : str.slice(lead, trail + 1)
+}
+
+/**
+ * @see https://infra.spec.whatwg.org/#isomorphic-decode
+ * @param {Uint8Array} input
+ * @returns {string}
+ */
+function isomorphicDecode (input) {
+  // 1. To isomorphic decode a byte sequence input, return a string whose code point
+  //    length is equal to input’s length and whose code points have the same values
+  //    as the values of input’s bytes, in the same order.
+  const length = input.length
+  if ((2 << 15) - 1 > length) {
+    return String.fromCharCode.apply(null, input)
+  }
+  let result = ''; let i = 0
+  let addition = (2 << 15) - 1
+  while (i < length) {
+    if (i + addition > length) {
+      addition = length - i
+    }
+    result += String.fromCharCode.apply(null, input.subarray(i, i += addition))
+  }
+  return result
+}
+
+/**
+ * @see https://mimesniff.spec.whatwg.org/#minimize-a-supported-mime-type
+ * @param {Exclude<ReturnType<typeof parseMIMEType>, 'failure'>} mimeType
+ */
+function minimizeSupportedMimeType (mimeType) {
+  switch (mimeType.essence) {
+    case 'application/ecmascript':
+    case 'application/javascript':
+    case 'application/x-ecmascript':
+    case 'application/x-javascript':
+    case 'text/ecmascript':
+    case 'text/javascript':
+    case 'text/javascript1.0':
+    case 'text/javascript1.1':
+    case 'text/javascript1.2':
+    case 'text/javascript1.3':
+    case 'text/javascript1.4':
+    case 'text/javascript1.5':
+    case 'text/jscript':
+    case 'text/livescript':
+    case 'text/x-ecmascript':
+    case 'text/x-javascript':
+      // 1. If mimeType is a JavaScript MIME type, then return "text/javascript".
+      return 'text/javascript'
+    case 'application/json':
+    case 'text/json':
+      // 2. If mimeType is a JSON MIME type, then return "application/json".
+      return 'application/json'
+    case 'image/svg+xml':
+      // 3. If mimeType’s essence is "image/svg+xml", then return "image/svg+xml".
+      return 'image/svg+xml'
+    case 'text/xml':
+    case 'application/xml':
+      // 4. If mimeType is an XML MIME type, then return "application/xml".
+      return 'application/xml'
+  }
+
+  // 2. If mimeType is a JSON MIME type, then return "application/json".
+  if (mimeType.subtype.endsWith('+json')) {
+    return 'application/json'
+  }
+
+  // 4. If mimeType is an XML MIME type, then return "application/xml".
+  if (mimeType.subtype.endsWith('+xml')) {
+    return 'application/xml'
+  }
+
+  // 5. If mimeType is supported by the user agent, then return mimeType’s essence.
+  // Technically, node doesn't support any mimetypes.
+
+  // 6. Return the empty string.
+  return ''
+}
+
+module.exports = {
+  dataURLProcessor,
+  URLSerializer,
+  collectASequenceOfCodePoints,
+  collectASequenceOfCodePointsFast,
+  stringPercentDecode,
+  parseMIMEType,
+  collectAnHTTPQuotedString,
+  serializeAMimeType,
+  removeChars,
+  removeHTTPWhitespace,
+  minimizeSupportedMimeType,
+  HTTP_TOKEN_CODEPOINTS,
+  isomorphicDecode
+}
+
+
+/***/ }),
+
+/***/ 77962:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kConnected, kSize } = __nccwpck_require__(5392)
+
+class CompatWeakRef {
+  constructor (value) {
+    this.value = value
+  }
+
+  deref () {
+    return this.value[kConnected] === 0 && this.value[kSize] === 0
+      ? undefined
+      : this.value
+  }
+}
+
+class CompatFinalizer {
+  constructor (finalizer) {
+    this.finalizer = finalizer
+  }
+
+  register (dispatcher, key) {
+    if (dispatcher.on) {
+      dispatcher.on('disconnect', () => {
+        if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) {
+          this.finalizer(key)
+        }
+      })
+    }
+  }
+
+  unregister (key) {}
+}
+
+module.exports = function () {
+  // FIXME: remove workaround when the Node bug is backported to v18
+  // https://github.com/nodejs/node/issues/49344#issuecomment-1741776308
+  if (process.env.NODE_V8_COVERAGE && process.version.startsWith('v18')) {
+    process._rawDebug('Using compatibility WeakRef and FinalizationRegistry')
+    return {
+      WeakRef: CompatWeakRef,
+      FinalizationRegistry: CompatFinalizer
+    }
+  }
+  return { WeakRef, FinalizationRegistry }
+}
+
+
+/***/ }),
+
+/***/ 52586:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Blob, File } = __nccwpck_require__(72254)
+const { kState } = __nccwpck_require__(78172)
+const { webidl } = __nccwpck_require__(37829)
+
+// TODO(@KhafraDev): remove
+class FileLike {
+  constructor (blobLike, fileName, options = {}) {
+    // TODO: argument idl type check
+
+    // The File constructor is invoked with two or three parameters, depending
+    // on whether the optional dictionary parameter is used. When the File()
+    // constructor is invoked, user agents must run the following steps:
+
+    // 1. Let bytes be the result of processing blob parts given fileBits and
+    // options.
+
+    // 2. Let n be the fileName argument to the constructor.
+    const n = fileName
+
+    // 3. Process FilePropertyBag dictionary argument by running the following
+    // substeps:
+
+    //    1. If the type member is provided and is not the empty string, let t
+    //    be set to the type dictionary member. If t contains any characters
+    //    outside the range U+0020 to U+007E, then set t to the empty string
+    //    and return from these substeps.
+    //    TODO
+    const t = options.type
+
+    //    2. Convert every character in t to ASCII lowercase.
+    //    TODO
+
+    //    3. If the lastModified member is provided, let d be set to the
+    //    lastModified dictionary member. If it is not provided, set d to the
+    //    current date and time represented as the number of milliseconds since
+    //    the Unix Epoch (which is the equivalent of Date.now() [ECMA-262]).
+    const d = options.lastModified ?? Date.now()
+
+    // 4. Return a new File object F such that:
+    // F refers to the bytes byte sequence.
+    // F.size is set to the number of total bytes in bytes.
+    // F.name is set to n.
+    // F.type is set to t.
+    // F.lastModified is set to d.
+
+    this[kState] = {
+      blobLike,
+      name: n,
+      type: t,
+      lastModified: d
+    }
+  }
+
+  stream (...args) {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].blobLike.stream(...args)
+  }
+
+  arrayBuffer (...args) {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].blobLike.arrayBuffer(...args)
+  }
+
+  slice (...args) {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].blobLike.slice(...args)
+  }
+
+  text (...args) {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].blobLike.text(...args)
+  }
+
+  get size () {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].blobLike.size
+  }
+
+  get type () {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].blobLike.type
+  }
+
+  get name () {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].name
+  }
+
+  get lastModified () {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].lastModified
+  }
+
+  get [Symbol.toStringTag] () {
+    return 'File'
+  }
+}
+
+webidl.converters.Blob = webidl.interfaceConverter(Blob)
+
+// If this function is moved to ./util.js, some tools (such as
+// rollup) will warn about circular dependencies. See:
+// https://github.com/nodejs/undici/issues/1629
+function isFileLike (object) {
+  return (
+    (object instanceof File) ||
+    (
+      object &&
+      (typeof object.stream === 'function' ||
+      typeof object.arrayBuffer === 'function') &&
+      object[Symbol.toStringTag] === 'File'
+    )
+  )
+}
+
+module.exports = { FileLike, isFileLike }
+
+
+/***/ }),
+
+/***/ 43227:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { isUSVString, bufferToLowerCasedHeaderName } = __nccwpck_require__(94407)
+const { utf8DecodeBytes } = __nccwpck_require__(91976)
+const { HTTP_TOKEN_CODEPOINTS, isomorphicDecode } = __nccwpck_require__(86954)
+const { isFileLike } = __nccwpck_require__(52586)
+const { makeEntry } = __nccwpck_require__(4923)
+const assert = __nccwpck_require__(98061)
+const { File: NodeFile } = __nccwpck_require__(72254)
+
+const File = globalThis.File ?? NodeFile
+
+const formDataNameBuffer = Buffer.from('form-data; name="')
+const filenameBuffer = Buffer.from('; filename')
+const dd = Buffer.from('--')
+const ddcrlf = Buffer.from('--\r\n')
+
+/**
+ * @param {string} chars
+ */
+function isAsciiString (chars) {
+  for (let i = 0; i < chars.length; ++i) {
+    if ((chars.charCodeAt(i) & ~0x7F) !== 0) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * @see https://andreubotella.github.io/multipart-form-data/#multipart-form-data-boundary
+ * @param {string} boundary
+ */
+function validateBoundary (boundary) {
+  const length = boundary.length
+
+  // - its length is greater or equal to 27 and lesser or equal to 70, and
+  if (length < 27 || length > 70) {
+    return false
+  }
+
+  // - it is composed by bytes in the ranges 0x30 to 0x39, 0x41 to 0x5A, or
+  //   0x61 to 0x7A, inclusive (ASCII alphanumeric), or which are 0x27 ('),
+  //   0x2D (-) or 0x5F (_).
+  for (let i = 0; i < length; ++i) {
+    const cp = boundary.charCodeAt(i)
+
+    if (!(
+      (cp >= 0x30 && cp <= 0x39) ||
+      (cp >= 0x41 && cp <= 0x5a) ||
+      (cp >= 0x61 && cp <= 0x7a) ||
+      cp === 0x27 ||
+      cp === 0x2d ||
+      cp === 0x5f
+    )) {
+      return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * @see https://andreubotella.github.io/multipart-form-data/#multipart-form-data-parser
+ * @param {Buffer} input
+ * @param {ReturnType<import('./data-url')['parseMIMEType']>} mimeType
+ */
+function multipartFormDataParser (input, mimeType) {
+  // 1. Assert: mimeType’s essence is "multipart/form-data".
+  assert(mimeType !== 'failure' && mimeType.essence === 'multipart/form-data')
+
+  const boundaryString = mimeType.parameters.get('boundary')
+
+  // 2. If mimeType’s parameters["boundary"] does not exist, return failure.
+  //    Otherwise, let boundary be the result of UTF-8 decoding mimeType’s
+  //    parameters["boundary"].
+  if (boundaryString === undefined) {
+    return 'failure'
+  }
+
+  const boundary = Buffer.from(`--${boundaryString}`, 'utf8')
+
+  // 3. Let entry list be an empty entry list.
+  const entryList = []
+
+  // 4. Let position be a pointer to a byte in input, initially pointing at
+  //    the first byte.
+  const position = { position: 0 }
+
+  // Note: undici addition, allows leading and trailing CRLFs.
+  while (input[position.position] === 0x0d && input[position.position + 1] === 0x0a) {
+    position.position += 2
+  }
+
+  let trailing = input.length
+
+  while (input[trailing - 1] === 0x0a && input[trailing - 2] === 0x0d) {
+    trailing -= 2
+  }
+
+  if (trailing !== input.length) {
+    input = input.subarray(0, trailing)
+  }
+
+  // 5. While true:
+  while (true) {
+    // 5.1. If position points to a sequence of bytes starting with 0x2D 0x2D
+    //      (`--`) followed by boundary, advance position by 2 + the length of
+    //      boundary. Otherwise, return failure.
+    // Note: boundary is padded with 2 dashes already, no need to add 2.
+    if (input.subarray(position.position, position.position + boundary.length).equals(boundary)) {
+      position.position += boundary.length
+    } else {
+      return 'failure'
+    }
+
+    // 5.2. If position points to the sequence of bytes 0x2D 0x2D 0x0D 0x0A
+    //      (`--` followed by CR LF) followed by the end of input, return entry list.
+    // Note: a body does NOT need to end with CRLF. It can end with --.
+    if (
+      (position.position === input.length - 2 && bufferStartsWith(input, dd, position)) ||
+      (position.position === input.length - 4 && bufferStartsWith(input, ddcrlf, position))
+    ) {
+      return entryList
+    }
+
+    // 5.3. If position does not point to a sequence of bytes starting with 0x0D
+    //      0x0A (CR LF), return failure.
+    if (input[position.position] !== 0x0d || input[position.position + 1] !== 0x0a) {
+      return 'failure'
+    }
+
+    // 5.4. Advance position by 2. (This skips past the newline.)
+    position.position += 2
+
+    // 5.5. Let name, filename and contentType be the result of parsing
+    //      multipart/form-data headers on input and position, if the result
+    //      is not failure. Otherwise, return failure.
+    const result = parseMultipartFormDataHeaders(input, position)
+
+    if (result === 'failure') {
+      return 'failure'
+    }
+
+    let { name, filename, contentType, encoding } = result
+
+    // 5.6. Advance position by 2. (This skips past the empty line that marks
+    //      the end of the headers.)
+    position.position += 2
+
+    // 5.7. Let body be the empty byte sequence.
+    let body
+
+    // 5.8. Body loop: While position is not past the end of input:
+    // TODO: the steps here are completely wrong
+    {
+      const boundaryIndex = input.indexOf(boundary.subarray(2), position.position)
+
+      if (boundaryIndex === -1) {
+        return 'failure'
+      }
+
+      body = input.subarray(position.position, boundaryIndex - 4)
+
+      position.position += body.length
+
+      // Note: position must be advanced by the body's length before being
+      // decoded, otherwise the parsing will fail.
+      if (encoding === 'base64') {
+        body = Buffer.from(body.toString(), 'base64')
+      }
+    }
+
+    // 5.9. If position does not point to a sequence of bytes starting with
+    //      0x0D 0x0A (CR LF), return failure. Otherwise, advance position by 2.
+    if (input[position.position] !== 0x0d || input[position.position + 1] !== 0x0a) {
+      return 'failure'
+    } else {
+      position.position += 2
+    }
+
+    // 5.10. If filename is not null:
+    let value
+
+    if (filename !== null) {
+      // 5.10.1. If contentType is null, set contentType to "text/plain".
+      contentType ??= 'text/plain'
+
+      // 5.10.2. If contentType is not an ASCII string, set contentType to the empty string.
+
+      // Note: `buffer.isAscii` can be used at zero-cost, but converting a string to a buffer is a high overhead.
+      // Content-Type is a relatively small string, so it is faster to use `String#charCodeAt`.
+      if (!isAsciiString(contentType)) {
+        contentType = ''
+      }
+
+      // 5.10.3. Let value be a new File object with name filename, type contentType, and body body.
+      value = new File([body], filename, { type: contentType })
+    } else {
+      // 5.11. Otherwise:
+
+      // 5.11.1. Let value be the UTF-8 decoding without BOM of body.
+      value = utf8DecodeBytes(Buffer.from(body))
+    }
+
+    // 5.12. Assert: name is a scalar value string and value is either a scalar value string or a File object.
+    assert(isUSVString(name))
+    assert((typeof value === 'string' && isUSVString(value)) || isFileLike(value))
+
+    // 5.13. Create an entry with name and value, and append it to entry list.
+    entryList.push(makeEntry(name, value, filename))
+  }
+}
+
+/**
+ * @see https://andreubotella.github.io/multipart-form-data/#parse-multipart-form-data-headers
+ * @param {Buffer} input
+ * @param {{ position: number }} position
+ */
+function parseMultipartFormDataHeaders (input, position) {
+  // 1. Let name, filename and contentType be null.
+  let name = null
+  let filename = null
+  let contentType = null
+  let encoding = null
+
+  // 2. While true:
+  while (true) {
+    // 2.1. If position points to a sequence of bytes starting with 0x0D 0x0A (CR LF):
+    if (input[position.position] === 0x0d && input[position.position + 1] === 0x0a) {
+      // 2.1.1. If name is null, return failure.
+      if (name === null) {
+        return 'failure'
+      }
+
+      // 2.1.2. Return name, filename and contentType.
+      return { name, filename, contentType, encoding }
+    }
+
+    // 2.2. Let header name be the result of collecting a sequence of bytes that are
+    //      not 0x0A (LF), 0x0D (CR) or 0x3A (:), given position.
+    let headerName = collectASequenceOfBytes(
+      (char) => char !== 0x0a && char !== 0x0d && char !== 0x3a,
+      input,
+      position
+    )
+
+    // 2.3. Remove any HTTP tab or space bytes from the start or end of header name.
+    headerName = removeChars(headerName, true, true, (char) => char === 0x9 || char === 0x20)
+
+    // 2.4. If header name does not match the field-name token production, return failure.
+    if (!HTTP_TOKEN_CODEPOINTS.test(headerName.toString())) {
+      return 'failure'
+    }
+
+    // 2.5. If the byte at position is not 0x3A (:), return failure.
+    if (input[position.position] !== 0x3a) {
+      return 'failure'
+    }
+
+    // 2.6. Advance position by 1.
+    position.position++
+
+    // 2.7. Collect a sequence of bytes that are HTTP tab or space bytes given position.
+    //      (Do nothing with those bytes.)
+    collectASequenceOfBytes(
+      (char) => char === 0x20 || char === 0x09,
+      input,
+      position
+    )
+
+    // 2.8. Byte-lowercase header name and switch on the result:
+    switch (bufferToLowerCasedHeaderName(headerName)) {
+      case 'content-disposition': {
+        // 1. Set name and filename to null.
+        name = filename = null
+
+        // 2. If position does not point to a sequence of bytes starting with
+        //    `form-data; name="`, return failure.
+        if (!bufferStartsWith(input, formDataNameBuffer, position)) {
+          return 'failure'
+        }
+
+        // 3. Advance position so it points at the byte after the next 0x22 (")
+        //    byte (the one in the sequence of bytes matched above).
+        position.position += 17
+
+        // 4. Set name to the result of parsing a multipart/form-data name given
+        //    input and position, if the result is not failure. Otherwise, return
+        //    failure.
+        name = parseMultipartFormDataName(input, position)
+
+        if (name === null) {
+          return 'failure'
+        }
+
+        // 5. If position points to a sequence of bytes starting with `; filename="`:
+        if (bufferStartsWith(input, filenameBuffer, position)) {
+          // Note: undici also handles filename*
+          let check = position.position + filenameBuffer.length
+
+          if (input[check] === 0x2a) {
+            position.position += 1
+            check += 1
+          }
+
+          if (input[check] !== 0x3d || input[check + 1] !== 0x22) { // ="
+            return 'failure'
+          }
+
+          // 1. Advance position so it points at the byte after the next 0x22 (") byte
+          //    (the one in the sequence of bytes matched above).
+          position.position += 12
+
+          // 2. Set filename to the result of parsing a multipart/form-data name given
+          //    input and position, if the result is not failure. Otherwise, return failure.
+          filename = parseMultipartFormDataName(input, position)
+
+          if (filename === null) {
+            return 'failure'
+          }
+        }
+
+        break
+      }
+      case 'content-type': {
+        // 1. Let header value be the result of collecting a sequence of bytes that are
+        //    not 0x0A (LF) or 0x0D (CR), given position.
+        let headerValue = collectASequenceOfBytes(
+          (char) => char !== 0x0a && char !== 0x0d,
+          input,
+          position
+        )
+
+        // 2. Remove any HTTP tab or space bytes from the end of header value.
+        headerValue = removeChars(headerValue, false, true, (char) => char === 0x9 || char === 0x20)
+
+        // 3. Set contentType to the isomorphic decoding of header value.
+        contentType = isomorphicDecode(headerValue)
+
+        break
+      }
+      case 'content-transfer-encoding': {
+        let headerValue = collectASequenceOfBytes(
+          (char) => char !== 0x0a && char !== 0x0d,
+          input,
+          position
+        )
+
+        headerValue = removeChars(headerValue, false, true, (char) => char === 0x9 || char === 0x20)
+
+        encoding = isomorphicDecode(headerValue)
+
+        break
+      }
+      default: {
+        // Collect a sequence of bytes that are not 0x0A (LF) or 0x0D (CR), given position.
+        // (Do nothing with those bytes.)
+        collectASequenceOfBytes(
+          (char) => char !== 0x0a && char !== 0x0d,
+          input,
+          position
+        )
+      }
+    }
+
+    // 2.9. If position does not point to a sequence of bytes starting with 0x0D 0x0A
+    //      (CR LF), return failure. Otherwise, advance position by 2 (past the newline).
+    if (input[position.position] !== 0x0d && input[position.position + 1] !== 0x0a) {
+      return 'failure'
+    } else {
+      position.position += 2
+    }
+  }
+}
+
+/**
+ * @see https://andreubotella.github.io/multipart-form-data/#parse-a-multipart-form-data-name
+ * @param {Buffer} input
+ * @param {{ position: number }} position
+ */
+function parseMultipartFormDataName (input, position) {
+  // 1. Assert: The byte at (position - 1) is 0x22 (").
+  assert(input[position.position - 1] === 0x22)
+
+  // 2. Let name be the result of collecting a sequence of bytes that are not 0x0A (LF), 0x0D (CR) or 0x22 ("), given position.
+  /** @type {string | Buffer} */
+  let name = collectASequenceOfBytes(
+    (char) => char !== 0x0a && char !== 0x0d && char !== 0x22,
+    input,
+    position
+  )
+
+  // 3. If the byte at position is not 0x22 ("), return failure. Otherwise, advance position by 1.
+  if (input[position.position] !== 0x22) {
+    return null // name could be 'failure'
+  } else {
+    position.position++
+  }
+
+  // 4. Replace any occurrence of the following subsequences in name with the given byte:
+  // - `%0A`: 0x0A (LF)
+  // - `%0D`: 0x0D (CR)
+  // - `%22`: 0x22 (")
+  name = new TextDecoder().decode(name)
+    .replace(/%0A/ig, '\n')
+    .replace(/%0D/ig, '\r')
+    .replace(/%22/g, '"')
+
+  // 5. Return the UTF-8 decoding without BOM of name.
+  return name
+}
+
+/**
+ * @param {(char: number) => boolean} condition
+ * @param {Buffer} input
+ * @param {{ position: number }} position
+ */
+function collectASequenceOfBytes (condition, input, position) {
+  let start = position.position
+
+  while (start < input.length && condition(input[start])) {
+    ++start
+  }
+
+  return input.subarray(position.position, (position.position = start))
+}
+
+/**
+ * @param {Buffer} buf
+ * @param {boolean} leading
+ * @param {boolean} trailing
+ * @param {(charCode: number) => boolean} predicate
+ * @returns {Buffer}
+ */
+function removeChars (buf, leading, trailing, predicate) {
+  let lead = 0
+  let trail = buf.length - 1
+
+  if (leading) {
+    while (lead < buf.length && predicate(buf[lead])) lead++
+  }
+
+  if (trailing) {
+    while (trail > 0 && predicate(buf[trail])) trail--
+  }
+
+  return lead === 0 && trail === buf.length - 1 ? buf : buf.subarray(lead, trail + 1)
+}
+
+/**
+ * Checks if {@param buffer} starts with {@param start}
+ * @param {Buffer} buffer
+ * @param {Buffer} start
+ * @param {{ position: number }} position
+ */
+function bufferStartsWith (buffer, start, position) {
+  if (buffer.length < start.length) {
+    return false
+  }
+
+  for (let i = 0; i < start.length; i++) {
+    if (start[i] !== buffer[position.position + i]) {
+      return false
+    }
+  }
+
+  return true
+}
+
+module.exports = {
+  multipartFormDataParser,
+  validateBoundary
+}
+
+
+/***/ }),
+
+/***/ 4923:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { isBlobLike, iteratorMixin } = __nccwpck_require__(91976)
+const { kState } = __nccwpck_require__(78172)
+const { kEnumerableProperty } = __nccwpck_require__(94407)
+const { FileLike, isFileLike } = __nccwpck_require__(52586)
+const { webidl } = __nccwpck_require__(37829)
+const { File: NativeFile } = __nccwpck_require__(72254)
+const nodeUtil = __nccwpck_require__(47261)
+
+/** @type {globalThis['File']} */
+const File = globalThis.File ?? NativeFile
+
+// https://xhr.spec.whatwg.org/#formdata
+class FormData {
+  constructor (form) {
+    webidl.util.markAsUncloneable(this)
+
+    if (form !== undefined) {
+      throw webidl.errors.conversionFailed({
+        prefix: 'FormData constructor',
+        argument: 'Argument 1',
+        types: ['undefined']
+      })
+    }
+
+    this[kState] = []
+  }
+
+  append (name, value, filename = undefined) {
+    webidl.brandCheck(this, FormData)
+
+    const prefix = 'FormData.append'
+    webidl.argumentLengthCheck(arguments, 2, prefix)
+
+    if (arguments.length === 3 && !isBlobLike(value)) {
+      throw new TypeError(
+        "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'"
+      )
+    }
+
+    // 1. Let value be value if given; otherwise blobValue.
+
+    name = webidl.converters.USVString(name, prefix, 'name')
+    value = isBlobLike(value)
+      ? webidl.converters.Blob(value, prefix, 'value', { strict: false })
+      : webidl.converters.USVString(value, prefix, 'value')
+    filename = arguments.length === 3
+      ? webidl.converters.USVString(filename, prefix, 'filename')
+      : undefined
+
+    // 2. Let entry be the result of creating an entry with
+    // name, value, and filename if given.
+    const entry = makeEntry(name, value, filename)
+
+    // 3. Append entry to this’s entry list.
+    this[kState].push(entry)
+  }
+
+  delete (name) {
+    webidl.brandCheck(this, FormData)
+
+    const prefix = 'FormData.delete'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    name = webidl.converters.USVString(name, prefix, 'name')
+
+    // The delete(name) method steps are to remove all entries whose name
+    // is name from this’s entry list.
+    this[kState] = this[kState].filter(entry => entry.name !== name)
+  }
+
+  get (name) {
+    webidl.brandCheck(this, FormData)
+
+    const prefix = 'FormData.get'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    name = webidl.converters.USVString(name, prefix, 'name')
+
+    // 1. If there is no entry whose name is name in this’s entry list,
+    // then return null.
+    const idx = this[kState].findIndex((entry) => entry.name === name)
+    if (idx === -1) {
+      return null
+    }
+
+    // 2. Return the value of the first entry whose name is name from
+    // this’s entry list.
+    return this[kState][idx].value
+  }
+
+  getAll (name) {
+    webidl.brandCheck(this, FormData)
+
+    const prefix = 'FormData.getAll'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    name = webidl.converters.USVString(name, prefix, 'name')
+
+    // 1. If there is no entry whose name is name in this’s entry list,
+    // then return the empty list.
+    // 2. Return the values of all entries whose name is name, in order,
+    // from this’s entry list.
+    return this[kState]
+      .filter((entry) => entry.name === name)
+      .map((entry) => entry.value)
+  }
+
+  has (name) {
+    webidl.brandCheck(this, FormData)
+
+    const prefix = 'FormData.has'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    name = webidl.converters.USVString(name, prefix, 'name')
+
+    // The has(name) method steps are to return true if there is an entry
+    // whose name is name in this’s entry list; otherwise false.
+    return this[kState].findIndex((entry) => entry.name === name) !== -1
+  }
+
+  set (name, value, filename = undefined) {
+    webidl.brandCheck(this, FormData)
+
+    const prefix = 'FormData.set'
+    webidl.argumentLengthCheck(arguments, 2, prefix)
+
+    if (arguments.length === 3 && !isBlobLike(value)) {
+      throw new TypeError(
+        "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'"
+      )
+    }
+
+    // The set(name, value) and set(name, blobValue, filename) method steps
+    // are:
+
+    // 1. Let value be value if given; otherwise blobValue.
+
+    name = webidl.converters.USVString(name, prefix, 'name')
+    value = isBlobLike(value)
+      ? webidl.converters.Blob(value, prefix, 'name', { strict: false })
+      : webidl.converters.USVString(value, prefix, 'name')
+    filename = arguments.length === 3
+      ? webidl.converters.USVString(filename, prefix, 'name')
+      : undefined
+
+    // 2. Let entry be the result of creating an entry with name, value, and
+    // filename if given.
+    const entry = makeEntry(name, value, filename)
+
+    // 3. If there are entries in this’s entry list whose name is name, then
+    // replace the first such entry with entry and remove the others.
+    const idx = this[kState].findIndex((entry) => entry.name === name)
+    if (idx !== -1) {
+      this[kState] = [
+        ...this[kState].slice(0, idx),
+        entry,
+        ...this[kState].slice(idx + 1).filter((entry) => entry.name !== name)
+      ]
+    } else {
+      // 4. Otherwise, append entry to this’s entry list.
+      this[kState].push(entry)
+    }
+  }
+
+  [nodeUtil.inspect.custom] (depth, options) {
+    const state = this[kState].reduce((a, b) => {
+      if (a[b.name]) {
+        if (Array.isArray(a[b.name])) {
+          a[b.name].push(b.value)
+        } else {
+          a[b.name] = [a[b.name], b.value]
+        }
+      } else {
+        a[b.name] = b.value
+      }
+
+      return a
+    }, { __proto__: null })
+
+    options.depth ??= depth
+    options.colors ??= true
+
+    const output = nodeUtil.formatWithOptions(options, state)
+
+    // remove [Object null prototype]
+    return `FormData ${output.slice(output.indexOf(']') + 2)}`
+  }
+}
+
+iteratorMixin('FormData', FormData, kState, 'name', 'value')
+
+Object.defineProperties(FormData.prototype, {
+  append: kEnumerableProperty,
+  delete: kEnumerableProperty,
+  get: kEnumerableProperty,
+  getAll: kEnumerableProperty,
+  has: kEnumerableProperty,
+  set: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'FormData',
+    configurable: true
+  }
+})
+
+/**
+ * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#create-an-entry
+ * @param {string} name
+ * @param {string|Blob} value
+ * @param {?string} filename
+ * @returns
+ */
+function makeEntry (name, value, filename) {
+  // 1. Set name to the result of converting name into a scalar value string.
+  // Note: This operation was done by the webidl converter USVString.
+
+  // 2. If value is a string, then set value to the result of converting
+  //    value into a scalar value string.
+  if (typeof value === 'string') {
+    // Note: This operation was done by the webidl converter USVString.
+  } else {
+    // 3. Otherwise:
+
+    // 1. If value is not a File object, then set value to a new File object,
+    //    representing the same bytes, whose name attribute value is "blob"
+    if (!isFileLike(value)) {
+      value = value instanceof Blob
+        ? new File([value], 'blob', { type: value.type })
+        : new FileLike(value, 'blob', { type: value.type })
+    }
+
+    // 2. If filename is given, then set value to a new File object,
+    //    representing the same bytes, whose name attribute is filename.
+    if (filename !== undefined) {
+      /** @type {FilePropertyBag} */
+      const options = {
+        type: value.type,
+        lastModified: value.lastModified
+      }
+
+      value = value instanceof NativeFile
+        ? new File([value], filename, options)
+        : new FileLike(value, filename, options)
+    }
+  }
+
+  // 4. Return an entry whose name is name and whose value is value.
+  return { name, value }
+}
+
+module.exports = { FormData, makeEntry }
+
+
+/***/ }),
+
+/***/ 71332:
+/***/ ((module) => {
+
+"use strict";
+
+
+// In case of breaking changes, increase the version
+// number to avoid conflicts.
+const globalOrigin = Symbol.for('undici.globalOrigin.1')
+
+function getGlobalOrigin () {
+  return globalThis[globalOrigin]
+}
+
+function setGlobalOrigin (newOrigin) {
+  if (newOrigin === undefined) {
+    Object.defineProperty(globalThis, globalOrigin, {
+      value: undefined,
+      writable: true,
+      enumerable: false,
+      configurable: false
+    })
+
+    return
+  }
+
+  const parsedURL = new URL(newOrigin)
+
+  if (parsedURL.protocol !== 'http:' && parsedURL.protocol !== 'https:') {
+    throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`)
+  }
+
+  Object.defineProperty(globalThis, globalOrigin, {
+    value: parsedURL,
+    writable: true,
+    enumerable: false,
+    configurable: false
+  })
+}
+
+module.exports = {
+  getGlobalOrigin,
+  setGlobalOrigin
+}
+
+
+/***/ }),
+
+/***/ 24997:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// https://github.com/Ethan-Arrowood/undici-fetch
+
+
+
+const { kConstruct } = __nccwpck_require__(5392)
+const { kEnumerableProperty } = __nccwpck_require__(94407)
+const {
+  iteratorMixin,
+  isValidHeaderName,
+  isValidHeaderValue
+} = __nccwpck_require__(91976)
+const { webidl } = __nccwpck_require__(37829)
+const assert = __nccwpck_require__(98061)
+const util = __nccwpck_require__(47261)
+
+const kHeadersMap = Symbol('headers map')
+const kHeadersSortedMap = Symbol('headers map sorted')
+
+/**
+ * @param {number} code
+ */
+function isHTTPWhiteSpaceCharCode (code) {
+  return code === 0x00a || code === 0x00d || code === 0x009 || code === 0x020
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-header-value-normalize
+ * @param {string} potentialValue
+ */
+function headerValueNormalize (potentialValue) {
+  //  To normalize a byte sequence potentialValue, remove
+  //  any leading and trailing HTTP whitespace bytes from
+  //  potentialValue.
+  let i = 0; let j = potentialValue.length
+
+  while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1))) --j
+  while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i))) ++i
+
+  return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j)
+}
+
+function fill (headers, object) {
+  // To fill a Headers object headers with a given object object, run these steps:
+
+  // 1. If object is a sequence, then for each header in object:
+  // Note: webidl conversion to array has already been done.
+  if (Array.isArray(object)) {
+    for (let i = 0; i < object.length; ++i) {
+      const header = object[i]
+      // 1. If header does not contain exactly two items, then throw a TypeError.
+      if (header.length !== 2) {
+        throw webidl.errors.exception({
+          header: 'Headers constructor',
+          message: `expected name/value pair to be length 2, found ${header.length}.`
+        })
+      }
+
+      // 2. Append (header’s first item, header’s second item) to headers.
+      appendHeader(headers, header[0], header[1])
+    }
+  } else if (typeof object === 'object' && object !== null) {
+    // Note: null should throw
+
+    // 2. Otherwise, object is a record, then for each key → value in object,
+    //    append (key, value) to headers
+    const keys = Object.keys(object)
+    for (let i = 0; i < keys.length; ++i) {
+      appendHeader(headers, keys[i], object[keys[i]])
+    }
+  } else {
+    throw webidl.errors.conversionFailed({
+      prefix: 'Headers constructor',
+      argument: 'Argument 1',
+      types: ['sequence<sequence<ByteString>>', 'record<ByteString, ByteString>']
+    })
+  }
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-headers-append
+ */
+function appendHeader (headers, name, value) {
+  // 1. Normalize value.
+  value = headerValueNormalize(value)
+
+  // 2. If name is not a header name or value is not a
+  //    header value, then throw a TypeError.
+  if (!isValidHeaderName(name)) {
+    throw webidl.errors.invalidArgument({
+      prefix: 'Headers.append',
+      value: name,
+      type: 'header name'
+    })
+  } else if (!isValidHeaderValue(value)) {
+    throw webidl.errors.invalidArgument({
+      prefix: 'Headers.append',
+      value,
+      type: 'header value'
+    })
+  }
+
+  // 3. If headers’s guard is "immutable", then throw a TypeError.
+  // 4. Otherwise, if headers’s guard is "request" and name is a
+  //    forbidden header name, return.
+  // 5. Otherwise, if headers’s guard is "request-no-cors":
+  //    TODO
+  // Note: undici does not implement forbidden header names
+  if (getHeadersGuard(headers) === 'immutable') {
+    throw new TypeError('immutable')
+  }
+
+  // 6. Otherwise, if headers’s guard is "response" and name is a
+  //    forbidden response-header name, return.
+
+  // 7. Append (name, value) to headers’s header list.
+  return getHeadersList(headers).append(name, value, false)
+
+  // 8. If headers’s guard is "request-no-cors", then remove
+  //    privileged no-CORS request headers from headers
+}
+
+function compareHeaderName (a, b) {
+  return a[0] < b[0] ? -1 : 1
+}
+
+class HeadersList {
+  /** @type {[string, string][]|null} */
+  cookies = null
+
+  constructor (init) {
+    if (init instanceof HeadersList) {
+      this[kHeadersMap] = new Map(init[kHeadersMap])
+      this[kHeadersSortedMap] = init[kHeadersSortedMap]
+      this.cookies = init.cookies === null ? null : [...init.cookies]
+    } else {
+      this[kHeadersMap] = new Map(init)
+      this[kHeadersSortedMap] = null
+    }
+  }
+
+  /**
+   * @see https://fetch.spec.whatwg.org/#header-list-contains
+   * @param {string} name
+   * @param {boolean} isLowerCase
+   */
+  contains (name, isLowerCase) {
+    // A header list list contains a header name name if list
+    // contains a header whose name is a byte-case-insensitive
+    // match for name.
+
+    return this[kHeadersMap].has(isLowerCase ? name : name.toLowerCase())
+  }
+
+  clear () {
+    this[kHeadersMap].clear()
+    this[kHeadersSortedMap] = null
+    this.cookies = null
+  }
+
+  /**
+   * @see https://fetch.spec.whatwg.org/#concept-header-list-append
+   * @param {string} name
+   * @param {string} value
+   * @param {boolean} isLowerCase
+   */
+  append (name, value, isLowerCase) {
+    this[kHeadersSortedMap] = null
+
+    // 1. If list contains name, then set name to the first such
+    //    header’s name.
+    const lowercaseName = isLowerCase ? name : name.toLowerCase()
+    const exists = this[kHeadersMap].get(lowercaseName)
+
+    // 2. Append (name, value) to list.
+    if (exists) {
+      const delimiter = lowercaseName === 'cookie' ? '; ' : ', '
+      this[kHeadersMap].set(lowercaseName, {
+        name: exists.name,
+        value: `${exists.value}${delimiter}${value}`
+      })
+    } else {
+      this[kHeadersMap].set(lowercaseName, { name, value })
+    }
+
+    if (lowercaseName === 'set-cookie') {
+      (this.cookies ??= []).push(value)
+    }
+  }
+
+  /**
+   * @see https://fetch.spec.whatwg.org/#concept-header-list-set
+   * @param {string} name
+   * @param {string} value
+   * @param {boolean} isLowerCase
+   */
+  set (name, value, isLowerCase) {
+    this[kHeadersSortedMap] = null
+    const lowercaseName = isLowerCase ? name : name.toLowerCase()
+
+    if (lowercaseName === 'set-cookie') {
+      this.cookies = [value]
+    }
+
+    // 1. If list contains name, then set the value of
+    //    the first such header to value and remove the
+    //    others.
+    // 2. Otherwise, append header (name, value) to list.
+    this[kHeadersMap].set(lowercaseName, { name, value })
+  }
+
+  /**
+   * @see https://fetch.spec.whatwg.org/#concept-header-list-delete
+   * @param {string} name
+   * @param {boolean} isLowerCase
+   */
+  delete (name, isLowerCase) {
+    this[kHeadersSortedMap] = null
+    if (!isLowerCase) name = name.toLowerCase()
+
+    if (name === 'set-cookie') {
+      this.cookies = null
+    }
+
+    this[kHeadersMap].delete(name)
+  }
+
+  /**
+   * @see https://fetch.spec.whatwg.org/#concept-header-list-get
+   * @param {string} name
+   * @param {boolean} isLowerCase
+   * @returns {string | null}
+   */
+  get (name, isLowerCase) {
+    // 1. If list does not contain name, then return null.
+    // 2. Return the values of all headers in list whose name
+    //    is a byte-case-insensitive match for name,
+    //    separated from each other by 0x2C 0x20, in order.
+    return this[kHeadersMap].get(isLowerCase ? name : name.toLowerCase())?.value ?? null
+  }
+
+  * [Symbol.iterator] () {
+    // use the lowercased name
+    for (const { 0: name, 1: { value } } of this[kHeadersMap]) {
+      yield [name, value]
+    }
+  }
+
+  get entries () {
+    const headers = {}
+
+    if (this[kHeadersMap].size !== 0) {
+      for (const { name, value } of this[kHeadersMap].values()) {
+        headers[name] = value
+      }
+    }
+
+    return headers
+  }
+
+  rawValues () {
+    return this[kHeadersMap].values()
+  }
+
+  get entriesList () {
+    const headers = []
+
+    if (this[kHeadersMap].size !== 0) {
+      for (const { 0: lowerName, 1: { name, value } } of this[kHeadersMap]) {
+        if (lowerName === 'set-cookie') {
+          for (const cookie of this.cookies) {
+            headers.push([name, cookie])
+          }
+        } else {
+          headers.push([name, value])
+        }
+      }
+    }
+
+    return headers
+  }
+
+  // https://fetch.spec.whatwg.org/#convert-header-names-to-a-sorted-lowercase-set
+  toSortedArray () {
+    const size = this[kHeadersMap].size
+    const array = new Array(size)
+    // In most cases, you will use the fast-path.
+    // fast-path: Use binary insertion sort for small arrays.
+    if (size <= 32) {
+      if (size === 0) {
+        // If empty, it is an empty array. To avoid the first index assignment.
+        return array
+      }
+      // Improve performance by unrolling loop and avoiding double-loop.
+      // Double-loop-less version of the binary insertion sort.
+      const iterator = this[kHeadersMap][Symbol.iterator]()
+      const firstValue = iterator.next().value
+      // set [name, value] to first index.
+      array[0] = [firstValue[0], firstValue[1].value]
+      // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
+      // 3.2.2. Assert: value is non-null.
+      assert(firstValue[1].value !== null)
+      for (
+        let i = 1, j = 0, right = 0, left = 0, pivot = 0, x, value;
+        i < size;
+        ++i
+      ) {
+        // get next value
+        value = iterator.next().value
+        // set [name, value] to current index.
+        x = array[i] = [value[0], value[1].value]
+        // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
+        // 3.2.2. Assert: value is non-null.
+        assert(x[1] !== null)
+        left = 0
+        right = i
+        // binary search
+        while (left < right) {
+          // middle index
+          pivot = left + ((right - left) >> 1)
+          // compare header name
+          if (array[pivot][0] <= x[0]) {
+            left = pivot + 1
+          } else {
+            right = pivot
+          }
+        }
+        if (i !== pivot) {
+          j = i
+          while (j > left) {
+            array[j] = array[--j]
+          }
+          array[left] = x
+        }
+      }
+      /* c8 ignore next 4 */
+      if (!iterator.next().done) {
+        // This is for debugging and will never be called.
+        throw new TypeError('Unreachable')
+      }
+      return array
+    } else {
+      // This case would be a rare occurrence.
+      // slow-path: fallback
+      let i = 0
+      for (const { 0: name, 1: { value } } of this[kHeadersMap]) {
+        array[i++] = [name, value]
+        // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
+        // 3.2.2. Assert: value is non-null.
+        assert(value !== null)
+      }
+      return array.sort(compareHeaderName)
+    }
+  }
+}
+
+// https://fetch.spec.whatwg.org/#headers-class
+class Headers {
+  #guard
+  #headersList
+
+  constructor (init = undefined) {
+    webidl.util.markAsUncloneable(this)
+
+    if (init === kConstruct) {
+      return
+    }
+
+    this.#headersList = new HeadersList()
+
+    // The new Headers(init) constructor steps are:
+
+    // 1. Set this’s guard to "none".
+    this.#guard = 'none'
+
+    // 2. If init is given, then fill this with init.
+    if (init !== undefined) {
+      init = webidl.converters.HeadersInit(init, 'Headers contructor', 'init')
+      fill(this, init)
+    }
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-append
+  append (name, value) {
+    webidl.brandCheck(this, Headers)
+
+    webidl.argumentLengthCheck(arguments, 2, 'Headers.append')
+
+    const prefix = 'Headers.append'
+    name = webidl.converters.ByteString(name, prefix, 'name')
+    value = webidl.converters.ByteString(value, prefix, 'value')
+
+    return appendHeader(this, name, value)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-delete
+  delete (name) {
+    webidl.brandCheck(this, Headers)
+
+    webidl.argumentLengthCheck(arguments, 1, 'Headers.delete')
+
+    const prefix = 'Headers.delete'
+    name = webidl.converters.ByteString(name, prefix, 'name')
+
+    // 1. If name is not a header name, then throw a TypeError.
+    if (!isValidHeaderName(name)) {
+      throw webidl.errors.invalidArgument({
+        prefix: 'Headers.delete',
+        value: name,
+        type: 'header name'
+      })
+    }
+
+    // 2. If this’s guard is "immutable", then throw a TypeError.
+    // 3. Otherwise, if this’s guard is "request" and name is a
+    //    forbidden header name, return.
+    // 4. Otherwise, if this’s guard is "request-no-cors", name
+    //    is not a no-CORS-safelisted request-header name, and
+    //    name is not a privileged no-CORS request-header name,
+    //    return.
+    // 5. Otherwise, if this’s guard is "response" and name is
+    //    a forbidden response-header name, return.
+    // Note: undici does not implement forbidden header names
+    if (this.#guard === 'immutable') {
+      throw new TypeError('immutable')
+    }
+
+    // 6. If this’s header list does not contain name, then
+    //    return.
+    if (!this.#headersList.contains(name, false)) {
+      return
+    }
+
+    // 7. Delete name from this’s header list.
+    // 8. If this’s guard is "request-no-cors", then remove
+    //    privileged no-CORS request headers from this.
+    this.#headersList.delete(name, false)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-get
+  get (name) {
+    webidl.brandCheck(this, Headers)
+
+    webidl.argumentLengthCheck(arguments, 1, 'Headers.get')
+
+    const prefix = 'Headers.get'
+    name = webidl.converters.ByteString(name, prefix, 'name')
+
+    // 1. If name is not a header name, then throw a TypeError.
+    if (!isValidHeaderName(name)) {
+      throw webidl.errors.invalidArgument({
+        prefix,
+        value: name,
+        type: 'header name'
+      })
+    }
+
+    // 2. Return the result of getting name from this’s header
+    //    list.
+    return this.#headersList.get(name, false)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-has
+  has (name) {
+    webidl.brandCheck(this, Headers)
+
+    webidl.argumentLengthCheck(arguments, 1, 'Headers.has')
+
+    const prefix = 'Headers.has'
+    name = webidl.converters.ByteString(name, prefix, 'name')
+
+    // 1. If name is not a header name, then throw a TypeError.
+    if (!isValidHeaderName(name)) {
+      throw webidl.errors.invalidArgument({
+        prefix,
+        value: name,
+        type: 'header name'
+      })
+    }
+
+    // 2. Return true if this’s header list contains name;
+    //    otherwise false.
+    return this.#headersList.contains(name, false)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-set
+  set (name, value) {
+    webidl.brandCheck(this, Headers)
+
+    webidl.argumentLengthCheck(arguments, 2, 'Headers.set')
+
+    const prefix = 'Headers.set'
+    name = webidl.converters.ByteString(name, prefix, 'name')
+    value = webidl.converters.ByteString(value, prefix, 'value')
+
+    // 1. Normalize value.
+    value = headerValueNormalize(value)
+
+    // 2. If name is not a header name or value is not a
+    //    header value, then throw a TypeError.
+    if (!isValidHeaderName(name)) {
+      throw webidl.errors.invalidArgument({
+        prefix,
+        value: name,
+        type: 'header name'
+      })
+    } else if (!isValidHeaderValue(value)) {
+      throw webidl.errors.invalidArgument({
+        prefix,
+        value,
+        type: 'header value'
+      })
+    }
+
+    // 3. If this’s guard is "immutable", then throw a TypeError.
+    // 4. Otherwise, if this’s guard is "request" and name is a
+    //    forbidden header name, return.
+    // 5. Otherwise, if this’s guard is "request-no-cors" and
+    //    name/value is not a no-CORS-safelisted request-header,
+    //    return.
+    // 6. Otherwise, if this’s guard is "response" and name is a
+    //    forbidden response-header name, return.
+    // Note: undici does not implement forbidden header names
+    if (this.#guard === 'immutable') {
+      throw new TypeError('immutable')
+    }
+
+    // 7. Set (name, value) in this’s header list.
+    // 8. If this’s guard is "request-no-cors", then remove
+    //    privileged no-CORS request headers from this
+    this.#headersList.set(name, value, false)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie
+  getSetCookie () {
+    webidl.brandCheck(this, Headers)
+
+    // 1. If this’s header list does not contain `Set-Cookie`, then return « ».
+    // 2. Return the values of all headers in this’s header list whose name is
+    //    a byte-case-insensitive match for `Set-Cookie`, in order.
+
+    const list = this.#headersList.cookies
+
+    if (list) {
+      return [...list]
+    }
+
+    return []
+  }
+
+  // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
+  get [kHeadersSortedMap] () {
+    if (this.#headersList[kHeadersSortedMap]) {
+      return this.#headersList[kHeadersSortedMap]
+    }
+
+    // 1. Let headers be an empty list of headers with the key being the name
+    //    and value the value.
+    const headers = []
+
+    // 2. Let names be the result of convert header names to a sorted-lowercase
+    //    set with all the names of the headers in list.
+    const names = this.#headersList.toSortedArray()
+
+    const cookies = this.#headersList.cookies
+
+    // fast-path
+    if (cookies === null || cookies.length === 1) {
+      // Note: The non-null assertion of value has already been done by `HeadersList#toSortedArray`
+      return (this.#headersList[kHeadersSortedMap] = names)
+    }
+
+    // 3. For each name of names:
+    for (let i = 0; i < names.length; ++i) {
+      const { 0: name, 1: value } = names[i]
+      // 1. If name is `set-cookie`, then:
+      if (name === 'set-cookie') {
+        // 1. Let values be a list of all values of headers in list whose name
+        //    is a byte-case-insensitive match for name, in order.
+
+        // 2. For each value of values:
+        // 1. Append (name, value) to headers.
+        for (let j = 0; j < cookies.length; ++j) {
+          headers.push([name, cookies[j]])
+        }
+      } else {
+        // 2. Otherwise:
+
+        // 1. Let value be the result of getting name from list.
+
+        // 2. Assert: value is non-null.
+        // Note: This operation was done by `HeadersList#toSortedArray`.
+
+        // 3. Append (name, value) to headers.
+        headers.push([name, value])
+      }
+    }
+
+    // 4. Return headers.
+    return (this.#headersList[kHeadersSortedMap] = headers)
+  }
+
+  [util.inspect.custom] (depth, options) {
+    options.depth ??= depth
+
+    return `Headers ${util.formatWithOptions(options, this.#headersList.entries)}`
+  }
+
+  static getHeadersGuard (o) {
+    return o.#guard
+  }
+
+  static setHeadersGuard (o, guard) {
+    o.#guard = guard
+  }
+
+  static getHeadersList (o) {
+    return o.#headersList
+  }
+
+  static setHeadersList (o, list) {
+    o.#headersList = list
+  }
+}
+
+const { getHeadersGuard, setHeadersGuard, getHeadersList, setHeadersList } = Headers
+Reflect.deleteProperty(Headers, 'getHeadersGuard')
+Reflect.deleteProperty(Headers, 'setHeadersGuard')
+Reflect.deleteProperty(Headers, 'getHeadersList')
+Reflect.deleteProperty(Headers, 'setHeadersList')
+
+iteratorMixin('Headers', Headers, kHeadersSortedMap, 0, 1)
+
+Object.defineProperties(Headers.prototype, {
+  append: kEnumerableProperty,
+  delete: kEnumerableProperty,
+  get: kEnumerableProperty,
+  has: kEnumerableProperty,
+  set: kEnumerableProperty,
+  getSetCookie: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'Headers',
+    configurable: true
+  },
+  [util.inspect.custom]: {
+    enumerable: false
+  }
+})
+
+webidl.converters.HeadersInit = function (V, prefix, argument) {
+  if (webidl.util.Type(V) === 'Object') {
+    const iterator = Reflect.get(V, Symbol.iterator)
+
+    // A work-around to ensure we send the properly-cased Headers when V is a Headers object.
+    // Read https://github.com/nodejs/undici/pull/3159#issuecomment-2075537226 before touching, please.
+    if (!util.types.isProxy(V) && iterator === Headers.prototype.entries) { // Headers object
+      try {
+        return getHeadersList(V).entriesList
+      } catch {
+        // fall-through
+      }
+    }
+
+    if (typeof iterator === 'function') {
+      return webidl.converters['sequence<sequence<ByteString>>'](V, prefix, argument, iterator.bind(V))
+    }
+
+    return webidl.converters['record<ByteString, ByteString>'](V, prefix, argument)
+  }
+
+  throw webidl.errors.conversionFailed({
+    prefix: 'Headers constructor',
+    argument: 'Argument 1',
+    types: ['sequence<sequence<ByteString>>', 'record<ByteString, ByteString>']
+  })
+}
+
+module.exports = {
+  fill,
+  // for test.
+  compareHeaderName,
+  Headers,
+  HeadersList,
+  getHeadersGuard,
+  setHeadersGuard,
+  setHeadersList,
+  getHeadersList
+}
+
+
+/***/ }),
+
+/***/ 31158:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// https://github.com/Ethan-Arrowood/undici-fetch
+
+
+
+const {
+  makeNetworkError,
+  makeAppropriateNetworkError,
+  filterResponse,
+  makeResponse,
+  fromInnerResponse
+} = __nccwpck_require__(33139)
+const { HeadersList } = __nccwpck_require__(24997)
+const { Request, cloneRequest } = __nccwpck_require__(13925)
+const zlib = __nccwpck_require__(65628)
+const {
+  bytesMatch,
+  makePolicyContainer,
+  clonePolicyContainer,
+  requestBadPort,
+  TAOCheck,
+  appendRequestOriginHeader,
+  responseLocationURL,
+  requestCurrentURL,
+  setRequestReferrerPolicyOnRedirect,
+  tryUpgradeRequestToAPotentiallyTrustworthyURL,
+  createOpaqueTimingInfo,
+  appendFetchMetadata,
+  corsCheck,
+  crossOriginResourcePolicyCheck,
+  determineRequestsReferrer,
+  coarsenedSharedCurrentTime,
+  createDeferredPromise,
+  isBlobLike,
+  sameOrigin,
+  isCancelled,
+  isAborted,
+  isErrorLike,
+  fullyReadBody,
+  readableStreamClose,
+  isomorphicEncode,
+  urlIsLocal,
+  urlIsHttpHttpsScheme,
+  urlHasHttpsScheme,
+  clampAndCoarsenConnectionTimingInfo,
+  simpleRangeHeaderValue,
+  buildContentRange,
+  createInflate,
+  extractMimeType
+} = __nccwpck_require__(91976)
+const { kState, kDispatcher } = __nccwpck_require__(78172)
+const assert = __nccwpck_require__(98061)
+const { safelyExtractBody, extractBody } = __nccwpck_require__(23291)
+const {
+  redirectStatusSet,
+  nullBodyStatus,
+  safeMethodsSet,
+  requestBodyHeader,
+  subresourceSet
+} = __nccwpck_require__(87979)
+const EE = __nccwpck_require__(15673)
+const { Readable, pipeline, finished } = __nccwpck_require__(84492)
+const { addAbortListener, isErrored, isReadable, bufferToLowerCasedHeaderName } = __nccwpck_require__(94407)
+const { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = __nccwpck_require__(86954)
+const { getGlobalDispatcher } = __nccwpck_require__(72354)
+const { webidl } = __nccwpck_require__(37829)
+const { STATUS_CODES } = __nccwpck_require__(88849)
+const GET_OR_HEAD = ['GET', 'HEAD']
+
+const defaultUserAgent = typeof __UNDICI_IS_NODE__ !== 'undefined' || typeof esbuildDetection !== 'undefined'
+  ? 'node'
+  : 'undici'
+
+/** @type {import('buffer').resolveObjectURL} */
+let resolveObjectURL
+
+class Fetch extends EE {
+  constructor (dispatcher) {
+    super()
+
+    this.dispatcher = dispatcher
+    this.connection = null
+    this.dump = false
+    this.state = 'ongoing'
+  }
+
+  terminate (reason) {
+    if (this.state !== 'ongoing') {
+      return
+    }
+
+    this.state = 'terminated'
+    this.connection?.destroy(reason)
+    this.emit('terminated', reason)
+  }
+
+  // https://fetch.spec.whatwg.org/#fetch-controller-abort
+  abort (error) {
+    if (this.state !== 'ongoing') {
+      return
+    }
+
+    // 1. Set controller’s state to "aborted".
+    this.state = 'aborted'
+
+    // 2. Let fallbackError be an "AbortError" DOMException.
+    // 3. Set error to fallbackError if it is not given.
+    if (!error) {
+      error = new DOMException('The operation was aborted.', 'AbortError')
+    }
+
+    // 4. Let serializedError be StructuredSerialize(error).
+    //    If that threw an exception, catch it, and let
+    //    serializedError be StructuredSerialize(fallbackError).
+
+    // 5. Set controller’s serialized abort reason to serializedError.
+    this.serializedAbortReason = error
+
+    this.connection?.destroy(error)
+    this.emit('terminated', error)
+  }
+}
+
+function handleFetchDone (response) {
+  finalizeAndReportTiming(response, 'fetch')
+}
+
+// https://fetch.spec.whatwg.org/#fetch-method
+function fetch (input, init = undefined) {
+  webidl.argumentLengthCheck(arguments, 1, 'globalThis.fetch')
+
+  // 1. Let p be a new promise.
+  let p = createDeferredPromise()
+
+  // 2. Let requestObject be the result of invoking the initial value of
+  // Request as constructor with input and init as arguments. If this throws
+  // an exception, reject p with it and return p.
+  let requestObject
+
+  try {
+    requestObject = new Request(input, init)
+  } catch (e) {
+    p.reject(e)
+    return p.promise
+  }
+
+  // 3. Let request be requestObject’s request.
+  const request = requestObject[kState]
+
+  // 4. If requestObject’s signal’s aborted flag is set, then:
+  if (requestObject.signal.aborted) {
+    // 1. Abort the fetch() call with p, request, null, and
+    //    requestObject’s signal’s abort reason.
+    abortFetch(p, request, null, requestObject.signal.reason)
+
+    // 2. Return p.
+    return p.promise
+  }
+
+  // 5. Let globalObject be request’s client’s global object.
+  const globalObject = request.client.globalObject
+
+  // 6. If globalObject is a ServiceWorkerGlobalScope object, then set
+  // request’s service-workers mode to "none".
+  if (globalObject?.constructor?.name === 'ServiceWorkerGlobalScope') {
+    request.serviceWorkers = 'none'
+  }
+
+  // 7. Let responseObject be null.
+  let responseObject = null
+
+  // 8. Let relevantRealm be this’s relevant Realm.
+
+  // 9. Let locallyAborted be false.
+  let locallyAborted = false
+
+  // 10. Let controller be null.
+  let controller = null
+
+  // 11. Add the following abort steps to requestObject’s signal:
+  addAbortListener(
+    requestObject.signal,
+    () => {
+      // 1. Set locallyAborted to true.
+      locallyAborted = true
+
+      // 2. Assert: controller is non-null.
+      assert(controller != null)
+
+      // 3. Abort controller with requestObject’s signal’s abort reason.
+      controller.abort(requestObject.signal.reason)
+
+      const realResponse = responseObject?.deref()
+
+      // 4. Abort the fetch() call with p, request, responseObject,
+      //    and requestObject’s signal’s abort reason.
+      abortFetch(p, request, realResponse, requestObject.signal.reason)
+    }
+  )
+
+  // 12. Let handleFetchDone given response response be to finalize and
+  // report timing with response, globalObject, and "fetch".
+  // see function handleFetchDone
+
+  // 13. Set controller to the result of calling fetch given request,
+  // with processResponseEndOfBody set to handleFetchDone, and processResponse
+  // given response being these substeps:
+
+  const processResponse = (response) => {
+    // 1. If locallyAborted is true, terminate these substeps.
+    if (locallyAborted) {
+      return
+    }
+
+    // 2. If response’s aborted flag is set, then:
+    if (response.aborted) {
+      // 1. Let deserializedError be the result of deserialize a serialized
+      //    abort reason given controller’s serialized abort reason and
+      //    relevantRealm.
+
+      // 2. Abort the fetch() call with p, request, responseObject, and
+      //    deserializedError.
+
+      abortFetch(p, request, responseObject, controller.serializedAbortReason)
+      return
+    }
+
+    // 3. If response is a network error, then reject p with a TypeError
+    // and terminate these substeps.
+    if (response.type === 'error') {
+      p.reject(new TypeError('fetch failed', { cause: response.error }))
+      return
+    }
+
+    // 4. Set responseObject to the result of creating a Response object,
+    // given response, "immutable", and relevantRealm.
+    responseObject = new WeakRef(fromInnerResponse(response, 'immutable'))
+
+    // 5. Resolve p with responseObject.
+    p.resolve(responseObject.deref())
+    p = null
+  }
+
+  controller = fetching({
+    request,
+    processResponseEndOfBody: handleFetchDone,
+    processResponse,
+    dispatcher: requestObject[kDispatcher] // undici
+  })
+
+  // 14. Return p.
+  return p.promise
+}
+
+// https://fetch.spec.whatwg.org/#finalize-and-report-timing
+function finalizeAndReportTiming (response, initiatorType = 'other') {
+  // 1. If response is an aborted network error, then return.
+  if (response.type === 'error' && response.aborted) {
+    return
+  }
+
+  // 2. If response’s URL list is null or empty, then return.
+  if (!response.urlList?.length) {
+    return
+  }
+
+  // 3. Let originalURL be response’s URL list[0].
+  const originalURL = response.urlList[0]
+
+  // 4. Let timingInfo be response’s timing info.
+  let timingInfo = response.timingInfo
+
+  // 5. Let cacheState be response’s cache state.
+  let cacheState = response.cacheState
+
+  // 6. If originalURL’s scheme is not an HTTP(S) scheme, then return.
+  if (!urlIsHttpHttpsScheme(originalURL)) {
+    return
+  }
+
+  // 7. If timingInfo is null, then return.
+  if (timingInfo === null) {
+    return
+  }
+
+  // 8. If response’s timing allow passed flag is not set, then:
+  if (!response.timingAllowPassed) {
+    //  1. Set timingInfo to a the result of creating an opaque timing info for timingInfo.
+    timingInfo = createOpaqueTimingInfo({
+      startTime: timingInfo.startTime
+    })
+
+    //  2. Set cacheState to the empty string.
+    cacheState = ''
+  }
+
+  // 9. Set timingInfo’s end time to the coarsened shared current time
+  // given global’s relevant settings object’s cross-origin isolated
+  // capability.
+  // TODO: given global’s relevant settings object’s cross-origin isolated
+  // capability?
+  timingInfo.endTime = coarsenedSharedCurrentTime()
+
+  // 10. Set response’s timing info to timingInfo.
+  response.timingInfo = timingInfo
+
+  // 11. Mark resource timing for timingInfo, originalURL, initiatorType,
+  // global, and cacheState.
+  markResourceTiming(
+    timingInfo,
+    originalURL.href,
+    initiatorType,
+    globalThis,
+    cacheState
+  )
+}
+
+// https://w3c.github.io/resource-timing/#dfn-mark-resource-timing
+const markResourceTiming = performance.markResourceTiming
+
+// https://fetch.spec.whatwg.org/#abort-fetch
+function abortFetch (p, request, responseObject, error) {
+  // 1. Reject promise with error.
+  if (p) {
+    // We might have already resolved the promise at this stage
+    p.reject(error)
+  }
+
+  // 2. If request’s body is not null and is readable, then cancel request’s
+  // body with error.
+  if (request.body != null && isReadable(request.body?.stream)) {
+    request.body.stream.cancel(error).catch((err) => {
+      if (err.code === 'ERR_INVALID_STATE') {
+        // Node bug?
+        return
+      }
+      throw err
+    })
+  }
+
+  // 3. If responseObject is null, then return.
+  if (responseObject == null) {
+    return
+  }
+
+  // 4. Let response be responseObject’s response.
+  const response = responseObject[kState]
+
+  // 5. If response’s body is not null and is readable, then error response’s
+  // body with error.
+  if (response.body != null && isReadable(response.body?.stream)) {
+    response.body.stream.cancel(error).catch((err) => {
+      if (err.code === 'ERR_INVALID_STATE') {
+        // Node bug?
+        return
+      }
+      throw err
+    })
+  }
+}
+
+// https://fetch.spec.whatwg.org/#fetching
+function fetching ({
+  request,
+  processRequestBodyChunkLength,
+  processRequestEndOfBody,
+  processResponse,
+  processResponseEndOfBody,
+  processResponseConsumeBody,
+  useParallelQueue = false,
+  dispatcher = getGlobalDispatcher() // undici
+}) {
+  // Ensure that the dispatcher is set accordingly
+  assert(dispatcher)
+
+  // 1. Let taskDestination be null.
+  let taskDestination = null
+
+  // 2. Let crossOriginIsolatedCapability be false.
+  let crossOriginIsolatedCapability = false
+
+  // 3. If request’s client is non-null, then:
+  if (request.client != null) {
+    // 1. Set taskDestination to request’s client’s global object.
+    taskDestination = request.client.globalObject
+
+    // 2. Set crossOriginIsolatedCapability to request’s client’s cross-origin
+    // isolated capability.
+    crossOriginIsolatedCapability =
+      request.client.crossOriginIsolatedCapability
+  }
+
+  // 4. If useParallelQueue is true, then set taskDestination to the result of
+  // starting a new parallel queue.
+  // TODO
+
+  // 5. Let timingInfo be a new fetch timing info whose start time and
+  // post-redirect start time are the coarsened shared current time given
+  // crossOriginIsolatedCapability.
+  const currentTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability)
+  const timingInfo = createOpaqueTimingInfo({
+    startTime: currentTime
+  })
+
+  // 6. Let fetchParams be a new fetch params whose
+  // request is request,
+  // timing info is timingInfo,
+  // process request body chunk length is processRequestBodyChunkLength,
+  // process request end-of-body is processRequestEndOfBody,
+  // process response is processResponse,
+  // process response consume body is processResponseConsumeBody,
+  // process response end-of-body is processResponseEndOfBody,
+  // task destination is taskDestination,
+  // and cross-origin isolated capability is crossOriginIsolatedCapability.
+  const fetchParams = {
+    controller: new Fetch(dispatcher),
+    request,
+    timingInfo,
+    processRequestBodyChunkLength,
+    processRequestEndOfBody,
+    processResponse,
+    processResponseConsumeBody,
+    processResponseEndOfBody,
+    taskDestination,
+    crossOriginIsolatedCapability
+  }
+
+  // 7. If request’s body is a byte sequence, then set request’s body to
+  //    request’s body as a body.
+  // NOTE: Since fetching is only called from fetch, body should already be
+  // extracted.
+  assert(!request.body || request.body.stream)
+
+  // 8. If request’s window is "client", then set request’s window to request’s
+  // client, if request’s client’s global object is a Window object; otherwise
+  // "no-window".
+  if (request.window === 'client') {
+    // TODO: What if request.client is null?
+    request.window =
+      request.client?.globalObject?.constructor?.name === 'Window'
+        ? request.client
+        : 'no-window'
+  }
+
+  // 9. If request’s origin is "client", then set request’s origin to request’s
+  // client’s origin.
+  if (request.origin === 'client') {
+    request.origin = request.client.origin
+  }
+
+  // 10. If all of the following conditions are true:
+  // TODO
+
+  // 11. If request’s policy container is "client", then:
+  if (request.policyContainer === 'client') {
+    // 1. If request’s client is non-null, then set request’s policy
+    // container to a clone of request’s client’s policy container. [HTML]
+    if (request.client != null) {
+      request.policyContainer = clonePolicyContainer(
+        request.client.policyContainer
+      )
+    } else {
+      // 2. Otherwise, set request’s policy container to a new policy
+      // container.
+      request.policyContainer = makePolicyContainer()
+    }
+  }
+
+  // 12. If request’s header list does not contain `Accept`, then:
+  if (!request.headersList.contains('accept', true)) {
+    // 1. Let value be `*/*`.
+    const value = '*/*'
+
+    // 2. A user agent should set value to the first matching statement, if
+    // any, switching on request’s destination:
+    // "document"
+    // "frame"
+    // "iframe"
+    // `text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8`
+    // "image"
+    // `image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5`
+    // "style"
+    // `text/css,*/*;q=0.1`
+    // TODO
+
+    // 3. Append `Accept`/value to request’s header list.
+    request.headersList.append('accept', value, true)
+  }
+
+  // 13. If request’s header list does not contain `Accept-Language`, then
+  // user agents should append `Accept-Language`/an appropriate value to
+  // request’s header list.
+  if (!request.headersList.contains('accept-language', true)) {
+    request.headersList.append('accept-language', '*', true)
+  }
+
+  // 14. If request’s priority is null, then use request’s initiator and
+  // destination appropriately in setting request’s priority to a
+  // user-agent-defined object.
+  if (request.priority === null) {
+    // TODO
+  }
+
+  // 15. If request is a subresource request, then:
+  if (subresourceSet.has(request.destination)) {
+    // TODO
+  }
+
+  // 16. Run main fetch given fetchParams.
+  mainFetch(fetchParams)
+    .catch(err => {
+      fetchParams.controller.terminate(err)
+    })
+
+  // 17. Return fetchParam's controller
+  return fetchParams.controller
+}
+
+// https://fetch.spec.whatwg.org/#concept-main-fetch
+async function mainFetch (fetchParams, recursive = false) {
+  // 1. Let request be fetchParams’s request.
+  const request = fetchParams.request
+
+  // 2. Let response be null.
+  let response = null
+
+  // 3. If request’s local-URLs-only flag is set and request’s current URL is
+  // not local, then set response to a network error.
+  if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) {
+    response = makeNetworkError('local URLs only')
+  }
+
+  // 4. Run report Content Security Policy violations for request.
+  // TODO
+
+  // 5. Upgrade request to a potentially trustworthy URL, if appropriate.
+  tryUpgradeRequestToAPotentiallyTrustworthyURL(request)
+
+  // 6. If should request be blocked due to a bad port, should fetching request
+  // be blocked as mixed content, or should request be blocked by Content
+  // Security Policy returns blocked, then set response to a network error.
+  if (requestBadPort(request) === 'blocked') {
+    response = makeNetworkError('bad port')
+  }
+  // TODO: should fetching request be blocked as mixed content?
+  // TODO: should request be blocked by Content Security Policy?
+
+  // 7. If request’s referrer policy is the empty string, then set request’s
+  // referrer policy to request’s policy container’s referrer policy.
+  if (request.referrerPolicy === '') {
+    request.referrerPolicy = request.policyContainer.referrerPolicy
+  }
+
+  // 8. If request’s referrer is not "no-referrer", then set request’s
+  // referrer to the result of invoking determine request’s referrer.
+  if (request.referrer !== 'no-referrer') {
+    request.referrer = determineRequestsReferrer(request)
+  }
+
+  // 9. Set request’s current URL’s scheme to "https" if all of the following
+  // conditions are true:
+  // - request’s current URL’s scheme is "http"
+  // - request’s current URL’s host is a domain
+  // - Matching request’s current URL’s host per Known HSTS Host Domain Name
+  //   Matching results in either a superdomain match with an asserted
+  //   includeSubDomains directive or a congruent match (with or without an
+  //   asserted includeSubDomains directive). [HSTS]
+  // TODO
+
+  // 10. If recursive is false, then run the remaining steps in parallel.
+  // TODO
+
+  // 11. If response is null, then set response to the result of running
+  // the steps corresponding to the first matching statement:
+  if (response === null) {
+    response = await (async () => {
+      const currentURL = requestCurrentURL(request)
+
+      if (
+        // - request’s current URL’s origin is same origin with request’s origin,
+        //   and request’s response tainting is "basic"
+        (sameOrigin(currentURL, request.url) && request.responseTainting === 'basic') ||
+        // request’s current URL’s scheme is "data"
+        (currentURL.protocol === 'data:') ||
+        // - request’s mode is "navigate" or "websocket"
+        (request.mode === 'navigate' || request.mode === 'websocket')
+      ) {
+        // 1. Set request’s response tainting to "basic".
+        request.responseTainting = 'basic'
+
+        // 2. Return the result of running scheme fetch given fetchParams.
+        return await schemeFetch(fetchParams)
+      }
+
+      // request’s mode is "same-origin"
+      if (request.mode === 'same-origin') {
+        // 1. Return a network error.
+        return makeNetworkError('request mode cannot be "same-origin"')
+      }
+
+      // request’s mode is "no-cors"
+      if (request.mode === 'no-cors') {
+        // 1. If request’s redirect mode is not "follow", then return a network
+        // error.
+        if (request.redirect !== 'follow') {
+          return makeNetworkError(
+            'redirect mode cannot be "follow" for "no-cors" request'
+          )
+        }
+
+        // 2. Set request’s response tainting to "opaque".
+        request.responseTainting = 'opaque'
+
+        // 3. Return the result of running scheme fetch given fetchParams.
+        return await schemeFetch(fetchParams)
+      }
+
+      // request’s current URL’s scheme is not an HTTP(S) scheme
+      if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) {
+        // Return a network error.
+        return makeNetworkError('URL scheme must be a HTTP(S) scheme')
+      }
+
+      // - request’s use-CORS-preflight flag is set
+      // - request’s unsafe-request flag is set and either request’s method is
+      //   not a CORS-safelisted method or CORS-unsafe request-header names with
+      //   request’s header list is not empty
+      //    1. Set request’s response tainting to "cors".
+      //    2. Let corsWithPreflightResponse be the result of running HTTP fetch
+      //    given fetchParams and true.
+      //    3. If corsWithPreflightResponse is a network error, then clear cache
+      //    entries using request.
+      //    4. Return corsWithPreflightResponse.
+      // TODO
+
+      // Otherwise
+      //    1. Set request’s response tainting to "cors".
+      request.responseTainting = 'cors'
+
+      //    2. Return the result of running HTTP fetch given fetchParams.
+      return await httpFetch(fetchParams)
+    })()
+  }
+
+  // 12. If recursive is true, then return response.
+  if (recursive) {
+    return response
+  }
+
+  // 13. If response is not a network error and response is not a filtered
+  // response, then:
+  if (response.status !== 0 && !response.internalResponse) {
+    // If request’s response tainting is "cors", then:
+    if (request.responseTainting === 'cors') {
+      // 1. Let headerNames be the result of extracting header list values
+      // given `Access-Control-Expose-Headers` and response’s header list.
+      // TODO
+      // 2. If request’s credentials mode is not "include" and headerNames
+      // contains `*`, then set response’s CORS-exposed header-name list to
+      // all unique header names in response’s header list.
+      // TODO
+      // 3. Otherwise, if headerNames is not null or failure, then set
+      // response’s CORS-exposed header-name list to headerNames.
+      // TODO
+    }
+
+    // Set response to the following filtered response with response as its
+    // internal response, depending on request’s response tainting:
+    if (request.responseTainting === 'basic') {
+      response = filterResponse(response, 'basic')
+    } else if (request.responseTainting === 'cors') {
+      response = filterResponse(response, 'cors')
+    } else if (request.responseTainting === 'opaque') {
+      response = filterResponse(response, 'opaque')
+    } else {
+      assert(false)
+    }
+  }
+
+  // 14. Let internalResponse be response, if response is a network error,
+  // and response’s internal response otherwise.
+  let internalResponse =
+    response.status === 0 ? response : response.internalResponse
+
+  // 15. If internalResponse’s URL list is empty, then set it to a clone of
+  // request’s URL list.
+  if (internalResponse.urlList.length === 0) {
+    internalResponse.urlList.push(...request.urlList)
+  }
+
+  // 16. If request’s timing allow failed flag is unset, then set
+  // internalResponse’s timing allow passed flag.
+  if (!request.timingAllowFailed) {
+    response.timingAllowPassed = true
+  }
+
+  // 17. If response is not a network error and any of the following returns
+  // blocked
+  // - should internalResponse to request be blocked as mixed content
+  // - should internalResponse to request be blocked by Content Security Policy
+  // - should internalResponse to request be blocked due to its MIME type
+  // - should internalResponse to request be blocked due to nosniff
+  // TODO
+
+  // 18. If response’s type is "opaque", internalResponse’s status is 206,
+  // internalResponse’s range-requested flag is set, and request’s header
+  // list does not contain `Range`, then set response and internalResponse
+  // to a network error.
+  if (
+    response.type === 'opaque' &&
+    internalResponse.status === 206 &&
+    internalResponse.rangeRequested &&
+    !request.headers.contains('range', true)
+  ) {
+    response = internalResponse = makeNetworkError()
+  }
+
+  // 19. If response is not a network error and either request’s method is
+  // `HEAD` or `CONNECT`, or internalResponse’s status is a null body status,
+  // set internalResponse’s body to null and disregard any enqueuing toward
+  // it (if any).
+  if (
+    response.status !== 0 &&
+    (request.method === 'HEAD' ||
+      request.method === 'CONNECT' ||
+      nullBodyStatus.includes(internalResponse.status))
+  ) {
+    internalResponse.body = null
+    fetchParams.controller.dump = true
+  }
+
+  // 20. If request’s integrity metadata is not the empty string, then:
+  if (request.integrity) {
+    // 1. Let processBodyError be this step: run fetch finale given fetchParams
+    // and a network error.
+    const processBodyError = (reason) =>
+      fetchFinale(fetchParams, makeNetworkError(reason))
+
+    // 2. If request’s response tainting is "opaque", or response’s body is null,
+    // then run processBodyError and abort these steps.
+    if (request.responseTainting === 'opaque' || response.body == null) {
+      processBodyError(response.error)
+      return
+    }
+
+    // 3. Let processBody given bytes be these steps:
+    const processBody = (bytes) => {
+      // 1. If bytes do not match request’s integrity metadata,
+      // then run processBodyError and abort these steps. [SRI]
+      if (!bytesMatch(bytes, request.integrity)) {
+        processBodyError('integrity mismatch')
+        return
+      }
+
+      // 2. Set response’s body to bytes as a body.
+      response.body = safelyExtractBody(bytes)[0]
+
+      // 3. Run fetch finale given fetchParams and response.
+      fetchFinale(fetchParams, response)
+    }
+
+    // 4. Fully read response’s body given processBody and processBodyError.
+    await fullyReadBody(response.body, processBody, processBodyError)
+  } else {
+    // 21. Otherwise, run fetch finale given fetchParams and response.
+    fetchFinale(fetchParams, response)
+  }
+}
+
+// https://fetch.spec.whatwg.org/#concept-scheme-fetch
+// given a fetch params fetchParams
+function schemeFetch (fetchParams) {
+  // Note: since the connection is destroyed on redirect, which sets fetchParams to a
+  // cancelled state, we do not want this condition to trigger *unless* there have been
+  // no redirects. See https://github.com/nodejs/undici/issues/1776
+  // 1. If fetchParams is canceled, then return the appropriate network error for fetchParams.
+  if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
+    return Promise.resolve(makeAppropriateNetworkError(fetchParams))
+  }
+
+  // 2. Let request be fetchParams’s request.
+  const { request } = fetchParams
+
+  const { protocol: scheme } = requestCurrentURL(request)
+
+  // 3. Switch on request’s current URL’s scheme and run the associated steps:
+  switch (scheme) {
+    case 'about:': {
+      // If request’s current URL’s path is the string "blank", then return a new response
+      // whose status message is `OK`, header list is « (`Content-Type`, `text/html;charset=utf-8`) »,
+      // and body is the empty byte sequence as a body.
+
+      // Otherwise, return a network error.
+      return Promise.resolve(makeNetworkError('about scheme is not supported'))
+    }
+    case 'blob:': {
+      if (!resolveObjectURL) {
+        resolveObjectURL = (__nccwpck_require__(72254).resolveObjectURL)
+      }
+
+      // 1. Let blobURLEntry be request’s current URL’s blob URL entry.
+      const blobURLEntry = requestCurrentURL(request)
+
+      // https://github.com/web-platform-tests/wpt/blob/7b0ebaccc62b566a1965396e5be7bb2bc06f841f/FileAPI/url/resources/fetch-tests.js#L52-L56
+      // Buffer.resolveObjectURL does not ignore URL queries.
+      if (blobURLEntry.search.length !== 0) {
+        return Promise.resolve(makeNetworkError('NetworkError when attempting to fetch resource.'))
+      }
+
+      const blob = resolveObjectURL(blobURLEntry.toString())
+
+      // 2. If request’s method is not `GET`, blobURLEntry is null, or blobURLEntry’s
+      //    object is not a Blob object, then return a network error.
+      if (request.method !== 'GET' || !isBlobLike(blob)) {
+        return Promise.resolve(makeNetworkError('invalid method'))
+      }
+
+      // 3. Let blob be blobURLEntry’s object.
+      // Note: done above
+
+      // 4. Let response be a new response.
+      const response = makeResponse()
+
+      // 5. Let fullLength be blob’s size.
+      const fullLength = blob.size
+
+      // 6. Let serializedFullLength be fullLength, serialized and isomorphic encoded.
+      const serializedFullLength = isomorphicEncode(`${fullLength}`)
+
+      // 7. Let type be blob’s type.
+      const type = blob.type
+
+      // 8. If request’s header list does not contain `Range`:
+      // 9. Otherwise:
+      if (!request.headersList.contains('range', true)) {
+        // 1. Let bodyWithType be the result of safely extracting blob.
+        // Note: in the FileAPI a blob "object" is a Blob *or* a MediaSource.
+        // In node, this can only ever be a Blob. Therefore we can safely
+        // use extractBody directly.
+        const bodyWithType = extractBody(blob)
+
+        // 2. Set response’s status message to `OK`.
+        response.statusText = 'OK'
+
+        // 3. Set response’s body to bodyWithType’s body.
+        response.body = bodyWithType[0]
+
+        // 4. Set response’s header list to « (`Content-Length`, serializedFullLength), (`Content-Type`, type) ».
+        response.headersList.set('content-length', serializedFullLength, true)
+        response.headersList.set('content-type', type, true)
+      } else {
+        // 1. Set response’s range-requested flag.
+        response.rangeRequested = true
+
+        // 2. Let rangeHeader be the result of getting `Range` from request’s header list.
+        const rangeHeader = request.headersList.get('range', true)
+
+        // 3. Let rangeValue be the result of parsing a single range header value given rangeHeader and true.
+        const rangeValue = simpleRangeHeaderValue(rangeHeader, true)
+
+        // 4. If rangeValue is failure, then return a network error.
+        if (rangeValue === 'failure') {
+          return Promise.resolve(makeNetworkError('failed to fetch the data URL'))
+        }
+
+        // 5. Let (rangeStart, rangeEnd) be rangeValue.
+        let { rangeStartValue: rangeStart, rangeEndValue: rangeEnd } = rangeValue
+
+        // 6. If rangeStart is null:
+        // 7. Otherwise:
+        if (rangeStart === null) {
+          // 1. Set rangeStart to fullLength − rangeEnd.
+          rangeStart = fullLength - rangeEnd
+
+          // 2. Set rangeEnd to rangeStart + rangeEnd − 1.
+          rangeEnd = rangeStart + rangeEnd - 1
+        } else {
+          // 1. If rangeStart is greater than or equal to fullLength, then return a network error.
+          if (rangeStart >= fullLength) {
+            return Promise.resolve(makeNetworkError('Range start is greater than the blob\'s size.'))
+          }
+
+          // 2. If rangeEnd is null or rangeEnd is greater than or equal to fullLength, then set
+          //    rangeEnd to fullLength − 1.
+          if (rangeEnd === null || rangeEnd >= fullLength) {
+            rangeEnd = fullLength - 1
+          }
+        }
+
+        // 8. Let slicedBlob be the result of invoking slice blob given blob, rangeStart,
+        //    rangeEnd + 1, and type.
+        const slicedBlob = blob.slice(rangeStart, rangeEnd, type)
+
+        // 9. Let slicedBodyWithType be the result of safely extracting slicedBlob.
+        // Note: same reason as mentioned above as to why we use extractBody
+        const slicedBodyWithType = extractBody(slicedBlob)
+
+        // 10. Set response’s body to slicedBodyWithType’s body.
+        response.body = slicedBodyWithType[0]
+
+        // 11. Let serializedSlicedLength be slicedBlob’s size, serialized and isomorphic encoded.
+        const serializedSlicedLength = isomorphicEncode(`${slicedBlob.size}`)
+
+        // 12. Let contentRange be the result of invoking build a content range given rangeStart,
+        //     rangeEnd, and fullLength.
+        const contentRange = buildContentRange(rangeStart, rangeEnd, fullLength)
+
+        // 13. Set response’s status to 206.
+        response.status = 206
+
+        // 14. Set response’s status message to `Partial Content`.
+        response.statusText = 'Partial Content'
+
+        // 15. Set response’s header list to « (`Content-Length`, serializedSlicedLength),
+        //     (`Content-Type`, type), (`Content-Range`, contentRange) ».
+        response.headersList.set('content-length', serializedSlicedLength, true)
+        response.headersList.set('content-type', type, true)
+        response.headersList.set('content-range', contentRange, true)
+      }
+
+      // 10. Return response.
+      return Promise.resolve(response)
+    }
+    case 'data:': {
+      // 1. Let dataURLStruct be the result of running the
+      //    data: URL processor on request’s current URL.
+      const currentURL = requestCurrentURL(request)
+      const dataURLStruct = dataURLProcessor(currentURL)
+
+      // 2. If dataURLStruct is failure, then return a
+      //    network error.
+      if (dataURLStruct === 'failure') {
+        return Promise.resolve(makeNetworkError('failed to fetch the data URL'))
+      }
+
+      // 3. Let mimeType be dataURLStruct’s MIME type, serialized.
+      const mimeType = serializeAMimeType(dataURLStruct.mimeType)
+
+      // 4. Return a response whose status message is `OK`,
+      //    header list is « (`Content-Type`, mimeType) »,
+      //    and body is dataURLStruct’s body as a body.
+      return Promise.resolve(makeResponse({
+        statusText: 'OK',
+        headersList: [
+          ['content-type', { name: 'Content-Type', value: mimeType }]
+        ],
+        body: safelyExtractBody(dataURLStruct.body)[0]
+      }))
+    }
+    case 'file:': {
+      // For now, unfortunate as it is, file URLs are left as an exercise for the reader.
+      // When in doubt, return a network error.
+      return Promise.resolve(makeNetworkError('not implemented... yet...'))
+    }
+    case 'http:':
+    case 'https:': {
+      // Return the result of running HTTP fetch given fetchParams.
+
+      return httpFetch(fetchParams)
+        .catch((err) => makeNetworkError(err))
+    }
+    default: {
+      return Promise.resolve(makeNetworkError('unknown scheme'))
+    }
+  }
+}
+
+// https://fetch.spec.whatwg.org/#finalize-response
+function finalizeResponse (fetchParams, response) {
+  // 1. Set fetchParams’s request’s done flag.
+  fetchParams.request.done = true
+
+  // 2, If fetchParams’s process response done is not null, then queue a fetch
+  // task to run fetchParams’s process response done given response, with
+  // fetchParams’s task destination.
+  if (fetchParams.processResponseDone != null) {
+    queueMicrotask(() => fetchParams.processResponseDone(response))
+  }
+}
+
+// https://fetch.spec.whatwg.org/#fetch-finale
+function fetchFinale (fetchParams, response) {
+  // 1. Let timingInfo be fetchParams’s timing info.
+  let timingInfo = fetchParams.timingInfo
+
+  // 2. If response is not a network error and fetchParams’s request’s client is a secure context,
+  //    then set timingInfo’s server-timing headers to the result of getting, decoding, and splitting
+  //    `Server-Timing` from response’s internal response’s header list.
+  // TODO
+
+  // 3. Let processResponseEndOfBody be the following steps:
+  const processResponseEndOfBody = () => {
+    // 1. Let unsafeEndTime be the unsafe shared current time.
+    const unsafeEndTime = Date.now() // ?
+
+    // 2. If fetchParams’s request’s destination is "document", then set fetchParams’s controller’s
+    //    full timing info to fetchParams’s timing info.
+    if (fetchParams.request.destination === 'document') {
+      fetchParams.controller.fullTimingInfo = timingInfo
+    }
+
+    // 3. Set fetchParams’s controller’s report timing steps to the following steps given a global object global:
+    fetchParams.controller.reportTimingSteps = () => {
+      // 1. If fetchParams’s request’s URL’s scheme is not an HTTP(S) scheme, then return.
+      if (fetchParams.request.url.protocol !== 'https:') {
+        return
+      }
+
+      // 2. Set timingInfo’s end time to the relative high resolution time given unsafeEndTime and global.
+      timingInfo.endTime = unsafeEndTime
+
+      // 3. Let cacheState be response’s cache state.
+      let cacheState = response.cacheState
+
+      // 4. Let bodyInfo be response’s body info.
+      const bodyInfo = response.bodyInfo
+
+      // 5. If response’s timing allow passed flag is not set, then set timingInfo to the result of creating an
+      //    opaque timing info for timingInfo and set cacheState to the empty string.
+      if (!response.timingAllowPassed) {
+        timingInfo = createOpaqueTimingInfo(timingInfo)
+
+        cacheState = ''
+      }
+
+      // 6. Let responseStatus be 0.
+      let responseStatus = 0
+
+      // 7. If fetchParams’s request’s mode is not "navigate" or response’s has-cross-origin-redirects is false:
+      if (fetchParams.request.mode !== 'navigator' || !response.hasCrossOriginRedirects) {
+        // 1. Set responseStatus to response’s status.
+        responseStatus = response.status
+
+        // 2. Let mimeType be the result of extracting a MIME type from response’s header list.
+        const mimeType = extractMimeType(response.headersList)
+
+        // 3. If mimeType is not failure, then set bodyInfo’s content type to the result of minimizing a supported MIME type given mimeType.
+        if (mimeType !== 'failure') {
+          bodyInfo.contentType = minimizeSupportedMimeType(mimeType)
+        }
+      }
+
+      // 8. If fetchParams’s request’s initiator type is non-null, then mark resource timing given timingInfo,
+      //    fetchParams’s request’s URL, fetchParams’s request’s initiator type, global, cacheState, bodyInfo,
+      //    and responseStatus.
+      if (fetchParams.request.initiatorType != null) {
+        // TODO: update markresourcetiming
+        markResourceTiming(timingInfo, fetchParams.request.url.href, fetchParams.request.initiatorType, globalThis, cacheState, bodyInfo, responseStatus)
+      }
+    }
+
+    // 4. Let processResponseEndOfBodyTask be the following steps:
+    const processResponseEndOfBodyTask = () => {
+      // 1. Set fetchParams’s request’s done flag.
+      fetchParams.request.done = true
+
+      // 2. If fetchParams’s process response end-of-body is non-null, then run fetchParams’s process
+      //    response end-of-body given response.
+      if (fetchParams.processResponseEndOfBody != null) {
+        queueMicrotask(() => fetchParams.processResponseEndOfBody(response))
+      }
+
+      // 3. If fetchParams’s request’s initiator type is non-null and fetchParams’s request’s client’s
+      //    global object is fetchParams’s task destination, then run fetchParams’s controller’s report
+      //    timing steps given fetchParams’s request’s client’s global object.
+      if (fetchParams.request.initiatorType != null) {
+        fetchParams.controller.reportTimingSteps()
+      }
+    }
+
+    // 5. Queue a fetch task to run processResponseEndOfBodyTask with fetchParams’s task destination
+    queueMicrotask(() => processResponseEndOfBodyTask())
+  }
+
+  // 4. If fetchParams’s process response is non-null, then queue a fetch task to run fetchParams’s
+  //    process response given response, with fetchParams’s task destination.
+  if (fetchParams.processResponse != null) {
+    queueMicrotask(() => {
+      fetchParams.processResponse(response)
+      fetchParams.processResponse = null
+    })
+  }
+
+  // 5. Let internalResponse be response, if response is a network error; otherwise response’s internal response.
+  const internalResponse = response.type === 'error' ? response : (response.internalResponse ?? response)
+
+  // 6. If internalResponse’s body is null, then run processResponseEndOfBody.
+  // 7. Otherwise:
+  if (internalResponse.body == null) {
+    processResponseEndOfBody()
+  } else {
+    // mcollina: all the following steps of the specs are skipped.
+    // The internal transform stream is not needed.
+    // See https://github.com/nodejs/undici/pull/3093#issuecomment-2050198541
+
+    // 1. Let transformStream be a new TransformStream.
+    // 2. Let identityTransformAlgorithm be an algorithm which, given chunk, enqueues chunk in transformStream.
+    // 3. Set up transformStream with transformAlgorithm set to identityTransformAlgorithm and flushAlgorithm
+    //    set to processResponseEndOfBody.
+    // 4. Set internalResponse’s body’s stream to the result of internalResponse’s body’s stream piped through transformStream.
+
+    finished(internalResponse.body.stream, () => {
+      processResponseEndOfBody()
+    })
+  }
+}
+
+// https://fetch.spec.whatwg.org/#http-fetch
+async function httpFetch (fetchParams) {
+  // 1. Let request be fetchParams’s request.
+  const request = fetchParams.request
+
+  // 2. Let response be null.
+  let response = null
+
+  // 3. Let actualResponse be null.
+  let actualResponse = null
+
+  // 4. Let timingInfo be fetchParams’s timing info.
+  const timingInfo = fetchParams.timingInfo
+
+  // 5. If request’s service-workers mode is "all", then:
+  if (request.serviceWorkers === 'all') {
+    // TODO
+  }
+
+  // 6. If response is null, then:
+  if (response === null) {
+    // 1. If makeCORSPreflight is true and one of these conditions is true:
+    // TODO
+
+    // 2. If request’s redirect mode is "follow", then set request’s
+    // service-workers mode to "none".
+    if (request.redirect === 'follow') {
+      request.serviceWorkers = 'none'
+    }
+
+    // 3. Set response and actualResponse to the result of running
+    // HTTP-network-or-cache fetch given fetchParams.
+    actualResponse = response = await httpNetworkOrCacheFetch(fetchParams)
+
+    // 4. If request’s response tainting is "cors" and a CORS check
+    // for request and response returns failure, then return a network error.
+    if (
+      request.responseTainting === 'cors' &&
+      corsCheck(request, response) === 'failure'
+    ) {
+      return makeNetworkError('cors failure')
+    }
+
+    // 5. If the TAO check for request and response returns failure, then set
+    // request’s timing allow failed flag.
+    if (TAOCheck(request, response) === 'failure') {
+      request.timingAllowFailed = true
+    }
+  }
+
+  // 7. If either request’s response tainting or response’s type
+  // is "opaque", and the cross-origin resource policy check with
+  // request’s origin, request’s client, request’s destination,
+  // and actualResponse returns blocked, then return a network error.
+  if (
+    (request.responseTainting === 'opaque' || response.type === 'opaque') &&
+    crossOriginResourcePolicyCheck(
+      request.origin,
+      request.client,
+      request.destination,
+      actualResponse
+    ) === 'blocked'
+  ) {
+    return makeNetworkError('blocked')
+  }
+
+  // 8. If actualResponse’s status is a redirect status, then:
+  if (redirectStatusSet.has(actualResponse.status)) {
+    // 1. If actualResponse’s status is not 303, request’s body is not null,
+    // and the connection uses HTTP/2, then user agents may, and are even
+    // encouraged to, transmit an RST_STREAM frame.
+    // See, https://github.com/whatwg/fetch/issues/1288
+    if (request.redirect !== 'manual') {
+      fetchParams.controller.connection.destroy(undefined, false)
+    }
+
+    // 2. Switch on request’s redirect mode:
+    if (request.redirect === 'error') {
+      // Set response to a network error.
+      response = makeNetworkError('unexpected redirect')
+    } else if (request.redirect === 'manual') {
+      // Set response to an opaque-redirect filtered response whose internal
+      // response is actualResponse.
+      // NOTE(spec): On the web this would return an `opaqueredirect` response,
+      // but that doesn't make sense server side.
+      // See https://github.com/nodejs/undici/issues/1193.
+      response = actualResponse
+    } else if (request.redirect === 'follow') {
+      // Set response to the result of running HTTP-redirect fetch given
+      // fetchParams and response.
+      response = await httpRedirectFetch(fetchParams, response)
+    } else {
+      assert(false)
+    }
+  }
+
+  // 9. Set response’s timing info to timingInfo.
+  response.timingInfo = timingInfo
+
+  // 10. Return response.
+  return response
+}
+
+// https://fetch.spec.whatwg.org/#http-redirect-fetch
+function httpRedirectFetch (fetchParams, response) {
+  // 1. Let request be fetchParams’s request.
+  const request = fetchParams.request
+
+  // 2. Let actualResponse be response, if response is not a filtered response,
+  // and response’s internal response otherwise.
+  const actualResponse = response.internalResponse
+    ? response.internalResponse
+    : response
+
+  // 3. Let locationURL be actualResponse’s location URL given request’s current
+  // URL’s fragment.
+  let locationURL
+
+  try {
+    locationURL = responseLocationURL(
+      actualResponse,
+      requestCurrentURL(request).hash
+    )
+
+    // 4. If locationURL is null, then return response.
+    if (locationURL == null) {
+      return response
+    }
+  } catch (err) {
+    // 5. If locationURL is failure, then return a network error.
+    return Promise.resolve(makeNetworkError(err))
+  }
+
+  // 6. If locationURL’s scheme is not an HTTP(S) scheme, then return a network
+  // error.
+  if (!urlIsHttpHttpsScheme(locationURL)) {
+    return Promise.resolve(makeNetworkError('URL scheme must be a HTTP(S) scheme'))
+  }
+
+  // 7. If request’s redirect count is 20, then return a network error.
+  if (request.redirectCount === 20) {
+    return Promise.resolve(makeNetworkError('redirect count exceeded'))
+  }
+
+  // 8. Increase request’s redirect count by 1.
+  request.redirectCount += 1
+
+  // 9. If request’s mode is "cors", locationURL includes credentials, and
+  // request’s origin is not same origin with locationURL’s origin, then return
+  //  a network error.
+  if (
+    request.mode === 'cors' &&
+    (locationURL.username || locationURL.password) &&
+    !sameOrigin(request, locationURL)
+  ) {
+    return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"'))
+  }
+
+  // 10. If request’s response tainting is "cors" and locationURL includes
+  // credentials, then return a network error.
+  if (
+    request.responseTainting === 'cors' &&
+    (locationURL.username || locationURL.password)
+  ) {
+    return Promise.resolve(makeNetworkError(
+      'URL cannot contain credentials for request mode "cors"'
+    ))
+  }
+
+  // 11. If actualResponse’s status is not 303, request’s body is non-null,
+  // and request’s body’s source is null, then return a network error.
+  if (
+    actualResponse.status !== 303 &&
+    request.body != null &&
+    request.body.source == null
+  ) {
+    return Promise.resolve(makeNetworkError())
+  }
+
+  // 12. If one of the following is true
+  // - actualResponse’s status is 301 or 302 and request’s method is `POST`
+  // - actualResponse’s status is 303 and request’s method is not `GET` or `HEAD`
+  if (
+    ([301, 302].includes(actualResponse.status) && request.method === 'POST') ||
+    (actualResponse.status === 303 &&
+      !GET_OR_HEAD.includes(request.method))
+  ) {
+    // then:
+    // 1. Set request’s method to `GET` and request’s body to null.
+    request.method = 'GET'
+    request.body = null
+
+    // 2. For each headerName of request-body-header name, delete headerName from
+    // request’s header list.
+    for (const headerName of requestBodyHeader) {
+      request.headersList.delete(headerName)
+    }
+  }
+
+  // 13. If request’s current URL’s origin is not same origin with locationURL’s
+  //     origin, then for each headerName of CORS non-wildcard request-header name,
+  //     delete headerName from request’s header list.
+  if (!sameOrigin(requestCurrentURL(request), locationURL)) {
+    // https://fetch.spec.whatwg.org/#cors-non-wildcard-request-header-name
+    request.headersList.delete('authorization', true)
+
+    // https://fetch.spec.whatwg.org/#authentication-entries
+    request.headersList.delete('proxy-authorization', true)
+
+    // "Cookie" and "Host" are forbidden request-headers, which undici doesn't implement.
+    request.headersList.delete('cookie', true)
+    request.headersList.delete('host', true)
+  }
+
+  // 14. If request’s body is non-null, then set request’s body to the first return
+  // value of safely extracting request’s body’s source.
+  if (request.body != null) {
+    assert(request.body.source != null)
+    request.body = safelyExtractBody(request.body.source)[0]
+  }
+
+  // 15. Let timingInfo be fetchParams’s timing info.
+  const timingInfo = fetchParams.timingInfo
+
+  // 16. Set timingInfo’s redirect end time and post-redirect start time to the
+  // coarsened shared current time given fetchParams’s cross-origin isolated
+  // capability.
+  timingInfo.redirectEndTime = timingInfo.postRedirectStartTime =
+    coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability)
+
+  // 17. If timingInfo’s redirect start time is 0, then set timingInfo’s
+  //  redirect start time to timingInfo’s start time.
+  if (timingInfo.redirectStartTime === 0) {
+    timingInfo.redirectStartTime = timingInfo.startTime
+  }
+
+  // 18. Append locationURL to request’s URL list.
+  request.urlList.push(locationURL)
+
+  // 19. Invoke set request’s referrer policy on redirect on request and
+  // actualResponse.
+  setRequestReferrerPolicyOnRedirect(request, actualResponse)
+
+  // 20. Return the result of running main fetch given fetchParams and true.
+  return mainFetch(fetchParams, true)
+}
+
+// https://fetch.spec.whatwg.org/#http-network-or-cache-fetch
+async function httpNetworkOrCacheFetch (
+  fetchParams,
+  isAuthenticationFetch = false,
+  isNewConnectionFetch = false
+) {
+  // 1. Let request be fetchParams’s request.
+  const request = fetchParams.request
+
+  // 2. Let httpFetchParams be null.
+  let httpFetchParams = null
+
+  // 3. Let httpRequest be null.
+  let httpRequest = null
+
+  // 4. Let response be null.
+  let response = null
+
+  // 5. Let storedResponse be null.
+  // TODO: cache
+
+  // 6. Let httpCache be null.
+  const httpCache = null
+
+  // 7. Let the revalidatingFlag be unset.
+  const revalidatingFlag = false
+
+  // 8. Run these steps, but abort when the ongoing fetch is terminated:
+
+  //    1. If request’s window is "no-window" and request’s redirect mode is
+  //    "error", then set httpFetchParams to fetchParams and httpRequest to
+  //    request.
+  if (request.window === 'no-window' && request.redirect === 'error') {
+    httpFetchParams = fetchParams
+    httpRequest = request
+  } else {
+    // Otherwise:
+
+    // 1. Set httpRequest to a clone of request.
+    httpRequest = cloneRequest(request)
+
+    // 2. Set httpFetchParams to a copy of fetchParams.
+    httpFetchParams = { ...fetchParams }
+
+    // 3. Set httpFetchParams’s request to httpRequest.
+    httpFetchParams.request = httpRequest
+  }
+
+  //    3. Let includeCredentials be true if one of
+  const includeCredentials =
+    request.credentials === 'include' ||
+    (request.credentials === 'same-origin' &&
+      request.responseTainting === 'basic')
+
+  //    4. Let contentLength be httpRequest’s body’s length, if httpRequest’s
+  //    body is non-null; otherwise null.
+  const contentLength = httpRequest.body ? httpRequest.body.length : null
+
+  //    5. Let contentLengthHeaderValue be null.
+  let contentLengthHeaderValue = null
+
+  //    6. If httpRequest’s body is null and httpRequest’s method is `POST` or
+  //    `PUT`, then set contentLengthHeaderValue to `0`.
+  if (
+    httpRequest.body == null &&
+    ['POST', 'PUT'].includes(httpRequest.method)
+  ) {
+    contentLengthHeaderValue = '0'
+  }
+
+  //    7. If contentLength is non-null, then set contentLengthHeaderValue to
+  //    contentLength, serialized and isomorphic encoded.
+  if (contentLength != null) {
+    contentLengthHeaderValue = isomorphicEncode(`${contentLength}`)
+  }
+
+  //    8. If contentLengthHeaderValue is non-null, then append
+  //    `Content-Length`/contentLengthHeaderValue to httpRequest’s header
+  //    list.
+  if (contentLengthHeaderValue != null) {
+    httpRequest.headersList.append('content-length', contentLengthHeaderValue, true)
+  }
+
+  //    9. If contentLengthHeaderValue is non-null, then append (`Content-Length`,
+  //    contentLengthHeaderValue) to httpRequest’s header list.
+
+  //    10. If contentLength is non-null and httpRequest’s keepalive is true,
+  //    then:
+  if (contentLength != null && httpRequest.keepalive) {
+    // NOTE: keepalive is a noop outside of browser context.
+  }
+
+  //    11. If httpRequest’s referrer is a URL, then append
+  //    `Referer`/httpRequest’s referrer, serialized and isomorphic encoded,
+  //     to httpRequest’s header list.
+  if (httpRequest.referrer instanceof URL) {
+    httpRequest.headersList.append('referer', isomorphicEncode(httpRequest.referrer.href), true)
+  }
+
+  //    12. Append a request `Origin` header for httpRequest.
+  appendRequestOriginHeader(httpRequest)
+
+  //    13. Append the Fetch metadata headers for httpRequest. [FETCH-METADATA]
+  appendFetchMetadata(httpRequest)
+
+  //    14. If httpRequest’s header list does not contain `User-Agent`, then
+  //    user agents should append `User-Agent`/default `User-Agent` value to
+  //    httpRequest’s header list.
+  if (!httpRequest.headersList.contains('user-agent', true)) {
+    httpRequest.headersList.append('user-agent', defaultUserAgent)
+  }
+
+  //    15. If httpRequest’s cache mode is "default" and httpRequest’s header
+  //    list contains `If-Modified-Since`, `If-None-Match`,
+  //    `If-Unmodified-Since`, `If-Match`, or `If-Range`, then set
+  //    httpRequest’s cache mode to "no-store".
+  if (
+    httpRequest.cache === 'default' &&
+    (httpRequest.headersList.contains('if-modified-since', true) ||
+      httpRequest.headersList.contains('if-none-match', true) ||
+      httpRequest.headersList.contains('if-unmodified-since', true) ||
+      httpRequest.headersList.contains('if-match', true) ||
+      httpRequest.headersList.contains('if-range', true))
+  ) {
+    httpRequest.cache = 'no-store'
+  }
+
+  //    16. If httpRequest’s cache mode is "no-cache", httpRequest’s prevent
+  //    no-cache cache-control header modification flag is unset, and
+  //    httpRequest’s header list does not contain `Cache-Control`, then append
+  //    `Cache-Control`/`max-age=0` to httpRequest’s header list.
+  if (
+    httpRequest.cache === 'no-cache' &&
+    !httpRequest.preventNoCacheCacheControlHeaderModification &&
+    !httpRequest.headersList.contains('cache-control', true)
+  ) {
+    httpRequest.headersList.append('cache-control', 'max-age=0', true)
+  }
+
+  //    17. If httpRequest’s cache mode is "no-store" or "reload", then:
+  if (httpRequest.cache === 'no-store' || httpRequest.cache === 'reload') {
+    // 1. If httpRequest’s header list does not contain `Pragma`, then append
+    // `Pragma`/`no-cache` to httpRequest’s header list.
+    if (!httpRequest.headersList.contains('pragma', true)) {
+      httpRequest.headersList.append('pragma', 'no-cache', true)
+    }
+
+    // 2. If httpRequest’s header list does not contain `Cache-Control`,
+    // then append `Cache-Control`/`no-cache` to httpRequest’s header list.
+    if (!httpRequest.headersList.contains('cache-control', true)) {
+      httpRequest.headersList.append('cache-control', 'no-cache', true)
+    }
+  }
+
+  //    18. If httpRequest’s header list contains `Range`, then append
+  //    `Accept-Encoding`/`identity` to httpRequest’s header list.
+  if (httpRequest.headersList.contains('range', true)) {
+    httpRequest.headersList.append('accept-encoding', 'identity', true)
+  }
+
+  //    19. Modify httpRequest’s header list per HTTP. Do not append a given
+  //    header if httpRequest’s header list contains that header’s name.
+  //    TODO: https://github.com/whatwg/fetch/issues/1285#issuecomment-896560129
+  if (!httpRequest.headersList.contains('accept-encoding', true)) {
+    if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) {
+      httpRequest.headersList.append('accept-encoding', 'br, gzip, deflate', true)
+    } else {
+      httpRequest.headersList.append('accept-encoding', 'gzip, deflate', true)
+    }
+  }
+
+  httpRequest.headersList.delete('host', true)
+
+  //    20. If includeCredentials is true, then:
+  if (includeCredentials) {
+    // 1. If the user agent is not configured to block cookies for httpRequest
+    // (see section 7 of [COOKIES]), then:
+    // TODO: credentials
+    // 2. If httpRequest’s header list does not contain `Authorization`, then:
+    // TODO: credentials
+  }
+
+  //    21. If there’s a proxy-authentication entry, use it as appropriate.
+  //    TODO: proxy-authentication
+
+  //    22. Set httpCache to the result of determining the HTTP cache
+  //    partition, given httpRequest.
+  //    TODO: cache
+
+  //    23. If httpCache is null, then set httpRequest’s cache mode to
+  //    "no-store".
+  if (httpCache == null) {
+    httpRequest.cache = 'no-store'
+  }
+
+  //    24. If httpRequest’s cache mode is neither "no-store" nor "reload",
+  //    then:
+  if (httpRequest.cache !== 'no-store' && httpRequest.cache !== 'reload') {
+    // TODO: cache
+  }
+
+  // 9. If aborted, then return the appropriate network error for fetchParams.
+  // TODO
+
+  // 10. If response is null, then:
+  if (response == null) {
+    // 1. If httpRequest’s cache mode is "only-if-cached", then return a
+    // network error.
+    if (httpRequest.cache === 'only-if-cached') {
+      return makeNetworkError('only if cached')
+    }
+
+    // 2. Let forwardResponse be the result of running HTTP-network fetch
+    // given httpFetchParams, includeCredentials, and isNewConnectionFetch.
+    const forwardResponse = await httpNetworkFetch(
+      httpFetchParams,
+      includeCredentials,
+      isNewConnectionFetch
+    )
+
+    // 3. If httpRequest’s method is unsafe and forwardResponse’s status is
+    // in the range 200 to 399, inclusive, invalidate appropriate stored
+    // responses in httpCache, as per the "Invalidation" chapter of HTTP
+    // Caching, and set storedResponse to null. [HTTP-CACHING]
+    if (
+      !safeMethodsSet.has(httpRequest.method) &&
+      forwardResponse.status >= 200 &&
+      forwardResponse.status <= 399
+    ) {
+      // TODO: cache
+    }
+
+    // 4. If the revalidatingFlag is set and forwardResponse’s status is 304,
+    // then:
+    if (revalidatingFlag && forwardResponse.status === 304) {
+      // TODO: cache
+    }
+
+    // 5. If response is null, then:
+    if (response == null) {
+      // 1. Set response to forwardResponse.
+      response = forwardResponse
+
+      // 2. Store httpRequest and forwardResponse in httpCache, as per the
+      // "Storing Responses in Caches" chapter of HTTP Caching. [HTTP-CACHING]
+      // TODO: cache
+    }
+  }
+
+  // 11. Set response’s URL list to a clone of httpRequest’s URL list.
+  response.urlList = [...httpRequest.urlList]
+
+  // 12. If httpRequest’s header list contains `Range`, then set response’s
+  // range-requested flag.
+  if (httpRequest.headersList.contains('range', true)) {
+    response.rangeRequested = true
+  }
+
+  // 13. Set response’s request-includes-credentials to includeCredentials.
+  response.requestIncludesCredentials = includeCredentials
+
+  // 14. If response’s status is 401, httpRequest’s response tainting is not
+  // "cors", includeCredentials is true, and request’s window is an environment
+  // settings object, then:
+  // TODO
+
+  // 15. If response’s status is 407, then:
+  if (response.status === 407) {
+    // 1. If request’s window is "no-window", then return a network error.
+    if (request.window === 'no-window') {
+      return makeNetworkError()
+    }
+
+    // 2. ???
+
+    // 3. If fetchParams is canceled, then return the appropriate network error for fetchParams.
+    if (isCancelled(fetchParams)) {
+      return makeAppropriateNetworkError(fetchParams)
+    }
+
+    // 4. Prompt the end user as appropriate in request’s window and store
+    // the result as a proxy-authentication entry. [HTTP-AUTH]
+    // TODO: Invoke some kind of callback?
+
+    // 5. Set response to the result of running HTTP-network-or-cache fetch given
+    // fetchParams.
+    // TODO
+    return makeNetworkError('proxy authentication required')
+  }
+
+  // 16. If all of the following are true
+  if (
+    // response’s status is 421
+    response.status === 421 &&
+    // isNewConnectionFetch is false
+    !isNewConnectionFetch &&
+    // request’s body is null, or request’s body is non-null and request’s body’s source is non-null
+    (request.body == null || request.body.source != null)
+  ) {
+    // then:
+
+    // 1. If fetchParams is canceled, then return the appropriate network error for fetchParams.
+    if (isCancelled(fetchParams)) {
+      return makeAppropriateNetworkError(fetchParams)
+    }
+
+    // 2. Set response to the result of running HTTP-network-or-cache
+    // fetch given fetchParams, isAuthenticationFetch, and true.
+
+    // TODO (spec): The spec doesn't specify this but we need to cancel
+    // the active response before we can start a new one.
+    // https://github.com/whatwg/fetch/issues/1293
+    fetchParams.controller.connection.destroy()
+
+    response = await httpNetworkOrCacheFetch(
+      fetchParams,
+      isAuthenticationFetch,
+      true
+    )
+  }
+
+  // 17. If isAuthenticationFetch is true, then create an authentication entry
+  if (isAuthenticationFetch) {
+    // TODO
+  }
+
+  // 18. Return response.
+  return response
+}
+
+// https://fetch.spec.whatwg.org/#http-network-fetch
+async function httpNetworkFetch (
+  fetchParams,
+  includeCredentials = false,
+  forceNewConnection = false
+) {
+  assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed)
+
+  fetchParams.controller.connection = {
+    abort: null,
+    destroyed: false,
+    destroy (err, abort = true) {
+      if (!this.destroyed) {
+        this.destroyed = true
+        if (abort) {
+          this.abort?.(err ?? new DOMException('The operation was aborted.', 'AbortError'))
+        }
+      }
+    }
+  }
+
+  // 1. Let request be fetchParams’s request.
+  const request = fetchParams.request
+
+  // 2. Let response be null.
+  let response = null
+
+  // 3. Let timingInfo be fetchParams’s timing info.
+  const timingInfo = fetchParams.timingInfo
+
+  // 4. Let httpCache be the result of determining the HTTP cache partition,
+  // given request.
+  // TODO: cache
+  const httpCache = null
+
+  // 5. If httpCache is null, then set request’s cache mode to "no-store".
+  if (httpCache == null) {
+    request.cache = 'no-store'
+  }
+
+  // 6. Let networkPartitionKey be the result of determining the network
+  // partition key given request.
+  // TODO
+
+  // 7. Let newConnection be "yes" if forceNewConnection is true; otherwise
+  // "no".
+  const newConnection = forceNewConnection ? 'yes' : 'no' // eslint-disable-line no-unused-vars
+
+  // 8. Switch on request’s mode:
+  if (request.mode === 'websocket') {
+    // Let connection be the result of obtaining a WebSocket connection,
+    // given request’s current URL.
+    // TODO
+  } else {
+    // Let connection be the result of obtaining a connection, given
+    // networkPartitionKey, request’s current URL’s origin,
+    // includeCredentials, and forceNewConnection.
+    // TODO
+  }
+
+  // 9. Run these steps, but abort when the ongoing fetch is terminated:
+
+  //    1. If connection is failure, then return a network error.
+
+  //    2. Set timingInfo’s final connection timing info to the result of
+  //    calling clamp and coarsen connection timing info with connection’s
+  //    timing info, timingInfo’s post-redirect start time, and fetchParams’s
+  //    cross-origin isolated capability.
+
+  //    3. If connection is not an HTTP/2 connection, request’s body is non-null,
+  //    and request’s body’s source is null, then append (`Transfer-Encoding`,
+  //    `chunked`) to request’s header list.
+
+  //    4. Set timingInfo’s final network-request start time to the coarsened
+  //    shared current time given fetchParams’s cross-origin isolated
+  //    capability.
+
+  //    5. Set response to the result of making an HTTP request over connection
+  //    using request with the following caveats:
+
+  //        - Follow the relevant requirements from HTTP. [HTTP] [HTTP-SEMANTICS]
+  //        [HTTP-COND] [HTTP-CACHING] [HTTP-AUTH]
+
+  //        - If request’s body is non-null, and request’s body’s source is null,
+  //        then the user agent may have a buffer of up to 64 kibibytes and store
+  //        a part of request’s body in that buffer. If the user agent reads from
+  //        request’s body beyond that buffer’s size and the user agent needs to
+  //        resend request, then instead return a network error.
+
+  //        - Set timingInfo’s final network-response start time to the coarsened
+  //        shared current time given fetchParams’s cross-origin isolated capability,
+  //        immediately after the user agent’s HTTP parser receives the first byte
+  //        of the response (e.g., frame header bytes for HTTP/2 or response status
+  //        line for HTTP/1.x).
+
+  //        - Wait until all the headers are transmitted.
+
+  //        - Any responses whose status is in the range 100 to 199, inclusive,
+  //        and is not 101, are to be ignored, except for the purposes of setting
+  //        timingInfo’s final network-response start time above.
+
+  //    - If request’s header list contains `Transfer-Encoding`/`chunked` and
+  //    response is transferred via HTTP/1.0 or older, then return a network
+  //    error.
+
+  //    - If the HTTP request results in a TLS client certificate dialog, then:
+
+  //        1. If request’s window is an environment settings object, make the
+  //        dialog available in request’s window.
+
+  //        2. Otherwise, return a network error.
+
+  // To transmit request’s body body, run these steps:
+  let requestBody = null
+  // 1. If body is null and fetchParams’s process request end-of-body is
+  // non-null, then queue a fetch task given fetchParams’s process request
+  // end-of-body and fetchParams’s task destination.
+  if (request.body == null && fetchParams.processRequestEndOfBody) {
+    queueMicrotask(() => fetchParams.processRequestEndOfBody())
+  } else if (request.body != null) {
+    // 2. Otherwise, if body is non-null:
+
+    //    1. Let processBodyChunk given bytes be these steps:
+    const processBodyChunk = async function * (bytes) {
+      // 1. If the ongoing fetch is terminated, then abort these steps.
+      if (isCancelled(fetchParams)) {
+        return
+      }
+
+      // 2. Run this step in parallel: transmit bytes.
+      yield bytes
+
+      // 3. If fetchParams’s process request body is non-null, then run
+      // fetchParams’s process request body given bytes’s length.
+      fetchParams.processRequestBodyChunkLength?.(bytes.byteLength)
+    }
+
+    // 2. Let processEndOfBody be these steps:
+    const processEndOfBody = () => {
+      // 1. If fetchParams is canceled, then abort these steps.
+      if (isCancelled(fetchParams)) {
+        return
+      }
+
+      // 2. If fetchParams’s process request end-of-body is non-null,
+      // then run fetchParams’s process request end-of-body.
+      if (fetchParams.processRequestEndOfBody) {
+        fetchParams.processRequestEndOfBody()
+      }
+    }
+
+    // 3. Let processBodyError given e be these steps:
+    const processBodyError = (e) => {
+      // 1. If fetchParams is canceled, then abort these steps.
+      if (isCancelled(fetchParams)) {
+        return
+      }
+
+      // 2. If e is an "AbortError" DOMException, then abort fetchParams’s controller.
+      if (e.name === 'AbortError') {
+        fetchParams.controller.abort()
+      } else {
+        fetchParams.controller.terminate(e)
+      }
+    }
+
+    // 4. Incrementally read request’s body given processBodyChunk, processEndOfBody,
+    // processBodyError, and fetchParams’s task destination.
+    requestBody = (async function * () {
+      try {
+        for await (const bytes of request.body.stream) {
+          yield * processBodyChunk(bytes)
+        }
+        processEndOfBody()
+      } catch (err) {
+        processBodyError(err)
+      }
+    })()
+  }
+
+  try {
+    // socket is only provided for websockets
+    const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody })
+
+    if (socket) {
+      response = makeResponse({ status, statusText, headersList, socket })
+    } else {
+      const iterator = body[Symbol.asyncIterator]()
+      fetchParams.controller.next = () => iterator.next()
+
+      response = makeResponse({ status, statusText, headersList })
+    }
+  } catch (err) {
+    // 10. If aborted, then:
+    if (err.name === 'AbortError') {
+      // 1. If connection uses HTTP/2, then transmit an RST_STREAM frame.
+      fetchParams.controller.connection.destroy()
+
+      // 2. Return the appropriate network error for fetchParams.
+      return makeAppropriateNetworkError(fetchParams, err)
+    }
+
+    return makeNetworkError(err)
+  }
+
+  // 11. Let pullAlgorithm be an action that resumes the ongoing fetch
+  // if it is suspended.
+  const pullAlgorithm = async () => {
+    await fetchParams.controller.resume()
+  }
+
+  // 12. Let cancelAlgorithm be an algorithm that aborts fetchParams’s
+  // controller with reason, given reason.
+  const cancelAlgorithm = (reason) => {
+    // If the aborted fetch was already terminated, then we do not
+    // need to do anything.
+    if (!isCancelled(fetchParams)) {
+      fetchParams.controller.abort(reason)
+    }
+  }
+
+  // 13. Let highWaterMark be a non-negative, non-NaN number, chosen by
+  // the user agent.
+  // TODO
+
+  // 14. Let sizeAlgorithm be an algorithm that accepts a chunk object
+  // and returns a non-negative, non-NaN, non-infinite number, chosen by the user agent.
+  // TODO
+
+  // 15. Let stream be a new ReadableStream.
+  // 16. Set up stream with byte reading support with pullAlgorithm set to pullAlgorithm,
+  //     cancelAlgorithm set to cancelAlgorithm.
+  const stream = new ReadableStream(
+    {
+      async start (controller) {
+        fetchParams.controller.controller = controller
+      },
+      async pull (controller) {
+        await pullAlgorithm(controller)
+      },
+      async cancel (reason) {
+        await cancelAlgorithm(reason)
+      },
+      type: 'bytes'
+    }
+  )
+
+  // 17. Run these steps, but abort when the ongoing fetch is terminated:
+
+  //    1. Set response’s body to a new body whose stream is stream.
+  response.body = { stream, source: null, length: null }
+
+  //    2. If response is not a network error and request’s cache mode is
+  //    not "no-store", then update response in httpCache for request.
+  //    TODO
+
+  //    3. If includeCredentials is true and the user agent is not configured
+  //    to block cookies for request (see section 7 of [COOKIES]), then run the
+  //    "set-cookie-string" parsing algorithm (see section 5.2 of [COOKIES]) on
+  //    the value of each header whose name is a byte-case-insensitive match for
+  //    `Set-Cookie` in response’s header list, if any, and request’s current URL.
+  //    TODO
+
+  // 18. If aborted, then:
+  // TODO
+
+  // 19. Run these steps in parallel:
+
+  //    1. Run these steps, but abort when fetchParams is canceled:
+  fetchParams.controller.onAborted = onAborted
+  fetchParams.controller.on('terminated', onAborted)
+  fetchParams.controller.resume = async () => {
+    // 1. While true
+    while (true) {
+      // 1-3. See onData...
+
+      // 4. Set bytes to the result of handling content codings given
+      // codings and bytes.
+      let bytes
+      let isFailure
+      try {
+        const { done, value } = await fetchParams.controller.next()
+
+        if (isAborted(fetchParams)) {
+          break
+        }
+
+        bytes = done ? undefined : value
+      } catch (err) {
+        if (fetchParams.controller.ended && !timingInfo.encodedBodySize) {
+          // zlib doesn't like empty streams.
+          bytes = undefined
+        } else {
+          bytes = err
+
+          // err may be propagated from the result of calling readablestream.cancel,
+          // which might not be an error. https://github.com/nodejs/undici/issues/2009
+          isFailure = true
+        }
+      }
+
+      if (bytes === undefined) {
+        // 2. Otherwise, if the bytes transmission for response’s message
+        // body is done normally and stream is readable, then close
+        // stream, finalize response for fetchParams and response, and
+        // abort these in-parallel steps.
+        readableStreamClose(fetchParams.controller.controller)
+
+        finalizeResponse(fetchParams, response)
+
+        return
+      }
+
+      // 5. Increase timingInfo’s decoded body size by bytes’s length.
+      timingInfo.decodedBodySize += bytes?.byteLength ?? 0
+
+      // 6. If bytes is failure, then terminate fetchParams’s controller.
+      if (isFailure) {
+        fetchParams.controller.terminate(bytes)
+        return
+      }
+
+      // 7. Enqueue a Uint8Array wrapping an ArrayBuffer containing bytes
+      // into stream.
+      const buffer = new Uint8Array(bytes)
+      if (buffer.byteLength) {
+        fetchParams.controller.controller.enqueue(buffer)
+      }
+
+      // 8. If stream is errored, then terminate the ongoing fetch.
+      if (isErrored(stream)) {
+        fetchParams.controller.terminate()
+        return
+      }
+
+      // 9. If stream doesn’t need more data ask the user agent to suspend
+      // the ongoing fetch.
+      if (fetchParams.controller.controller.desiredSize <= 0) {
+        return
+      }
+    }
+  }
+
+  //    2. If aborted, then:
+  function onAborted (reason) {
+    // 2. If fetchParams is aborted, then:
+    if (isAborted(fetchParams)) {
+      // 1. Set response’s aborted flag.
+      response.aborted = true
+
+      // 2. If stream is readable, then error stream with the result of
+      //    deserialize a serialized abort reason given fetchParams’s
+      //    controller’s serialized abort reason and an
+      //    implementation-defined realm.
+      if (isReadable(stream)) {
+        fetchParams.controller.controller.error(
+          fetchParams.controller.serializedAbortReason
+        )
+      }
+    } else {
+      // 3. Otherwise, if stream is readable, error stream with a TypeError.
+      if (isReadable(stream)) {
+        fetchParams.controller.controller.error(new TypeError('terminated', {
+          cause: isErrorLike(reason) ? reason : undefined
+        }))
+      }
+    }
+
+    // 4. If connection uses HTTP/2, then transmit an RST_STREAM frame.
+    // 5. Otherwise, the user agent should close connection unless it would be bad for performance to do so.
+    fetchParams.controller.connection.destroy()
+  }
+
+  // 20. Return response.
+  return response
+
+  function dispatch ({ body }) {
+    const url = requestCurrentURL(request)
+    /** @type {import('../..').Agent} */
+    const agent = fetchParams.controller.dispatcher
+
+    return new Promise((resolve, reject) => agent.dispatch(
+      {
+        path: url.pathname + url.search,
+        origin: url.origin,
+        method: request.method,
+        body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body,
+        headers: request.headersList.entries,
+        maxRedirections: 0,
+        upgrade: request.mode === 'websocket' ? 'websocket' : undefined
+      },
+      {
+        body: null,
+        abort: null,
+
+        onConnect (abort) {
+          // TODO (fix): Do we need connection here?
+          const { connection } = fetchParams.controller
+
+          // Set timingInfo’s final connection timing info to the result of calling clamp and coarsen
+          // connection timing info with connection’s timing info, timingInfo’s post-redirect start
+          // time, and fetchParams’s cross-origin isolated capability.
+          // TODO: implement connection timing
+          timingInfo.finalConnectionTimingInfo = clampAndCoarsenConnectionTimingInfo(undefined, timingInfo.postRedirectStartTime, fetchParams.crossOriginIsolatedCapability)
+
+          if (connection.destroyed) {
+            abort(new DOMException('The operation was aborted.', 'AbortError'))
+          } else {
+            fetchParams.controller.on('terminated', abort)
+            this.abort = connection.abort = abort
+          }
+
+          // Set timingInfo’s final network-request start time to the coarsened shared current time given
+          // fetchParams’s cross-origin isolated capability.
+          timingInfo.finalNetworkRequestStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability)
+        },
+
+        onResponseStarted () {
+          // Set timingInfo’s final network-response start time to the coarsened shared current
+          // time given fetchParams’s cross-origin isolated capability, immediately after the
+          // user agent’s HTTP parser receives the first byte of the response (e.g., frame header
+          // bytes for HTTP/2 or response status line for HTTP/1.x).
+          timingInfo.finalNetworkResponseStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability)
+        },
+
+        onHeaders (status, rawHeaders, resume, statusText) {
+          if (status < 200) {
+            return
+          }
+
+          let location = ''
+
+          const headersList = new HeadersList()
+
+          for (let i = 0; i < rawHeaders.length; i += 2) {
+            headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString('latin1'), true)
+          }
+          location = headersList.get('location', true)
+
+          this.body = new Readable({ read: resume })
+
+          const decoders = []
+
+          const willFollow = location && request.redirect === 'follow' &&
+            redirectStatusSet.has(status)
+
+          // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding
+          if (request.method !== 'HEAD' && request.method !== 'CONNECT' && !nullBodyStatus.includes(status) && !willFollow) {
+            // https://www.rfc-editor.org/rfc/rfc7231#section-3.1.2.1
+            const contentEncoding = headersList.get('content-encoding', true)
+            // "All content-coding values are case-insensitive..."
+            /** @type {string[]} */
+            const codings = contentEncoding ? contentEncoding.toLowerCase().split(',') : []
+
+            // Limit the number of content-encodings to prevent resource exhaustion.
+            // CVE fix similar to urllib3 (GHSA-gm62-xv2j-4w53) and curl (CVE-2022-32206).
+            const maxContentEncodings = 5
+            if (codings.length > maxContentEncodings) {
+              reject(new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`))
+              return true
+            }
+
+            for (let i = codings.length - 1; i >= 0; --i) {
+              const coding = codings[i].trim()
+              // https://www.rfc-editor.org/rfc/rfc9112.html#section-7.2
+              if (coding === 'x-gzip' || coding === 'gzip') {
+                decoders.push(zlib.createGunzip({
+                  // Be less strict when decoding compressed responses, since sometimes
+                  // servers send slightly invalid responses that are still accepted
+                  // by common browsers.
+                  // Always using Z_SYNC_FLUSH is what cURL does.
+                  flush: zlib.constants.Z_SYNC_FLUSH,
+                  finishFlush: zlib.constants.Z_SYNC_FLUSH
+                }))
+              } else if (coding === 'deflate') {
+                decoders.push(createInflate({
+                  flush: zlib.constants.Z_SYNC_FLUSH,
+                  finishFlush: zlib.constants.Z_SYNC_FLUSH
+                }))
+              } else if (coding === 'br') {
+                decoders.push(zlib.createBrotliDecompress({
+                  flush: zlib.constants.BROTLI_OPERATION_FLUSH,
+                  finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH
+                }))
+              } else {
+                decoders.length = 0
+                break
+              }
+            }
+          }
+
+          const onError = this.onError.bind(this)
+
+          resolve({
+            status,
+            statusText,
+            headersList,
+            body: decoders.length
+              ? pipeline(this.body, ...decoders, (err) => {
+                if (err) {
+                  this.onError(err)
+                }
+              }).on('error', onError)
+              : this.body.on('error', onError)
+          })
+
+          return true
+        },
+
+        onData (chunk) {
+          if (fetchParams.controller.dump) {
+            return
+          }
+
+          // 1. If one or more bytes have been transmitted from response’s
+          // message body, then:
+
+          //  1. Let bytes be the transmitted bytes.
+          const bytes = chunk
+
+          //  2. Let codings be the result of extracting header list values
+          //  given `Content-Encoding` and response’s header list.
+          //  See pullAlgorithm.
+
+          //  3. Increase timingInfo’s encoded body size by bytes’s length.
+          timingInfo.encodedBodySize += bytes.byteLength
+
+          //  4. See pullAlgorithm...
+
+          return this.body.push(bytes)
+        },
+
+        onComplete () {
+          if (this.abort) {
+            fetchParams.controller.off('terminated', this.abort)
+          }
+
+          if (fetchParams.controller.onAborted) {
+            fetchParams.controller.off('terminated', fetchParams.controller.onAborted)
+          }
+
+          fetchParams.controller.ended = true
+
+          this.body.push(null)
+        },
+
+        onError (error) {
+          if (this.abort) {
+            fetchParams.controller.off('terminated', this.abort)
+          }
+
+          this.body?.destroy(error)
+
+          fetchParams.controller.terminate(error)
+
+          reject(error)
+        },
+
+        onUpgrade (status, rawHeaders, socket) {
+          if (status !== 101) {
+            return
+          }
+
+          const headersList = new HeadersList()
+
+          for (let i = 0; i < rawHeaders.length; i += 2) {
+            headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString('latin1'), true)
+          }
+
+          resolve({
+            status,
+            statusText: STATUS_CODES[status],
+            headersList,
+            socket
+          })
+
+          return true
+        }
+      }
+    ))
+  }
+}
+
+module.exports = {
+  fetch,
+  Fetch,
+  fetching,
+  finalizeAndReportTiming
+}
+
+
+/***/ }),
+
+/***/ 13925:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+/* globals AbortController */
+
+
+
+const { extractBody, mixinBody, cloneBody, bodyUnusable } = __nccwpck_require__(23291)
+const { Headers, fill: fillHeaders, HeadersList, setHeadersGuard, getHeadersGuard, setHeadersList, getHeadersList } = __nccwpck_require__(24997)
+const { FinalizationRegistry } = __nccwpck_require__(77962)()
+const util = __nccwpck_require__(94407)
+const nodeUtil = __nccwpck_require__(47261)
+const {
+  isValidHTTPToken,
+  sameOrigin,
+  environmentSettingsObject
+} = __nccwpck_require__(91976)
+const {
+  forbiddenMethodsSet,
+  corsSafeListedMethodsSet,
+  referrerPolicy,
+  requestRedirect,
+  requestMode,
+  requestCredentials,
+  requestCache,
+  requestDuplex
+} = __nccwpck_require__(87979)
+const { kEnumerableProperty, normalizedMethodRecordsBase, normalizedMethodRecords } = util
+const { kHeaders, kSignal, kState, kDispatcher } = __nccwpck_require__(78172)
+const { webidl } = __nccwpck_require__(37829)
+const { URLSerializer } = __nccwpck_require__(86954)
+const { kConstruct } = __nccwpck_require__(5392)
+const assert = __nccwpck_require__(98061)
+const { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = __nccwpck_require__(15673)
+
+const kAbortController = Symbol('abortController')
+
+const requestFinalizer = new FinalizationRegistry(({ signal, abort }) => {
+  signal.removeEventListener('abort', abort)
+})
+
+const dependentControllerMap = new WeakMap()
+
+function buildAbort (acRef) {
+  return abort
+
+  function abort () {
+    const ac = acRef.deref()
+    if (ac !== undefined) {
+      // Currently, there is a problem with FinalizationRegistry.
+      // https://github.com/nodejs/node/issues/49344
+      // https://github.com/nodejs/node/issues/47748
+      // In the case of abort, the first step is to unregister from it.
+      // If the controller can refer to it, it is still registered.
+      // It will be removed in the future.
+      requestFinalizer.unregister(abort)
+
+      // Unsubscribe a listener.
+      // FinalizationRegistry will no longer be called, so this must be done.
+      this.removeEventListener('abort', abort)
+
+      ac.abort(this.reason)
+
+      const controllerList = dependentControllerMap.get(ac.signal)
+
+      if (controllerList !== undefined) {
+        if (controllerList.size !== 0) {
+          for (const ref of controllerList) {
+            const ctrl = ref.deref()
+            if (ctrl !== undefined) {
+              ctrl.abort(this.reason)
+            }
+          }
+          controllerList.clear()
+        }
+        dependentControllerMap.delete(ac.signal)
+      }
+    }
+  }
+}
+
+let patchMethodWarning = false
+
+// https://fetch.spec.whatwg.org/#request-class
+class Request {
+  // https://fetch.spec.whatwg.org/#dom-request
+  constructor (input, init = {}) {
+    webidl.util.markAsUncloneable(this)
+    if (input === kConstruct) {
+      return
+    }
+
+    const prefix = 'Request constructor'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    input = webidl.converters.RequestInfo(input, prefix, 'input')
+    init = webidl.converters.RequestInit(init, prefix, 'init')
+
+    // 1. Let request be null.
+    let request = null
+
+    // 2. Let fallbackMode be null.
+    let fallbackMode = null
+
+    // 3. Let baseURL be this’s relevant settings object’s API base URL.
+    const baseUrl = environmentSettingsObject.settingsObject.baseUrl
+
+    // 4. Let signal be null.
+    let signal = null
+
+    // 5. If input is a string, then:
+    if (typeof input === 'string') {
+      this[kDispatcher] = init.dispatcher
+
+      // 1. Let parsedURL be the result of parsing input with baseURL.
+      // 2. If parsedURL is failure, then throw a TypeError.
+      let parsedURL
+      try {
+        parsedURL = new URL(input, baseUrl)
+      } catch (err) {
+        throw new TypeError('Failed to parse URL from ' + input, { cause: err })
+      }
+
+      // 3. If parsedURL includes credentials, then throw a TypeError.
+      if (parsedURL.username || parsedURL.password) {
+        throw new TypeError(
+          'Request cannot be constructed from a URL that includes credentials: ' +
+            input
+        )
+      }
+
+      // 4. Set request to a new request whose URL is parsedURL.
+      request = makeRequest({ urlList: [parsedURL] })
+
+      // 5. Set fallbackMode to "cors".
+      fallbackMode = 'cors'
+    } else {
+      this[kDispatcher] = init.dispatcher || input[kDispatcher]
+
+      // 6. Otherwise:
+
+      // 7. Assert: input is a Request object.
+      assert(input instanceof Request)
+
+      // 8. Set request to input’s request.
+      request = input[kState]
+
+      // 9. Set signal to input’s signal.
+      signal = input[kSignal]
+    }
+
+    // 7. Let origin be this’s relevant settings object’s origin.
+    const origin = environmentSettingsObject.settingsObject.origin
+
+    // 8. Let window be "client".
+    let window = 'client'
+
+    // 9. If request’s window is an environment settings object and its origin
+    // is same origin with origin, then set window to request’s window.
+    if (
+      request.window?.constructor?.name === 'EnvironmentSettingsObject' &&
+      sameOrigin(request.window, origin)
+    ) {
+      window = request.window
+    }
+
+    // 10. If init["window"] exists and is non-null, then throw a TypeError.
+    if (init.window != null) {
+      throw new TypeError(`'window' option '${window}' must be null`)
+    }
+
+    // 11. If init["window"] exists, then set window to "no-window".
+    if ('window' in init) {
+      window = 'no-window'
+    }
+
+    // 12. Set request to a new request with the following properties:
+    request = makeRequest({
+      // URL request’s URL.
+      // undici implementation note: this is set as the first item in request's urlList in makeRequest
+      // method request’s method.
+      method: request.method,
+      // header list A copy of request’s header list.
+      // undici implementation note: headersList is cloned in makeRequest
+      headersList: request.headersList,
+      // unsafe-request flag Set.
+      unsafeRequest: request.unsafeRequest,
+      // client This’s relevant settings object.
+      client: environmentSettingsObject.settingsObject,
+      // window window.
+      window,
+      // priority request’s priority.
+      priority: request.priority,
+      // origin request’s origin. The propagation of the origin is only significant for navigation requests
+      // being handled by a service worker. In this scenario a request can have an origin that is different
+      // from the current client.
+      origin: request.origin,
+      // referrer request’s referrer.
+      referrer: request.referrer,
+      // referrer policy request’s referrer policy.
+      referrerPolicy: request.referrerPolicy,
+      // mode request’s mode.
+      mode: request.mode,
+      // credentials mode request’s credentials mode.
+      credentials: request.credentials,
+      // cache mode request’s cache mode.
+      cache: request.cache,
+      // redirect mode request’s redirect mode.
+      redirect: request.redirect,
+      // integrity metadata request’s integrity metadata.
+      integrity: request.integrity,
+      // keepalive request’s keepalive.
+      keepalive: request.keepalive,
+      // reload-navigation flag request’s reload-navigation flag.
+      reloadNavigation: request.reloadNavigation,
+      // history-navigation flag request’s history-navigation flag.
+      historyNavigation: request.historyNavigation,
+      // URL list A clone of request’s URL list.
+      urlList: [...request.urlList]
+    })
+
+    const initHasKey = Object.keys(init).length !== 0
+
+    // 13. If init is not empty, then:
+    if (initHasKey) {
+      // 1. If request’s mode is "navigate", then set it to "same-origin".
+      if (request.mode === 'navigate') {
+        request.mode = 'same-origin'
+      }
+
+      // 2. Unset request’s reload-navigation flag.
+      request.reloadNavigation = false
+
+      // 3. Unset request’s history-navigation flag.
+      request.historyNavigation = false
+
+      // 4. Set request’s origin to "client".
+      request.origin = 'client'
+
+      // 5. Set request’s referrer to "client"
+      request.referrer = 'client'
+
+      // 6. Set request’s referrer policy to the empty string.
+      request.referrerPolicy = ''
+
+      // 7. Set request’s URL to request’s current URL.
+      request.url = request.urlList[request.urlList.length - 1]
+
+      // 8. Set request’s URL list to « request’s URL ».
+      request.urlList = [request.url]
+    }
+
+    // 14. If init["referrer"] exists, then:
+    if (init.referrer !== undefined) {
+      // 1. Let referrer be init["referrer"].
+      const referrer = init.referrer
+
+      // 2. If referrer is the empty string, then set request’s referrer to "no-referrer".
+      if (referrer === '') {
+        request.referrer = 'no-referrer'
+      } else {
+        // 1. Let parsedReferrer be the result of parsing referrer with
+        // baseURL.
+        // 2. If parsedReferrer is failure, then throw a TypeError.
+        let parsedReferrer
+        try {
+          parsedReferrer = new URL(referrer, baseUrl)
+        } catch (err) {
+          throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err })
+        }
+
+        // 3. If one of the following is true
+        // - parsedReferrer’s scheme is "about" and path is the string "client"
+        // - parsedReferrer’s origin is not same origin with origin
+        // then set request’s referrer to "client".
+        if (
+          (parsedReferrer.protocol === 'about:' && parsedReferrer.hostname === 'client') ||
+          (origin && !sameOrigin(parsedReferrer, environmentSettingsObject.settingsObject.baseUrl))
+        ) {
+          request.referrer = 'client'
+        } else {
+          // 4. Otherwise, set request’s referrer to parsedReferrer.
+          request.referrer = parsedReferrer
+        }
+      }
+    }
+
+    // 15. If init["referrerPolicy"] exists, then set request’s referrer policy
+    // to it.
+    if (init.referrerPolicy !== undefined) {
+      request.referrerPolicy = init.referrerPolicy
+    }
+
+    // 16. Let mode be init["mode"] if it exists, and fallbackMode otherwise.
+    let mode
+    if (init.mode !== undefined) {
+      mode = init.mode
+    } else {
+      mode = fallbackMode
+    }
+
+    // 17. If mode is "navigate", then throw a TypeError.
+    if (mode === 'navigate') {
+      throw webidl.errors.exception({
+        header: 'Request constructor',
+        message: 'invalid request mode navigate.'
+      })
+    }
+
+    // 18. If mode is non-null, set request’s mode to mode.
+    if (mode != null) {
+      request.mode = mode
+    }
+
+    // 19. If init["credentials"] exists, then set request’s credentials mode
+    // to it.
+    if (init.credentials !== undefined) {
+      request.credentials = init.credentials
+    }
+
+    // 18. If init["cache"] exists, then set request’s cache mode to it.
+    if (init.cache !== undefined) {
+      request.cache = init.cache
+    }
+
+    // 21. If request’s cache mode is "only-if-cached" and request’s mode is
+    // not "same-origin", then throw a TypeError.
+    if (request.cache === 'only-if-cached' && request.mode !== 'same-origin') {
+      throw new TypeError(
+        "'only-if-cached' can be set only with 'same-origin' mode"
+      )
+    }
+
+    // 22. If init["redirect"] exists, then set request’s redirect mode to it.
+    if (init.redirect !== undefined) {
+      request.redirect = init.redirect
+    }
+
+    // 23. If init["integrity"] exists, then set request’s integrity metadata to it.
+    if (init.integrity != null) {
+      request.integrity = String(init.integrity)
+    }
+
+    // 24. If init["keepalive"] exists, then set request’s keepalive to it.
+    if (init.keepalive !== undefined) {
+      request.keepalive = Boolean(init.keepalive)
+    }
+
+    // 25. If init["method"] exists, then:
+    if (init.method !== undefined) {
+      // 1. Let method be init["method"].
+      let method = init.method
+
+      const mayBeNormalized = normalizedMethodRecords[method]
+
+      if (mayBeNormalized !== undefined) {
+        // Note: Bypass validation DELETE, GET, HEAD, OPTIONS, POST, PUT, PATCH and these lowercase ones
+        request.method = mayBeNormalized
+      } else {
+        // 2. If method is not a method or method is a forbidden method, then
+        // throw a TypeError.
+        if (!isValidHTTPToken(method)) {
+          throw new TypeError(`'${method}' is not a valid HTTP method.`)
+        }
+
+        const upperCase = method.toUpperCase()
+
+        if (forbiddenMethodsSet.has(upperCase)) {
+          throw new TypeError(`'${method}' HTTP method is unsupported.`)
+        }
+
+        // 3. Normalize method.
+        // https://fetch.spec.whatwg.org/#concept-method-normalize
+        // Note: must be in uppercase
+        method = normalizedMethodRecordsBase[upperCase] ?? method
+
+        // 4. Set request’s method to method.
+        request.method = method
+      }
+
+      if (!patchMethodWarning && request.method === 'patch') {
+        process.emitWarning('Using `patch` is highly likely to result in a `405 Method Not Allowed`. `PATCH` is much more likely to succeed.', {
+          code: 'UNDICI-FETCH-patch'
+        })
+
+        patchMethodWarning = true
+      }
+    }
+
+    // 26. If init["signal"] exists, then set signal to it.
+    if (init.signal !== undefined) {
+      signal = init.signal
+    }
+
+    // 27. Set this’s request to request.
+    this[kState] = request
+
+    // 28. Set this’s signal to a new AbortSignal object with this’s relevant
+    // Realm.
+    // TODO: could this be simplified with AbortSignal.any
+    // (https://dom.spec.whatwg.org/#dom-abortsignal-any)
+    const ac = new AbortController()
+    this[kSignal] = ac.signal
+
+    // 29. If signal is not null, then make this’s signal follow signal.
+    if (signal != null) {
+      if (
+        !signal ||
+        typeof signal.aborted !== 'boolean' ||
+        typeof signal.addEventListener !== 'function'
+      ) {
+        throw new TypeError(
+          "Failed to construct 'Request': member signal is not of type AbortSignal."
+        )
+      }
+
+      if (signal.aborted) {
+        ac.abort(signal.reason)
+      } else {
+        // Keep a strong ref to ac while request object
+        // is alive. This is needed to prevent AbortController
+        // from being prematurely garbage collected.
+        // See, https://github.com/nodejs/undici/issues/1926.
+        this[kAbortController] = ac
+
+        const acRef = new WeakRef(ac)
+        const abort = buildAbort(acRef)
+
+        // Third-party AbortControllers may not work with these.
+        // See, https://github.com/nodejs/undici/pull/1910#issuecomment-1464495619.
+        try {
+          // If the max amount of listeners is equal to the default, increase it
+          // This is only available in node >= v19.9.0
+          if (typeof getMaxListeners === 'function' && getMaxListeners(signal) === defaultMaxListeners) {
+            setMaxListeners(1500, signal)
+          } else if (getEventListeners(signal, 'abort').length >= defaultMaxListeners) {
+            setMaxListeners(1500, signal)
+          }
+        } catch {}
+
+        util.addAbortListener(signal, abort)
+        // The third argument must be a registry key to be unregistered.
+        // Without it, you cannot unregister.
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
+        // abort is used as the unregister key. (because it is unique)
+        requestFinalizer.register(ac, { signal, abort }, abort)
+      }
+    }
+
+    // 30. Set this’s headers to a new Headers object with this’s relevant
+    // Realm, whose header list is request’s header list and guard is
+    // "request".
+    this[kHeaders] = new Headers(kConstruct)
+    setHeadersList(this[kHeaders], request.headersList)
+    setHeadersGuard(this[kHeaders], 'request')
+
+    // 31. If this’s request’s mode is "no-cors", then:
+    if (mode === 'no-cors') {
+      // 1. If this’s request’s method is not a CORS-safelisted method,
+      // then throw a TypeError.
+      if (!corsSafeListedMethodsSet.has(request.method)) {
+        throw new TypeError(
+          `'${request.method} is unsupported in no-cors mode.`
+        )
+      }
+
+      // 2. Set this’s headers’s guard to "request-no-cors".
+      setHeadersGuard(this[kHeaders], 'request-no-cors')
+    }
+
+    // 32. If init is not empty, then:
+    if (initHasKey) {
+      /** @type {HeadersList} */
+      const headersList = getHeadersList(this[kHeaders])
+      // 1. Let headers be a copy of this’s headers and its associated header
+      // list.
+      // 2. If init["headers"] exists, then set headers to init["headers"].
+      const headers = init.headers !== undefined ? init.headers : new HeadersList(headersList)
+
+      // 3. Empty this’s headers’s header list.
+      headersList.clear()
+
+      // 4. If headers is a Headers object, then for each header in its header
+      // list, append header’s name/header’s value to this’s headers.
+      if (headers instanceof HeadersList) {
+        for (const { name, value } of headers.rawValues()) {
+          headersList.append(name, value, false)
+        }
+        // Note: Copy the `set-cookie` meta-data.
+        headersList.cookies = headers.cookies
+      } else {
+        // 5. Otherwise, fill this’s headers with headers.
+        fillHeaders(this[kHeaders], headers)
+      }
+    }
+
+    // 33. Let inputBody be input’s request’s body if input is a Request
+    // object; otherwise null.
+    const inputBody = input instanceof Request ? input[kState].body : null
+
+    // 34. If either init["body"] exists and is non-null or inputBody is
+    // non-null, and request’s method is `GET` or `HEAD`, then throw a
+    // TypeError.
+    if (
+      (init.body != null || inputBody != null) &&
+      (request.method === 'GET' || request.method === 'HEAD')
+    ) {
+      throw new TypeError('Request with GET/HEAD method cannot have body.')
+    }
+
+    // 35. Let initBody be null.
+    let initBody = null
+
+    // 36. If init["body"] exists and is non-null, then:
+    if (init.body != null) {
+      // 1. Let Content-Type be null.
+      // 2. Set initBody and Content-Type to the result of extracting
+      // init["body"], with keepalive set to request’s keepalive.
+      const [extractedBody, contentType] = extractBody(
+        init.body,
+        request.keepalive
+      )
+      initBody = extractedBody
+
+      // 3, If Content-Type is non-null and this’s headers’s header list does
+      // not contain `Content-Type`, then append `Content-Type`/Content-Type to
+      // this’s headers.
+      if (contentType && !getHeadersList(this[kHeaders]).contains('content-type', true)) {
+        this[kHeaders].append('content-type', contentType)
+      }
+    }
+
+    // 37. Let inputOrInitBody be initBody if it is non-null; otherwise
+    // inputBody.
+    const inputOrInitBody = initBody ?? inputBody
+
+    // 38. If inputOrInitBody is non-null and inputOrInitBody’s source is
+    // null, then:
+    if (inputOrInitBody != null && inputOrInitBody.source == null) {
+      // 1. If initBody is non-null and init["duplex"] does not exist,
+      //    then throw a TypeError.
+      if (initBody != null && init.duplex == null) {
+        throw new TypeError('RequestInit: duplex option is required when sending a body.')
+      }
+
+      // 2. If this’s request’s mode is neither "same-origin" nor "cors",
+      // then throw a TypeError.
+      if (request.mode !== 'same-origin' && request.mode !== 'cors') {
+        throw new TypeError(
+          'If request is made from ReadableStream, mode should be "same-origin" or "cors"'
+        )
+      }
+
+      // 3. Set this’s request’s use-CORS-preflight flag.
+      request.useCORSPreflightFlag = true
+    }
+
+    // 39. Let finalBody be inputOrInitBody.
+    let finalBody = inputOrInitBody
+
+    // 40. If initBody is null and inputBody is non-null, then:
+    if (initBody == null && inputBody != null) {
+      // 1. If input is unusable, then throw a TypeError.
+      if (bodyUnusable(input)) {
+        throw new TypeError(
+          'Cannot construct a Request with a Request object that has already been used.'
+        )
+      }
+
+      // 2. Set finalBody to the result of creating a proxy for inputBody.
+      // https://streams.spec.whatwg.org/#readablestream-create-a-proxy
+      const identityTransform = new TransformStream()
+      inputBody.stream.pipeThrough(identityTransform)
+      finalBody = {
+        source: inputBody.source,
+        length: inputBody.length,
+        stream: identityTransform.readable
+      }
+    }
+
+    // 41. Set this’s request’s body to finalBody.
+    this[kState].body = finalBody
+  }
+
+  // Returns request’s HTTP method, which is "GET" by default.
+  get method () {
+    webidl.brandCheck(this, Request)
+
+    // The method getter steps are to return this’s request’s method.
+    return this[kState].method
+  }
+
+  // Returns the URL of request as a string.
+  get url () {
+    webidl.brandCheck(this, Request)
+
+    // The url getter steps are to return this’s request’s URL, serialized.
+    return URLSerializer(this[kState].url)
+  }
+
+  // Returns a Headers object consisting of the headers associated with request.
+  // Note that headers added in the network layer by the user agent will not
+  // be accounted for in this object, e.g., the "Host" header.
+  get headers () {
+    webidl.brandCheck(this, Request)
+
+    // The headers getter steps are to return this’s headers.
+    return this[kHeaders]
+  }
+
+  // Returns the kind of resource requested by request, e.g., "document"
+  // or "script".
+  get destination () {
+    webidl.brandCheck(this, Request)
+
+    // The destination getter are to return this’s request’s destination.
+    return this[kState].destination
+  }
+
+  // Returns the referrer of request. Its value can be a same-origin URL if
+  // explicitly set in init, the empty string to indicate no referrer, and
+  // "about:client" when defaulting to the global’s default. This is used
+  // during fetching to determine the value of the `Referer` header of the
+  // request being made.
+  get referrer () {
+    webidl.brandCheck(this, Request)
+
+    // 1. If this’s request’s referrer is "no-referrer", then return the
+    // empty string.
+    if (this[kState].referrer === 'no-referrer') {
+      return ''
+    }
+
+    // 2. If this’s request’s referrer is "client", then return
+    // "about:client".
+    if (this[kState].referrer === 'client') {
+      return 'about:client'
+    }
+
+    // Return this’s request’s referrer, serialized.
+    return this[kState].referrer.toString()
+  }
+
+  // Returns the referrer policy associated with request.
+  // This is used during fetching to compute the value of the request’s
+  // referrer.
+  get referrerPolicy () {
+    webidl.brandCheck(this, Request)
+
+    // The referrerPolicy getter steps are to return this’s request’s referrer policy.
+    return this[kState].referrerPolicy
+  }
+
+  // Returns the mode associated with request, which is a string indicating
+  // whether the request will use CORS, or will be restricted to same-origin
+  // URLs.
+  get mode () {
+    webidl.brandCheck(this, Request)
+
+    // The mode getter steps are to return this’s request’s mode.
+    return this[kState].mode
+  }
+
+  // Returns the credentials mode associated with request,
+  // which is a string indicating whether credentials will be sent with the
+  // request always, never, or only when sent to a same-origin URL.
+  get credentials () {
+    // The credentials getter steps are to return this’s request’s credentials mode.
+    return this[kState].credentials
+  }
+
+  // Returns the cache mode associated with request,
+  // which is a string indicating how the request will
+  // interact with the browser’s cache when fetching.
+  get cache () {
+    webidl.brandCheck(this, Request)
+
+    // The cache getter steps are to return this’s request’s cache mode.
+    return this[kState].cache
+  }
+
+  // Returns the redirect mode associated with request,
+  // which is a string indicating how redirects for the
+  // request will be handled during fetching. A request
+  // will follow redirects by default.
+  get redirect () {
+    webidl.brandCheck(this, Request)
+
+    // The redirect getter steps are to return this’s request’s redirect mode.
+    return this[kState].redirect
+  }
+
+  // Returns request’s subresource integrity metadata, which is a
+  // cryptographic hash of the resource being fetched. Its value
+  // consists of multiple hashes separated by whitespace. [SRI]
+  get integrity () {
+    webidl.brandCheck(this, Request)
+
+    // The integrity getter steps are to return this’s request’s integrity
+    // metadata.
+    return this[kState].integrity
+  }
+
+  // Returns a boolean indicating whether or not request can outlive the
+  // global in which it was created.
+  get keepalive () {
+    webidl.brandCheck(this, Request)
+
+    // The keepalive getter steps are to return this’s request’s keepalive.
+    return this[kState].keepalive
+  }
+
+  // Returns a boolean indicating whether or not request is for a reload
+  // navigation.
+  get isReloadNavigation () {
+    webidl.brandCheck(this, Request)
+
+    // The isReloadNavigation getter steps are to return true if this’s
+    // request’s reload-navigation flag is set; otherwise false.
+    return this[kState].reloadNavigation
+  }
+
+  // Returns a boolean indicating whether or not request is for a history
+  // navigation (a.k.a. back-forward navigation).
+  get isHistoryNavigation () {
+    webidl.brandCheck(this, Request)
+
+    // The isHistoryNavigation getter steps are to return true if this’s request’s
+    // history-navigation flag is set; otherwise false.
+    return this[kState].historyNavigation
+  }
+
+  // Returns the signal associated with request, which is an AbortSignal
+  // object indicating whether or not request has been aborted, and its
+  // abort event handler.
+  get signal () {
+    webidl.brandCheck(this, Request)
+
+    // The signal getter steps are to return this’s signal.
+    return this[kSignal]
+  }
+
+  get body () {
+    webidl.brandCheck(this, Request)
+
+    return this[kState].body ? this[kState].body.stream : null
+  }
+
+  get bodyUsed () {
+    webidl.brandCheck(this, Request)
+
+    return !!this[kState].body && util.isDisturbed(this[kState].body.stream)
+  }
+
+  get duplex () {
+    webidl.brandCheck(this, Request)
+
+    return 'half'
+  }
+
+  // Returns a clone of request.
+  clone () {
+    webidl.brandCheck(this, Request)
+
+    // 1. If this is unusable, then throw a TypeError.
+    if (bodyUnusable(this)) {
+      throw new TypeError('unusable')
+    }
+
+    // 2. Let clonedRequest be the result of cloning this’s request.
+    const clonedRequest = cloneRequest(this[kState])
+
+    // 3. Let clonedRequestObject be the result of creating a Request object,
+    // given clonedRequest, this’s headers’s guard, and this’s relevant Realm.
+    // 4. Make clonedRequestObject’s signal follow this’s signal.
+    const ac = new AbortController()
+    if (this.signal.aborted) {
+      ac.abort(this.signal.reason)
+    } else {
+      let list = dependentControllerMap.get(this.signal)
+      if (list === undefined) {
+        list = new Set()
+        dependentControllerMap.set(this.signal, list)
+      }
+      const acRef = new WeakRef(ac)
+      list.add(acRef)
+      util.addAbortListener(
+        ac.signal,
+        buildAbort(acRef)
+      )
+    }
+
+    // 4. Return clonedRequestObject.
+    return fromInnerRequest(clonedRequest, ac.signal, getHeadersGuard(this[kHeaders]))
+  }
+
+  [nodeUtil.inspect.custom] (depth, options) {
+    if (options.depth === null) {
+      options.depth = 2
+    }
+
+    options.colors ??= true
+
+    const properties = {
+      method: this.method,
+      url: this.url,
+      headers: this.headers,
+      destination: this.destination,
+      referrer: this.referrer,
+      referrerPolicy: this.referrerPolicy,
+      mode: this.mode,
+      credentials: this.credentials,
+      cache: this.cache,
+      redirect: this.redirect,
+      integrity: this.integrity,
+      keepalive: this.keepalive,
+      isReloadNavigation: this.isReloadNavigation,
+      isHistoryNavigation: this.isHistoryNavigation,
+      signal: this.signal
+    }
+
+    return `Request ${nodeUtil.formatWithOptions(options, properties)}`
+  }
+}
+
+mixinBody(Request)
+
+// https://fetch.spec.whatwg.org/#requests
+function makeRequest (init) {
+  return {
+    method: init.method ?? 'GET',
+    localURLsOnly: init.localURLsOnly ?? false,
+    unsafeRequest: init.unsafeRequest ?? false,
+    body: init.body ?? null,
+    client: init.client ?? null,
+    reservedClient: init.reservedClient ?? null,
+    replacesClientId: init.replacesClientId ?? '',
+    window: init.window ?? 'client',
+    keepalive: init.keepalive ?? false,
+    serviceWorkers: init.serviceWorkers ?? 'all',
+    initiator: init.initiator ?? '',
+    destination: init.destination ?? '',
+    priority: init.priority ?? null,
+    origin: init.origin ?? 'client',
+    policyContainer: init.policyContainer ?? 'client',
+    referrer: init.referrer ?? 'client',
+    referrerPolicy: init.referrerPolicy ?? '',
+    mode: init.mode ?? 'no-cors',
+    useCORSPreflightFlag: init.useCORSPreflightFlag ?? false,
+    credentials: init.credentials ?? 'same-origin',
+    useCredentials: init.useCredentials ?? false,
+    cache: init.cache ?? 'default',
+    redirect: init.redirect ?? 'follow',
+    integrity: init.integrity ?? '',
+    cryptoGraphicsNonceMetadata: init.cryptoGraphicsNonceMetadata ?? '',
+    parserMetadata: init.parserMetadata ?? '',
+    reloadNavigation: init.reloadNavigation ?? false,
+    historyNavigation: init.historyNavigation ?? false,
+    userActivation: init.userActivation ?? false,
+    taintedOrigin: init.taintedOrigin ?? false,
+    redirectCount: init.redirectCount ?? 0,
+    responseTainting: init.responseTainting ?? 'basic',
+    preventNoCacheCacheControlHeaderModification: init.preventNoCacheCacheControlHeaderModification ?? false,
+    done: init.done ?? false,
+    timingAllowFailed: init.timingAllowFailed ?? false,
+    urlList: init.urlList,
+    url: init.urlList[0],
+    headersList: init.headersList
+      ? new HeadersList(init.headersList)
+      : new HeadersList()
+  }
+}
+
+// https://fetch.spec.whatwg.org/#concept-request-clone
+function cloneRequest (request) {
+  // To clone a request request, run these steps:
+
+  // 1. Let newRequest be a copy of request, except for its body.
+  const newRequest = makeRequest({ ...request, body: null })
+
+  // 2. If request’s body is non-null, set newRequest’s body to the
+  // result of cloning request’s body.
+  if (request.body != null) {
+    newRequest.body = cloneBody(newRequest, request.body)
+  }
+
+  // 3. Return newRequest.
+  return newRequest
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#request-create
+ * @param {any} innerRequest
+ * @param {AbortSignal} signal
+ * @param {'request' | 'immutable' | 'request-no-cors' | 'response' | 'none'} guard
+ * @returns {Request}
+ */
+function fromInnerRequest (innerRequest, signal, guard) {
+  const request = new Request(kConstruct)
+  request[kState] = innerRequest
+  request[kSignal] = signal
+  request[kHeaders] = new Headers(kConstruct)
+  setHeadersList(request[kHeaders], innerRequest.headersList)
+  setHeadersGuard(request[kHeaders], guard)
+  return request
+}
+
+Object.defineProperties(Request.prototype, {
+  method: kEnumerableProperty,
+  url: kEnumerableProperty,
+  headers: kEnumerableProperty,
+  redirect: kEnumerableProperty,
+  clone: kEnumerableProperty,
+  signal: kEnumerableProperty,
+  duplex: kEnumerableProperty,
+  destination: kEnumerableProperty,
+  body: kEnumerableProperty,
+  bodyUsed: kEnumerableProperty,
+  isHistoryNavigation: kEnumerableProperty,
+  isReloadNavigation: kEnumerableProperty,
+  keepalive: kEnumerableProperty,
+  integrity: kEnumerableProperty,
+  cache: kEnumerableProperty,
+  credentials: kEnumerableProperty,
+  attribute: kEnumerableProperty,
+  referrerPolicy: kEnumerableProperty,
+  referrer: kEnumerableProperty,
+  mode: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'Request',
+    configurable: true
+  }
+})
+
+webidl.converters.Request = webidl.interfaceConverter(
+  Request
+)
+
+// https://fetch.spec.whatwg.org/#requestinfo
+webidl.converters.RequestInfo = function (V, prefix, argument) {
+  if (typeof V === 'string') {
+    return webidl.converters.USVString(V, prefix, argument)
+  }
+
+  if (V instanceof Request) {
+    return webidl.converters.Request(V, prefix, argument)
+  }
+
+  return webidl.converters.USVString(V, prefix, argument)
+}
+
+webidl.converters.AbortSignal = webidl.interfaceConverter(
+  AbortSignal
+)
+
+// https://fetch.spec.whatwg.org/#requestinit
+webidl.converters.RequestInit = webidl.dictionaryConverter([
+  {
+    key: 'method',
+    converter: webidl.converters.ByteString
+  },
+  {
+    key: 'headers',
+    converter: webidl.converters.HeadersInit
+  },
+  {
+    key: 'body',
+    converter: webidl.nullableConverter(
+      webidl.converters.BodyInit
+    )
+  },
+  {
+    key: 'referrer',
+    converter: webidl.converters.USVString
+  },
+  {
+    key: 'referrerPolicy',
+    converter: webidl.converters.DOMString,
+    // https://w3c.github.io/webappsec-referrer-policy/#referrer-policy
+    allowedValues: referrerPolicy
+  },
+  {
+    key: 'mode',
+    converter: webidl.converters.DOMString,
+    // https://fetch.spec.whatwg.org/#concept-request-mode
+    allowedValues: requestMode
+  },
+  {
+    key: 'credentials',
+    converter: webidl.converters.DOMString,
+    // https://fetch.spec.whatwg.org/#requestcredentials
+    allowedValues: requestCredentials
+  },
+  {
+    key: 'cache',
+    converter: webidl.converters.DOMString,
+    // https://fetch.spec.whatwg.org/#requestcache
+    allowedValues: requestCache
+  },
+  {
+    key: 'redirect',
+    converter: webidl.converters.DOMString,
+    // https://fetch.spec.whatwg.org/#requestredirect
+    allowedValues: requestRedirect
+  },
+  {
+    key: 'integrity',
+    converter: webidl.converters.DOMString
+  },
+  {
+    key: 'keepalive',
+    converter: webidl.converters.boolean
+  },
+  {
+    key: 'signal',
+    converter: webidl.nullableConverter(
+      (signal) => webidl.converters.AbortSignal(
+        signal,
+        'RequestInit',
+        'signal',
+        { strict: false }
+      )
+    )
+  },
+  {
+    key: 'window',
+    converter: webidl.converters.any
+  },
+  {
+    key: 'duplex',
+    converter: webidl.converters.DOMString,
+    allowedValues: requestDuplex
+  },
+  {
+    key: 'dispatcher', // undici specific option
+    converter: webidl.converters.any
+  }
+])
+
+module.exports = { Request, makeRequest, fromInnerRequest, cloneRequest }
+
+
+/***/ }),
+
+/***/ 33139:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Headers, HeadersList, fill, getHeadersGuard, setHeadersGuard, setHeadersList } = __nccwpck_require__(24997)
+const { extractBody, cloneBody, mixinBody, hasFinalizationRegistry, streamRegistry, bodyUnusable } = __nccwpck_require__(23291)
+const util = __nccwpck_require__(94407)
+const nodeUtil = __nccwpck_require__(47261)
+const { kEnumerableProperty } = util
+const {
+  isValidReasonPhrase,
+  isCancelled,
+  isAborted,
+  isBlobLike,
+  serializeJavascriptValueToJSONString,
+  isErrorLike,
+  isomorphicEncode,
+  environmentSettingsObject: relevantRealm
+} = __nccwpck_require__(91976)
+const {
+  redirectStatusSet,
+  nullBodyStatus
+} = __nccwpck_require__(87979)
+const { kState, kHeaders } = __nccwpck_require__(78172)
+const { webidl } = __nccwpck_require__(37829)
+const { FormData } = __nccwpck_require__(4923)
+const { URLSerializer } = __nccwpck_require__(86954)
+const { kConstruct } = __nccwpck_require__(5392)
+const assert = __nccwpck_require__(98061)
+const { types } = __nccwpck_require__(47261)
+
+const textEncoder = new TextEncoder('utf-8')
+
+// https://fetch.spec.whatwg.org/#response-class
+class Response {
+  // Creates network error Response.
+  static error () {
+    // The static error() method steps are to return the result of creating a
+    // Response object, given a new network error, "immutable", and this’s
+    // relevant Realm.
+    const responseObject = fromInnerResponse(makeNetworkError(), 'immutable')
+
+    return responseObject
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-response-json
+  static json (data, init = {}) {
+    webidl.argumentLengthCheck(arguments, 1, 'Response.json')
+
+    if (init !== null) {
+      init = webidl.converters.ResponseInit(init)
+    }
+
+    // 1. Let bytes the result of running serialize a JavaScript value to JSON bytes on data.
+    const bytes = textEncoder.encode(
+      serializeJavascriptValueToJSONString(data)
+    )
+
+    // 2. Let body be the result of extracting bytes.
+    const body = extractBody(bytes)
+
+    // 3. Let responseObject be the result of creating a Response object, given a new response,
+    //    "response", and this’s relevant Realm.
+    const responseObject = fromInnerResponse(makeResponse({}), 'response')
+
+    // 4. Perform initialize a response given responseObject, init, and (body, "application/json").
+    initializeResponse(responseObject, init, { body: body[0], type: 'application/json' })
+
+    // 5. Return responseObject.
+    return responseObject
+  }
+
+  // Creates a redirect Response that redirects to url with status status.
+  static redirect (url, status = 302) {
+    webidl.argumentLengthCheck(arguments, 1, 'Response.redirect')
+
+    url = webidl.converters.USVString(url)
+    status = webidl.converters['unsigned short'](status)
+
+    // 1. Let parsedURL be the result of parsing url with current settings
+    // object’s API base URL.
+    // 2. If parsedURL is failure, then throw a TypeError.
+    // TODO: base-URL?
+    let parsedURL
+    try {
+      parsedURL = new URL(url, relevantRealm.settingsObject.baseUrl)
+    } catch (err) {
+      throw new TypeError(`Failed to parse URL from ${url}`, { cause: err })
+    }
+
+    // 3. If status is not a redirect status, then throw a RangeError.
+    if (!redirectStatusSet.has(status)) {
+      throw new RangeError(`Invalid status code ${status}`)
+    }
+
+    // 4. Let responseObject be the result of creating a Response object,
+    // given a new response, "immutable", and this’s relevant Realm.
+    const responseObject = fromInnerResponse(makeResponse({}), 'immutable')
+
+    // 5. Set responseObject’s response’s status to status.
+    responseObject[kState].status = status
+
+    // 6. Let value be parsedURL, serialized and isomorphic encoded.
+    const value = isomorphicEncode(URLSerializer(parsedURL))
+
+    // 7. Append `Location`/value to responseObject’s response’s header list.
+    responseObject[kState].headersList.append('location', value, true)
+
+    // 8. Return responseObject.
+    return responseObject
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-response
+  constructor (body = null, init = {}) {
+    webidl.util.markAsUncloneable(this)
+    if (body === kConstruct) {
+      return
+    }
+
+    if (body !== null) {
+      body = webidl.converters.BodyInit(body)
+    }
+
+    init = webidl.converters.ResponseInit(init)
+
+    // 1. Set this’s response to a new response.
+    this[kState] = makeResponse({})
+
+    // 2. Set this’s headers to a new Headers object with this’s relevant
+    // Realm, whose header list is this’s response’s header list and guard
+    // is "response".
+    this[kHeaders] = new Headers(kConstruct)
+    setHeadersGuard(this[kHeaders], 'response')
+    setHeadersList(this[kHeaders], this[kState].headersList)
+
+    // 3. Let bodyWithType be null.
+    let bodyWithType = null
+
+    // 4. If body is non-null, then set bodyWithType to the result of extracting body.
+    if (body != null) {
+      const [extractedBody, type] = extractBody(body)
+      bodyWithType = { body: extractedBody, type }
+    }
+
+    // 5. Perform initialize a response given this, init, and bodyWithType.
+    initializeResponse(this, init, bodyWithType)
+  }
+
+  // Returns response’s type, e.g., "cors".
+  get type () {
+    webidl.brandCheck(this, Response)
+
+    // The type getter steps are to return this’s response’s type.
+    return this[kState].type
+  }
+
+  // Returns response’s URL, if it has one; otherwise the empty string.
+  get url () {
+    webidl.brandCheck(this, Response)
+
+    const urlList = this[kState].urlList
+
+    // The url getter steps are to return the empty string if this’s
+    // response’s URL is null; otherwise this’s response’s URL,
+    // serialized with exclude fragment set to true.
+    const url = urlList[urlList.length - 1] ?? null
+
+    if (url === null) {
+      return ''
+    }
+
+    return URLSerializer(url, true)
+  }
+
+  // Returns whether response was obtained through a redirect.
+  get redirected () {
+    webidl.brandCheck(this, Response)
+
+    // The redirected getter steps are to return true if this’s response’s URL
+    // list has more than one item; otherwise false.
+    return this[kState].urlList.length > 1
+  }
+
+  // Returns response’s status.
+  get status () {
+    webidl.brandCheck(this, Response)
+
+    // The status getter steps are to return this’s response’s status.
+    return this[kState].status
+  }
+
+  // Returns whether response’s status is an ok status.
+  get ok () {
+    webidl.brandCheck(this, Response)
+
+    // The ok getter steps are to return true if this’s response’s status is an
+    // ok status; otherwise false.
+    return this[kState].status >= 200 && this[kState].status <= 299
+  }
+
+  // Returns response’s status message.
+  get statusText () {
+    webidl.brandCheck(this, Response)
+
+    // The statusText getter steps are to return this’s response’s status
+    // message.
+    return this[kState].statusText
+  }
+
+  // Returns response’s headers as Headers.
+  get headers () {
+    webidl.brandCheck(this, Response)
+
+    // The headers getter steps are to return this’s headers.
+    return this[kHeaders]
+  }
+
+  get body () {
+    webidl.brandCheck(this, Response)
+
+    return this[kState].body ? this[kState].body.stream : null
+  }
+
+  get bodyUsed () {
+    webidl.brandCheck(this, Response)
+
+    return !!this[kState].body && util.isDisturbed(this[kState].body.stream)
+  }
+
+  // Returns a clone of response.
+  clone () {
+    webidl.brandCheck(this, Response)
+
+    // 1. If this is unusable, then throw a TypeError.
+    if (bodyUnusable(this)) {
+      throw webidl.errors.exception({
+        header: 'Response.clone',
+        message: 'Body has already been consumed.'
+      })
+    }
+
+    // 2. Let clonedResponse be the result of cloning this’s response.
+    const clonedResponse = cloneResponse(this[kState])
+
+    // Note: To re-register because of a new stream.
+    if (hasFinalizationRegistry && this[kState].body?.stream) {
+      streamRegistry.register(this, new WeakRef(this[kState].body.stream))
+    }
+
+    // 3. Return the result of creating a Response object, given
+    // clonedResponse, this’s headers’s guard, and this’s relevant Realm.
+    return fromInnerResponse(clonedResponse, getHeadersGuard(this[kHeaders]))
+  }
+
+  [nodeUtil.inspect.custom] (depth, options) {
+    if (options.depth === null) {
+      options.depth = 2
+    }
+
+    options.colors ??= true
+
+    const properties = {
+      status: this.status,
+      statusText: this.statusText,
+      headers: this.headers,
+      body: this.body,
+      bodyUsed: this.bodyUsed,
+      ok: this.ok,
+      redirected: this.redirected,
+      type: this.type,
+      url: this.url
+    }
+
+    return `Response ${nodeUtil.formatWithOptions(options, properties)}`
+  }
+}
+
+mixinBody(Response)
+
+Object.defineProperties(Response.prototype, {
+  type: kEnumerableProperty,
+  url: kEnumerableProperty,
+  status: kEnumerableProperty,
+  ok: kEnumerableProperty,
+  redirected: kEnumerableProperty,
+  statusText: kEnumerableProperty,
+  headers: kEnumerableProperty,
+  clone: kEnumerableProperty,
+  body: kEnumerableProperty,
+  bodyUsed: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'Response',
+    configurable: true
+  }
+})
+
+Object.defineProperties(Response, {
+  json: kEnumerableProperty,
+  redirect: kEnumerableProperty,
+  error: kEnumerableProperty
+})
+
+// https://fetch.spec.whatwg.org/#concept-response-clone
+function cloneResponse (response) {
+  // To clone a response response, run these steps:
+
+  // 1. If response is a filtered response, then return a new identical
+  // filtered response whose internal response is a clone of response’s
+  // internal response.
+  if (response.internalResponse) {
+    return filterResponse(
+      cloneResponse(response.internalResponse),
+      response.type
+    )
+  }
+
+  // 2. Let newResponse be a copy of response, except for its body.
+  const newResponse = makeResponse({ ...response, body: null })
+
+  // 3. If response’s body is non-null, then set newResponse’s body to the
+  // result of cloning response’s body.
+  if (response.body != null) {
+    newResponse.body = cloneBody(newResponse, response.body)
+  }
+
+  // 4. Return newResponse.
+  return newResponse
+}
+
+function makeResponse (init) {
+  return {
+    aborted: false,
+    rangeRequested: false,
+    timingAllowPassed: false,
+    requestIncludesCredentials: false,
+    type: 'default',
+    status: 200,
+    timingInfo: null,
+    cacheState: '',
+    statusText: '',
+    ...init,
+    headersList: init?.headersList
+      ? new HeadersList(init?.headersList)
+      : new HeadersList(),
+    urlList: init?.urlList ? [...init.urlList] : []
+  }
+}
+
+function makeNetworkError (reason) {
+  const isError = isErrorLike(reason)
+  return makeResponse({
+    type: 'error',
+    status: 0,
+    error: isError
+      ? reason
+      : new Error(reason ? String(reason) : reason),
+    aborted: reason && reason.name === 'AbortError'
+  })
+}
+
+// @see https://fetch.spec.whatwg.org/#concept-network-error
+function isNetworkError (response) {
+  return (
+    // A network error is a response whose type is "error",
+    response.type === 'error' &&
+    // status is 0
+    response.status === 0
+  )
+}
+
+function makeFilteredResponse (response, state) {
+  state = {
+    internalResponse: response,
+    ...state
+  }
+
+  return new Proxy(response, {
+    get (target, p) {
+      return p in state ? state[p] : target[p]
+    },
+    set (target, p, value) {
+      assert(!(p in state))
+      target[p] = value
+      return true
+    }
+  })
+}
+
+// https://fetch.spec.whatwg.org/#concept-filtered-response
+function filterResponse (response, type) {
+  // Set response to the following filtered response with response as its
+  // internal response, depending on request’s response tainting:
+  if (type === 'basic') {
+    // A basic filtered response is a filtered response whose type is "basic"
+    // and header list excludes any headers in internal response’s header list
+    // whose name is a forbidden response-header name.
+
+    // Note: undici does not implement forbidden response-header names
+    return makeFilteredResponse(response, {
+      type: 'basic',
+      headersList: response.headersList
+    })
+  } else if (type === 'cors') {
+    // A CORS filtered response is a filtered response whose type is "cors"
+    // and header list excludes any headers in internal response’s header
+    // list whose name is not a CORS-safelisted response-header name, given
+    // internal response’s CORS-exposed header-name list.
+
+    // Note: undici does not implement CORS-safelisted response-header names
+    return makeFilteredResponse(response, {
+      type: 'cors',
+      headersList: response.headersList
+    })
+  } else if (type === 'opaque') {
+    // An opaque filtered response is a filtered response whose type is
+    // "opaque", URL list is the empty list, status is 0, status message
+    // is the empty byte sequence, header list is empty, and body is null.
+
+    return makeFilteredResponse(response, {
+      type: 'opaque',
+      urlList: Object.freeze([]),
+      status: 0,
+      statusText: '',
+      body: null
+    })
+  } else if (type === 'opaqueredirect') {
+    // An opaque-redirect filtered response is a filtered response whose type
+    // is "opaqueredirect", status is 0, status message is the empty byte
+    // sequence, header list is empty, and body is null.
+
+    return makeFilteredResponse(response, {
+      type: 'opaqueredirect',
+      status: 0,
+      statusText: '',
+      headersList: [],
+      body: null
+    })
+  } else {
+    assert(false)
+  }
+}
+
+// https://fetch.spec.whatwg.org/#appropriate-network-error
+function makeAppropriateNetworkError (fetchParams, err = null) {
+  // 1. Assert: fetchParams is canceled.
+  assert(isCancelled(fetchParams))
+
+  // 2. Return an aborted network error if fetchParams is aborted;
+  // otherwise return a network error.
+  return isAborted(fetchParams)
+    ? makeNetworkError(Object.assign(new DOMException('The operation was aborted.', 'AbortError'), { cause: err }))
+    : makeNetworkError(Object.assign(new DOMException('Request was cancelled.'), { cause: err }))
+}
+
+// https://whatpr.org/fetch/1392.html#initialize-a-response
+function initializeResponse (response, init, body) {
+  // 1. If init["status"] is not in the range 200 to 599, inclusive, then
+  //    throw a RangeError.
+  if (init.status !== null && (init.status < 200 || init.status > 599)) {
+    throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.')
+  }
+
+  // 2. If init["statusText"] does not match the reason-phrase token production,
+  //    then throw a TypeError.
+  if ('statusText' in init && init.statusText != null) {
+    // See, https://datatracker.ietf.org/doc/html/rfc7230#section-3.1.2:
+    //   reason-phrase  = *( HTAB / SP / VCHAR / obs-text )
+    if (!isValidReasonPhrase(String(init.statusText))) {
+      throw new TypeError('Invalid statusText')
+    }
+  }
+
+  // 3. Set response’s response’s status to init["status"].
+  if ('status' in init && init.status != null) {
+    response[kState].status = init.status
+  }
+
+  // 4. Set response’s response’s status message to init["statusText"].
+  if ('statusText' in init && init.statusText != null) {
+    response[kState].statusText = init.statusText
+  }
+
+  // 5. If init["headers"] exists, then fill response’s headers with init["headers"].
+  if ('headers' in init && init.headers != null) {
+    fill(response[kHeaders], init.headers)
+  }
+
+  // 6. If body was given, then:
+  if (body) {
+    // 1. If response's status is a null body status, then throw a TypeError.
+    if (nullBodyStatus.includes(response.status)) {
+      throw webidl.errors.exception({
+        header: 'Response constructor',
+        message: `Invalid response status code ${response.status}`
+      })
+    }
+
+    // 2. Set response's body to body's body.
+    response[kState].body = body.body
+
+    // 3. If body's type is non-null and response's header list does not contain
+    //    `Content-Type`, then append (`Content-Type`, body's type) to response's header list.
+    if (body.type != null && !response[kState].headersList.contains('content-type', true)) {
+      response[kState].headersList.append('content-type', body.type, true)
+    }
+  }
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#response-create
+ * @param {any} innerResponse
+ * @param {'request' | 'immutable' | 'request-no-cors' | 'response' | 'none'} guard
+ * @returns {Response}
+ */
+function fromInnerResponse (innerResponse, guard) {
+  const response = new Response(kConstruct)
+  response[kState] = innerResponse
+  response[kHeaders] = new Headers(kConstruct)
+  setHeadersList(response[kHeaders], innerResponse.headersList)
+  setHeadersGuard(response[kHeaders], guard)
+
+  if (hasFinalizationRegistry && innerResponse.body?.stream) {
+    // If the target (response) is reclaimed, the cleanup callback may be called at some point with
+    // the held value provided for it (innerResponse.body.stream). The held value can be any value:
+    // a primitive or an object, even undefined. If the held value is an object, the registry keeps
+    // a strong reference to it (so it can pass it to the cleanup callback later). Reworded from
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
+    streamRegistry.register(response, new WeakRef(innerResponse.body.stream))
+  }
+
+  return response
+}
+
+webidl.converters.ReadableStream = webidl.interfaceConverter(
+  ReadableStream
+)
+
+webidl.converters.FormData = webidl.interfaceConverter(
+  FormData
+)
+
+webidl.converters.URLSearchParams = webidl.interfaceConverter(
+  URLSearchParams
+)
+
+// https://fetch.spec.whatwg.org/#typedefdef-xmlhttprequestbodyinit
+webidl.converters.XMLHttpRequestBodyInit = function (V, prefix, name) {
+  if (typeof V === 'string') {
+    return webidl.converters.USVString(V, prefix, name)
+  }
+
+  if (isBlobLike(V)) {
+    return webidl.converters.Blob(V, prefix, name, { strict: false })
+  }
+
+  if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
+    return webidl.converters.BufferSource(V, prefix, name)
+  }
+
+  if (util.isFormDataLike(V)) {
+    return webidl.converters.FormData(V, prefix, name, { strict: false })
+  }
+
+  if (V instanceof URLSearchParams) {
+    return webidl.converters.URLSearchParams(V, prefix, name)
+  }
+
+  return webidl.converters.DOMString(V, prefix, name)
+}
+
+// https://fetch.spec.whatwg.org/#bodyinit
+webidl.converters.BodyInit = function (V, prefix, argument) {
+  if (V instanceof ReadableStream) {
+    return webidl.converters.ReadableStream(V, prefix, argument)
+  }
+
+  // Note: the spec doesn't include async iterables,
+  // this is an undici extension.
+  if (V?.[Symbol.asyncIterator]) {
+    return V
+  }
+
+  return webidl.converters.XMLHttpRequestBodyInit(V, prefix, argument)
+}
+
+webidl.converters.ResponseInit = webidl.dictionaryConverter([
+  {
+    key: 'status',
+    converter: webidl.converters['unsigned short'],
+    defaultValue: () => 200
+  },
+  {
+    key: 'statusText',
+    converter: webidl.converters.ByteString,
+    defaultValue: () => ''
+  },
+  {
+    key: 'headers',
+    converter: webidl.converters.HeadersInit
+  }
+])
+
+module.exports = {
+  isNetworkError,
+  makeNetworkError,
+  makeResponse,
+  makeAppropriateNetworkError,
+  filterResponse,
+  Response,
+  cloneResponse,
+  fromInnerResponse
+}
+
+
+/***/ }),
+
+/***/ 78172:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = {
+  kUrl: Symbol('url'),
+  kHeaders: Symbol('headers'),
+  kSignal: Symbol('signal'),
+  kState: Symbol('state'),
+  kDispatcher: Symbol('dispatcher')
+}
+
+
+/***/ }),
+
+/***/ 91976:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Transform } = __nccwpck_require__(84492)
+const zlib = __nccwpck_require__(65628)
+const { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = __nccwpck_require__(87979)
+const { getGlobalOrigin } = __nccwpck_require__(71332)
+const { collectASequenceOfCodePoints, collectAnHTTPQuotedString, removeChars, parseMIMEType } = __nccwpck_require__(86954)
+const { performance } = __nccwpck_require__(38846)
+const { isBlobLike, ReadableStreamFrom, isValidHTTPToken, normalizedMethodRecordsBase } = __nccwpck_require__(94407)
+const assert = __nccwpck_require__(98061)
+const { isUint8Array } = __nccwpck_require__(93746)
+const { webidl } = __nccwpck_require__(37829)
+
+let supportedHashes = []
+
+// https://nodejs.org/api/crypto.html#determining-if-crypto-support-is-unavailable
+/** @type {import('crypto')} */
+let crypto
+try {
+  crypto = __nccwpck_require__(6005)
+  const possibleRelevantHashes = ['sha256', 'sha384', 'sha512']
+  supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash))
+/* c8 ignore next 3 */
+} catch {
+
+}
+
+function responseURL (response) {
+  // https://fetch.spec.whatwg.org/#responses
+  // A response has an associated URL. It is a pointer to the last URL
+  // in response’s URL list and null if response’s URL list is empty.
+  const urlList = response.urlList
+  const length = urlList.length
+  return length === 0 ? null : urlList[length - 1].toString()
+}
+
+// https://fetch.spec.whatwg.org/#concept-response-location-url
+function responseLocationURL (response, requestFragment) {
+  // 1. If response’s status is not a redirect status, then return null.
+  if (!redirectStatusSet.has(response.status)) {
+    return null
+  }
+
+  // 2. Let location be the result of extracting header list values given
+  // `Location` and response’s header list.
+  let location = response.headersList.get('location', true)
+
+  // 3. If location is a header value, then set location to the result of
+  //    parsing location with response’s URL.
+  if (location !== null && isValidHeaderValue(location)) {
+    if (!isValidEncodedURL(location)) {
+      // Some websites respond location header in UTF-8 form without encoding them as ASCII
+      // and major browsers redirect them to correctly UTF-8 encoded addresses.
+      // Here, we handle that behavior in the same way.
+      location = normalizeBinaryStringToUtf8(location)
+    }
+    location = new URL(location, responseURL(response))
+  }
+
+  // 4. If location is a URL whose fragment is null, then set location’s
+  // fragment to requestFragment.
+  if (location && !location.hash) {
+    location.hash = requestFragment
+  }
+
+  // 5. Return location.
+  return location
+}
+
+/**
+ * @see https://www.rfc-editor.org/rfc/rfc1738#section-2.2
+ * @param {string} url
+ * @returns {boolean}
+ */
+function isValidEncodedURL (url) {
+  for (let i = 0; i < url.length; ++i) {
+    const code = url.charCodeAt(i)
+
+    if (
+      code > 0x7E || // Non-US-ASCII + DEL
+      code < 0x20 // Control characters NUL - US
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * If string contains non-ASCII characters, assumes it's UTF-8 encoded and decodes it.
+ * Since UTF-8 is a superset of ASCII, this will work for ASCII strings as well.
+ * @param {string} value
+ * @returns {string}
+ */
+function normalizeBinaryStringToUtf8 (value) {
+  return Buffer.from(value, 'binary').toString('utf8')
+}
+
+/** @returns {URL} */
+function requestCurrentURL (request) {
+  return request.urlList[request.urlList.length - 1]
+}
+
+function requestBadPort (request) {
+  // 1. Let url be request’s current URL.
+  const url = requestCurrentURL(request)
+
+  // 2. If url’s scheme is an HTTP(S) scheme and url’s port is a bad port,
+  // then return blocked.
+  if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) {
+    return 'blocked'
+  }
+
+  // 3. Return allowed.
+  return 'allowed'
+}
+
+function isErrorLike (object) {
+  return object instanceof Error || (
+    object?.constructor?.name === 'Error' ||
+    object?.constructor?.name === 'DOMException'
+  )
+}
+
+// Check whether |statusText| is a ByteString and
+// matches the Reason-Phrase token production.
+// RFC 2616: https://tools.ietf.org/html/rfc2616
+// RFC 7230: https://tools.ietf.org/html/rfc7230
+// "reason-phrase = *( HTAB / SP / VCHAR / obs-text )"
+// https://github.com/chromium/chromium/blob/94.0.4604.1/third_party/blink/renderer/core/fetch/response.cc#L116
+function isValidReasonPhrase (statusText) {
+  for (let i = 0; i < statusText.length; ++i) {
+    const c = statusText.charCodeAt(i)
+    if (
+      !(
+        (
+          c === 0x09 || // HTAB
+          (c >= 0x20 && c <= 0x7e) || // SP / VCHAR
+          (c >= 0x80 && c <= 0xff)
+        ) // obs-text
+      )
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#header-name
+ * @param {string} potentialValue
+ */
+const isValidHeaderName = isValidHTTPToken
+
+/**
+ * @see https://fetch.spec.whatwg.org/#header-value
+ * @param {string} potentialValue
+ */
+function isValidHeaderValue (potentialValue) {
+  // - Has no leading or trailing HTTP tab or space bytes.
+  // - Contains no 0x00 (NUL) or HTTP newline bytes.
+  return (
+    potentialValue[0] === '\t' ||
+    potentialValue[0] === ' ' ||
+    potentialValue[potentialValue.length - 1] === '\t' ||
+    potentialValue[potentialValue.length - 1] === ' ' ||
+    potentialValue.includes('\n') ||
+    potentialValue.includes('\r') ||
+    potentialValue.includes('\0')
+  ) === false
+}
+
+// https://w3c.github.io/webappsec-referrer-policy/#set-requests-referrer-policy-on-redirect
+function setRequestReferrerPolicyOnRedirect (request, actualResponse) {
+  //  Given a request request and a response actualResponse, this algorithm
+  //  updates request’s referrer policy according to the Referrer-Policy
+  //  header (if any) in actualResponse.
+
+  // 1. Let policy be the result of executing § 8.1 Parse a referrer policy
+  // from a Referrer-Policy header on actualResponse.
+
+  // 8.1 Parse a referrer policy from a Referrer-Policy header
+  // 1. Let policy-tokens be the result of extracting header list values given `Referrer-Policy` and response’s header list.
+  const { headersList } = actualResponse
+  // 2. Let policy be the empty string.
+  // 3. For each token in policy-tokens, if token is a referrer policy and token is not the empty string, then set policy to token.
+  // 4. Return policy.
+  const policyHeader = (headersList.get('referrer-policy', true) ?? '').split(',')
+
+  // Note: As the referrer-policy can contain multiple policies
+  // separated by comma, we need to loop through all of them
+  // and pick the first valid one.
+  // Ref: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy#specify_a_fallback_policy
+  let policy = ''
+  if (policyHeader.length > 0) {
+    // The right-most policy takes precedence.
+    // The left-most policy is the fallback.
+    for (let i = policyHeader.length; i !== 0; i--) {
+      const token = policyHeader[i - 1].trim()
+      if (referrerPolicyTokens.has(token)) {
+        policy = token
+        break
+      }
+    }
+  }
+
+  // 2. If policy is not the empty string, then set request’s referrer policy to policy.
+  if (policy !== '') {
+    request.referrerPolicy = policy
+  }
+}
+
+// https://fetch.spec.whatwg.org/#cross-origin-resource-policy-check
+function crossOriginResourcePolicyCheck () {
+  // TODO
+  return 'allowed'
+}
+
+// https://fetch.spec.whatwg.org/#concept-cors-check
+function corsCheck () {
+  // TODO
+  return 'success'
+}
+
+// https://fetch.spec.whatwg.org/#concept-tao-check
+function TAOCheck () {
+  // TODO
+  return 'success'
+}
+
+function appendFetchMetadata (httpRequest) {
+  //  https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-dest-header
+  //  TODO
+
+  //  https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-mode-header
+
+  //  1. Assert: r’s url is a potentially trustworthy URL.
+  //  TODO
+
+  //  2. Let header be a Structured Header whose value is a token.
+  let header = null
+
+  //  3. Set header’s value to r’s mode.
+  header = httpRequest.mode
+
+  //  4. Set a structured field value `Sec-Fetch-Mode`/header in r’s header list.
+  httpRequest.headersList.set('sec-fetch-mode', header, true)
+
+  //  https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-site-header
+  //  TODO
+
+  //  https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-user-header
+  //  TODO
+}
+
+// https://fetch.spec.whatwg.org/#append-a-request-origin-header
+function appendRequestOriginHeader (request) {
+  // 1. Let serializedOrigin be the result of byte-serializing a request origin
+  //    with request.
+  // TODO: implement "byte-serializing a request origin"
+  let serializedOrigin = request.origin
+
+  // - "'client' is changed to an origin during fetching."
+  //   This doesn't happen in undici (in most cases) because undici, by default,
+  //   has no concept of origin.
+  // - request.origin can also be set to request.client.origin (client being
+  //   an environment settings object), which is undefined without using
+  //   setGlobalOrigin.
+  if (serializedOrigin === 'client' || serializedOrigin === undefined) {
+    return
+  }
+
+  // 2. If request’s response tainting is "cors" or request’s mode is "websocket",
+  //    then append (`Origin`, serializedOrigin) to request’s header list.
+  // 3. Otherwise, if request’s method is neither `GET` nor `HEAD`, then:
+  if (request.responseTainting === 'cors' || request.mode === 'websocket') {
+    request.headersList.append('origin', serializedOrigin, true)
+  } else if (request.method !== 'GET' && request.method !== 'HEAD') {
+    // 1. Switch on request’s referrer policy:
+    switch (request.referrerPolicy) {
+      case 'no-referrer':
+        // Set serializedOrigin to `null`.
+        serializedOrigin = null
+        break
+      case 'no-referrer-when-downgrade':
+      case 'strict-origin':
+      case 'strict-origin-when-cross-origin':
+        // If request’s origin is a tuple origin, its scheme is "https", and
+        // request’s current URL’s scheme is not "https", then set
+        // serializedOrigin to `null`.
+        if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) {
+          serializedOrigin = null
+        }
+        break
+      case 'same-origin':
+        // If request’s origin is not same origin with request’s current URL’s
+        // origin, then set serializedOrigin to `null`.
+        if (!sameOrigin(request, requestCurrentURL(request))) {
+          serializedOrigin = null
+        }
+        break
+      default:
+        // Do nothing.
+    }
+
+    // 2. Append (`Origin`, serializedOrigin) to request’s header list.
+    request.headersList.append('origin', serializedOrigin, true)
+  }
+}
+
+// https://w3c.github.io/hr-time/#dfn-coarsen-time
+function coarsenTime (timestamp, crossOriginIsolatedCapability) {
+  // TODO
+  return timestamp
+}
+
+// https://fetch.spec.whatwg.org/#clamp-and-coarsen-connection-timing-info
+function clampAndCoarsenConnectionTimingInfo (connectionTimingInfo, defaultStartTime, crossOriginIsolatedCapability) {
+  if (!connectionTimingInfo?.startTime || connectionTimingInfo.startTime < defaultStartTime) {
+    return {
+      domainLookupStartTime: defaultStartTime,
+      domainLookupEndTime: defaultStartTime,
+      connectionStartTime: defaultStartTime,
+      connectionEndTime: defaultStartTime,
+      secureConnectionStartTime: defaultStartTime,
+      ALPNNegotiatedProtocol: connectionTimingInfo?.ALPNNegotiatedProtocol
+    }
+  }
+
+  return {
+    domainLookupStartTime: coarsenTime(connectionTimingInfo.domainLookupStartTime, crossOriginIsolatedCapability),
+    domainLookupEndTime: coarsenTime(connectionTimingInfo.domainLookupEndTime, crossOriginIsolatedCapability),
+    connectionStartTime: coarsenTime(connectionTimingInfo.connectionStartTime, crossOriginIsolatedCapability),
+    connectionEndTime: coarsenTime(connectionTimingInfo.connectionEndTime, crossOriginIsolatedCapability),
+    secureConnectionStartTime: coarsenTime(connectionTimingInfo.secureConnectionStartTime, crossOriginIsolatedCapability),
+    ALPNNegotiatedProtocol: connectionTimingInfo.ALPNNegotiatedProtocol
+  }
+}
+
+// https://w3c.github.io/hr-time/#dfn-coarsened-shared-current-time
+function coarsenedSharedCurrentTime (crossOriginIsolatedCapability) {
+  return coarsenTime(performance.now(), crossOriginIsolatedCapability)
+}
+
+// https://fetch.spec.whatwg.org/#create-an-opaque-timing-info
+function createOpaqueTimingInfo (timingInfo) {
+  return {
+    startTime: timingInfo.startTime ?? 0,
+    redirectStartTime: 0,
+    redirectEndTime: 0,
+    postRedirectStartTime: timingInfo.startTime ?? 0,
+    finalServiceWorkerStartTime: 0,
+    finalNetworkResponseStartTime: 0,
+    finalNetworkRequestStartTime: 0,
+    endTime: 0,
+    encodedBodySize: 0,
+    decodedBodySize: 0,
+    finalConnectionTimingInfo: null
+  }
+}
+
+// https://html.spec.whatwg.org/multipage/origin.html#policy-container
+function makePolicyContainer () {
+  // Note: the fetch spec doesn't make use of embedder policy or CSP list
+  return {
+    referrerPolicy: 'strict-origin-when-cross-origin'
+  }
+}
+
+// https://html.spec.whatwg.org/multipage/origin.html#clone-a-policy-container
+function clonePolicyContainer (policyContainer) {
+  return {
+    referrerPolicy: policyContainer.referrerPolicy
+  }
+}
+
+// https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer
+function determineRequestsReferrer (request) {
+  // 1. Let policy be request's referrer policy.
+  const policy = request.referrerPolicy
+
+  // Note: policy cannot (shouldn't) be null or an empty string.
+  assert(policy)
+
+  // 2. Let environment be request’s client.
+
+  let referrerSource = null
+
+  // 3. Switch on request’s referrer:
+  if (request.referrer === 'client') {
+    // Note: node isn't a browser and doesn't implement document/iframes,
+    // so we bypass this step and replace it with our own.
+
+    const globalOrigin = getGlobalOrigin()
+
+    if (!globalOrigin || globalOrigin.origin === 'null') {
+      return 'no-referrer'
+    }
+
+    // note: we need to clone it as it's mutated
+    referrerSource = new URL(globalOrigin)
+  } else if (request.referrer instanceof URL) {
+    // Let referrerSource be request’s referrer.
+    referrerSource = request.referrer
+  }
+
+  // 4. Let request’s referrerURL be the result of stripping referrerSource for
+  //    use as a referrer.
+  let referrerURL = stripURLForReferrer(referrerSource)
+
+  // 5. Let referrerOrigin be the result of stripping referrerSource for use as
+  //    a referrer, with the origin-only flag set to true.
+  const referrerOrigin = stripURLForReferrer(referrerSource, true)
+
+  // 6. If the result of serializing referrerURL is a string whose length is
+  //    greater than 4096, set referrerURL to referrerOrigin.
+  if (referrerURL.toString().length > 4096) {
+    referrerURL = referrerOrigin
+  }
+
+  const areSameOrigin = sameOrigin(request, referrerURL)
+  const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) &&
+    !isURLPotentiallyTrustworthy(request.url)
+
+  // 8. Execute the switch statements corresponding to the value of policy:
+  switch (policy) {
+    case 'origin': return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true)
+    case 'unsafe-url': return referrerURL
+    case 'same-origin':
+      return areSameOrigin ? referrerOrigin : 'no-referrer'
+    case 'origin-when-cross-origin':
+      return areSameOrigin ? referrerURL : referrerOrigin
+    case 'strict-origin-when-cross-origin': {
+      const currentURL = requestCurrentURL(request)
+
+      // 1. If the origin of referrerURL and the origin of request’s current
+      //    URL are the same, then return referrerURL.
+      if (sameOrigin(referrerURL, currentURL)) {
+        return referrerURL
+      }
+
+      // 2. If referrerURL is a potentially trustworthy URL and request’s
+      //    current URL is not a potentially trustworthy URL, then return no
+      //    referrer.
+      if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
+        return 'no-referrer'
+      }
+
+      // 3. Return referrerOrigin.
+      return referrerOrigin
+    }
+    case 'strict-origin': // eslint-disable-line
+      /**
+         * 1. If referrerURL is a potentially trustworthy URL and
+         * request’s current URL is not a potentially trustworthy URL,
+         * then return no referrer.
+         * 2. Return referrerOrigin
+        */
+    case 'no-referrer-when-downgrade': // eslint-disable-line
+      /**
+       * 1. If referrerURL is a potentially trustworthy URL and
+       * request’s current URL is not a potentially trustworthy URL,
+       * then return no referrer.
+       * 2. Return referrerOrigin
+      */
+
+    default: // eslint-disable-line
+      return isNonPotentiallyTrustWorthy ? 'no-referrer' : referrerOrigin
+  }
+}
+
+/**
+ * @see https://w3c.github.io/webappsec-referrer-policy/#strip-url
+ * @param {URL} url
+ * @param {boolean|undefined} originOnly
+ */
+function stripURLForReferrer (url, originOnly) {
+  // 1. Assert: url is a URL.
+  assert(url instanceof URL)
+
+  url = new URL(url)
+
+  // 2. If url’s scheme is a local scheme, then return no referrer.
+  if (url.protocol === 'file:' || url.protocol === 'about:' || url.protocol === 'blank:') {
+    return 'no-referrer'
+  }
+
+  // 3. Set url’s username to the empty string.
+  url.username = ''
+
+  // 4. Set url’s password to the empty string.
+  url.password = ''
+
+  // 5. Set url’s fragment to null.
+  url.hash = ''
+
+  // 6. If the origin-only flag is true, then:
+  if (originOnly) {
+    // 1. Set url’s path to « the empty string ».
+    url.pathname = ''
+
+    // 2. Set url’s query to null.
+    url.search = ''
+  }
+
+  // 7. Return url.
+  return url
+}
+
+function isURLPotentiallyTrustworthy (url) {
+  if (!(url instanceof URL)) {
+    return false
+  }
+
+  // If child of about, return true
+  if (url.href === 'about:blank' || url.href === 'about:srcdoc') {
+    return true
+  }
+
+  // If scheme is data, return true
+  if (url.protocol === 'data:') return true
+
+  // If file, return true
+  if (url.protocol === 'file:') return true
+
+  return isOriginPotentiallyTrustworthy(url.origin)
+
+  function isOriginPotentiallyTrustworthy (origin) {
+    // If origin is explicitly null, return false
+    if (origin == null || origin === 'null') return false
+
+    const originAsURL = new URL(origin)
+
+    // If secure, return true
+    if (originAsURL.protocol === 'https:' || originAsURL.protocol === 'wss:') {
+      return true
+    }
+
+    // If localhost or variants, return true
+    if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) ||
+     (originAsURL.hostname === 'localhost' || originAsURL.hostname.includes('localhost.')) ||
+     (originAsURL.hostname.endsWith('.localhost'))) {
+      return true
+    }
+
+    // If any other, return false
+    return false
+  }
+}
+
+/**
+ * @see https://w3c.github.io/webappsec-subresource-integrity/#does-response-match-metadatalist
+ * @param {Uint8Array} bytes
+ * @param {string} metadataList
+ */
+function bytesMatch (bytes, metadataList) {
+  // If node is not built with OpenSSL support, we cannot check
+  // a request's integrity, so allow it by default (the spec will
+  // allow requests if an invalid hash is given, as precedence).
+  /* istanbul ignore if: only if node is built with --without-ssl */
+  if (crypto === undefined) {
+    return true
+  }
+
+  // 1. Let parsedMetadata be the result of parsing metadataList.
+  const parsedMetadata = parseMetadata(metadataList)
+
+  // 2. If parsedMetadata is no metadata, return true.
+  if (parsedMetadata === 'no metadata') {
+    return true
+  }
+
+  // 3. If response is not eligible for integrity validation, return false.
+  // TODO
+
+  // 4. If parsedMetadata is the empty set, return true.
+  if (parsedMetadata.length === 0) {
+    return true
+  }
+
+  // 5. Let metadata be the result of getting the strongest
+  //    metadata from parsedMetadata.
+  const strongest = getStrongestMetadata(parsedMetadata)
+  const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest)
+
+  // 6. For each item in metadata:
+  for (const item of metadata) {
+    // 1. Let algorithm be the alg component of item.
+    const algorithm = item.algo
+
+    // 2. Let expectedValue be the val component of item.
+    const expectedValue = item.hash
+
+    // See https://github.com/web-platform-tests/wpt/commit/e4c5cc7a5e48093220528dfdd1c4012dc3837a0e
+    // "be liberal with padding". This is annoying, and it's not even in the spec.
+
+    // 3. Let actualValue be the result of applying algorithm to bytes.
+    let actualValue = crypto.createHash(algorithm).update(bytes).digest('base64')
+
+    if (actualValue[actualValue.length - 1] === '=') {
+      if (actualValue[actualValue.length - 2] === '=') {
+        actualValue = actualValue.slice(0, -2)
+      } else {
+        actualValue = actualValue.slice(0, -1)
+      }
+    }
+
+    // 4. If actualValue is a case-sensitive match for expectedValue,
+    //    return true.
+    if (compareBase64Mixed(actualValue, expectedValue)) {
+      return true
+    }
+  }
+
+  // 7. Return false.
+  return false
+}
+
+// https://w3c.github.io/webappsec-subresource-integrity/#grammardef-hash-with-options
+// https://www.w3.org/TR/CSP2/#source-list-syntax
+// https://www.rfc-editor.org/rfc/rfc5234#appendix-B.1
+const parseHashWithOptions = /(?<algo>sha256|sha384|sha512)-((?<hash>[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i
+
+/**
+ * @see https://w3c.github.io/webappsec-subresource-integrity/#parse-metadata
+ * @param {string} metadata
+ */
+function parseMetadata (metadata) {
+  // 1. Let result be the empty set.
+  /** @type {{ algo: string, hash: string }[]} */
+  const result = []
+
+  // 2. Let empty be equal to true.
+  let empty = true
+
+  // 3. For each token returned by splitting metadata on spaces:
+  for (const token of metadata.split(' ')) {
+    // 1. Set empty to false.
+    empty = false
+
+    // 2. Parse token as a hash-with-options.
+    const parsedToken = parseHashWithOptions.exec(token)
+
+    // 3. If token does not parse, continue to the next token.
+    if (
+      parsedToken === null ||
+      parsedToken.groups === undefined ||
+      parsedToken.groups.algo === undefined
+    ) {
+      // Note: Chromium blocks the request at this point, but Firefox
+      // gives a warning that an invalid integrity was given. The
+      // correct behavior is to ignore these, and subsequently not
+      // check the integrity of the resource.
+      continue
+    }
+
+    // 4. Let algorithm be the hash-algo component of token.
+    const algorithm = parsedToken.groups.algo.toLowerCase()
+
+    // 5. If algorithm is a hash function recognized by the user
+    //    agent, add the parsed token to result.
+    if (supportedHashes.includes(algorithm)) {
+      result.push(parsedToken.groups)
+    }
+  }
+
+  // 4. Return no metadata if empty is true, otherwise return result.
+  if (empty === true) {
+    return 'no metadata'
+  }
+
+  return result
+}
+
+/**
+ * @param {{ algo: 'sha256' | 'sha384' | 'sha512' }[]} metadataList
+ */
+function getStrongestMetadata (metadataList) {
+  // Let algorithm be the algo component of the first item in metadataList.
+  // Can be sha256
+  let algorithm = metadataList[0].algo
+  // If the algorithm is sha512, then it is the strongest
+  // and we can return immediately
+  if (algorithm[3] === '5') {
+    return algorithm
+  }
+
+  for (let i = 1; i < metadataList.length; ++i) {
+    const metadata = metadataList[i]
+    // If the algorithm is sha512, then it is the strongest
+    // and we can break the loop immediately
+    if (metadata.algo[3] === '5') {
+      algorithm = 'sha512'
+      break
+    // If the algorithm is sha384, then a potential sha256 or sha384 is ignored
+    } else if (algorithm[3] === '3') {
+      continue
+    // algorithm is sha256, check if algorithm is sha384 and if so, set it as
+    // the strongest
+    } else if (metadata.algo[3] === '3') {
+      algorithm = 'sha384'
+    }
+  }
+  return algorithm
+}
+
+function filterMetadataListByAlgorithm (metadataList, algorithm) {
+  if (metadataList.length === 1) {
+    return metadataList
+  }
+
+  let pos = 0
+  for (let i = 0; i < metadataList.length; ++i) {
+    if (metadataList[i].algo === algorithm) {
+      metadataList[pos++] = metadataList[i]
+    }
+  }
+
+  metadataList.length = pos
+
+  return metadataList
+}
+
+/**
+ * Compares two base64 strings, allowing for base64url
+ * in the second string.
+ *
+* @param {string} actualValue always base64
+ * @param {string} expectedValue base64 or base64url
+ * @returns {boolean}
+ */
+function compareBase64Mixed (actualValue, expectedValue) {
+  if (actualValue.length !== expectedValue.length) {
+    return false
+  }
+  for (let i = 0; i < actualValue.length; ++i) {
+    if (actualValue[i] !== expectedValue[i]) {
+      if (
+        (actualValue[i] === '+' && expectedValue[i] === '-') ||
+        (actualValue[i] === '/' && expectedValue[i] === '_')
+      ) {
+        continue
+      }
+      return false
+    }
+  }
+
+  return true
+}
+
+// https://w3c.github.io/webappsec-upgrade-insecure-requests/#upgrade-request
+function tryUpgradeRequestToAPotentiallyTrustworthyURL (request) {
+  // TODO
+}
+
+/**
+ * @link {https://html.spec.whatwg.org/multipage/origin.html#same-origin}
+ * @param {URL} A
+ * @param {URL} B
+ */
+function sameOrigin (A, B) {
+  // 1. If A and B are the same opaque origin, then return true.
+  if (A.origin === B.origin && A.origin === 'null') {
+    return true
+  }
+
+  // 2. If A and B are both tuple origins and their schemes,
+  //    hosts, and port are identical, then return true.
+  if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) {
+    return true
+  }
+
+  // 3. Return false.
+  return false
+}
+
+function createDeferredPromise () {
+  let res
+  let rej
+  const promise = new Promise((resolve, reject) => {
+    res = resolve
+    rej = reject
+  })
+
+  return { promise, resolve: res, reject: rej }
+}
+
+function isAborted (fetchParams) {
+  return fetchParams.controller.state === 'aborted'
+}
+
+function isCancelled (fetchParams) {
+  return fetchParams.controller.state === 'aborted' ||
+    fetchParams.controller.state === 'terminated'
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-method-normalize
+ * @param {string} method
+ */
+function normalizeMethod (method) {
+  return normalizedMethodRecordsBase[method.toLowerCase()] ?? method
+}
+
+// https://infra.spec.whatwg.org/#serialize-a-javascript-value-to-a-json-string
+function serializeJavascriptValueToJSONString (value) {
+  // 1. Let result be ? Call(%JSON.stringify%, undefined, « value »).
+  const result = JSON.stringify(value)
+
+  // 2. If result is undefined, then throw a TypeError.
+  if (result === undefined) {
+    throw new TypeError('Value is not JSON serializable')
+  }
+
+  // 3. Assert: result is a string.
+  assert(typeof result === 'string')
+
+  // 4. Return result.
+  return result
+}
+
+// https://tc39.es/ecma262/#sec-%25iteratorprototype%25-object
+const esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))
+
+/**
+ * @see https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
+ * @param {string} name name of the instance
+ * @param {symbol} kInternalIterator
+ * @param {string | number} [keyIndex]
+ * @param {string | number} [valueIndex]
+ */
+function createIterator (name, kInternalIterator, keyIndex = 0, valueIndex = 1) {
+  class FastIterableIterator {
+    /** @type {any} */
+    #target
+    /** @type {'key' | 'value' | 'key+value'} */
+    #kind
+    /** @type {number} */
+    #index
+
+    /**
+     * @see https://webidl.spec.whatwg.org/#dfn-default-iterator-object
+     * @param {unknown} target
+     * @param {'key' | 'value' | 'key+value'} kind
+     */
+    constructor (target, kind) {
+      this.#target = target
+      this.#kind = kind
+      this.#index = 0
+    }
+
+    next () {
+      // 1. Let interface be the interface for which the iterator prototype object exists.
+      // 2. Let thisValue be the this value.
+      // 3. Let object be ? ToObject(thisValue).
+      // 4. If object is a platform object, then perform a security
+      //    check, passing:
+      // 5. If object is not a default iterator object for interface,
+      //    then throw a TypeError.
+      if (typeof this !== 'object' || this === null || !(#target in this)) {
+        throw new TypeError(
+          `'next' called on an object that does not implement interface ${name} Iterator.`
+        )
+      }
+
+      // 6. Let index be object’s index.
+      // 7. Let kind be object’s kind.
+      // 8. Let values be object’s target's value pairs to iterate over.
+      const index = this.#index
+      const values = this.#target[kInternalIterator]
+
+      // 9. Let len be the length of values.
+      const len = values.length
+
+      // 10. If index is greater than or equal to len, then return
+      //     CreateIterResultObject(undefined, true).
+      if (index >= len) {
+        return {
+          value: undefined,
+          done: true
+        }
+      }
+
+      // 11. Let pair be the entry in values at index index.
+      const { [keyIndex]: key, [valueIndex]: value } = values[index]
+
+      // 12. Set object’s index to index + 1.
+      this.#index = index + 1
+
+      // 13. Return the iterator result for pair and kind.
+
+      // https://webidl.spec.whatwg.org/#iterator-result
+
+      // 1. Let result be a value determined by the value of kind:
+      let result
+      switch (this.#kind) {
+        case 'key':
+          // 1. Let idlKey be pair’s key.
+          // 2. Let key be the result of converting idlKey to an
+          //    ECMAScript value.
+          // 3. result is key.
+          result = key
+          break
+        case 'value':
+          // 1. Let idlValue be pair’s value.
+          // 2. Let value be the result of converting idlValue to
+          //    an ECMAScript value.
+          // 3. result is value.
+          result = value
+          break
+        case 'key+value':
+          // 1. Let idlKey be pair’s key.
+          // 2. Let idlValue be pair’s value.
+          // 3. Let key be the result of converting idlKey to an
+          //    ECMAScript value.
+          // 4. Let value be the result of converting idlValue to
+          //    an ECMAScript value.
+          // 5. Let array be ! ArrayCreate(2).
+          // 6. Call ! CreateDataProperty(array, "0", key).
+          // 7. Call ! CreateDataProperty(array, "1", value).
+          // 8. result is array.
+          result = [key, value]
+          break
+      }
+
+      // 2. Return CreateIterResultObject(result, false).
+      return {
+        value: result,
+        done: false
+      }
+    }
+  }
+
+  // https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
+  // @ts-ignore
+  delete FastIterableIterator.prototype.constructor
+
+  Object.setPrototypeOf(FastIterableIterator.prototype, esIteratorPrototype)
+
+  Object.defineProperties(FastIterableIterator.prototype, {
+    [Symbol.toStringTag]: {
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: `${name} Iterator`
+    },
+    next: { writable: true, enumerable: true, configurable: true }
+  })
+
+  /**
+   * @param {unknown} target
+   * @param {'key' | 'value' | 'key+value'} kind
+   * @returns {IterableIterator<any>}
+   */
+  return function (target, kind) {
+    return new FastIterableIterator(target, kind)
+  }
+}
+
+/**
+ * @see https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
+ * @param {string} name name of the instance
+ * @param {any} object class
+ * @param {symbol} kInternalIterator
+ * @param {string | number} [keyIndex]
+ * @param {string | number} [valueIndex]
+ */
+function iteratorMixin (name, object, kInternalIterator, keyIndex = 0, valueIndex = 1) {
+  const makeIterator = createIterator(name, kInternalIterator, keyIndex, valueIndex)
+
+  const properties = {
+    keys: {
+      writable: true,
+      enumerable: true,
+      configurable: true,
+      value: function keys () {
+        webidl.brandCheck(this, object)
+        return makeIterator(this, 'key')
+      }
+    },
+    values: {
+      writable: true,
+      enumerable: true,
+      configurable: true,
+      value: function values () {
+        webidl.brandCheck(this, object)
+        return makeIterator(this, 'value')
+      }
+    },
+    entries: {
+      writable: true,
+      enumerable: true,
+      configurable: true,
+      value: function entries () {
+        webidl.brandCheck(this, object)
+        return makeIterator(this, 'key+value')
+      }
+    },
+    forEach: {
+      writable: true,
+      enumerable: true,
+      configurable: true,
+      value: function forEach (callbackfn, thisArg = globalThis) {
+        webidl.brandCheck(this, object)
+        webidl.argumentLengthCheck(arguments, 1, `${name}.forEach`)
+        if (typeof callbackfn !== 'function') {
+          throw new TypeError(
+            `Failed to execute 'forEach' on '${name}': parameter 1 is not of type 'Function'.`
+          )
+        }
+        for (const { 0: key, 1: value } of makeIterator(this, 'key+value')) {
+          callbackfn.call(thisArg, value, key, this)
+        }
+      }
+    }
+  }
+
+  return Object.defineProperties(object.prototype, {
+    ...properties,
+    [Symbol.iterator]: {
+      writable: true,
+      enumerable: false,
+      configurable: true,
+      value: properties.entries.value
+    }
+  })
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#body-fully-read
+ */
+async function fullyReadBody (body, processBody, processBodyError) {
+  // 1. If taskDestination is null, then set taskDestination to
+  //    the result of starting a new parallel queue.
+
+  // 2. Let successSteps given a byte sequence bytes be to queue a
+  //    fetch task to run processBody given bytes, with taskDestination.
+  const successSteps = processBody
+
+  // 3. Let errorSteps be to queue a fetch task to run processBodyError,
+  //    with taskDestination.
+  const errorSteps = processBodyError
+
+  // 4. Let reader be the result of getting a reader for body’s stream.
+  //    If that threw an exception, then run errorSteps with that
+  //    exception and return.
+  let reader
+
+  try {
+    reader = body.stream.getReader()
+  } catch (e) {
+    errorSteps(e)
+    return
+  }
+
+  // 5. Read all bytes from reader, given successSteps and errorSteps.
+  try {
+    successSteps(await readAllBytes(reader))
+  } catch (e) {
+    errorSteps(e)
+  }
+}
+
+function isReadableStreamLike (stream) {
+  return stream instanceof ReadableStream || (
+    stream[Symbol.toStringTag] === 'ReadableStream' &&
+    typeof stream.tee === 'function'
+  )
+}
+
+/**
+ * @param {ReadableStreamController<Uint8Array>} controller
+ */
+function readableStreamClose (controller) {
+  try {
+    controller.close()
+    controller.byobRequest?.respond(0)
+  } catch (err) {
+    // TODO: add comment explaining why this error occurs.
+    if (!err.message.includes('Controller is already closed') && !err.message.includes('ReadableStream is already closed')) {
+      throw err
+    }
+  }
+}
+
+const invalidIsomorphicEncodeValueRegex = /[^\x00-\xFF]/ // eslint-disable-line
+
+/**
+ * @see https://infra.spec.whatwg.org/#isomorphic-encode
+ * @param {string} input
+ */
+function isomorphicEncode (input) {
+  // 1. Assert: input contains no code points greater than U+00FF.
+  assert(!invalidIsomorphicEncodeValueRegex.test(input))
+
+  // 2. Return a byte sequence whose length is equal to input’s code
+  //    point length and whose bytes have the same values as the
+  //    values of input’s code points, in the same order
+  return input
+}
+
+/**
+ * @see https://streams.spec.whatwg.org/#readablestreamdefaultreader-read-all-bytes
+ * @see https://streams.spec.whatwg.org/#read-loop
+ * @param {ReadableStreamDefaultReader} reader
+ */
+async function readAllBytes (reader) {
+  const bytes = []
+  let byteLength = 0
+
+  while (true) {
+    const { done, value: chunk } = await reader.read()
+
+    if (done) {
+      // 1. Call successSteps with bytes.
+      return Buffer.concat(bytes, byteLength)
+    }
+
+    // 1. If chunk is not a Uint8Array object, call failureSteps
+    //    with a TypeError and abort these steps.
+    if (!isUint8Array(chunk)) {
+      throw new TypeError('Received non-Uint8Array chunk')
+    }
+
+    // 2. Append the bytes represented by chunk to bytes.
+    bytes.push(chunk)
+    byteLength += chunk.length
+
+    // 3. Read-loop given reader, bytes, successSteps, and failureSteps.
+  }
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#is-local
+ * @param {URL} url
+ */
+function urlIsLocal (url) {
+  assert('protocol' in url) // ensure it's a url object
+
+  const protocol = url.protocol
+
+  return protocol === 'about:' || protocol === 'blob:' || protocol === 'data:'
+}
+
+/**
+ * @param {string|URL} url
+ * @returns {boolean}
+ */
+function urlHasHttpsScheme (url) {
+  return (
+    (
+      typeof url === 'string' &&
+      url[5] === ':' &&
+      url[0] === 'h' &&
+      url[1] === 't' &&
+      url[2] === 't' &&
+      url[3] === 'p' &&
+      url[4] === 's'
+    ) ||
+    url.protocol === 'https:'
+  )
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#http-scheme
+ * @param {URL} url
+ */
+function urlIsHttpHttpsScheme (url) {
+  assert('protocol' in url) // ensure it's a url object
+
+  const protocol = url.protocol
+
+  return protocol === 'http:' || protocol === 'https:'
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#simple-range-header-value
+ * @param {string} value
+ * @param {boolean} allowWhitespace
+ */
+function simpleRangeHeaderValue (value, allowWhitespace) {
+  // 1. Let data be the isomorphic decoding of value.
+  // Note: isomorphic decoding takes a sequence of bytes (ie. a Uint8Array) and turns it into a string,
+  // nothing more. We obviously don't need to do that if value is a string already.
+  const data = value
+
+  // 2. If data does not start with "bytes", then return failure.
+  if (!data.startsWith('bytes')) {
+    return 'failure'
+  }
+
+  // 3. Let position be a position variable for data, initially pointing at the 5th code point of data.
+  const position = { position: 5 }
+
+  // 4. If allowWhitespace is true, collect a sequence of code points that are HTTP tab or space,
+  //    from data given position.
+  if (allowWhitespace) {
+    collectASequenceOfCodePoints(
+      (char) => char === '\t' || char === ' ',
+      data,
+      position
+    )
+  }
+
+  // 5. If the code point at position within data is not U+003D (=), then return failure.
+  if (data.charCodeAt(position.position) !== 0x3D) {
+    return 'failure'
+  }
+
+  // 6. Advance position by 1.
+  position.position++
+
+  // 7. If allowWhitespace is true, collect a sequence of code points that are HTTP tab or space, from
+  //    data given position.
+  if (allowWhitespace) {
+    collectASequenceOfCodePoints(
+      (char) => char === '\t' || char === ' ',
+      data,
+      position
+    )
+  }
+
+  // 8. Let rangeStart be the result of collecting a sequence of code points that are ASCII digits,
+  //    from data given position.
+  const rangeStart = collectASequenceOfCodePoints(
+    (char) => {
+      const code = char.charCodeAt(0)
+
+      return code >= 0x30 && code <= 0x39
+    },
+    data,
+    position
+  )
+
+  // 9. Let rangeStartValue be rangeStart, interpreted as decimal number, if rangeStart is not the
+  //    empty string; otherwise null.
+  const rangeStartValue = rangeStart.length ? Number(rangeStart) : null
+
+  // 10. If allowWhitespace is true, collect a sequence of code points that are HTTP tab or space,
+  //     from data given position.
+  if (allowWhitespace) {
+    collectASequenceOfCodePoints(
+      (char) => char === '\t' || char === ' ',
+      data,
+      position
+    )
+  }
+
+  // 11. If the code point at position within data is not U+002D (-), then return failure.
+  if (data.charCodeAt(position.position) !== 0x2D) {
+    return 'failure'
+  }
+
+  // 12. Advance position by 1.
+  position.position++
+
+  // 13. If allowWhitespace is true, collect a sequence of code points that are HTTP tab
+  //     or space, from data given position.
+  // Note from Khafra: its the same step as in #8 again lol
+  if (allowWhitespace) {
+    collectASequenceOfCodePoints(
+      (char) => char === '\t' || char === ' ',
+      data,
+      position
+    )
+  }
+
+  // 14. Let rangeEnd be the result of collecting a sequence of code points that are
+  //     ASCII digits, from data given position.
+  // Note from Khafra: you wouldn't guess it, but this is also the same step as #8
+  const rangeEnd = collectASequenceOfCodePoints(
+    (char) => {
+      const code = char.charCodeAt(0)
+
+      return code >= 0x30 && code <= 0x39
+    },
+    data,
+    position
+  )
+
+  // 15. Let rangeEndValue be rangeEnd, interpreted as decimal number, if rangeEnd
+  //     is not the empty string; otherwise null.
+  // Note from Khafra: THE SAME STEP, AGAIN!!!
+  // Note: why interpret as a decimal if we only collect ascii digits?
+  const rangeEndValue = rangeEnd.length ? Number(rangeEnd) : null
+
+  // 16. If position is not past the end of data, then return failure.
+  if (position.position < data.length) {
+    return 'failure'
+  }
+
+  // 17. If rangeEndValue and rangeStartValue are null, then return failure.
+  if (rangeEndValue === null && rangeStartValue === null) {
+    return 'failure'
+  }
+
+  // 18. If rangeStartValue and rangeEndValue are numbers, and rangeStartValue is
+  //     greater than rangeEndValue, then return failure.
+  // Note: ... when can they not be numbers?
+  if (rangeStartValue > rangeEndValue) {
+    return 'failure'
+  }
+
+  // 19. Return (rangeStartValue, rangeEndValue).
+  return { rangeStartValue, rangeEndValue }
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#build-a-content-range
+ * @param {number} rangeStart
+ * @param {number} rangeEnd
+ * @param {number} fullLength
+ */
+function buildContentRange (rangeStart, rangeEnd, fullLength) {
+  // 1. Let contentRange be `bytes `.
+  let contentRange = 'bytes '
+
+  // 2. Append rangeStart, serialized and isomorphic encoded, to contentRange.
+  contentRange += isomorphicEncode(`${rangeStart}`)
+
+  // 3. Append 0x2D (-) to contentRange.
+  contentRange += '-'
+
+  // 4. Append rangeEnd, serialized and isomorphic encoded to contentRange.
+  contentRange += isomorphicEncode(`${rangeEnd}`)
+
+  // 5. Append 0x2F (/) to contentRange.
+  contentRange += '/'
+
+  // 6. Append fullLength, serialized and isomorphic encoded to contentRange.
+  contentRange += isomorphicEncode(`${fullLength}`)
+
+  // 7. Return contentRange.
+  return contentRange
+}
+
+// A Stream, which pipes the response to zlib.createInflate() or
+// zlib.createInflateRaw() depending on the first byte of the Buffer.
+// If the lower byte of the first byte is 0x08, then the stream is
+// interpreted as a zlib stream, otherwise it's interpreted as a
+// raw deflate stream.
+class InflateStream extends Transform {
+  #zlibOptions
+
+  /** @param {zlib.ZlibOptions} [zlibOptions] */
+  constructor (zlibOptions) {
+    super()
+    this.#zlibOptions = zlibOptions
+  }
+
+  _transform (chunk, encoding, callback) {
+    if (!this._inflateStream) {
+      if (chunk.length === 0) {
+        callback()
+        return
+      }
+      this._inflateStream = (chunk[0] & 0x0F) === 0x08
+        ? zlib.createInflate(this.#zlibOptions)
+        : zlib.createInflateRaw(this.#zlibOptions)
+
+      this._inflateStream.on('data', this.push.bind(this))
+      this._inflateStream.on('end', () => this.push(null))
+      this._inflateStream.on('error', (err) => this.destroy(err))
+    }
+
+    this._inflateStream.write(chunk, encoding, callback)
+  }
+
+  _final (callback) {
+    if (this._inflateStream) {
+      this._inflateStream.end()
+      this._inflateStream = null
+    }
+    callback()
+  }
+}
+
+/**
+ * @param {zlib.ZlibOptions} [zlibOptions]
+ * @returns {InflateStream}
+ */
+function createInflate (zlibOptions) {
+  return new InflateStream(zlibOptions)
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-header-extract-mime-type
+ * @param {import('./headers').HeadersList} headers
+ */
+function extractMimeType (headers) {
+  // 1. Let charset be null.
+  let charset = null
+
+  // 2. Let essence be null.
+  let essence = null
+
+  // 3. Let mimeType be null.
+  let mimeType = null
+
+  // 4. Let values be the result of getting, decoding, and splitting `Content-Type` from headers.
+  const values = getDecodeSplit('content-type', headers)
+
+  // 5. If values is null, then return failure.
+  if (values === null) {
+    return 'failure'
+  }
+
+  // 6. For each value of values:
+  for (const value of values) {
+    // 6.1. Let temporaryMimeType be the result of parsing value.
+    const temporaryMimeType = parseMIMEType(value)
+
+    // 6.2. If temporaryMimeType is failure or its essence is "*/*", then continue.
+    if (temporaryMimeType === 'failure' || temporaryMimeType.essence === '*/*') {
+      continue
+    }
+
+    // 6.3. Set mimeType to temporaryMimeType.
+    mimeType = temporaryMimeType
+
+    // 6.4. If mimeType’s essence is not essence, then:
+    if (mimeType.essence !== essence) {
+      // 6.4.1. Set charset to null.
+      charset = null
+
+      // 6.4.2. If mimeType’s parameters["charset"] exists, then set charset to
+      //        mimeType’s parameters["charset"].
+      if (mimeType.parameters.has('charset')) {
+        charset = mimeType.parameters.get('charset')
+      }
+
+      // 6.4.3. Set essence to mimeType’s essence.
+      essence = mimeType.essence
+    } else if (!mimeType.parameters.has('charset') && charset !== null) {
+      // 6.5. Otherwise, if mimeType’s parameters["charset"] does not exist, and
+      //      charset is non-null, set mimeType’s parameters["charset"] to charset.
+      mimeType.parameters.set('charset', charset)
+    }
+  }
+
+  // 7. If mimeType is null, then return failure.
+  if (mimeType == null) {
+    return 'failure'
+  }
+
+  // 8. Return mimeType.
+  return mimeType
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#header-value-get-decode-and-split
+ * @param {string|null} value
+ */
+function gettingDecodingSplitting (value) {
+  // 1. Let input be the result of isomorphic decoding value.
+  const input = value
+
+  // 2. Let position be a position variable for input, initially pointing at the start of input.
+  const position = { position: 0 }
+
+  // 3. Let values be a list of strings, initially empty.
+  const values = []
+
+  // 4. Let temporaryValue be the empty string.
+  let temporaryValue = ''
+
+  // 5. While position is not past the end of input:
+  while (position.position < input.length) {
+    // 5.1. Append the result of collecting a sequence of code points that are not U+0022 (")
+    //      or U+002C (,) from input, given position, to temporaryValue.
+    temporaryValue += collectASequenceOfCodePoints(
+      (char) => char !== '"' && char !== ',',
+      input,
+      position
+    )
+
+    // 5.2. If position is not past the end of input, then:
+    if (position.position < input.length) {
+      // 5.2.1. If the code point at position within input is U+0022 ("), then:
+      if (input.charCodeAt(position.position) === 0x22) {
+        // 5.2.1.1. Append the result of collecting an HTTP quoted string from input, given position, to temporaryValue.
+        temporaryValue += collectAnHTTPQuotedString(
+          input,
+          position
+        )
+
+        // 5.2.1.2. If position is not past the end of input, then continue.
+        if (position.position < input.length) {
+          continue
+        }
+      } else {
+        // 5.2.2. Otherwise:
+
+        // 5.2.2.1. Assert: the code point at position within input is U+002C (,).
+        assert(input.charCodeAt(position.position) === 0x2C)
+
+        // 5.2.2.2. Advance position by 1.
+        position.position++
+      }
+    }
+
+    // 5.3. Remove all HTTP tab or space from the start and end of temporaryValue.
+    temporaryValue = removeChars(temporaryValue, true, true, (char) => char === 0x9 || char === 0x20)
+
+    // 5.4. Append temporaryValue to values.
+    values.push(temporaryValue)
+
+    // 5.6. Set temporaryValue to the empty string.
+    temporaryValue = ''
+  }
+
+  // 6. Return values.
+  return values
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-header-list-get-decode-split
+ * @param {string} name lowercase header name
+ * @param {import('./headers').HeadersList} list
+ */
+function getDecodeSplit (name, list) {
+  // 1. Let value be the result of getting name from list.
+  const value = list.get(name, true)
+
+  // 2. If value is null, then return null.
+  if (value === null) {
+    return null
+  }
+
+  // 3. Return the result of getting, decoding, and splitting value.
+  return gettingDecodingSplitting(value)
+}
+
+const textDecoder = new TextDecoder()
+
+/**
+ * @see https://encoding.spec.whatwg.org/#utf-8-decode
+ * @param {Buffer} buffer
+ */
+function utf8DecodeBytes (buffer) {
+  if (buffer.length === 0) {
+    return ''
+  }
+
+  // 1. Let buffer be the result of peeking three bytes from
+  //    ioQueue, converted to a byte sequence.
+
+  // 2. If buffer is 0xEF 0xBB 0xBF, then read three
+  //    bytes from ioQueue. (Do nothing with those bytes.)
+  if (buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) {
+    buffer = buffer.subarray(3)
+  }
+
+  // 3. Process a queue with an instance of UTF-8’s
+  //    decoder, ioQueue, output, and "replacement".
+  const output = textDecoder.decode(buffer)
+
+  // 4. Return output.
+  return output
+}
+
+class EnvironmentSettingsObjectBase {
+  get baseUrl () {
+    return getGlobalOrigin()
+  }
+
+  get origin () {
+    return this.baseUrl?.origin
+  }
+
+  policyContainer = makePolicyContainer()
+}
+
+class EnvironmentSettingsObject {
+  settingsObject = new EnvironmentSettingsObjectBase()
+}
+
+const environmentSettingsObject = new EnvironmentSettingsObject()
+
+module.exports = {
+  isAborted,
+  isCancelled,
+  isValidEncodedURL,
+  createDeferredPromise,
+  ReadableStreamFrom,
+  tryUpgradeRequestToAPotentiallyTrustworthyURL,
+  clampAndCoarsenConnectionTimingInfo,
+  coarsenedSharedCurrentTime,
+  determineRequestsReferrer,
+  makePolicyContainer,
+  clonePolicyContainer,
+  appendFetchMetadata,
+  appendRequestOriginHeader,
+  TAOCheck,
+  corsCheck,
+  crossOriginResourcePolicyCheck,
+  createOpaqueTimingInfo,
+  setRequestReferrerPolicyOnRedirect,
+  isValidHTTPToken,
+  requestBadPort,
+  requestCurrentURL,
+  responseURL,
+  responseLocationURL,
+  isBlobLike,
+  isURLPotentiallyTrustworthy,
+  isValidReasonPhrase,
+  sameOrigin,
+  normalizeMethod,
+  serializeJavascriptValueToJSONString,
+  iteratorMixin,
+  createIterator,
+  isValidHeaderName,
+  isValidHeaderValue,
+  isErrorLike,
+  fullyReadBody,
+  bytesMatch,
+  isReadableStreamLike,
+  readableStreamClose,
+  isomorphicEncode,
+  urlIsLocal,
+  urlHasHttpsScheme,
+  urlIsHttpHttpsScheme,
+  readAllBytes,
+  simpleRangeHeaderValue,
+  buildContentRange,
+  parseMetadata,
+  createInflate,
+  extractMimeType,
+  getDecodeSplit,
+  utf8DecodeBytes,
+  environmentSettingsObject
+}
+
+
+/***/ }),
+
+/***/ 37829:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { types, inspect } = __nccwpck_require__(47261)
+const { markAsUncloneable } = __nccwpck_require__(24086)
+const { toUSVString } = __nccwpck_require__(94407)
+
+/** @type {import('../../../types/webidl').Webidl} */
+const webidl = {}
+webidl.converters = {}
+webidl.util = {}
+webidl.errors = {}
+
+webidl.errors.exception = function (message) {
+  return new TypeError(`${message.header}: ${message.message}`)
+}
+
+webidl.errors.conversionFailed = function (context) {
+  const plural = context.types.length === 1 ? '' : ' one of'
+  const message =
+    `${context.argument} could not be converted to` +
+    `${plural}: ${context.types.join(', ')}.`
+
+  return webidl.errors.exception({
+    header: context.prefix,
+    message
+  })
+}
+
+webidl.errors.invalidArgument = function (context) {
+  return webidl.errors.exception({
+    header: context.prefix,
+    message: `"${context.value}" is an invalid ${context.type}.`
+  })
+}
+
+// https://webidl.spec.whatwg.org/#implements
+webidl.brandCheck = function (V, I, opts) {
+  if (opts?.strict !== false) {
+    if (!(V instanceof I)) {
+      const err = new TypeError('Illegal invocation')
+      err.code = 'ERR_INVALID_THIS' // node compat.
+      throw err
+    }
+  } else {
+    if (V?.[Symbol.toStringTag] !== I.prototype[Symbol.toStringTag]) {
+      const err = new TypeError('Illegal invocation')
+      err.code = 'ERR_INVALID_THIS' // node compat.
+      throw err
+    }
+  }
+}
+
+webidl.argumentLengthCheck = function ({ length }, min, ctx) {
+  if (length < min) {
+    throw webidl.errors.exception({
+      message: `${min} argument${min !== 1 ? 's' : ''} required, ` +
+               `but${length ? ' only' : ''} ${length} found.`,
+      header: ctx
+    })
+  }
+}
+
+webidl.illegalConstructor = function () {
+  throw webidl.errors.exception({
+    header: 'TypeError',
+    message: 'Illegal constructor'
+  })
+}
+
+// https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
+webidl.util.Type = function (V) {
+  switch (typeof V) {
+    case 'undefined': return 'Undefined'
+    case 'boolean': return 'Boolean'
+    case 'string': return 'String'
+    case 'symbol': return 'Symbol'
+    case 'number': return 'Number'
+    case 'bigint': return 'BigInt'
+    case 'function':
+    case 'object': {
+      if (V === null) {
+        return 'Null'
+      }
+
+      return 'Object'
+    }
+  }
+}
+
+webidl.util.markAsUncloneable = markAsUncloneable || (() => {})
+// https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+webidl.util.ConvertToInt = function (V, bitLength, signedness, opts) {
+  let upperBound
+  let lowerBound
+
+  // 1. If bitLength is 64, then:
+  if (bitLength === 64) {
+    // 1. Let upperBound be 2^53 − 1.
+    upperBound = Math.pow(2, 53) - 1
+
+    // 2. If signedness is "unsigned", then let lowerBound be 0.
+    if (signedness === 'unsigned') {
+      lowerBound = 0
+    } else {
+      // 3. Otherwise let lowerBound be −2^53 + 1.
+      lowerBound = Math.pow(-2, 53) + 1
+    }
+  } else if (signedness === 'unsigned') {
+    // 2. Otherwise, if signedness is "unsigned", then:
+
+    // 1. Let lowerBound be 0.
+    lowerBound = 0
+
+    // 2. Let upperBound be 2^bitLength − 1.
+    upperBound = Math.pow(2, bitLength) - 1
+  } else {
+    // 3. Otherwise:
+
+    // 1. Let lowerBound be -2^bitLength − 1.
+    lowerBound = Math.pow(-2, bitLength) - 1
+
+    // 2. Let upperBound be 2^bitLength − 1 − 1.
+    upperBound = Math.pow(2, bitLength - 1) - 1
+  }
+
+  // 4. Let x be ? ToNumber(V).
+  let x = Number(V)
+
+  // 5. If x is −0, then set x to +0.
+  if (x === 0) {
+    x = 0
+  }
+
+  // 6. If the conversion is to an IDL type associated
+  //    with the [EnforceRange] extended attribute, then:
+  if (opts?.enforceRange === true) {
+    // 1. If x is NaN, +∞, or −∞, then throw a TypeError.
+    if (
+      Number.isNaN(x) ||
+      x === Number.POSITIVE_INFINITY ||
+      x === Number.NEGATIVE_INFINITY
+    ) {
+      throw webidl.errors.exception({
+        header: 'Integer conversion',
+        message: `Could not convert ${webidl.util.Stringify(V)} to an integer.`
+      })
+    }
+
+    // 2. Set x to IntegerPart(x).
+    x = webidl.util.IntegerPart(x)
+
+    // 3. If x < lowerBound or x > upperBound, then
+    //    throw a TypeError.
+    if (x < lowerBound || x > upperBound) {
+      throw webidl.errors.exception({
+        header: 'Integer conversion',
+        message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.`
+      })
+    }
+
+    // 4. Return x.
+    return x
+  }
+
+  // 7. If x is not NaN and the conversion is to an IDL
+  //    type associated with the [Clamp] extended
+  //    attribute, then:
+  if (!Number.isNaN(x) && opts?.clamp === true) {
+    // 1. Set x to min(max(x, lowerBound), upperBound).
+    x = Math.min(Math.max(x, lowerBound), upperBound)
+
+    // 2. Round x to the nearest integer, choosing the
+    //    even integer if it lies halfway between two,
+    //    and choosing +0 rather than −0.
+    if (Math.floor(x) % 2 === 0) {
+      x = Math.floor(x)
+    } else {
+      x = Math.ceil(x)
+    }
+
+    // 3. Return x.
+    return x
+  }
+
+  // 8. If x is NaN, +0, +∞, or −∞, then return +0.
+  if (
+    Number.isNaN(x) ||
+    (x === 0 && Object.is(0, x)) ||
+    x === Number.POSITIVE_INFINITY ||
+    x === Number.NEGATIVE_INFINITY
+  ) {
+    return 0
+  }
+
+  // 9. Set x to IntegerPart(x).
+  x = webidl.util.IntegerPart(x)
+
+  // 10. Set x to x modulo 2^bitLength.
+  x = x % Math.pow(2, bitLength)
+
+  // 11. If signedness is "signed" and x ≥ 2^bitLength − 1,
+  //    then return x − 2^bitLength.
+  if (signedness === 'signed' && x >= Math.pow(2, bitLength) - 1) {
+    return x - Math.pow(2, bitLength)
+  }
+
+  // 12. Otherwise, return x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#abstract-opdef-integerpart
+webidl.util.IntegerPart = function (n) {
+  // 1. Let r be floor(abs(n)).
+  const r = Math.floor(Math.abs(n))
+
+  // 2. If n < 0, then return -1 × r.
+  if (n < 0) {
+    return -1 * r
+  }
+
+  // 3. Otherwise, return r.
+  return r
+}
+
+webidl.util.Stringify = function (V) {
+  const type = webidl.util.Type(V)
+
+  switch (type) {
+    case 'Symbol':
+      return `Symbol(${V.description})`
+    case 'Object':
+      return inspect(V)
+    case 'String':
+      return `"${V}"`
+    default:
+      return `${V}`
+  }
+}
+
+// https://webidl.spec.whatwg.org/#es-sequence
+webidl.sequenceConverter = function (converter) {
+  return (V, prefix, argument, Iterable) => {
+    // 1. If Type(V) is not Object, throw a TypeError.
+    if (webidl.util.Type(V) !== 'Object') {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: `${argument} (${webidl.util.Stringify(V)}) is not iterable.`
+      })
+    }
+
+    // 2. Let method be ? GetMethod(V, @@iterator).
+    /** @type {Generator} */
+    const method = typeof Iterable === 'function' ? Iterable() : V?.[Symbol.iterator]?.()
+    const seq = []
+    let index = 0
+
+    // 3. If method is undefined, throw a TypeError.
+    if (
+      method === undefined ||
+      typeof method.next !== 'function'
+    ) {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: `${argument} is not iterable.`
+      })
+    }
+
+    // https://webidl.spec.whatwg.org/#create-sequence-from-iterable
+    while (true) {
+      const { done, value } = method.next()
+
+      if (done) {
+        break
+      }
+
+      seq.push(converter(value, prefix, `${argument}[${index++}]`))
+    }
+
+    return seq
+  }
+}
+
+// https://webidl.spec.whatwg.org/#es-to-record
+webidl.recordConverter = function (keyConverter, valueConverter) {
+  return (O, prefix, argument) => {
+    // 1. If Type(O) is not Object, throw a TypeError.
+    if (webidl.util.Type(O) !== 'Object') {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: `${argument} ("${webidl.util.Type(O)}") is not an Object.`
+      })
+    }
+
+    // 2. Let result be a new empty instance of record<K, V>.
+    const result = {}
+
+    if (!types.isProxy(O)) {
+      // 1. Let desc be ? O.[[GetOwnProperty]](key).
+      const keys = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)]
+
+      for (const key of keys) {
+        // 1. Let typedKey be key converted to an IDL value of type K.
+        const typedKey = keyConverter(key, prefix, argument)
+
+        // 2. Let value be ? Get(O, key).
+        // 3. Let typedValue be value converted to an IDL value of type V.
+        const typedValue = valueConverter(O[key], prefix, argument)
+
+        // 4. Set result[typedKey] to typedValue.
+        result[typedKey] = typedValue
+      }
+
+      // 5. Return result.
+      return result
+    }
+
+    // 3. Let keys be ? O.[[OwnPropertyKeys]]().
+    const keys = Reflect.ownKeys(O)
+
+    // 4. For each key of keys.
+    for (const key of keys) {
+      // 1. Let desc be ? O.[[GetOwnProperty]](key).
+      const desc = Reflect.getOwnPropertyDescriptor(O, key)
+
+      // 2. If desc is not undefined and desc.[[Enumerable]] is true:
+      if (desc?.enumerable) {
+        // 1. Let typedKey be key converted to an IDL value of type K.
+        const typedKey = keyConverter(key, prefix, argument)
+
+        // 2. Let value be ? Get(O, key).
+        // 3. Let typedValue be value converted to an IDL value of type V.
+        const typedValue = valueConverter(O[key], prefix, argument)
+
+        // 4. Set result[typedKey] to typedValue.
+        result[typedKey] = typedValue
+      }
+    }
+
+    // 5. Return result.
+    return result
+  }
+}
+
+webidl.interfaceConverter = function (i) {
+  return (V, prefix, argument, opts) => {
+    if (opts?.strict !== false && !(V instanceof i)) {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: `Expected ${argument} ("${webidl.util.Stringify(V)}") to be an instance of ${i.name}.`
+      })
+    }
+
+    return V
+  }
+}
+
+webidl.dictionaryConverter = function (converters) {
+  return (dictionary, prefix, argument) => {
+    const type = webidl.util.Type(dictionary)
+    const dict = {}
+
+    if (type === 'Null' || type === 'Undefined') {
+      return dict
+    } else if (type !== 'Object') {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
+      })
+    }
+
+    for (const options of converters) {
+      const { key, defaultValue, required, converter } = options
+
+      if (required === true) {
+        if (!Object.hasOwn(dictionary, key)) {
+          throw webidl.errors.exception({
+            header: prefix,
+            message: `Missing required key "${key}".`
+          })
+        }
+      }
+
+      let value = dictionary[key]
+      const hasDefault = Object.hasOwn(options, 'defaultValue')
+
+      // Only use defaultValue if value is undefined and
+      // a defaultValue options was provided.
+      if (hasDefault && value !== null) {
+        value ??= defaultValue()
+      }
+
+      // A key can be optional and have no default value.
+      // When this happens, do not perform a conversion,
+      // and do not assign the key a value.
+      if (required || hasDefault || value !== undefined) {
+        value = converter(value, prefix, `${argument}.${key}`)
+
+        if (
+          options.allowedValues &&
+          !options.allowedValues.includes(value)
+        ) {
+          throw webidl.errors.exception({
+            header: prefix,
+            message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(', ')}.`
+          })
+        }
+
+        dict[key] = value
+      }
+    }
+
+    return dict
+  }
+}
+
+webidl.nullableConverter = function (converter) {
+  return (V, prefix, argument) => {
+    if (V === null) {
+      return V
+    }
+
+    return converter(V, prefix, argument)
+  }
+}
+
+// https://webidl.spec.whatwg.org/#es-DOMString
+webidl.converters.DOMString = function (V, prefix, argument, opts) {
+  // 1. If V is null and the conversion is to an IDL type
+  //    associated with the [LegacyNullToEmptyString]
+  //    extended attribute, then return the DOMString value
+  //    that represents the empty string.
+  if (V === null && opts?.legacyNullToEmptyString) {
+    return ''
+  }
+
+  // 2. Let x be ? ToString(V).
+  if (typeof V === 'symbol') {
+    throw webidl.errors.exception({
+      header: prefix,
+      message: `${argument} is a symbol, which cannot be converted to a DOMString.`
+    })
+  }
+
+  // 3. Return the IDL DOMString value that represents the
+  //    same sequence of code units as the one the
+  //    ECMAScript String value x represents.
+  return String(V)
+}
+
+// https://webidl.spec.whatwg.org/#es-ByteString
+webidl.converters.ByteString = function (V, prefix, argument) {
+  // 1. Let x be ? ToString(V).
+  // Note: DOMString converter perform ? ToString(V)
+  const x = webidl.converters.DOMString(V, prefix, argument)
+
+  // 2. If the value of any element of x is greater than
+  //    255, then throw a TypeError.
+  for (let index = 0; index < x.length; index++) {
+    if (x.charCodeAt(index) > 255) {
+      throw new TypeError(
+        'Cannot convert argument to a ByteString because the character at ' +
+        `index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.`
+      )
+    }
+  }
+
+  // 3. Return an IDL ByteString value whose length is the
+  //    length of x, and where the value of each element is
+  //    the value of the corresponding element of x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#es-USVString
+// TODO: rewrite this so we can control the errors thrown
+webidl.converters.USVString = toUSVString
+
+// https://webidl.spec.whatwg.org/#es-boolean
+webidl.converters.boolean = function (V) {
+  // 1. Let x be the result of computing ToBoolean(V).
+  const x = Boolean(V)
+
+  // 2. Return the IDL boolean value that is the one that represents
+  //    the same truth value as the ECMAScript Boolean value x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#es-any
+webidl.converters.any = function (V) {
+  return V
+}
+
+// https://webidl.spec.whatwg.org/#es-long-long
+webidl.converters['long long'] = function (V, prefix, argument) {
+  // 1. Let x be ? ConvertToInt(V, 64, "signed").
+  const x = webidl.util.ConvertToInt(V, 64, 'signed', undefined, prefix, argument)
+
+  // 2. Return the IDL long long value that represents
+  //    the same numeric value as x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#es-unsigned-long-long
+webidl.converters['unsigned long long'] = function (V, prefix, argument) {
+  // 1. Let x be ? ConvertToInt(V, 64, "unsigned").
+  const x = webidl.util.ConvertToInt(V, 64, 'unsigned', undefined, prefix, argument)
+
+  // 2. Return the IDL unsigned long long value that
+  //    represents the same numeric value as x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#es-unsigned-long
+webidl.converters['unsigned long'] = function (V, prefix, argument) {
+  // 1. Let x be ? ConvertToInt(V, 32, "unsigned").
+  const x = webidl.util.ConvertToInt(V, 32, 'unsigned', undefined, prefix, argument)
+
+  // 2. Return the IDL unsigned long value that
+  //    represents the same numeric value as x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#es-unsigned-short
+webidl.converters['unsigned short'] = function (V, prefix, argument, opts) {
+  // 1. Let x be ? ConvertToInt(V, 16, "unsigned").
+  const x = webidl.util.ConvertToInt(V, 16, 'unsigned', opts, prefix, argument)
+
+  // 2. Return the IDL unsigned short value that represents
+  //    the same numeric value as x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#idl-ArrayBuffer
+webidl.converters.ArrayBuffer = function (V, prefix, argument, opts) {
+  // 1. If Type(V) is not Object, or V does not have an
+  //    [[ArrayBufferData]] internal slot, then throw a
+  //    TypeError.
+  // see: https://tc39.es/ecma262/#sec-properties-of-the-arraybuffer-instances
+  // see: https://tc39.es/ecma262/#sec-properties-of-the-sharedarraybuffer-instances
+  if (
+    webidl.util.Type(V) !== 'Object' ||
+    !types.isAnyArrayBuffer(V)
+  ) {
+    throw webidl.errors.conversionFailed({
+      prefix,
+      argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+      types: ['ArrayBuffer']
+    })
+  }
+
+  // 2. If the conversion is not to an IDL type associated
+  //    with the [AllowShared] extended attribute, and
+  //    IsSharedArrayBuffer(V) is true, then throw a
+  //    TypeError.
+  if (opts?.allowShared === false && types.isSharedArrayBuffer(V)) {
+    throw webidl.errors.exception({
+      header: 'ArrayBuffer',
+      message: 'SharedArrayBuffer is not allowed.'
+    })
+  }
+
+  // 3. If the conversion is not to an IDL type associated
+  //    with the [AllowResizable] extended attribute, and
+  //    IsResizableArrayBuffer(V) is true, then throw a
+  //    TypeError.
+  if (V.resizable || V.growable) {
+    throw webidl.errors.exception({
+      header: 'ArrayBuffer',
+      message: 'Received a resizable ArrayBuffer.'
+    })
+  }
+
+  // 4. Return the IDL ArrayBuffer value that is a
+  //    reference to the same object as V.
+  return V
+}
+
+webidl.converters.TypedArray = function (V, T, prefix, name, opts) {
+  // 1. Let T be the IDL type V is being converted to.
+
+  // 2. If Type(V) is not Object, or V does not have a
+  //    [[TypedArrayName]] internal slot with a value
+  //    equal to T’s name, then throw a TypeError.
+  if (
+    webidl.util.Type(V) !== 'Object' ||
+    !types.isTypedArray(V) ||
+    V.constructor.name !== T.name
+  ) {
+    throw webidl.errors.conversionFailed({
+      prefix,
+      argument: `${name} ("${webidl.util.Stringify(V)}")`,
+      types: [T.name]
+    })
+  }
+
+  // 3. If the conversion is not to an IDL type associated
+  //    with the [AllowShared] extended attribute, and
+  //    IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is
+  //    true, then throw a TypeError.
+  if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
+    throw webidl.errors.exception({
+      header: 'ArrayBuffer',
+      message: 'SharedArrayBuffer is not allowed.'
+    })
+  }
+
+  // 4. If the conversion is not to an IDL type associated
+  //    with the [AllowResizable] extended attribute, and
+  //    IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is
+  //    true, then throw a TypeError.
+  if (V.buffer.resizable || V.buffer.growable) {
+    throw webidl.errors.exception({
+      header: 'ArrayBuffer',
+      message: 'Received a resizable ArrayBuffer.'
+    })
+  }
+
+  // 5. Return the IDL value of type T that is a reference
+  //    to the same object as V.
+  return V
+}
+
+webidl.converters.DataView = function (V, prefix, name, opts) {
+  // 1. If Type(V) is not Object, or V does not have a
+  //    [[DataView]] internal slot, then throw a TypeError.
+  if (webidl.util.Type(V) !== 'Object' || !types.isDataView(V)) {
+    throw webidl.errors.exception({
+      header: prefix,
+      message: `${name} is not a DataView.`
+    })
+  }
+
+  // 2. If the conversion is not to an IDL type associated
+  //    with the [AllowShared] extended attribute, and
+  //    IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is true,
+  //    then throw a TypeError.
+  if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
+    throw webidl.errors.exception({
+      header: 'ArrayBuffer',
+      message: 'SharedArrayBuffer is not allowed.'
+    })
+  }
+
+  // 3. If the conversion is not to an IDL type associated
+  //    with the [AllowResizable] extended attribute, and
+  //    IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is
+  //    true, then throw a TypeError.
+  if (V.buffer.resizable || V.buffer.growable) {
+    throw webidl.errors.exception({
+      header: 'ArrayBuffer',
+      message: 'Received a resizable ArrayBuffer.'
+    })
+  }
+
+  // 4. Return the IDL DataView value that is a reference
+  //    to the same object as V.
+  return V
+}
+
+// https://webidl.spec.whatwg.org/#BufferSource
+webidl.converters.BufferSource = function (V, prefix, name, opts) {
+  if (types.isAnyArrayBuffer(V)) {
+    return webidl.converters.ArrayBuffer(V, prefix, name, { ...opts, allowShared: false })
+  }
+
+  if (types.isTypedArray(V)) {
+    return webidl.converters.TypedArray(V, V.constructor, prefix, name, { ...opts, allowShared: false })
+  }
+
+  if (types.isDataView(V)) {
+    return webidl.converters.DataView(V, prefix, name, { ...opts, allowShared: false })
+  }
+
+  throw webidl.errors.conversionFailed({
+    prefix,
+    argument: `${name} ("${webidl.util.Stringify(V)}")`,
+    types: ['BufferSource']
+  })
+}
+
+webidl.converters['sequence<ByteString>'] = webidl.sequenceConverter(
+  webidl.converters.ByteString
+)
+
+webidl.converters['sequence<sequence<ByteString>>'] = webidl.sequenceConverter(
+  webidl.converters['sequence<ByteString>']
+)
+
+webidl.converters['record<ByteString, ByteString>'] = webidl.recordConverter(
+  webidl.converters.ByteString,
+  webidl.converters.ByteString
+)
+
+module.exports = {
+  webidl
+}
+
+
+/***/ }),
+
+/***/ 19420:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * @see https://encoding.spec.whatwg.org/#concept-encoding-get
+ * @param {string|undefined} label
+ */
+function getEncoding (label) {
+  if (!label) {
+    return 'failure'
+  }
+
+  // 1. Remove any leading and trailing ASCII whitespace from label.
+  // 2. If label is an ASCII case-insensitive match for any of the
+  //    labels listed in the table below, then return the
+  //    corresponding encoding; otherwise return failure.
+  switch (label.trim().toLowerCase()) {
+    case 'unicode-1-1-utf-8':
+    case 'unicode11utf8':
+    case 'unicode20utf8':
+    case 'utf-8':
+    case 'utf8':
+    case 'x-unicode20utf8':
+      return 'UTF-8'
+    case '866':
+    case 'cp866':
+    case 'csibm866':
+    case 'ibm866':
+      return 'IBM866'
+    case 'csisolatin2':
+    case 'iso-8859-2':
+    case 'iso-ir-101':
+    case 'iso8859-2':
+    case 'iso88592':
+    case 'iso_8859-2':
+    case 'iso_8859-2:1987':
+    case 'l2':
+    case 'latin2':
+      return 'ISO-8859-2'
+    case 'csisolatin3':
+    case 'iso-8859-3':
+    case 'iso-ir-109':
+    case 'iso8859-3':
+    case 'iso88593':
+    case 'iso_8859-3':
+    case 'iso_8859-3:1988':
+    case 'l3':
+    case 'latin3':
+      return 'ISO-8859-3'
+    case 'csisolatin4':
+    case 'iso-8859-4':
+    case 'iso-ir-110':
+    case 'iso8859-4':
+    case 'iso88594':
+    case 'iso_8859-4':
+    case 'iso_8859-4:1988':
+    case 'l4':
+    case 'latin4':
+      return 'ISO-8859-4'
+    case 'csisolatincyrillic':
+    case 'cyrillic':
+    case 'iso-8859-5':
+    case 'iso-ir-144':
+    case 'iso8859-5':
+    case 'iso88595':
+    case 'iso_8859-5':
+    case 'iso_8859-5:1988':
+      return 'ISO-8859-5'
+    case 'arabic':
+    case 'asmo-708':
+    case 'csiso88596e':
+    case 'csiso88596i':
+    case 'csisolatinarabic':
+    case 'ecma-114':
+    case 'iso-8859-6':
+    case 'iso-8859-6-e':
+    case 'iso-8859-6-i':
+    case 'iso-ir-127':
+    case 'iso8859-6':
+    case 'iso88596':
+    case 'iso_8859-6':
+    case 'iso_8859-6:1987':
+      return 'ISO-8859-6'
+    case 'csisolatingreek':
+    case 'ecma-118':
+    case 'elot_928':
+    case 'greek':
+    case 'greek8':
+    case 'iso-8859-7':
+    case 'iso-ir-126':
+    case 'iso8859-7':
+    case 'iso88597':
+    case 'iso_8859-7':
+    case 'iso_8859-7:1987':
+    case 'sun_eu_greek':
+      return 'ISO-8859-7'
+    case 'csiso88598e':
+    case 'csisolatinhebrew':
+    case 'hebrew':
+    case 'iso-8859-8':
+    case 'iso-8859-8-e':
+    case 'iso-ir-138':
+    case 'iso8859-8':
+    case 'iso88598':
+    case 'iso_8859-8':
+    case 'iso_8859-8:1988':
+    case 'visual':
+      return 'ISO-8859-8'
+    case 'csiso88598i':
+    case 'iso-8859-8-i':
+    case 'logical':
+      return 'ISO-8859-8-I'
+    case 'csisolatin6':
+    case 'iso-8859-10':
+    case 'iso-ir-157':
+    case 'iso8859-10':
+    case 'iso885910':
+    case 'l6':
+    case 'latin6':
+      return 'ISO-8859-10'
+    case 'iso-8859-13':
+    case 'iso8859-13':
+    case 'iso885913':
+      return 'ISO-8859-13'
+    case 'iso-8859-14':
+    case 'iso8859-14':
+    case 'iso885914':
+      return 'ISO-8859-14'
+    case 'csisolatin9':
+    case 'iso-8859-15':
+    case 'iso8859-15':
+    case 'iso885915':
+    case 'iso_8859-15':
+    case 'l9':
+      return 'ISO-8859-15'
+    case 'iso-8859-16':
+      return 'ISO-8859-16'
+    case 'cskoi8r':
+    case 'koi':
+    case 'koi8':
+    case 'koi8-r':
+    case 'koi8_r':
+      return 'KOI8-R'
+    case 'koi8-ru':
+    case 'koi8-u':
+      return 'KOI8-U'
+    case 'csmacintosh':
+    case 'mac':
+    case 'macintosh':
+    case 'x-mac-roman':
+      return 'macintosh'
+    case 'iso-8859-11':
+    case 'iso8859-11':
+    case 'iso885911':
+    case 'tis-620':
+    case 'windows-874':
+      return 'windows-874'
+    case 'cp1250':
+    case 'windows-1250':
+    case 'x-cp1250':
+      return 'windows-1250'
+    case 'cp1251':
+    case 'windows-1251':
+    case 'x-cp1251':
+      return 'windows-1251'
+    case 'ansi_x3.4-1968':
+    case 'ascii':
+    case 'cp1252':
+    case 'cp819':
+    case 'csisolatin1':
+    case 'ibm819':
+    case 'iso-8859-1':
+    case 'iso-ir-100':
+    case 'iso8859-1':
+    case 'iso88591':
+    case 'iso_8859-1':
+    case 'iso_8859-1:1987':
+    case 'l1':
+    case 'latin1':
+    case 'us-ascii':
+    case 'windows-1252':
+    case 'x-cp1252':
+      return 'windows-1252'
+    case 'cp1253':
+    case 'windows-1253':
+    case 'x-cp1253':
+      return 'windows-1253'
+    case 'cp1254':
+    case 'csisolatin5':
+    case 'iso-8859-9':
+    case 'iso-ir-148':
+    case 'iso8859-9':
+    case 'iso88599':
+    case 'iso_8859-9':
+    case 'iso_8859-9:1989':
+    case 'l5':
+    case 'latin5':
+    case 'windows-1254':
+    case 'x-cp1254':
+      return 'windows-1254'
+    case 'cp1255':
+    case 'windows-1255':
+    case 'x-cp1255':
+      return 'windows-1255'
+    case 'cp1256':
+    case 'windows-1256':
+    case 'x-cp1256':
+      return 'windows-1256'
+    case 'cp1257':
+    case 'windows-1257':
+    case 'x-cp1257':
+      return 'windows-1257'
+    case 'cp1258':
+    case 'windows-1258':
+    case 'x-cp1258':
+      return 'windows-1258'
+    case 'x-mac-cyrillic':
+    case 'x-mac-ukrainian':
+      return 'x-mac-cyrillic'
+    case 'chinese':
+    case 'csgb2312':
+    case 'csiso58gb231280':
+    case 'gb2312':
+    case 'gb_2312':
+    case 'gb_2312-80':
+    case 'gbk':
+    case 'iso-ir-58':
+    case 'x-gbk':
+      return 'GBK'
+    case 'gb18030':
+      return 'gb18030'
+    case 'big5':
+    case 'big5-hkscs':
+    case 'cn-big5':
+    case 'csbig5':
+    case 'x-x-big5':
+      return 'Big5'
+    case 'cseucpkdfmtjapanese':
+    case 'euc-jp':
+    case 'x-euc-jp':
+      return 'EUC-JP'
+    case 'csiso2022jp':
+    case 'iso-2022-jp':
+      return 'ISO-2022-JP'
+    case 'csshiftjis':
+    case 'ms932':
+    case 'ms_kanji':
+    case 'shift-jis':
+    case 'shift_jis':
+    case 'sjis':
+    case 'windows-31j':
+    case 'x-sjis':
+      return 'Shift_JIS'
+    case 'cseuckr':
+    case 'csksc56011987':
+    case 'euc-kr':
+    case 'iso-ir-149':
+    case 'korean':
+    case 'ks_c_5601-1987':
+    case 'ks_c_5601-1989':
+    case 'ksc5601':
+    case 'ksc_5601':
+    case 'windows-949':
+      return 'EUC-KR'
+    case 'csiso2022kr':
+    case 'hz-gb-2312':
+    case 'iso-2022-cn':
+    case 'iso-2022-cn-ext':
+    case 'iso-2022-kr':
+    case 'replacement':
+      return 'replacement'
+    case 'unicodefffe':
+    case 'utf-16be':
+      return 'UTF-16BE'
+    case 'csunicode':
+    case 'iso-10646-ucs-2':
+    case 'ucs-2':
+    case 'unicode':
+    case 'unicodefeff':
+    case 'utf-16':
+    case 'utf-16le':
+      return 'UTF-16LE'
+    case 'x-user-defined':
+      return 'x-user-defined'
+    default: return 'failure'
+  }
+}
+
+module.exports = {
+  getEncoding
+}
+
+
+/***/ }),
+
+/***/ 70923:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  staticPropertyDescriptors,
+  readOperation,
+  fireAProgressEvent
+} = __nccwpck_require__(82947)
+const {
+  kState,
+  kError,
+  kResult,
+  kEvents,
+  kAborted
+} = __nccwpck_require__(24666)
+const { webidl } = __nccwpck_require__(37829)
+const { kEnumerableProperty } = __nccwpck_require__(94407)
+
+class FileReader extends EventTarget {
+  constructor () {
+    super()
+
+    this[kState] = 'empty'
+    this[kResult] = null
+    this[kError] = null
+    this[kEvents] = {
+      loadend: null,
+      error: null,
+      abort: null,
+      load: null,
+      progress: null,
+      loadstart: null
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer
+   * @param {import('buffer').Blob} blob
+   */
+  readAsArrayBuffer (blob) {
+    webidl.brandCheck(this, FileReader)
+
+    webidl.argumentLengthCheck(arguments, 1, 'FileReader.readAsArrayBuffer')
+
+    blob = webidl.converters.Blob(blob, { strict: false })
+
+    // The readAsArrayBuffer(blob) method, when invoked,
+    // must initiate a read operation for blob with ArrayBuffer.
+    readOperation(this, blob, 'ArrayBuffer')
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#readAsBinaryString
+   * @param {import('buffer').Blob} blob
+   */
+  readAsBinaryString (blob) {
+    webidl.brandCheck(this, FileReader)
+
+    webidl.argumentLengthCheck(arguments, 1, 'FileReader.readAsBinaryString')
+
+    blob = webidl.converters.Blob(blob, { strict: false })
+
+    // The readAsBinaryString(blob) method, when invoked,
+    // must initiate a read operation for blob with BinaryString.
+    readOperation(this, blob, 'BinaryString')
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#readAsDataText
+   * @param {import('buffer').Blob} blob
+   * @param {string?} encoding
+   */
+  readAsText (blob, encoding = undefined) {
+    webidl.brandCheck(this, FileReader)
+
+    webidl.argumentLengthCheck(arguments, 1, 'FileReader.readAsText')
+
+    blob = webidl.converters.Blob(blob, { strict: false })
+
+    if (encoding !== undefined) {
+      encoding = webidl.converters.DOMString(encoding, 'FileReader.readAsText', 'encoding')
+    }
+
+    // The readAsText(blob, encoding) method, when invoked,
+    // must initiate a read operation for blob with Text and encoding.
+    readOperation(this, blob, 'Text', encoding)
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL
+   * @param {import('buffer').Blob} blob
+   */
+  readAsDataURL (blob) {
+    webidl.brandCheck(this, FileReader)
+
+    webidl.argumentLengthCheck(arguments, 1, 'FileReader.readAsDataURL')
+
+    blob = webidl.converters.Blob(blob, { strict: false })
+
+    // The readAsDataURL(blob) method, when invoked, must
+    // initiate a read operation for blob with DataURL.
+    readOperation(this, blob, 'DataURL')
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dfn-abort
+   */
+  abort () {
+    // 1. If this's state is "empty" or if this's state is
+    //    "done" set this's result to null and terminate
+    //    this algorithm.
+    if (this[kState] === 'empty' || this[kState] === 'done') {
+      this[kResult] = null
+      return
+    }
+
+    // 2. If this's state is "loading" set this's state to
+    //    "done" and set this's result to null.
+    if (this[kState] === 'loading') {
+      this[kState] = 'done'
+      this[kResult] = null
+    }
+
+    // 3. If there are any tasks from this on the file reading
+    //    task source in an affiliated task queue, then remove
+    //    those tasks from that task queue.
+    this[kAborted] = true
+
+    // 4. Terminate the algorithm for the read method being processed.
+    // TODO
+
+    // 5. Fire a progress event called abort at this.
+    fireAProgressEvent('abort', this)
+
+    // 6. If this's state is not "loading", fire a progress
+    //    event called loadend at this.
+    if (this[kState] !== 'loading') {
+      fireAProgressEvent('loadend', this)
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate
+   */
+  get readyState () {
+    webidl.brandCheck(this, FileReader)
+
+    switch (this[kState]) {
+      case 'empty': return this.EMPTY
+      case 'loading': return this.LOADING
+      case 'done': return this.DONE
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dom-filereader-result
+   */
+  get result () {
+    webidl.brandCheck(this, FileReader)
+
+    // The result attribute’s getter, when invoked, must return
+    // this's result.
+    return this[kResult]
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dom-filereader-error
+   */
+  get error () {
+    webidl.brandCheck(this, FileReader)
+
+    // The error attribute’s getter, when invoked, must return
+    // this's error.
+    return this[kError]
+  }
+
+  get onloadend () {
+    webidl.brandCheck(this, FileReader)
+
+    return this[kEvents].loadend
+  }
+
+  set onloadend (fn) {
+    webidl.brandCheck(this, FileReader)
+
+    if (this[kEvents].loadend) {
+      this.removeEventListener('loadend', this[kEvents].loadend)
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].loadend = fn
+      this.addEventListener('loadend', fn)
+    } else {
+      this[kEvents].loadend = null
+    }
+  }
+
+  get onerror () {
+    webidl.brandCheck(this, FileReader)
+
+    return this[kEvents].error
+  }
+
+  set onerror (fn) {
+    webidl.brandCheck(this, FileReader)
+
+    if (this[kEvents].error) {
+      this.removeEventListener('error', this[kEvents].error)
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].error = fn
+      this.addEventListener('error', fn)
+    } else {
+      this[kEvents].error = null
+    }
+  }
+
+  get onloadstart () {
+    webidl.brandCheck(this, FileReader)
+
+    return this[kEvents].loadstart
+  }
+
+  set onloadstart (fn) {
+    webidl.brandCheck(this, FileReader)
+
+    if (this[kEvents].loadstart) {
+      this.removeEventListener('loadstart', this[kEvents].loadstart)
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].loadstart = fn
+      this.addEventListener('loadstart', fn)
+    } else {
+      this[kEvents].loadstart = null
+    }
+  }
+
+  get onprogress () {
+    webidl.brandCheck(this, FileReader)
+
+    return this[kEvents].progress
+  }
+
+  set onprogress (fn) {
+    webidl.brandCheck(this, FileReader)
+
+    if (this[kEvents].progress) {
+      this.removeEventListener('progress', this[kEvents].progress)
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].progress = fn
+      this.addEventListener('progress', fn)
+    } else {
+      this[kEvents].progress = null
+    }
+  }
+
+  get onload () {
+    webidl.brandCheck(this, FileReader)
+
+    return this[kEvents].load
+  }
+
+  set onload (fn) {
+    webidl.brandCheck(this, FileReader)
+
+    if (this[kEvents].load) {
+      this.removeEventListener('load', this[kEvents].load)
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].load = fn
+      this.addEventListener('load', fn)
+    } else {
+      this[kEvents].load = null
+    }
+  }
+
+  get onabort () {
+    webidl.brandCheck(this, FileReader)
+
+    return this[kEvents].abort
+  }
+
+  set onabort (fn) {
+    webidl.brandCheck(this, FileReader)
+
+    if (this[kEvents].abort) {
+      this.removeEventListener('abort', this[kEvents].abort)
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].abort = fn
+      this.addEventListener('abort', fn)
+    } else {
+      this[kEvents].abort = null
+    }
+  }
+}
+
+// https://w3c.github.io/FileAPI/#dom-filereader-empty
+FileReader.EMPTY = FileReader.prototype.EMPTY = 0
+// https://w3c.github.io/FileAPI/#dom-filereader-loading
+FileReader.LOADING = FileReader.prototype.LOADING = 1
+// https://w3c.github.io/FileAPI/#dom-filereader-done
+FileReader.DONE = FileReader.prototype.DONE = 2
+
+Object.defineProperties(FileReader.prototype, {
+  EMPTY: staticPropertyDescriptors,
+  LOADING: staticPropertyDescriptors,
+  DONE: staticPropertyDescriptors,
+  readAsArrayBuffer: kEnumerableProperty,
+  readAsBinaryString: kEnumerableProperty,
+  readAsText: kEnumerableProperty,
+  readAsDataURL: kEnumerableProperty,
+  abort: kEnumerableProperty,
+  readyState: kEnumerableProperty,
+  result: kEnumerableProperty,
+  error: kEnumerableProperty,
+  onloadstart: kEnumerableProperty,
+  onprogress: kEnumerableProperty,
+  onload: kEnumerableProperty,
+  onabort: kEnumerableProperty,
+  onerror: kEnumerableProperty,
+  onloadend: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'FileReader',
+    writable: false,
+    enumerable: false,
+    configurable: true
+  }
+})
+
+Object.defineProperties(FileReader, {
+  EMPTY: staticPropertyDescriptors,
+  LOADING: staticPropertyDescriptors,
+  DONE: staticPropertyDescriptors
+})
+
+module.exports = {
+  FileReader
+}
+
+
+/***/ }),
+
+/***/ 62415:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { webidl } = __nccwpck_require__(37829)
+
+const kState = Symbol('ProgressEvent state')
+
+/**
+ * @see https://xhr.spec.whatwg.org/#progressevent
+ */
+class ProgressEvent extends Event {
+  constructor (type, eventInitDict = {}) {
+    type = webidl.converters.DOMString(type, 'ProgressEvent constructor', 'type')
+    eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {})
+
+    super(type, eventInitDict)
+
+    this[kState] = {
+      lengthComputable: eventInitDict.lengthComputable,
+      loaded: eventInitDict.loaded,
+      total: eventInitDict.total
+    }
+  }
+
+  get lengthComputable () {
+    webidl.brandCheck(this, ProgressEvent)
+
+    return this[kState].lengthComputable
+  }
+
+  get loaded () {
+    webidl.brandCheck(this, ProgressEvent)
+
+    return this[kState].loaded
+  }
+
+  get total () {
+    webidl.brandCheck(this, ProgressEvent)
+
+    return this[kState].total
+  }
+}
+
+webidl.converters.ProgressEventInit = webidl.dictionaryConverter([
+  {
+    key: 'lengthComputable',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'loaded',
+    converter: webidl.converters['unsigned long long'],
+    defaultValue: () => 0
+  },
+  {
+    key: 'total',
+    converter: webidl.converters['unsigned long long'],
+    defaultValue: () => 0
+  },
+  {
+    key: 'bubbles',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'cancelable',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'composed',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  }
+])
+
+module.exports = {
+  ProgressEvent
+}
+
+
+/***/ }),
+
+/***/ 24666:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = {
+  kState: Symbol('FileReader state'),
+  kResult: Symbol('FileReader result'),
+  kError: Symbol('FileReader error'),
+  kLastProgressEventFired: Symbol('FileReader last progress event fired timestamp'),
+  kEvents: Symbol('FileReader events'),
+  kAborted: Symbol('FileReader aborted')
+}
+
+
+/***/ }),
+
+/***/ 82947:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  kState,
+  kError,
+  kResult,
+  kAborted,
+  kLastProgressEventFired
+} = __nccwpck_require__(24666)
+const { ProgressEvent } = __nccwpck_require__(62415)
+const { getEncoding } = __nccwpck_require__(19420)
+const { serializeAMimeType, parseMIMEType } = __nccwpck_require__(86954)
+const { types } = __nccwpck_require__(47261)
+const { StringDecoder } = __nccwpck_require__(71576)
+const { btoa } = __nccwpck_require__(72254)
+
+/** @type {PropertyDescriptor} */
+const staticPropertyDescriptors = {
+  enumerable: true,
+  writable: false,
+  configurable: false
+}
+
+/**
+ * @see https://w3c.github.io/FileAPI/#readOperation
+ * @param {import('./filereader').FileReader} fr
+ * @param {import('buffer').Blob} blob
+ * @param {string} type
+ * @param {string?} encodingName
+ */
+function readOperation (fr, blob, type, encodingName) {
+  // 1. If fr’s state is "loading", throw an InvalidStateError
+  //    DOMException.
+  if (fr[kState] === 'loading') {
+    throw new DOMException('Invalid state', 'InvalidStateError')
+  }
+
+  // 2. Set fr’s state to "loading".
+  fr[kState] = 'loading'
+
+  // 3. Set fr’s result to null.
+  fr[kResult] = null
+
+  // 4. Set fr’s error to null.
+  fr[kError] = null
+
+  // 5. Let stream be the result of calling get stream on blob.
+  /** @type {import('stream/web').ReadableStream} */
+  const stream = blob.stream()
+
+  // 6. Let reader be the result of getting a reader from stream.
+  const reader = stream.getReader()
+
+  // 7. Let bytes be an empty byte sequence.
+  /** @type {Uint8Array[]} */
+  const bytes = []
+
+  // 8. Let chunkPromise be the result of reading a chunk from
+  //    stream with reader.
+  let chunkPromise = reader.read()
+
+  // 9. Let isFirstChunk be true.
+  let isFirstChunk = true
+
+  // 10. In parallel, while true:
+  // Note: "In parallel" just means non-blocking
+  // Note 2: readOperation itself cannot be async as double
+  // reading the body would then reject the promise, instead
+  // of throwing an error.
+  ;(async () => {
+    while (!fr[kAborted]) {
+      // 1. Wait for chunkPromise to be fulfilled or rejected.
+      try {
+        const { done, value } = await chunkPromise
+
+        // 2. If chunkPromise is fulfilled, and isFirstChunk is
+        //    true, queue a task to fire a progress event called
+        //    loadstart at fr.
+        if (isFirstChunk && !fr[kAborted]) {
+          queueMicrotask(() => {
+            fireAProgressEvent('loadstart', fr)
+          })
+        }
+
+        // 3. Set isFirstChunk to false.
+        isFirstChunk = false
+
+        // 4. If chunkPromise is fulfilled with an object whose
+        //    done property is false and whose value property is
+        //    a Uint8Array object, run these steps:
+        if (!done && types.isUint8Array(value)) {
+          // 1. Let bs be the byte sequence represented by the
+          //    Uint8Array object.
+
+          // 2. Append bs to bytes.
+          bytes.push(value)
+
+          // 3. If roughly 50ms have passed since these steps
+          //    were last invoked, queue a task to fire a
+          //    progress event called progress at fr.
+          if (
+            (
+              fr[kLastProgressEventFired] === undefined ||
+              Date.now() - fr[kLastProgressEventFired] >= 50
+            ) &&
+            !fr[kAborted]
+          ) {
+            fr[kLastProgressEventFired] = Date.now()
+            queueMicrotask(() => {
+              fireAProgressEvent('progress', fr)
+            })
+          }
+
+          // 4. Set chunkPromise to the result of reading a
+          //    chunk from stream with reader.
+          chunkPromise = reader.read()
+        } else if (done) {
+          // 5. Otherwise, if chunkPromise is fulfilled with an
+          //    object whose done property is true, queue a task
+          //    to run the following steps and abort this algorithm:
+          queueMicrotask(() => {
+            // 1. Set fr’s state to "done".
+            fr[kState] = 'done'
+
+            // 2. Let result be the result of package data given
+            //    bytes, type, blob’s type, and encodingName.
+            try {
+              const result = packageData(bytes, type, blob.type, encodingName)
+
+              // 4. Else:
+
+              if (fr[kAborted]) {
+                return
+              }
+
+              // 1. Set fr’s result to result.
+              fr[kResult] = result
+
+              // 2. Fire a progress event called load at the fr.
+              fireAProgressEvent('load', fr)
+            } catch (error) {
+              // 3. If package data threw an exception error:
+
+              // 1. Set fr’s error to error.
+              fr[kError] = error
+
+              // 2. Fire a progress event called error at fr.
+              fireAProgressEvent('error', fr)
+            }
+
+            // 5. If fr’s state is not "loading", fire a progress
+            //    event called loadend at the fr.
+            if (fr[kState] !== 'loading') {
+              fireAProgressEvent('loadend', fr)
+            }
+          })
+
+          break
+        }
+      } catch (error) {
+        if (fr[kAborted]) {
+          return
+        }
+
+        // 6. Otherwise, if chunkPromise is rejected with an
+        //    error error, queue a task to run the following
+        //    steps and abort this algorithm:
+        queueMicrotask(() => {
+          // 1. Set fr’s state to "done".
+          fr[kState] = 'done'
+
+          // 2. Set fr’s error to error.
+          fr[kError] = error
+
+          // 3. Fire a progress event called error at fr.
+          fireAProgressEvent('error', fr)
+
+          // 4. If fr’s state is not "loading", fire a progress
+          //    event called loadend at fr.
+          if (fr[kState] !== 'loading') {
+            fireAProgressEvent('loadend', fr)
+          }
+        })
+
+        break
+      }
+    }
+  })()
+}
+
+/**
+ * @see https://w3c.github.io/FileAPI/#fire-a-progress-event
+ * @see https://dom.spec.whatwg.org/#concept-event-fire
+ * @param {string} e The name of the event
+ * @param {import('./filereader').FileReader} reader
+ */
+function fireAProgressEvent (e, reader) {
+  // The progress event e does not bubble. e.bubbles must be false
+  // The progress event e is NOT cancelable. e.cancelable must be false
+  const event = new ProgressEvent(e, {
+    bubbles: false,
+    cancelable: false
+  })
+
+  reader.dispatchEvent(event)
+}
+
+/**
+ * @see https://w3c.github.io/FileAPI/#blob-package-data
+ * @param {Uint8Array[]} bytes
+ * @param {string} type
+ * @param {string?} mimeType
+ * @param {string?} encodingName
+ */
+function packageData (bytes, type, mimeType, encodingName) {
+  // 1. A Blob has an associated package data algorithm, given
+  //    bytes, a type, a optional mimeType, and a optional
+  //    encodingName, which switches on type and runs the
+  //    associated steps:
+
+  switch (type) {
+    case 'DataURL': {
+      // 1. Return bytes as a DataURL [RFC2397] subject to
+      //    the considerations below:
+      //  * Use mimeType as part of the Data URL if it is
+      //    available in keeping with the Data URL
+      //    specification [RFC2397].
+      //  * If mimeType is not available return a Data URL
+      //    without a media-type. [RFC2397].
+
+      // https://datatracker.ietf.org/doc/html/rfc2397#section-3
+      // dataurl    := "data:" [ mediatype ] [ ";base64" ] "," data
+      // mediatype  := [ type "/" subtype ] *( ";" parameter )
+      // data       := *urlchar
+      // parameter  := attribute "=" value
+      let dataURL = 'data:'
+
+      const parsed = parseMIMEType(mimeType || 'application/octet-stream')
+
+      if (parsed !== 'failure') {
+        dataURL += serializeAMimeType(parsed)
+      }
+
+      dataURL += ';base64,'
+
+      const decoder = new StringDecoder('latin1')
+
+      for (const chunk of bytes) {
+        dataURL += btoa(decoder.write(chunk))
+      }
+
+      dataURL += btoa(decoder.end())
+
+      return dataURL
+    }
+    case 'Text': {
+      // 1. Let encoding be failure
+      let encoding = 'failure'
+
+      // 2. If the encodingName is present, set encoding to the
+      //    result of getting an encoding from encodingName.
+      if (encodingName) {
+        encoding = getEncoding(encodingName)
+      }
+
+      // 3. If encoding is failure, and mimeType is present:
+      if (encoding === 'failure' && mimeType) {
+        // 1. Let type be the result of parse a MIME type
+        //    given mimeType.
+        const type = parseMIMEType(mimeType)
+
+        // 2. If type is not failure, set encoding to the result
+        //    of getting an encoding from type’s parameters["charset"].
+        if (type !== 'failure') {
+          encoding = getEncoding(type.parameters.get('charset'))
+        }
+      }
+
+      // 4. If encoding is failure, then set encoding to UTF-8.
+      if (encoding === 'failure') {
+        encoding = 'UTF-8'
+      }
+
+      // 5. Decode bytes using fallback encoding encoding, and
+      //    return the result.
+      return decode(bytes, encoding)
+    }
+    case 'ArrayBuffer': {
+      // Return a new ArrayBuffer whose contents are bytes.
+      const sequence = combineByteSequences(bytes)
+
+      return sequence.buffer
+    }
+    case 'BinaryString': {
+      // Return bytes as a binary string, in which every byte
+      //  is represented by a code unit of equal value [0..255].
+      let binaryString = ''
+
+      const decoder = new StringDecoder('latin1')
+
+      for (const chunk of bytes) {
+        binaryString += decoder.write(chunk)
+      }
+
+      binaryString += decoder.end()
+
+      return binaryString
+    }
+  }
+}
+
+/**
+ * @see https://encoding.spec.whatwg.org/#decode
+ * @param {Uint8Array[]} ioQueue
+ * @param {string} encoding
+ */
+function decode (ioQueue, encoding) {
+  const bytes = combineByteSequences(ioQueue)
+
+  // 1. Let BOMEncoding be the result of BOM sniffing ioQueue.
+  const BOMEncoding = BOMSniffing(bytes)
+
+  let slice = 0
+
+  // 2. If BOMEncoding is non-null:
+  if (BOMEncoding !== null) {
+    // 1. Set encoding to BOMEncoding.
+    encoding = BOMEncoding
+
+    // 2. Read three bytes from ioQueue, if BOMEncoding is
+    //    UTF-8; otherwise read two bytes.
+    //    (Do nothing with those bytes.)
+    slice = BOMEncoding === 'UTF-8' ? 3 : 2
+  }
+
+  // 3. Process a queue with an instance of encoding’s
+  //    decoder, ioQueue, output, and "replacement".
+
+  // 4. Return output.
+
+  const sliced = bytes.slice(slice)
+  return new TextDecoder(encoding).decode(sliced)
+}
+
+/**
+ * @see https://encoding.spec.whatwg.org/#bom-sniff
+ * @param {Uint8Array} ioQueue
+ */
+function BOMSniffing (ioQueue) {
+  // 1. Let BOM be the result of peeking 3 bytes from ioQueue,
+  //    converted to a byte sequence.
+  const [a, b, c] = ioQueue
+
+  // 2. For each of the rows in the table below, starting with
+  //    the first one and going down, if BOM starts with the
+  //    bytes given in the first column, then return the
+  //    encoding given in the cell in the second column of that
+  //    row. Otherwise, return null.
+  if (a === 0xEF && b === 0xBB && c === 0xBF) {
+    return 'UTF-8'
+  } else if (a === 0xFE && b === 0xFF) {
+    return 'UTF-16BE'
+  } else if (a === 0xFF && b === 0xFE) {
+    return 'UTF-16LE'
+  }
+
+  return null
+}
+
+/**
+ * @param {Uint8Array[]} sequences
+ */
+function combineByteSequences (sequences) {
+  const size = sequences.reduce((a, b) => {
+    return a + b.byteLength
+  }, 0)
+
+  let offset = 0
+
+  return sequences.reduce((a, b) => {
+    a.set(b, offset)
+    offset += b.byteLength
+    return a
+  }, new Uint8Array(size))
+}
+
+module.exports = {
+  staticPropertyDescriptors,
+  readOperation,
+  fireAProgressEvent
+}
+
+
+/***/ }),
+
+/***/ 19072:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = __nccwpck_require__(15318)
+const {
+  kReadyState,
+  kSentClose,
+  kByteParser,
+  kReceivedClose,
+  kResponse
+} = __nccwpck_require__(38471)
+const { fireEvent, failWebsocketConnection, isClosing, isClosed, isEstablished, parseExtensions } = __nccwpck_require__(13187)
+const { channels } = __nccwpck_require__(8627)
+const { CloseEvent } = __nccwpck_require__(15135)
+const { makeRequest } = __nccwpck_require__(13925)
+const { fetching } = __nccwpck_require__(31158)
+const { Headers, getHeadersList } = __nccwpck_require__(24997)
+const { getDecodeSplit } = __nccwpck_require__(91976)
+const { WebsocketFrameSend } = __nccwpck_require__(61163)
+
+/** @type {import('crypto')} */
+let crypto
+try {
+  crypto = __nccwpck_require__(6005)
+/* c8 ignore next 3 */
+} catch {
+
+}
+
+/**
+ * @see https://websockets.spec.whatwg.org/#concept-websocket-establish
+ * @param {URL} url
+ * @param {string|string[]} protocols
+ * @param {import('./websocket').WebSocket} ws
+ * @param {(response: any, extensions: string[] | undefined) => void} onEstablish
+ * @param {Partial<import('../../types/websocket').WebSocketInit>} options
+ */
+function establishWebSocketConnection (url, protocols, client, ws, onEstablish, options) {
+  // 1. Let requestURL be a copy of url, with its scheme set to "http", if url’s
+  //    scheme is "ws", and to "https" otherwise.
+  const requestURL = url
+
+  requestURL.protocol = url.protocol === 'ws:' ? 'http:' : 'https:'
+
+  // 2. Let request be a new request, whose URL is requestURL, client is client,
+  //    service-workers mode is "none", referrer is "no-referrer", mode is
+  //    "websocket", credentials mode is "include", cache mode is "no-store" ,
+  //    and redirect mode is "error".
+  const request = makeRequest({
+    urlList: [requestURL],
+    client,
+    serviceWorkers: 'none',
+    referrer: 'no-referrer',
+    mode: 'websocket',
+    credentials: 'include',
+    cache: 'no-store',
+    redirect: 'error'
+  })
+
+  // Note: undici extension, allow setting custom headers.
+  if (options.headers) {
+    const headersList = getHeadersList(new Headers(options.headers))
+
+    request.headersList = headersList
+  }
+
+  // 3. Append (`Upgrade`, `websocket`) to request’s header list.
+  // 4. Append (`Connection`, `Upgrade`) to request’s header list.
+  // Note: both of these are handled by undici currently.
+  // https://github.com/nodejs/undici/blob/68c269c4144c446f3f1220951338daef4a6b5ec4/lib/client.js#L1397
+
+  // 5. Let keyValue be a nonce consisting of a randomly selected
+  //    16-byte value that has been forgiving-base64-encoded and
+  //    isomorphic encoded.
+  const keyValue = crypto.randomBytes(16).toString('base64')
+
+  // 6. Append (`Sec-WebSocket-Key`, keyValue) to request’s
+  //    header list.
+  request.headersList.append('sec-websocket-key', keyValue)
+
+  // 7. Append (`Sec-WebSocket-Version`, `13`) to request’s
+  //    header list.
+  request.headersList.append('sec-websocket-version', '13')
+
+  // 8. For each protocol in protocols, combine
+  //    (`Sec-WebSocket-Protocol`, protocol) in request’s header
+  //    list.
+  for (const protocol of protocols) {
+    request.headersList.append('sec-websocket-protocol', protocol)
+  }
+
+  // 9. Let permessageDeflate be a user-agent defined
+  //    "permessage-deflate" extension header value.
+  // https://github.com/mozilla/gecko-dev/blob/ce78234f5e653a5d3916813ff990f053510227bc/netwerk/protocol/websocket/WebSocketChannel.cpp#L2673
+  const permessageDeflate = 'permessage-deflate; client_max_window_bits'
+
+  // 10. Append (`Sec-WebSocket-Extensions`, permessageDeflate) to
+  //     request’s header list.
+  request.headersList.append('sec-websocket-extensions', permessageDeflate)
+
+  // 11. Fetch request with useParallelQueue set to true, and
+  //     processResponse given response being these steps:
+  const controller = fetching({
+    request,
+    useParallelQueue: true,
+    dispatcher: options.dispatcher,
+    processResponse (response) {
+      // 1. If response is a network error or its status is not 101,
+      //    fail the WebSocket connection.
+      if (response.type === 'error' || response.status !== 101) {
+        failWebsocketConnection(ws, 'Received network error or non-101 status code.')
+        return
+      }
+
+      // 2. If protocols is not the empty list and extracting header
+      //    list values given `Sec-WebSocket-Protocol` and response’s
+      //    header list results in null, failure, or the empty byte
+      //    sequence, then fail the WebSocket connection.
+      if (protocols.length !== 0 && !response.headersList.get('Sec-WebSocket-Protocol')) {
+        failWebsocketConnection(ws, 'Server did not respond with sent protocols.')
+        return
+      }
+
+      // 3. Follow the requirements stated step 2 to step 6, inclusive,
+      //    of the last set of steps in section 4.1 of The WebSocket
+      //    Protocol to validate response. This either results in fail
+      //    the WebSocket connection or the WebSocket connection is
+      //    established.
+
+      // 2. If the response lacks an |Upgrade| header field or the |Upgrade|
+      //    header field contains a value that is not an ASCII case-
+      //    insensitive match for the value "websocket", the client MUST
+      //    _Fail the WebSocket Connection_.
+      if (response.headersList.get('Upgrade')?.toLowerCase() !== 'websocket') {
+        failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".')
+        return
+      }
+
+      // 3. If the response lacks a |Connection| header field or the
+      //    |Connection| header field doesn't contain a token that is an
+      //    ASCII case-insensitive match for the value "Upgrade", the client
+      //    MUST _Fail the WebSocket Connection_.
+      if (response.headersList.get('Connection')?.toLowerCase() !== 'upgrade') {
+        failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".')
+        return
+      }
+
+      // 4. If the response lacks a |Sec-WebSocket-Accept| header field or
+      //    the |Sec-WebSocket-Accept| contains a value other than the
+      //    base64-encoded SHA-1 of the concatenation of the |Sec-WebSocket-
+      //    Key| (as a string, not base64-decoded) with the string "258EAFA5-
+      //    E914-47DA-95CA-C5AB0DC85B11" but ignoring any leading and
+      //    trailing whitespace, the client MUST _Fail the WebSocket
+      //    Connection_.
+      const secWSAccept = response.headersList.get('Sec-WebSocket-Accept')
+      const digest = crypto.createHash('sha1').update(keyValue + uid).digest('base64')
+      if (secWSAccept !== digest) {
+        failWebsocketConnection(ws, 'Incorrect hash received in Sec-WebSocket-Accept header.')
+        return
+      }
+
+      // 5. If the response includes a |Sec-WebSocket-Extensions| header
+      //    field and this header field indicates the use of an extension
+      //    that was not present in the client's handshake (the server has
+      //    indicated an extension not requested by the client), the client
+      //    MUST _Fail the WebSocket Connection_.  (The parsing of this
+      //    header field to determine which extensions are requested is
+      //    discussed in Section 9.1.)
+      const secExtension = response.headersList.get('Sec-WebSocket-Extensions')
+      let extensions
+
+      if (secExtension !== null) {
+        extensions = parseExtensions(secExtension)
+
+        if (!extensions.has('permessage-deflate')) {
+          failWebsocketConnection(ws, 'Sec-WebSocket-Extensions header does not match.')
+          return
+        }
+      }
+
+      // 6. If the response includes a |Sec-WebSocket-Protocol| header field
+      //    and this header field indicates the use of a subprotocol that was
+      //    not present in the client's handshake (the server has indicated a
+      //    subprotocol not requested by the client), the client MUST _Fail
+      //    the WebSocket Connection_.
+      const secProtocol = response.headersList.get('Sec-WebSocket-Protocol')
+
+      if (secProtocol !== null) {
+        const requestProtocols = getDecodeSplit('sec-websocket-protocol', request.headersList)
+
+        // The client can request that the server use a specific subprotocol by
+        // including the |Sec-WebSocket-Protocol| field in its handshake.  If it
+        // is specified, the server needs to include the same field and one of
+        // the selected subprotocol values in its response for the connection to
+        // be established.
+        if (!requestProtocols.includes(secProtocol)) {
+          failWebsocketConnection(ws, 'Protocol was not set in the opening handshake.')
+          return
+        }
+      }
+
+      response.socket.on('data', onSocketData)
+      response.socket.on('close', onSocketClose)
+      response.socket.on('error', onSocketError)
+
+      if (channels.open.hasSubscribers) {
+        channels.open.publish({
+          address: response.socket.address(),
+          protocol: secProtocol,
+          extensions: secExtension
+        })
+      }
+
+      onEstablish(response, extensions)
+    }
+  })
+
+  return controller
+}
+
+function closeWebSocketConnection (ws, code, reason, reasonByteLength) {
+  if (isClosing(ws) || isClosed(ws)) {
+    // If this's ready state is CLOSING (2) or CLOSED (3)
+    // Do nothing.
+  } else if (!isEstablished(ws)) {
+    // If the WebSocket connection is not yet established
+    // Fail the WebSocket connection and set this's ready state
+    // to CLOSING (2).
+    failWebsocketConnection(ws, 'Connection was closed before it was established.')
+    ws[kReadyState] = states.CLOSING
+  } else if (ws[kSentClose] === sentCloseFrameState.NOT_SENT) {
+    // If the WebSocket closing handshake has not yet been started
+    // Start the WebSocket closing handshake and set this's ready
+    // state to CLOSING (2).
+    // - If neither code nor reason is present, the WebSocket Close
+    //   message must not have a body.
+    // - If code is present, then the status code to use in the
+    //   WebSocket Close message must be the integer given by code.
+    // - If reason is also present, then reasonBytes must be
+    //   provided in the Close message after the status code.
+
+    ws[kSentClose] = sentCloseFrameState.PROCESSING
+
+    const frame = new WebsocketFrameSend()
+
+    // If neither code nor reason is present, the WebSocket Close
+    // message must not have a body.
+
+    // If code is present, then the status code to use in the
+    // WebSocket Close message must be the integer given by code.
+    if (code !== undefined && reason === undefined) {
+      frame.frameData = Buffer.allocUnsafe(2)
+      frame.frameData.writeUInt16BE(code, 0)
+    } else if (code !== undefined && reason !== undefined) {
+      // If reason is also present, then reasonBytes must be
+      // provided in the Close message after the status code.
+      frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength)
+      frame.frameData.writeUInt16BE(code, 0)
+      // the body MAY contain UTF-8-encoded data with value /reason/
+      frame.frameData.write(reason, 2, 'utf-8')
+    } else {
+      frame.frameData = emptyBuffer
+    }
+
+    /** @type {import('stream').Duplex} */
+    const socket = ws[kResponse].socket
+
+    socket.write(frame.createFrame(opcodes.CLOSE))
+
+    ws[kSentClose] = sentCloseFrameState.SENT
+
+    // Upon either sending or receiving a Close control frame, it is said
+    // that _The WebSocket Closing Handshake is Started_ and that the
+    // WebSocket connection is in the CLOSING state.
+    ws[kReadyState] = states.CLOSING
+  } else {
+    // Otherwise
+    // Set this's ready state to CLOSING (2).
+    ws[kReadyState] = states.CLOSING
+  }
+}
+
+/**
+ * @param {Buffer} chunk
+ */
+function onSocketData (chunk) {
+  if (!this.ws[kByteParser].write(chunk)) {
+    this.pause()
+  }
+}
+
+/**
+ * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
+ * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.4
+ */
+function onSocketClose () {
+  const { ws } = this
+  const { [kResponse]: response } = ws
+
+  response.socket.off('data', onSocketData)
+  response.socket.off('close', onSocketClose)
+  response.socket.off('error', onSocketError)
+
+  // If the TCP connection was closed after the
+  // WebSocket closing handshake was completed, the WebSocket connection
+  // is said to have been closed _cleanly_.
+  const wasClean = ws[kSentClose] === sentCloseFrameState.SENT && ws[kReceivedClose]
+
+  let code = 1005
+  let reason = ''
+
+  const result = ws[kByteParser].closingInfo
+
+  if (result && !result.error) {
+    code = result.code ?? 1005
+    reason = result.reason
+  } else if (!ws[kReceivedClose]) {
+    // If _The WebSocket
+    // Connection is Closed_ and no Close control frame was received by the
+    // endpoint (such as could occur if the underlying transport connection
+    // is lost), _The WebSocket Connection Close Code_ is considered to be
+    // 1006.
+    code = 1006
+  }
+
+  // 1. Change the ready state to CLOSED (3).
+  ws[kReadyState] = states.CLOSED
+
+  // 2. If the user agent was required to fail the WebSocket
+  //    connection, or if the WebSocket connection was closed
+  //    after being flagged as full, fire an event named error
+  //    at the WebSocket object.
+  // TODO
+
+  // 3. Fire an event named close at the WebSocket object,
+  //    using CloseEvent, with the wasClean attribute
+  //    initialized to true if the connection closed cleanly
+  //    and false otherwise, the code attribute initialized to
+  //    the WebSocket connection close code, and the reason
+  //    attribute initialized to the result of applying UTF-8
+  //    decode without BOM to the WebSocket connection close
+  //    reason.
+  // TODO: process.nextTick
+  fireEvent('close', ws, (type, init) => new CloseEvent(type, init), {
+    wasClean, code, reason
+  })
+
+  if (channels.close.hasSubscribers) {
+    channels.close.publish({
+      websocket: ws,
+      code,
+      reason
+    })
+  }
+}
+
+function onSocketError (error) {
+  const { ws } = this
+
+  ws[kReadyState] = states.CLOSING
+
+  if (channels.socketError.hasSubscribers) {
+    channels.socketError.publish(error)
+  }
+
+  this.destroy()
+}
+
+module.exports = {
+  establishWebSocketConnection,
+  closeWebSocketConnection
+}
+
+
+/***/ }),
+
+/***/ 15318:
+/***/ ((module) => {
+
+"use strict";
+
+
+// This is a Globally Unique Identifier unique used
+// to validate that the endpoint accepts websocket
+// connections.
+// See https://www.rfc-editor.org/rfc/rfc6455.html#section-1.3
+const uid = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+/** @type {PropertyDescriptor} */
+const staticPropertyDescriptors = {
+  enumerable: true,
+  writable: false,
+  configurable: false
+}
+
+const states = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+}
+
+const sentCloseFrameState = {
+  NOT_SENT: 0,
+  PROCESSING: 1,
+  SENT: 2
+}
+
+const opcodes = {
+  CONTINUATION: 0x0,
+  TEXT: 0x1,
+  BINARY: 0x2,
+  CLOSE: 0x8,
+  PING: 0x9,
+  PONG: 0xA
+}
+
+const maxUnsigned16Bit = 2 ** 16 - 1 // 65535
+
+const parserStates = {
+  INFO: 0,
+  PAYLOADLENGTH_16: 2,
+  PAYLOADLENGTH_64: 3,
+  READ_DATA: 4
+}
+
+const emptyBuffer = Buffer.allocUnsafe(0)
+
+const sendHints = {
+  string: 1,
+  typedArray: 2,
+  arrayBuffer: 3,
+  blob: 4
+}
+
+module.exports = {
+  uid,
+  sentCloseFrameState,
+  staticPropertyDescriptors,
+  states,
+  opcodes,
+  maxUnsigned16Bit,
+  parserStates,
+  emptyBuffer,
+  sendHints
+}
+
+
+/***/ }),
+
+/***/ 15135:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { webidl } = __nccwpck_require__(37829)
+const { kEnumerableProperty } = __nccwpck_require__(94407)
+const { kConstruct } = __nccwpck_require__(5392)
+const { MessagePort } = __nccwpck_require__(24086)
+
+/**
+ * @see https://html.spec.whatwg.org/multipage/comms.html#messageevent
+ */
+class MessageEvent extends Event {
+  #eventInit
+
+  constructor (type, eventInitDict = {}) {
+    if (type === kConstruct) {
+      super(arguments[1], arguments[2])
+      webidl.util.markAsUncloneable(this)
+      return
+    }
+
+    const prefix = 'MessageEvent constructor'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    type = webidl.converters.DOMString(type, prefix, 'type')
+    eventInitDict = webidl.converters.MessageEventInit(eventInitDict, prefix, 'eventInitDict')
+
+    super(type, eventInitDict)
+
+    this.#eventInit = eventInitDict
+    webidl.util.markAsUncloneable(this)
+  }
+
+  get data () {
+    webidl.brandCheck(this, MessageEvent)
+
+    return this.#eventInit.data
+  }
+
+  get origin () {
+    webidl.brandCheck(this, MessageEvent)
+
+    return this.#eventInit.origin
+  }
+
+  get lastEventId () {
+    webidl.brandCheck(this, MessageEvent)
+
+    return this.#eventInit.lastEventId
+  }
+
+  get source () {
+    webidl.brandCheck(this, MessageEvent)
+
+    return this.#eventInit.source
+  }
+
+  get ports () {
+    webidl.brandCheck(this, MessageEvent)
+
+    if (!Object.isFrozen(this.#eventInit.ports)) {
+      Object.freeze(this.#eventInit.ports)
+    }
+
+    return this.#eventInit.ports
+  }
+
+  initMessageEvent (
+    type,
+    bubbles = false,
+    cancelable = false,
+    data = null,
+    origin = '',
+    lastEventId = '',
+    source = null,
+    ports = []
+  ) {
+    webidl.brandCheck(this, MessageEvent)
+
+    webidl.argumentLengthCheck(arguments, 1, 'MessageEvent.initMessageEvent')
+
+    return new MessageEvent(type, {
+      bubbles, cancelable, data, origin, lastEventId, source, ports
+    })
+  }
+
+  static createFastMessageEvent (type, init) {
+    const messageEvent = new MessageEvent(kConstruct, type, init)
+    messageEvent.#eventInit = init
+    messageEvent.#eventInit.data ??= null
+    messageEvent.#eventInit.origin ??= ''
+    messageEvent.#eventInit.lastEventId ??= ''
+    messageEvent.#eventInit.source ??= null
+    messageEvent.#eventInit.ports ??= []
+    return messageEvent
+  }
+}
+
+const { createFastMessageEvent } = MessageEvent
+delete MessageEvent.createFastMessageEvent
+
+/**
+ * @see https://websockets.spec.whatwg.org/#the-closeevent-interface
+ */
+class CloseEvent extends Event {
+  #eventInit
+
+  constructor (type, eventInitDict = {}) {
+    const prefix = 'CloseEvent constructor'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    type = webidl.converters.DOMString(type, prefix, 'type')
+    eventInitDict = webidl.converters.CloseEventInit(eventInitDict)
+
+    super(type, eventInitDict)
+
+    this.#eventInit = eventInitDict
+    webidl.util.markAsUncloneable(this)
+  }
+
+  get wasClean () {
+    webidl.brandCheck(this, CloseEvent)
+
+    return this.#eventInit.wasClean
+  }
+
+  get code () {
+    webidl.brandCheck(this, CloseEvent)
+
+    return this.#eventInit.code
+  }
+
+  get reason () {
+    webidl.brandCheck(this, CloseEvent)
+
+    return this.#eventInit.reason
+  }
+}
+
+// https://html.spec.whatwg.org/multipage/webappapis.html#the-errorevent-interface
+class ErrorEvent extends Event {
+  #eventInit
+
+  constructor (type, eventInitDict) {
+    const prefix = 'ErrorEvent constructor'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    super(type, eventInitDict)
+    webidl.util.markAsUncloneable(this)
+
+    type = webidl.converters.DOMString(type, prefix, 'type')
+    eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {})
+
+    this.#eventInit = eventInitDict
+  }
+
+  get message () {
+    webidl.brandCheck(this, ErrorEvent)
+
+    return this.#eventInit.message
+  }
+
+  get filename () {
+    webidl.brandCheck(this, ErrorEvent)
+
+    return this.#eventInit.filename
+  }
+
+  get lineno () {
+    webidl.brandCheck(this, ErrorEvent)
+
+    return this.#eventInit.lineno
+  }
+
+  get colno () {
+    webidl.brandCheck(this, ErrorEvent)
+
+    return this.#eventInit.colno
+  }
+
+  get error () {
+    webidl.brandCheck(this, ErrorEvent)
+
+    return this.#eventInit.error
+  }
+}
+
+Object.defineProperties(MessageEvent.prototype, {
+  [Symbol.toStringTag]: {
+    value: 'MessageEvent',
+    configurable: true
+  },
+  data: kEnumerableProperty,
+  origin: kEnumerableProperty,
+  lastEventId: kEnumerableProperty,
+  source: kEnumerableProperty,
+  ports: kEnumerableProperty,
+  initMessageEvent: kEnumerableProperty
+})
+
+Object.defineProperties(CloseEvent.prototype, {
+  [Symbol.toStringTag]: {
+    value: 'CloseEvent',
+    configurable: true
+  },
+  reason: kEnumerableProperty,
+  code: kEnumerableProperty,
+  wasClean: kEnumerableProperty
+})
+
+Object.defineProperties(ErrorEvent.prototype, {
+  [Symbol.toStringTag]: {
+    value: 'ErrorEvent',
+    configurable: true
+  },
+  message: kEnumerableProperty,
+  filename: kEnumerableProperty,
+  lineno: kEnumerableProperty,
+  colno: kEnumerableProperty,
+  error: kEnumerableProperty
+})
+
+webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort)
+
+webidl.converters['sequence<MessagePort>'] = webidl.sequenceConverter(
+  webidl.converters.MessagePort
+)
+
+const eventInit = [
+  {
+    key: 'bubbles',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'cancelable',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'composed',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  }
+]
+
+webidl.converters.MessageEventInit = webidl.dictionaryConverter([
+  ...eventInit,
+  {
+    key: 'data',
+    converter: webidl.converters.any,
+    defaultValue: () => null
+  },
+  {
+    key: 'origin',
+    converter: webidl.converters.USVString,
+    defaultValue: () => ''
+  },
+  {
+    key: 'lastEventId',
+    converter: webidl.converters.DOMString,
+    defaultValue: () => ''
+  },
+  {
+    key: 'source',
+    // Node doesn't implement WindowProxy or ServiceWorker, so the only
+    // valid value for source is a MessagePort.
+    converter: webidl.nullableConverter(webidl.converters.MessagePort),
+    defaultValue: () => null
+  },
+  {
+    key: 'ports',
+    converter: webidl.converters['sequence<MessagePort>'],
+    defaultValue: () => new Array(0)
+  }
+])
+
+webidl.converters.CloseEventInit = webidl.dictionaryConverter([
+  ...eventInit,
+  {
+    key: 'wasClean',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'code',
+    converter: webidl.converters['unsigned short'],
+    defaultValue: () => 0
+  },
+  {
+    key: 'reason',
+    converter: webidl.converters.USVString,
+    defaultValue: () => ''
+  }
+])
+
+webidl.converters.ErrorEventInit = webidl.dictionaryConverter([
+  ...eventInit,
+  {
+    key: 'message',
+    converter: webidl.converters.DOMString,
+    defaultValue: () => ''
+  },
+  {
+    key: 'filename',
+    converter: webidl.converters.USVString,
+    defaultValue: () => ''
+  },
+  {
+    key: 'lineno',
+    converter: webidl.converters['unsigned long'],
+    defaultValue: () => 0
+  },
+  {
+    key: 'colno',
+    converter: webidl.converters['unsigned long'],
+    defaultValue: () => 0
+  },
+  {
+    key: 'error',
+    converter: webidl.converters.any
+  }
+])
+
+module.exports = {
+  MessageEvent,
+  CloseEvent,
+  ErrorEvent,
+  createFastMessageEvent
+}
+
+
+/***/ }),
+
+/***/ 61163:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { maxUnsigned16Bit } = __nccwpck_require__(15318)
+
+const BUFFER_SIZE = 16386
+
+/** @type {import('crypto')} */
+let crypto
+let buffer = null
+let bufIdx = BUFFER_SIZE
+
+try {
+  crypto = __nccwpck_require__(6005)
+/* c8 ignore next 3 */
+} catch {
+  crypto = {
+    // not full compatibility, but minimum.
+    randomFillSync: function randomFillSync (buffer, _offset, _size) {
+      for (let i = 0; i < buffer.length; ++i) {
+        buffer[i] = Math.random() * 255 | 0
+      }
+      return buffer
+    }
+  }
+}
+
+function generateMask () {
+  if (bufIdx === BUFFER_SIZE) {
+    bufIdx = 0
+    crypto.randomFillSync((buffer ??= Buffer.allocUnsafe(BUFFER_SIZE)), 0, BUFFER_SIZE)
+  }
+  return [buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++]]
+}
+
+class WebsocketFrameSend {
+  /**
+   * @param {Buffer|undefined} data
+   */
+  constructor (data) {
+    this.frameData = data
+  }
+
+  createFrame (opcode) {
+    const frameData = this.frameData
+    const maskKey = generateMask()
+    const bodyLength = frameData?.byteLength ?? 0
+
+    /** @type {number} */
+    let payloadLength = bodyLength // 0-125
+    let offset = 6
+
+    if (bodyLength > maxUnsigned16Bit) {
+      offset += 8 // payload length is next 8 bytes
+      payloadLength = 127
+    } else if (bodyLength > 125) {
+      offset += 2 // payload length is next 2 bytes
+      payloadLength = 126
+    }
+
+    const buffer = Buffer.allocUnsafe(bodyLength + offset)
+
+    // Clear first 2 bytes, everything else is overwritten
+    buffer[0] = buffer[1] = 0
+    buffer[0] |= 0x80 // FIN
+    buffer[0] = (buffer[0] & 0xF0) + opcode // opcode
+
+    /*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> */
+    buffer[offset - 4] = maskKey[0]
+    buffer[offset - 3] = maskKey[1]
+    buffer[offset - 2] = maskKey[2]
+    buffer[offset - 1] = maskKey[3]
+
+    buffer[1] = payloadLength
+
+    if (payloadLength === 126) {
+      buffer.writeUInt16BE(bodyLength, 2)
+    } else if (payloadLength === 127) {
+      // Clear extended payload length
+      buffer[2] = buffer[3] = 0
+      buffer.writeUIntBE(bodyLength, 4, 6)
+    }
+
+    buffer[1] |= 0x80 // MASK
+
+    // mask body
+    for (let i = 0; i < bodyLength; ++i) {
+      buffer[offset + i] = frameData[i] ^ maskKey[i & 3]
+    }
+
+    return buffer
+  }
+}
+
+module.exports = {
+  WebsocketFrameSend
+}
+
+
+/***/ }),
+
+/***/ 67356:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { createInflateRaw, Z_DEFAULT_WINDOWBITS } = __nccwpck_require__(65628)
+const { isValidClientWindowBits } = __nccwpck_require__(13187)
+
+const tail = Buffer.from([0x00, 0x00, 0xff, 0xff])
+const kBuffer = Symbol('kBuffer')
+const kLength = Symbol('kLength')
+
+class PerMessageDeflate {
+  /** @type {import('node:zlib').InflateRaw} */
+  #inflate
+
+  #options = {}
+
+  constructor (extensions) {
+    this.#options.serverNoContextTakeover = extensions.has('server_no_context_takeover')
+    this.#options.serverMaxWindowBits = extensions.get('server_max_window_bits')
+  }
+
+  decompress (chunk, fin, callback) {
+    // An endpoint uses the following algorithm to decompress a message.
+    // 1.  Append 4 octets of 0x00 0x00 0xff 0xff to the tail end of the
+    //     payload of the message.
+    // 2.  Decompress the resulting data using DEFLATE.
+
+    if (!this.#inflate) {
+      let windowBits = Z_DEFAULT_WINDOWBITS
+
+      if (this.#options.serverMaxWindowBits) { // empty values default to Z_DEFAULT_WINDOWBITS
+        if (!isValidClientWindowBits(this.#options.serverMaxWindowBits)) {
+          callback(new Error('Invalid server_max_window_bits'))
+          return
+        }
+
+        windowBits = Number.parseInt(this.#options.serverMaxWindowBits)
+      }
+
+      this.#inflate = createInflateRaw({ windowBits })
+      this.#inflate[kBuffer] = []
+      this.#inflate[kLength] = 0
+
+      this.#inflate.on('data', (data) => {
+        this.#inflate[kBuffer].push(data)
+        this.#inflate[kLength] += data.length
+      })
+
+      this.#inflate.on('error', (err) => {
+        this.#inflate = null
+        callback(err)
+      })
+    }
+
+    this.#inflate.write(chunk)
+    if (fin) {
+      this.#inflate.write(tail)
+    }
+
+    this.#inflate.flush(() => {
+      const full = Buffer.concat(this.#inflate[kBuffer], this.#inflate[kLength])
+
+      this.#inflate[kBuffer].length = 0
+      this.#inflate[kLength] = 0
+
+      callback(null, full)
+    })
+  }
+}
+
+module.exports = { PerMessageDeflate }
+
+
+/***/ }),
+
+/***/ 47879:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Writable } = __nccwpck_require__(84492)
+const assert = __nccwpck_require__(98061)
+const { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = __nccwpck_require__(15318)
+const { kReadyState, kSentClose, kResponse, kReceivedClose } = __nccwpck_require__(38471)
+const { channels } = __nccwpck_require__(8627)
+const {
+  isValidStatusCode,
+  isValidOpcode,
+  failWebsocketConnection,
+  websocketMessageReceived,
+  utf8Decode,
+  isControlFrame,
+  isTextBinaryFrame,
+  isContinuationFrame
+} = __nccwpck_require__(13187)
+const { WebsocketFrameSend } = __nccwpck_require__(61163)
+const { closeWebSocketConnection } = __nccwpck_require__(19072)
+const { PerMessageDeflate } = __nccwpck_require__(67356)
+
+// This code was influenced by ws released under the MIT license.
+// Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+// Copyright (c) 2013 Arnout Kazemier and contributors
+// Copyright (c) 2016 Luigi Pinca and contributors
+
+class ByteParser extends Writable {
+  #buffers = []
+  #byteOffset = 0
+  #loop = false
+
+  #state = parserStates.INFO
+
+  #info = {}
+  #fragments = []
+
+  /** @type {Map<string, PerMessageDeflate>} */
+  #extensions
+
+  constructor (ws, extensions) {
+    super()
+
+    this.ws = ws
+    this.#extensions = extensions == null ? new Map() : extensions
+
+    if (this.#extensions.has('permessage-deflate')) {
+      this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions))
+    }
+  }
+
+  /**
+   * @param {Buffer} chunk
+   * @param {() => void} callback
+   */
+  _write (chunk, _, callback) {
+    this.#buffers.push(chunk)
+    this.#byteOffset += chunk.length
+    this.#loop = true
+
+    this.run(callback)
+  }
+
+  /**
+   * Runs whenever a new chunk is received.
+   * Callback is called whenever there are no more chunks buffering,
+   * or not enough bytes are buffered to parse.
+   */
+  run (callback) {
+    while (this.#loop) {
+      if (this.#state === parserStates.INFO) {
+        // If there aren't enough bytes to parse the payload length, etc.
+        if (this.#byteOffset < 2) {
+          return callback()
+        }
+
+        const buffer = this.consume(2)
+        const fin = (buffer[0] & 0x80) !== 0
+        const opcode = buffer[0] & 0x0F
+        const masked = (buffer[1] & 0x80) === 0x80
+
+        const fragmented = !fin && opcode !== opcodes.CONTINUATION
+        const payloadLength = buffer[1] & 0x7F
+
+        const rsv1 = buffer[0] & 0x40
+        const rsv2 = buffer[0] & 0x20
+        const rsv3 = buffer[0] & 0x10
+
+        if (!isValidOpcode(opcode)) {
+          failWebsocketConnection(this.ws, 'Invalid opcode received')
+          return callback()
+        }
+
+        if (masked) {
+          failWebsocketConnection(this.ws, 'Frame cannot be masked')
+          return callback()
+        }
+
+        // MUST be 0 unless an extension is negotiated that defines meanings
+        // for non-zero values.  If a nonzero value is received and none of
+        // the negotiated extensions defines the meaning of such a nonzero
+        // value, the receiving endpoint MUST _Fail the WebSocket
+        // Connection_.
+        // This document allocates the RSV1 bit of the WebSocket header for
+        // PMCEs and calls the bit the "Per-Message Compressed" bit.  On a
+        // WebSocket connection where a PMCE is in use, this bit indicates
+        // whether a message is compressed or not.
+        if (rsv1 !== 0 && !this.#extensions.has('permessage-deflate')) {
+          failWebsocketConnection(this.ws, 'Expected RSV1 to be clear.')
+          return
+        }
+
+        if (rsv2 !== 0 || rsv3 !== 0) {
+          failWebsocketConnection(this.ws, 'RSV1, RSV2, RSV3 must be clear')
+          return
+        }
+
+        if (fragmented && !isTextBinaryFrame(opcode)) {
+          // Only text and binary frames can be fragmented
+          failWebsocketConnection(this.ws, 'Invalid frame type was fragmented.')
+          return
+        }
+
+        // If we are already parsing a text/binary frame and do not receive either
+        // a continuation frame or close frame, fail the connection.
+        if (isTextBinaryFrame(opcode) && this.#fragments.length > 0) {
+          failWebsocketConnection(this.ws, 'Expected continuation frame')
+          return
+        }
+
+        if (this.#info.fragmented && fragmented) {
+          // A fragmented frame can't be fragmented itself
+          failWebsocketConnection(this.ws, 'Fragmented frame exceeded 125 bytes.')
+          return
+        }
+
+        // "All control frames MUST have a payload length of 125 bytes or less
+        // and MUST NOT be fragmented."
+        if ((payloadLength > 125 || fragmented) && isControlFrame(opcode)) {
+          failWebsocketConnection(this.ws, 'Control frame either too large or fragmented')
+          return
+        }
+
+        if (isContinuationFrame(opcode) && this.#fragments.length === 0 && !this.#info.compressed) {
+          failWebsocketConnection(this.ws, 'Unexpected continuation frame')
+          return
+        }
+
+        if (payloadLength <= 125) {
+          this.#info.payloadLength = payloadLength
+          this.#state = parserStates.READ_DATA
+        } else if (payloadLength === 126) {
+          this.#state = parserStates.PAYLOADLENGTH_16
+        } else if (payloadLength === 127) {
+          this.#state = parserStates.PAYLOADLENGTH_64
+        }
+
+        if (isTextBinaryFrame(opcode)) {
+          this.#info.binaryType = opcode
+          this.#info.compressed = rsv1 !== 0
+        }
+
+        this.#info.opcode = opcode
+        this.#info.masked = masked
+        this.#info.fin = fin
+        this.#info.fragmented = fragmented
+      } else if (this.#state === parserStates.PAYLOADLENGTH_16) {
+        if (this.#byteOffset < 2) {
+          return callback()
+        }
+
+        const buffer = this.consume(2)
+
+        this.#info.payloadLength = buffer.readUInt16BE(0)
+        this.#state = parserStates.READ_DATA
+      } else if (this.#state === parserStates.PAYLOADLENGTH_64) {
+        if (this.#byteOffset < 8) {
+          return callback()
+        }
+
+        const buffer = this.consume(8)
+        const upper = buffer.readUInt32BE(0)
+
+        // 2^31 is the maximum bytes an arraybuffer can contain
+        // on 32-bit systems. Although, on 64-bit systems, this is
+        // 2^53-1 bytes.
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length
+        // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/common/globals.h;drc=1946212ac0100668f14eb9e2843bdd846e510a1e;bpv=1;bpt=1;l=1275
+        // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/objects/js-array-buffer.h;l=34;drc=1946212ac0100668f14eb9e2843bdd846e510a1e
+        if (upper > 2 ** 31 - 1) {
+          failWebsocketConnection(this.ws, 'Received payload length > 2^31 bytes.')
+          return
+        }
+
+        const lower = buffer.readUInt32BE(4)
+
+        this.#info.payloadLength = (upper << 8) + lower
+        this.#state = parserStates.READ_DATA
+      } else if (this.#state === parserStates.READ_DATA) {
+        if (this.#byteOffset < this.#info.payloadLength) {
+          return callback()
+        }
+
+        const body = this.consume(this.#info.payloadLength)
+
+        if (isControlFrame(this.#info.opcode)) {
+          this.#loop = this.parseControlFrame(body)
+          this.#state = parserStates.INFO
+        } else {
+          if (!this.#info.compressed) {
+            this.#fragments.push(body)
+
+            // If the frame is not fragmented, a message has been received.
+            // If the frame is fragmented, it will terminate with a fin bit set
+            // and an opcode of 0 (continuation), therefore we handle that when
+            // parsing continuation frames, not here.
+            if (!this.#info.fragmented && this.#info.fin) {
+              const fullMessage = Buffer.concat(this.#fragments)
+              websocketMessageReceived(this.ws, this.#info.binaryType, fullMessage)
+              this.#fragments.length = 0
+            }
+
+            this.#state = parserStates.INFO
+          } else {
+            this.#extensions.get('permessage-deflate').decompress(body, this.#info.fin, (error, data) => {
+              if (error) {
+                closeWebSocketConnection(this.ws, 1007, error.message, error.message.length)
+                return
+              }
+
+              this.#fragments.push(data)
+
+              if (!this.#info.fin) {
+                this.#state = parserStates.INFO
+                this.#loop = true
+                this.run(callback)
+                return
+              }
+
+              websocketMessageReceived(this.ws, this.#info.binaryType, Buffer.concat(this.#fragments))
+
+              this.#loop = true
+              this.#state = parserStates.INFO
+              this.#fragments.length = 0
+              this.run(callback)
+            })
+
+            this.#loop = false
+            break
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Take n bytes from the buffered Buffers
+   * @param {number} n
+   * @returns {Buffer}
+   */
+  consume (n) {
+    if (n > this.#byteOffset) {
+      throw new Error('Called consume() before buffers satiated.')
+    } else if (n === 0) {
+      return emptyBuffer
+    }
+
+    if (this.#buffers[0].length === n) {
+      this.#byteOffset -= this.#buffers[0].length
+      return this.#buffers.shift()
+    }
+
+    const buffer = Buffer.allocUnsafe(n)
+    let offset = 0
+
+    while (offset !== n) {
+      const next = this.#buffers[0]
+      const { length } = next
+
+      if (length + offset === n) {
+        buffer.set(this.#buffers.shift(), offset)
+        break
+      } else if (length + offset > n) {
+        buffer.set(next.subarray(0, n - offset), offset)
+        this.#buffers[0] = next.subarray(n - offset)
+        break
+      } else {
+        buffer.set(this.#buffers.shift(), offset)
+        offset += next.length
+      }
+    }
+
+    this.#byteOffset -= n
+
+    return buffer
+  }
+
+  parseCloseBody (data) {
+    assert(data.length !== 1)
+
+    // https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.5
+    /** @type {number|undefined} */
+    let code
+
+    if (data.length >= 2) {
+      // _The WebSocket Connection Close Code_ is
+      // defined as the status code (Section 7.4) contained in the first Close
+      // control frame received by the application
+      code = data.readUInt16BE(0)
+    }
+
+    if (code !== undefined && !isValidStatusCode(code)) {
+      return { code: 1002, reason: 'Invalid status code', error: true }
+    }
+
+    // https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.6
+    /** @type {Buffer} */
+    let reason = data.subarray(2)
+
+    // Remove BOM
+    if (reason[0] === 0xEF && reason[1] === 0xBB && reason[2] === 0xBF) {
+      reason = reason.subarray(3)
+    }
+
+    try {
+      reason = utf8Decode(reason)
+    } catch {
+      return { code: 1007, reason: 'Invalid UTF-8', error: true }
+    }
+
+    return { code, reason, error: false }
+  }
+
+  /**
+   * Parses control frames.
+   * @param {Buffer} body
+   */
+  parseControlFrame (body) {
+    const { opcode, payloadLength } = this.#info
+
+    if (opcode === opcodes.CLOSE) {
+      if (payloadLength === 1) {
+        failWebsocketConnection(this.ws, 'Received close frame with a 1-byte body.')
+        return false
+      }
+
+      this.#info.closeInfo = this.parseCloseBody(body)
+
+      if (this.#info.closeInfo.error) {
+        const { code, reason } = this.#info.closeInfo
+
+        closeWebSocketConnection(this.ws, code, reason, reason.length)
+        failWebsocketConnection(this.ws, reason)
+        return false
+      }
+
+      if (this.ws[kSentClose] !== sentCloseFrameState.SENT) {
+        // If an endpoint receives a Close frame and did not previously send a
+        // Close frame, the endpoint MUST send a Close frame in response.  (When
+        // sending a Close frame in response, the endpoint typically echos the
+        // status code it received.)
+        let body = emptyBuffer
+        if (this.#info.closeInfo.code) {
+          body = Buffer.allocUnsafe(2)
+          body.writeUInt16BE(this.#info.closeInfo.code, 0)
+        }
+        const closeFrame = new WebsocketFrameSend(body)
+
+        this.ws[kResponse].socket.write(
+          closeFrame.createFrame(opcodes.CLOSE),
+          (err) => {
+            if (!err) {
+              this.ws[kSentClose] = sentCloseFrameState.SENT
+            }
+          }
+        )
+      }
+
+      // Upon either sending or receiving a Close control frame, it is said
+      // that _The WebSocket Closing Handshake is Started_ and that the
+      // WebSocket connection is in the CLOSING state.
+      this.ws[kReadyState] = states.CLOSING
+      this.ws[kReceivedClose] = true
+
+      return false
+    } else if (opcode === opcodes.PING) {
+      // Upon receipt of a Ping frame, an endpoint MUST send a Pong frame in
+      // response, unless it already received a Close frame.
+      // A Pong frame sent in response to a Ping frame must have identical
+      // "Application data"
+
+      if (!this.ws[kReceivedClose]) {
+        const frame = new WebsocketFrameSend(body)
+
+        this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG))
+
+        if (channels.ping.hasSubscribers) {
+          channels.ping.publish({
+            payload: body
+          })
+        }
+      }
+    } else if (opcode === opcodes.PONG) {
+      // A Pong frame MAY be sent unsolicited.  This serves as a
+      // unidirectional heartbeat.  A response to an unsolicited Pong frame is
+      // not expected.
+
+      if (channels.pong.hasSubscribers) {
+        channels.pong.publish({
+          payload: body
+        })
+      }
+    }
+
+    return true
+  }
+
+  get closingInfo () {
+    return this.#info.closeInfo
+  }
+}
+
+module.exports = {
+  ByteParser
+}
+
+
+/***/ }),
+
+/***/ 91445:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { WebsocketFrameSend } = __nccwpck_require__(61163)
+const { opcodes, sendHints } = __nccwpck_require__(15318)
+const FixedQueue = __nccwpck_require__(82285)
+
+/** @type {typeof Uint8Array} */
+const FastBuffer = Buffer[Symbol.species]
+
+/**
+ * @typedef {object} SendQueueNode
+ * @property {Promise<void> | null} promise
+ * @property {((...args: any[]) => any)} callback
+ * @property {Buffer | null} frame
+ */
+
+class SendQueue {
+  /**
+   * @type {FixedQueue}
+   */
+  #queue = new FixedQueue()
+
+  /**
+   * @type {boolean}
+   */
+  #running = false
+
+  /** @type {import('node:net').Socket} */
+  #socket
+
+  constructor (socket) {
+    this.#socket = socket
+  }
+
+  add (item, cb, hint) {
+    if (hint !== sendHints.blob) {
+      const frame = createFrame(item, hint)
+      if (!this.#running) {
+        // fast-path
+        this.#socket.write(frame, cb)
+      } else {
+        /** @type {SendQueueNode} */
+        const node = {
+          promise: null,
+          callback: cb,
+          frame
+        }
+        this.#queue.push(node)
+      }
+      return
+    }
+
+    /** @type {SendQueueNode} */
+    const node = {
+      promise: item.arrayBuffer().then((ab) => {
+        node.promise = null
+        node.frame = createFrame(ab, hint)
+      }),
+      callback: cb,
+      frame: null
+    }
+
+    this.#queue.push(node)
+
+    if (!this.#running) {
+      this.#run()
+    }
+  }
+
+  async #run () {
+    this.#running = true
+    const queue = this.#queue
+    while (!queue.isEmpty()) {
+      const node = queue.shift()
+      // wait pending promise
+      if (node.promise !== null) {
+        await node.promise
+      }
+      // write
+      this.#socket.write(node.frame, node.callback)
+      // cleanup
+      node.callback = node.frame = null
+    }
+    this.#running = false
+  }
+}
+
+function createFrame (data, hint) {
+  return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.string ? opcodes.TEXT : opcodes.BINARY)
+}
+
+function toBuffer (data, hint) {
+  switch (hint) {
+    case sendHints.string:
+      return Buffer.from(data)
+    case sendHints.arrayBuffer:
+    case sendHints.blob:
+      return new FastBuffer(data)
+    case sendHints.typedArray:
+      return new FastBuffer(data.buffer, data.byteOffset, data.byteLength)
+  }
+}
+
+module.exports = { SendQueue }
+
+
+/***/ }),
+
+/***/ 38471:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = {
+  kWebSocketURL: Symbol('url'),
+  kReadyState: Symbol('ready state'),
+  kController: Symbol('controller'),
+  kResponse: Symbol('response'),
+  kBinaryType: Symbol('binary type'),
+  kSentClose: Symbol('sent close'),
+  kReceivedClose: Symbol('received close'),
+  kByteParser: Symbol('byte parser')
+}
+
+
+/***/ }),
+
+/***/ 13187:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = __nccwpck_require__(38471)
+const { states, opcodes } = __nccwpck_require__(15318)
+const { ErrorEvent, createFastMessageEvent } = __nccwpck_require__(15135)
+const { isUtf8 } = __nccwpck_require__(72254)
+const { collectASequenceOfCodePointsFast, removeHTTPWhitespace } = __nccwpck_require__(86954)
+
+/* globals Blob */
+
+/**
+ * @param {import('./websocket').WebSocket} ws
+ * @returns {boolean}
+ */
+function isConnecting (ws) {
+  // If the WebSocket connection is not yet established, and the connection
+  // is not yet closed, then the WebSocket connection is in the CONNECTING state.
+  return ws[kReadyState] === states.CONNECTING
+}
+
+/**
+ * @param {import('./websocket').WebSocket} ws
+ * @returns {boolean}
+ */
+function isEstablished (ws) {
+  // If the server's response is validated as provided for above, it is
+  // said that _The WebSocket Connection is Established_ and that the
+  // WebSocket Connection is in the OPEN state.
+  return ws[kReadyState] === states.OPEN
+}
+
+/**
+ * @param {import('./websocket').WebSocket} ws
+ * @returns {boolean}
+ */
+function isClosing (ws) {
+  // Upon either sending or receiving a Close control frame, it is said
+  // that _The WebSocket Closing Handshake is Started_ and that the
+  // WebSocket connection is in the CLOSING state.
+  return ws[kReadyState] === states.CLOSING
+}
+
+/**
+ * @param {import('./websocket').WebSocket} ws
+ * @returns {boolean}
+ */
+function isClosed (ws) {
+  return ws[kReadyState] === states.CLOSED
+}
+
+/**
+ * @see https://dom.spec.whatwg.org/#concept-event-fire
+ * @param {string} e
+ * @param {EventTarget} target
+ * @param {(...args: ConstructorParameters<typeof Event>) => Event} eventFactory
+ * @param {EventInit | undefined} eventInitDict
+ */
+function fireEvent (e, target, eventFactory = (type, init) => new Event(type, init), eventInitDict = {}) {
+  // 1. If eventConstructor is not given, then let eventConstructor be Event.
+
+  // 2. Let event be the result of creating an event given eventConstructor,
+  //    in the relevant realm of target.
+  // 3. Initialize event’s type attribute to e.
+  const event = eventFactory(e, eventInitDict)
+
+  // 4. Initialize any other IDL attributes of event as described in the
+  //    invocation of this algorithm.
+
+  // 5. Return the result of dispatching event at target, with legacy target
+  //    override flag set if set.
+  target.dispatchEvent(event)
+}
+
+/**
+ * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
+ * @param {import('./websocket').WebSocket} ws
+ * @param {number} type Opcode
+ * @param {Buffer} data application data
+ */
+function websocketMessageReceived (ws, type, data) {
+  // 1. If ready state is not OPEN (1), then return.
+  if (ws[kReadyState] !== states.OPEN) {
+    return
+  }
+
+  // 2. Let dataForEvent be determined by switching on type and binary type:
+  let dataForEvent
+
+  if (type === opcodes.TEXT) {
+    // -> type indicates that the data is Text
+    //      a new DOMString containing data
+    try {
+      dataForEvent = utf8Decode(data)
+    } catch {
+      failWebsocketConnection(ws, 'Received invalid UTF-8 in text frame.')
+      return
+    }
+  } else if (type === opcodes.BINARY) {
+    if (ws[kBinaryType] === 'blob') {
+      // -> type indicates that the data is Binary and binary type is "blob"
+      //      a new Blob object, created in the relevant Realm of the WebSocket
+      //      object, that represents data as its raw data
+      dataForEvent = new Blob([data])
+    } else {
+      // -> type indicates that the data is Binary and binary type is "arraybuffer"
+      //      a new ArrayBuffer object, created in the relevant Realm of the
+      //      WebSocket object, whose contents are data
+      dataForEvent = toArrayBuffer(data)
+    }
+  }
+
+  // 3. Fire an event named message at the WebSocket object, using MessageEvent,
+  //    with the origin attribute initialized to the serialization of the WebSocket
+  //    object’s url's origin, and the data attribute initialized to dataForEvent.
+  fireEvent('message', ws, createFastMessageEvent, {
+    origin: ws[kWebSocketURL].origin,
+    data: dataForEvent
+  })
+}
+
+function toArrayBuffer (buffer) {
+  if (buffer.byteLength === buffer.buffer.byteLength) {
+    return buffer.buffer
+  }
+  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
+}
+
+/**
+ * @see https://datatracker.ietf.org/doc/html/rfc6455
+ * @see https://datatracker.ietf.org/doc/html/rfc2616
+ * @see https://bugs.chromium.org/p/chromium/issues/detail?id=398407
+ * @param {string} protocol
+ */
+function isValidSubprotocol (protocol) {
+  // If present, this value indicates one
+  // or more comma-separated subprotocol the client wishes to speak,
+  // ordered by preference.  The elements that comprise this value
+  // MUST be non-empty strings with characters in the range U+0021 to
+  // U+007E not including separator characters as defined in
+  // [RFC2616] and MUST all be unique strings.
+  if (protocol.length === 0) {
+    return false
+  }
+
+  for (let i = 0; i < protocol.length; ++i) {
+    const code = protocol.charCodeAt(i)
+
+    if (
+      code < 0x21 || // CTL, contains SP (0x20) and HT (0x09)
+      code > 0x7E ||
+      code === 0x22 || // "
+      code === 0x28 || // (
+      code === 0x29 || // )
+      code === 0x2C || // ,
+      code === 0x2F || // /
+      code === 0x3A || // :
+      code === 0x3B || // ;
+      code === 0x3C || // <
+      code === 0x3D || // =
+      code === 0x3E || // >
+      code === 0x3F || // ?
+      code === 0x40 || // @
+      code === 0x5B || // [
+      code === 0x5C || // \
+      code === 0x5D || // ]
+      code === 0x7B || // {
+      code === 0x7D // }
+    ) {
+      return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7-4
+ * @param {number} code
+ */
+function isValidStatusCode (code) {
+  if (code >= 1000 && code < 1015) {
+    return (
+      code !== 1004 && // reserved
+      code !== 1005 && // "MUST NOT be set as a status code"
+      code !== 1006 // "MUST NOT be set as a status code"
+    )
+  }
+
+  return code >= 3000 && code <= 4999
+}
+
+/**
+ * @param {import('./websocket').WebSocket} ws
+ * @param {string|undefined} reason
+ */
+function failWebsocketConnection (ws, reason) {
+  const { [kController]: controller, [kResponse]: response } = ws
+
+  controller.abort()
+
+  if (response?.socket && !response.socket.destroyed) {
+    response.socket.destroy()
+  }
+
+  if (reason) {
+    // TODO: process.nextTick
+    fireEvent('error', ws, (type, init) => new ErrorEvent(type, init), {
+      error: new Error(reason),
+      message: reason
+    })
+  }
+}
+
+/**
+ * @see https://datatracker.ietf.org/doc/html/rfc6455#section-5.5
+ * @param {number} opcode
+ */
+function isControlFrame (opcode) {
+  return (
+    opcode === opcodes.CLOSE ||
+    opcode === opcodes.PING ||
+    opcode === opcodes.PONG
+  )
+}
+
+function isContinuationFrame (opcode) {
+  return opcode === opcodes.CONTINUATION
+}
+
+function isTextBinaryFrame (opcode) {
+  return opcode === opcodes.TEXT || opcode === opcodes.BINARY
+}
+
+function isValidOpcode (opcode) {
+  return isTextBinaryFrame(opcode) || isContinuationFrame(opcode) || isControlFrame(opcode)
+}
+
+/**
+ * Parses a Sec-WebSocket-Extensions header value.
+ * @param {string} extensions
+ * @returns {Map<string, string>}
+ */
+// TODO(@Uzlopak, @KhafraDev): make compliant https://datatracker.ietf.org/doc/html/rfc6455#section-9.1
+function parseExtensions (extensions) {
+  const position = { position: 0 }
+  const extensionList = new Map()
+
+  while (position.position < extensions.length) {
+    const pair = collectASequenceOfCodePointsFast(';', extensions, position)
+    const [name, value = ''] = pair.split('=')
+
+    extensionList.set(
+      removeHTTPWhitespace(name, true, false),
+      removeHTTPWhitespace(value, false, true)
+    )
+
+    position.position++
+  }
+
+  return extensionList
+}
+
+/**
+ * @see https://www.rfc-editor.org/rfc/rfc7692#section-7.1.2.2
+ * @description "client-max-window-bits = 1*DIGIT"
+ * @param {string} value
+ */
+function isValidClientWindowBits (value) {
+  for (let i = 0; i < value.length; i++) {
+    const byte = value.charCodeAt(i)
+
+    if (byte < 0x30 || byte > 0x39) {
+      return false
+    }
+  }
+
+  return true
+}
+
+// https://nodejs.org/api/intl.html#detecting-internationalization-support
+const hasIntl = typeof process.versions.icu === 'string'
+const fatalDecoder = hasIntl ? new TextDecoder('utf-8', { fatal: true }) : undefined
+
+/**
+ * Converts a Buffer to utf-8, even on platforms without icu.
+ * @param {Buffer} buffer
+ */
+const utf8Decode = hasIntl
+  ? fatalDecoder.decode.bind(fatalDecoder)
+  : function (buffer) {
+    if (isUtf8(buffer)) {
+      return buffer.toString('utf-8')
+    }
+    throw new TypeError('Invalid utf-8 received.')
+  }
+
+module.exports = {
+  isConnecting,
+  isEstablished,
+  isClosing,
+  isClosed,
+  fireEvent,
+  isValidSubprotocol,
+  isValidStatusCode,
+  failWebsocketConnection,
+  websocketMessageReceived,
+  utf8Decode,
+  isControlFrame,
+  isContinuationFrame,
+  isTextBinaryFrame,
+  isValidOpcode,
+  parseExtensions,
+  isValidClientWindowBits
+}
+
+
+/***/ }),
+
+/***/ 75860:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { webidl } = __nccwpck_require__(37829)
+const { URLSerializer } = __nccwpck_require__(86954)
+const { environmentSettingsObject } = __nccwpck_require__(91976)
+const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints } = __nccwpck_require__(15318)
+const {
+  kWebSocketURL,
+  kReadyState,
+  kController,
+  kBinaryType,
+  kResponse,
+  kSentClose,
+  kByteParser
+} = __nccwpck_require__(38471)
+const {
+  isConnecting,
+  isEstablished,
+  isClosing,
+  isValidSubprotocol,
+  fireEvent
+} = __nccwpck_require__(13187)
+const { establishWebSocketConnection, closeWebSocketConnection } = __nccwpck_require__(19072)
+const { ByteParser } = __nccwpck_require__(47879)
+const { kEnumerableProperty, isBlobLike } = __nccwpck_require__(94407)
+const { getGlobalDispatcher } = __nccwpck_require__(72354)
+const { types } = __nccwpck_require__(47261)
+const { ErrorEvent, CloseEvent } = __nccwpck_require__(15135)
+const { SendQueue } = __nccwpck_require__(91445)
+
+// https://websockets.spec.whatwg.org/#interface-definition
+class WebSocket extends EventTarget {
+  #events = {
+    open: null,
+    error: null,
+    close: null,
+    message: null
+  }
+
+  #bufferedAmount = 0
+  #protocol = ''
+  #extensions = ''
+
+  /** @type {SendQueue} */
+  #sendQueue
+
+  /**
+   * @param {string} url
+   * @param {string|string[]} protocols
+   */
+  constructor (url, protocols = []) {
+    super()
+
+    webidl.util.markAsUncloneable(this)
+
+    const prefix = 'WebSocket constructor'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    const options = webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'](protocols, prefix, 'options')
+
+    url = webidl.converters.USVString(url, prefix, 'url')
+    protocols = options.protocols
+
+    // 1. Let baseURL be this's relevant settings object's API base URL.
+    const baseURL = environmentSettingsObject.settingsObject.baseUrl
+
+    // 1. Let urlRecord be the result of applying the URL parser to url with baseURL.
+    let urlRecord
+
+    try {
+      urlRecord = new URL(url, baseURL)
+    } catch (e) {
+      // 3. If urlRecord is failure, then throw a "SyntaxError" DOMException.
+      throw new DOMException(e, 'SyntaxError')
+    }
+
+    // 4. If urlRecord’s scheme is "http", then set urlRecord’s scheme to "ws".
+    if (urlRecord.protocol === 'http:') {
+      urlRecord.protocol = 'ws:'
+    } else if (urlRecord.protocol === 'https:') {
+      // 5. Otherwise, if urlRecord’s scheme is "https", set urlRecord’s scheme to "wss".
+      urlRecord.protocol = 'wss:'
+    }
+
+    // 6. If urlRecord’s scheme is not "ws" or "wss", then throw a "SyntaxError" DOMException.
+    if (urlRecord.protocol !== 'ws:' && urlRecord.protocol !== 'wss:') {
+      throw new DOMException(
+        `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
+        'SyntaxError'
+      )
+    }
+
+    // 7. If urlRecord’s fragment is non-null, then throw a "SyntaxError"
+    //    DOMException.
+    if (urlRecord.hash || urlRecord.href.endsWith('#')) {
+      throw new DOMException('Got fragment', 'SyntaxError')
+    }
+
+    // 8. If protocols is a string, set protocols to a sequence consisting
+    //    of just that string.
+    if (typeof protocols === 'string') {
+      protocols = [protocols]
+    }
+
+    // 9. If any of the values in protocols occur more than once or otherwise
+    //    fail to match the requirements for elements that comprise the value
+    //    of `Sec-WebSocket-Protocol` fields as defined by The WebSocket
+    //    protocol, then throw a "SyntaxError" DOMException.
+    if (protocols.length !== new Set(protocols.map(p => p.toLowerCase())).size) {
+      throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError')
+    }
+
+    if (protocols.length > 0 && !protocols.every(p => isValidSubprotocol(p))) {
+      throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError')
+    }
+
+    // 10. Set this's url to urlRecord.
+    this[kWebSocketURL] = new URL(urlRecord.href)
+
+    // 11. Let client be this's relevant settings object.
+    const client = environmentSettingsObject.settingsObject
+
+    // 12. Run this step in parallel:
+
+    //    1. Establish a WebSocket connection given urlRecord, protocols,
+    //       and client.
+    this[kController] = establishWebSocketConnection(
+      urlRecord,
+      protocols,
+      client,
+      this,
+      (response, extensions) => this.#onConnectionEstablished(response, extensions),
+      options
+    )
+
+    // Each WebSocket object has an associated ready state, which is a
+    // number representing the state of the connection. Initially it must
+    // be CONNECTING (0).
+    this[kReadyState] = WebSocket.CONNECTING
+
+    this[kSentClose] = sentCloseFrameState.NOT_SENT
+
+    // The extensions attribute must initially return the empty string.
+
+    // The protocol attribute must initially return the empty string.
+
+    // Each WebSocket object has an associated binary type, which is a
+    // BinaryType. Initially it must be "blob".
+    this[kBinaryType] = 'blob'
+  }
+
+  /**
+   * @see https://websockets.spec.whatwg.org/#dom-websocket-close
+   * @param {number|undefined} code
+   * @param {string|undefined} reason
+   */
+  close (code = undefined, reason = undefined) {
+    webidl.brandCheck(this, WebSocket)
+
+    const prefix = 'WebSocket.close'
+
+    if (code !== undefined) {
+      code = webidl.converters['unsigned short'](code, prefix, 'code', { clamp: true })
+    }
+
+    if (reason !== undefined) {
+      reason = webidl.converters.USVString(reason, prefix, 'reason')
+    }
+
+    // 1. If code is present, but is neither an integer equal to 1000 nor an
+    //    integer in the range 3000 to 4999, inclusive, throw an
+    //    "InvalidAccessError" DOMException.
+    if (code !== undefined) {
+      if (code !== 1000 && (code < 3000 || code > 4999)) {
+        throw new DOMException('invalid code', 'InvalidAccessError')
+      }
+    }
+
+    let reasonByteLength = 0
+
+    // 2. If reason is present, then run these substeps:
+    if (reason !== undefined) {
+      // 1. Let reasonBytes be the result of encoding reason.
+      // 2. If reasonBytes is longer than 123 bytes, then throw a
+      //    "SyntaxError" DOMException.
+      reasonByteLength = Buffer.byteLength(reason)
+
+      if (reasonByteLength > 123) {
+        throw new DOMException(
+          `Reason must be less than 123 bytes; received ${reasonByteLength}`,
+          'SyntaxError'
+        )
+      }
+    }
+
+    // 3. Run the first matching steps from the following list:
+    closeWebSocketConnection(this, code, reason, reasonByteLength)
+  }
+
+  /**
+   * @see https://websockets.spec.whatwg.org/#dom-websocket-send
+   * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data
+   */
+  send (data) {
+    webidl.brandCheck(this, WebSocket)
+
+    const prefix = 'WebSocket.send'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    data = webidl.converters.WebSocketSendData(data, prefix, 'data')
+
+    // 1. If this's ready state is CONNECTING, then throw an
+    //    "InvalidStateError" DOMException.
+    if (isConnecting(this)) {
+      throw new DOMException('Sent before connected.', 'InvalidStateError')
+    }
+
+    // 2. Run the appropriate set of steps from the following list:
+    // https://datatracker.ietf.org/doc/html/rfc6455#section-6.1
+    // https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
+
+    if (!isEstablished(this) || isClosing(this)) {
+      return
+    }
+
+    // If data is a string
+    if (typeof data === 'string') {
+      // If the WebSocket connection is established and the WebSocket
+      // closing handshake has not yet started, then the user agent
+      // must send a WebSocket Message comprised of the data argument
+      // using a text frame opcode; if the data cannot be sent, e.g.
+      // because it would need to be buffered but the buffer is full,
+      // the user agent must flag the WebSocket as full and then close
+      // the WebSocket connection. Any invocation of this method with a
+      // string argument that does not throw an exception must increase
+      // the bufferedAmount attribute by the number of bytes needed to
+      // express the argument as UTF-8.
+
+      const length = Buffer.byteLength(data)
+
+      this.#bufferedAmount += length
+      this.#sendQueue.add(data, () => {
+        this.#bufferedAmount -= length
+      }, sendHints.string)
+    } else if (types.isArrayBuffer(data)) {
+      // If the WebSocket connection is established, and the WebSocket
+      // closing handshake has not yet started, then the user agent must
+      // send a WebSocket Message comprised of data using a binary frame
+      // opcode; if the data cannot be sent, e.g. because it would need
+      // to be buffered but the buffer is full, the user agent must flag
+      // the WebSocket as full and then close the WebSocket connection.
+      // The data to be sent is the data stored in the buffer described
+      // by the ArrayBuffer object. Any invocation of this method with an
+      // ArrayBuffer argument that does not throw an exception must
+      // increase the bufferedAmount attribute by the length of the
+      // ArrayBuffer in bytes.
+
+      this.#bufferedAmount += data.byteLength
+      this.#sendQueue.add(data, () => {
+        this.#bufferedAmount -= data.byteLength
+      }, sendHints.arrayBuffer)
+    } else if (ArrayBuffer.isView(data)) {
+      // If the WebSocket connection is established, and the WebSocket
+      // closing handshake has not yet started, then the user agent must
+      // send a WebSocket Message comprised of data using a binary frame
+      // opcode; if the data cannot be sent, e.g. because it would need to
+      // be buffered but the buffer is full, the user agent must flag the
+      // WebSocket as full and then close the WebSocket connection. The
+      // data to be sent is the data stored in the section of the buffer
+      // described by the ArrayBuffer object that data references. Any
+      // invocation of this method with this kind of argument that does
+      // not throw an exception must increase the bufferedAmount attribute
+      // by the length of data’s buffer in bytes.
+
+      this.#bufferedAmount += data.byteLength
+      this.#sendQueue.add(data, () => {
+        this.#bufferedAmount -= data.byteLength
+      }, sendHints.typedArray)
+    } else if (isBlobLike(data)) {
+      // If the WebSocket connection is established, and the WebSocket
+      // closing handshake has not yet started, then the user agent must
+      // send a WebSocket Message comprised of data using a binary frame
+      // opcode; if the data cannot be sent, e.g. because it would need to
+      // be buffered but the buffer is full, the user agent must flag the
+      // WebSocket as full and then close the WebSocket connection. The data
+      // to be sent is the raw data represented by the Blob object. Any
+      // invocation of this method with a Blob argument that does not throw
+      // an exception must increase the bufferedAmount attribute by the size
+      // of the Blob object’s raw data, in bytes.
+
+      this.#bufferedAmount += data.size
+      this.#sendQueue.add(data, () => {
+        this.#bufferedAmount -= data.size
+      }, sendHints.blob)
+    }
+  }
+
+  get readyState () {
+    webidl.brandCheck(this, WebSocket)
+
+    // The readyState getter steps are to return this's ready state.
+    return this[kReadyState]
+  }
+
+  get bufferedAmount () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#bufferedAmount
+  }
+
+  get url () {
+    webidl.brandCheck(this, WebSocket)
+
+    // The url getter steps are to return this's url, serialized.
+    return URLSerializer(this[kWebSocketURL])
+  }
+
+  get extensions () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#extensions
+  }
+
+  get protocol () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#protocol
+  }
+
+  get onopen () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#events.open
+  }
+
+  set onopen (fn) {
+    webidl.brandCheck(this, WebSocket)
+
+    if (this.#events.open) {
+      this.removeEventListener('open', this.#events.open)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.open = fn
+      this.addEventListener('open', fn)
+    } else {
+      this.#events.open = null
+    }
+  }
+
+  get onerror () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#events.error
+  }
+
+  set onerror (fn) {
+    webidl.brandCheck(this, WebSocket)
+
+    if (this.#events.error) {
+      this.removeEventListener('error', this.#events.error)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.error = fn
+      this.addEventListener('error', fn)
+    } else {
+      this.#events.error = null
+    }
+  }
+
+  get onclose () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#events.close
+  }
+
+  set onclose (fn) {
+    webidl.brandCheck(this, WebSocket)
+
+    if (this.#events.close) {
+      this.removeEventListener('close', this.#events.close)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.close = fn
+      this.addEventListener('close', fn)
+    } else {
+      this.#events.close = null
+    }
+  }
+
+  get onmessage () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#events.message
+  }
+
+  set onmessage (fn) {
+    webidl.brandCheck(this, WebSocket)
+
+    if (this.#events.message) {
+      this.removeEventListener('message', this.#events.message)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.message = fn
+      this.addEventListener('message', fn)
+    } else {
+      this.#events.message = null
+    }
+  }
+
+  get binaryType () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this[kBinaryType]
+  }
+
+  set binaryType (type) {
+    webidl.brandCheck(this, WebSocket)
+
+    if (type !== 'blob' && type !== 'arraybuffer') {
+      this[kBinaryType] = 'blob'
+    } else {
+      this[kBinaryType] = type
+    }
+  }
+
+  /**
+   * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
+   */
+  #onConnectionEstablished (response, parsedExtensions) {
+    // processResponse is called when the "response’s header list has been received and initialized."
+    // once this happens, the connection is open
+    this[kResponse] = response
+
+    const parser = new ByteParser(this, parsedExtensions)
+    parser.on('drain', onParserDrain)
+    parser.on('error', onParserError.bind(this))
+
+    response.socket.ws = this
+    this[kByteParser] = parser
+
+    this.#sendQueue = new SendQueue(response.socket)
+
+    // 1. Change the ready state to OPEN (1).
+    this[kReadyState] = states.OPEN
+
+    // 2. Change the extensions attribute’s value to the extensions in use, if
+    //    it is not the null value.
+    // https://datatracker.ietf.org/doc/html/rfc6455#section-9.1
+    const extensions = response.headersList.get('sec-websocket-extensions')
+
+    if (extensions !== null) {
+      this.#extensions = extensions
+    }
+
+    // 3. Change the protocol attribute’s value to the subprotocol in use, if
+    //    it is not the null value.
+    // https://datatracker.ietf.org/doc/html/rfc6455#section-1.9
+    const protocol = response.headersList.get('sec-websocket-protocol')
+
+    if (protocol !== null) {
+      this.#protocol = protocol
+    }
+
+    // 4. Fire an event named open at the WebSocket object.
+    fireEvent('open', this)
+  }
+}
+
+// https://websockets.spec.whatwg.org/#dom-websocket-connecting
+WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING
+// https://websockets.spec.whatwg.org/#dom-websocket-open
+WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN
+// https://websockets.spec.whatwg.org/#dom-websocket-closing
+WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING
+// https://websockets.spec.whatwg.org/#dom-websocket-closed
+WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED
+
+Object.defineProperties(WebSocket.prototype, {
+  CONNECTING: staticPropertyDescriptors,
+  OPEN: staticPropertyDescriptors,
+  CLOSING: staticPropertyDescriptors,
+  CLOSED: staticPropertyDescriptors,
+  url: kEnumerableProperty,
+  readyState: kEnumerableProperty,
+  bufferedAmount: kEnumerableProperty,
+  onopen: kEnumerableProperty,
+  onerror: kEnumerableProperty,
+  onclose: kEnumerableProperty,
+  close: kEnumerableProperty,
+  onmessage: kEnumerableProperty,
+  binaryType: kEnumerableProperty,
+  send: kEnumerableProperty,
+  extensions: kEnumerableProperty,
+  protocol: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'WebSocket',
+    writable: false,
+    enumerable: false,
+    configurable: true
+  }
+})
+
+Object.defineProperties(WebSocket, {
+  CONNECTING: staticPropertyDescriptors,
+  OPEN: staticPropertyDescriptors,
+  CLOSING: staticPropertyDescriptors,
+  CLOSED: staticPropertyDescriptors
+})
+
+webidl.converters['sequence<DOMString>'] = webidl.sequenceConverter(
+  webidl.converters.DOMString
+)
+
+webidl.converters['DOMString or sequence<DOMString>'] = function (V, prefix, argument) {
+  if (webidl.util.Type(V) === 'Object' && Symbol.iterator in V) {
+    return webidl.converters['sequence<DOMString>'](V)
+  }
+
+  return webidl.converters.DOMString(V, prefix, argument)
+}
+
+// This implements the proposal made in https://github.com/whatwg/websockets/issues/42
+webidl.converters.WebSocketInit = webidl.dictionaryConverter([
+  {
+    key: 'protocols',
+    converter: webidl.converters['DOMString or sequence<DOMString>'],
+    defaultValue: () => new Array(0)
+  },
+  {
+    key: 'dispatcher',
+    converter: webidl.converters.any,
+    defaultValue: () => getGlobalDispatcher()
+  },
+  {
+    key: 'headers',
+    converter: webidl.nullableConverter(webidl.converters.HeadersInit)
+  }
+])
+
+webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'] = function (V) {
+  if (webidl.util.Type(V) === 'Object' && !(Symbol.iterator in V)) {
+    return webidl.converters.WebSocketInit(V)
+  }
+
+  return { protocols: webidl.converters['DOMString or sequence<DOMString>'](V) }
+}
+
+webidl.converters.WebSocketSendData = function (V) {
+  if (webidl.util.Type(V) === 'Object') {
+    if (isBlobLike(V)) {
+      return webidl.converters.Blob(V, { strict: false })
+    }
+
+    if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
+      return webidl.converters.BufferSource(V)
+    }
+  }
+
+  return webidl.converters.USVString(V)
+}
+
+function onParserDrain () {
+  this.ws[kResponse].socket.resume()
+}
+
+function onParserError (err) {
+  let message
+  let code
+
+  if (err instanceof CloseEvent) {
+    message = err.reason
+    code = err.code
+  } else {
+    message = err.message
+  }
+
+  fireEvent('error', this, () => new ErrorEvent('error', { error: err, message }))
+
+  closeWebSocketConnection(this, code)
+}
+
+module.exports = {
+  WebSocket
+}
+
+
 /***/ }),
 
 /***/ 87351:
@@ -12987,7 +40401,7 @@ exports.RetryHelper = RetryHelper;
 
 /***/ }),
 
-/***/ 27784:
+/***/ 54188:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
@@ -22507,6 +49921,8 @@ function Minimatch (pattern, options) {
   }
 
   this.options = options
+  this.maxGlobstarRecursion = options.maxGlobstarRecursion !== undefined
+    ? options.maxGlobstarRecursion : 200
   this.set = []
   this.pattern = pattern
   this.regexp = null
@@ -22755,6 +50171,9 @@ function parse (pattern, isSub) {
           continue
         }
 
+        // coalesce consecutive non-globstar * characters
+        if (c === '*' && stateChar === '*') continue
+
         // if we already have a stateChar, then it means
         // that there was something like ** or +? in there.
         // Handle the stateChar, then proceed with this one.
@@ -23149,19 +50568,163 @@ Minimatch.prototype.match = function match (f, partial) {
 // out of pattern, then that's fine, as long as all
 // the parts match.
 Minimatch.prototype.matchOne = function (file, pattern, partial) {
-  var options = this.options
+  if (pattern.indexOf(GLOBSTAR) !== -1) {
+    return this._matchGlobstar(file, pattern, partial, 0, 0)
+  }
+  return this._matchOne(file, pattern, partial, 0, 0)
+}
 
-  this.debug('matchOne',
-    { 'this': this, file: file, pattern: pattern })
+Minimatch.prototype._matchGlobstar = function (file, pattern, partial, fileIndex, patternIndex) {
+  var i
 
-  this.debug('matchOne', file.length, pattern.length)
+  // find first globstar from patternIndex
+  var firstgs = -1
+  for (i = patternIndex; i < pattern.length; i++) {
+    if (pattern[i] === GLOBSTAR) { firstgs = i; break }
+  }
 
-  for (var fi = 0,
-      pi = 0,
-      fl = file.length,
-      pl = pattern.length
-      ; (fi < fl) && (pi < pl)
-      ; fi++, pi++) {
+  // find last globstar
+  var lastgs = -1
+  for (i = pattern.length - 1; i >= 0; i--) {
+    if (pattern[i] === GLOBSTAR) { lastgs = i; break }
+  }
+
+  var head = pattern.slice(patternIndex, firstgs)
+  var body = partial ? pattern.slice(firstgs + 1) : pattern.slice(firstgs + 1, lastgs)
+  var tail = partial ? [] : pattern.slice(lastgs + 1)
+
+  // check the head
+  if (head.length) {
+    var fileHead = file.slice(fileIndex, fileIndex + head.length)
+    if (!this._matchOne(fileHead, head, partial, 0, 0)) {
+      return false
+    }
+    fileIndex += head.length
+  }
+
+  // check the tail
+  var fileTailMatch = 0
+  if (tail.length) {
+    if (tail.length + fileIndex > file.length) return false
+
+    var tailStart = file.length - tail.length
+    if (this._matchOne(file, tail, partial, tailStart, 0)) {
+      fileTailMatch = tail.length
+    } else {
+      // affordance for stuff like a/**/* matching a/b/
+      if (file[file.length - 1] !== '' ||
+          fileIndex + tail.length === file.length) {
+        return false
+      }
+      tailStart--
+      if (!this._matchOne(file, tail, partial, tailStart, 0)) {
+        return false
+      }
+      fileTailMatch = tail.length + 1
+    }
+  }
+
+  // if body is empty (single ** between head and tail)
+  if (!body.length) {
+    var sawSome = !!fileTailMatch
+    for (i = fileIndex; i < file.length - fileTailMatch; i++) {
+      var f = String(file[i])
+      sawSome = true
+      if (f === '.' || f === '..' ||
+          (!this.options.dot && f.charAt(0) === '.')) {
+        return false
+      }
+    }
+    return partial || sawSome
+  }
+
+  // split body into segments at each GLOBSTAR
+  var bodySegments = [[[], 0]]
+  var currentBody = bodySegments[0]
+  var nonGsParts = 0
+  var nonGsPartsSums = [0]
+  for (var bi = 0; bi < body.length; bi++) {
+    var b = body[bi]
+    if (b === GLOBSTAR) {
+      nonGsPartsSums.push(nonGsParts)
+      currentBody = [[], 0]
+      bodySegments.push(currentBody)
+    } else {
+      currentBody[0].push(b)
+      nonGsParts++
+    }
+  }
+
+  var idx = bodySegments.length - 1
+  var fileLength = file.length - fileTailMatch
+  for (var si = 0; si < bodySegments.length; si++) {
+    bodySegments[si][1] = fileLength -
+      (nonGsPartsSums[idx--] + bodySegments[si][0].length)
+  }
+
+  return !!this._matchGlobStarBodySections(
+    file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch
+  )
+}
+
+// return false for "nope, not matching"
+// return null for "not matching, cannot keep trying"
+Minimatch.prototype._matchGlobStarBodySections = function (
+  file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail
+) {
+  var bs = bodySegments[bodyIndex]
+  if (!bs) {
+    // just make sure there are no bad dots
+    for (var i = fileIndex; i < file.length; i++) {
+      sawTail = true
+      var f = file[i]
+      if (f === '.' || f === '..' ||
+          (!this.options.dot && f.charAt(0) === '.')) {
+        return false
+      }
+    }
+    return sawTail
+  }
+
+  var body = bs[0]
+  var after = bs[1]
+  while (fileIndex <= after) {
+    var m = this._matchOne(
+      file.slice(0, fileIndex + body.length),
+      body,
+      partial,
+      fileIndex,
+      0
+    )
+    // if limit exceeded, no match. intentional false negative,
+    // acceptable break in correctness for security.
+    if (m && globStarDepth < this.maxGlobstarRecursion) {
+      var sub = this._matchGlobStarBodySections(
+        file, bodySegments,
+        fileIndex + body.length, bodyIndex + 1,
+        partial, globStarDepth + 1, sawTail
+      )
+      if (sub !== false) {
+        return sub
+      }
+    }
+    var f = file[fileIndex]
+    if (f === '.' || f === '..' ||
+        (!this.options.dot && f.charAt(0) === '.')) {
+      return false
+    }
+    fileIndex++
+  }
+  return partial || null
+}
+
+Minimatch.prototype._matchOne = function (file, pattern, partial, fileIndex, patternIndex) {
+  var fi, pi, fl, pl
+  for (
+    fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length
+    ; (fi < fl) && (pi < pl)
+    ; fi++, pi++
+  ) {
     this.debug('matchOne loop')
     var p = pattern[pi]
     var f = file[fi]
@@ -23171,87 +50734,7 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
     // should be impossible.
     // some invalid regexp stuff in the set.
     /* istanbul ignore if */
-    if (p === false) return false
-
-    if (p === GLOBSTAR) {
-      this.debug('GLOBSTAR', [pattern, p, f])
-
-      // "**"
-      // a/**/b/**/c would match the following:
-      // a/b/x/y/z/c
-      // a/x/y/z/b/c
-      // a/b/x/b/x/c
-      // a/b/c
-      // To do this, take the rest of the pattern after
-      // the **, and see if it would match the file remainder.
-      // If so, return success.
-      // If not, the ** "swallows" a segment, and try again.
-      // This is recursively awful.
-      //
-      // a/**/b/**/c matching a/b/x/y/z/c
-      // - a matches a
-      // - doublestar
-      //   - matchOne(b/x/y/z/c, b/**/c)
-      //     - b matches b
-      //     - doublestar
-      //       - matchOne(x/y/z/c, c) -> no
-      //       - matchOne(y/z/c, c) -> no
-      //       - matchOne(z/c, c) -> no
-      //       - matchOne(c, c) yes, hit
-      var fr = fi
-      var pr = pi + 1
-      if (pr === pl) {
-        this.debug('** at the end')
-        // a ** at the end will just swallow the rest.
-        // We have found a match.
-        // however, it will not swallow /.x, unless
-        // options.dot is set.
-        // . and .. are *never* matched by **, for explosively
-        // exponential reasons.
-        for (; fi < fl; fi++) {
-          if (file[fi] === '.' || file[fi] === '..' ||
-            (!options.dot && file[fi].charAt(0) === '.')) return false
-        }
-        return true
-      }
-
-      // ok, let's see if we can swallow whatever we can.
-      while (fr < fl) {
-        var swallowee = file[fr]
-
-        this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)
-
-        // XXX remove this slice.  Just pass the start index.
-        if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-          this.debug('globstar found match!', fr, fl, swallowee)
-          // found a match.
-          return true
-        } else {
-          // can't swallow "." or ".." ever.
-          // can only swallow ".foo" when explicitly asked.
-          if (swallowee === '.' || swallowee === '..' ||
-            (!options.dot && swallowee.charAt(0) === '.')) {
-            this.debug('dot detected!', file, fr, pattern, pr)
-            break
-          }
-
-          // ** swallows a segment, and continue.
-          this.debug('globstar swallow a segment, and continue')
-          fr++
-        }
-      }
-
-      // no match was found.
-      // However, in partial mode, we can't say this is necessarily over.
-      // If there's more *pattern* left, then
-      /* istanbul ignore if */
-      if (partial) {
-        // ran out of file
-        this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
-        if (fr === fl) return true
-      }
-      return false
-    }
+    if (p === false || p === GLOBSTAR) return false
 
     // something other than **
     // non-magic patterns just have to match exactly
@@ -23268,17 +50751,6 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
     if (!hit) return false
   }
 
-  // Note: ending in / means that we'll get a final ""
-  // at the end of the pattern.  This can only match a
-  // corresponding "" at the end of the file.
-  // If the file ends in /, then it can only match a
-  // a pattern that ends in /, unless the pattern just
-  // doesn't have any more for it. But, a/b/ should *not*
-  // match "a/b/*", even though "" matches against the
-  // [^/]*? pattern, except in partial mode, where it might
-  // simply not be reached yet.
-  // However, a/b/ should still satisfy a/*
-
   // now either we fell off the end of the pattern, or we're done.
   if (fi === fl && pi === pl) {
     // ran out of pattern and filename at the same time.
@@ -49660,7 +77132,7 @@ const fs = __importStar(__nccwpck_require__(57147));
 const semver = __importStar(__nccwpck_require__(11383));
 const cache = __importStar(__nccwpck_require__(27799));
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const constants_1 = __nccwpck_require__(69042);
 function getTempDir() {
     const tempDirectory = process.env['RUNNER_TEMP'] || os_1.default.tmpdir();
@@ -49939,6 +77411,22 @@ module.exports = require("net");
 
 /***/ }),
 
+/***/ 98061:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:assert");
+
+/***/ }),
+
+/***/ 92761:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:async_hooks");
+
+/***/ }),
+
 /***/ 72254:
 /***/ ((module) => {
 
@@ -49947,6 +77435,14 @@ module.exports = require("node:buffer");
 
 /***/ }),
 
+/***/ 40027:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:console");
+
+/***/ }),
+
 /***/ 6005:
 /***/ ((module) => {
 
@@ -49955,6 +77451,22 @@ module.exports = require("node:crypto");
 
 /***/ }),
 
+/***/ 65714:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:diagnostics_channel");
+
+/***/ }),
+
+/***/ 30604:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:dns");
+
+/***/ }),
+
 /***/ 15673:
 /***/ ((module) => {
 
@@ -49979,6 +77491,14 @@ module.exports = require("node:http");
 
 /***/ }),
 
+/***/ 42725:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:http2");
+
+/***/ }),
+
 /***/ 22286:
 /***/ ((module) => {
 
@@ -49987,6 +77507,14 @@ module.exports = require("node:https");
 
 /***/ }),
 
+/***/ 87503:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:net");
+
+/***/ }),
+
 /***/ 70612:
 /***/ ((module) => {
 
@@ -49995,6 +77523,14 @@ module.exports = require("node:os");
 
 /***/ }),
 
+/***/ 38846:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:perf_hooks");
+
+/***/ }),
+
 /***/ 97742:
 /***/ ((module) => {
 
@@ -50003,6 +77539,14 @@ module.exports = require("node:process");
 
 /***/ }),
 
+/***/ 39630:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:querystring");
+
+/***/ }),
+
 /***/ 84492:
 /***/ ((module) => {
 
@@ -50011,6 +77555,22 @@ module.exports = require("node:stream");
 
 /***/ }),
 
+/***/ 31764:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:tls");
+
+/***/ }),
+
+/***/ 41041:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:url");
+
+/***/ }),
+
 /***/ 47261:
 /***/ ((module) => {
 
@@ -50019,6 +77579,22 @@ module.exports = require("node:util");
 
 /***/ }),
 
+/***/ 93746:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:util/types");
+
+/***/ }),
+
+/***/ 24086:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:worker_threads");
+
+/***/ }),
+
 /***/ 65628:
 /***/ ((module) => {
 
@@ -92845,7 +120421,7 @@ function randomUUID() {
 /***/ 74577:
 /***/ ((module) => {
 
-(()=>{"use strict";var t={d:(e,i)=>{for(var n in i)t.o(i,n)&&!t.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:i[n]})},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r:t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})}},e={};t.r(e),t.d(e,{XMLBuilder:()=>lt,XMLParser:()=>tt,XMLValidator:()=>pt});const i=":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD",n=new RegExp("^["+i+"]["+i+"\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$");function s(t,e){const i=[];let n=e.exec(t);for(;n;){const s=[];s.startIndex=e.lastIndex-n[0].length;const r=n.length;for(let t=0;t<r;t++)s.push(n[t]);i.push(s),n=e.exec(t)}return i}const r=function(t){return!(null==n.exec(t))},o={allowBooleanAttributes:!1,unpairedTags:[]};function a(t,e){e=Object.assign({},o,e);const i=[];let n=!1,s=!1;"\ufeff"===t[0]&&(t=t.substr(1));for(let o=0;o<t.length;o++)if("<"===t[o]&&"?"===t[o+1]){if(o+=2,o=u(t,o),o.err)return o}else{if("<"!==t[o]){if(l(t[o]))continue;return x("InvalidChar","char '"+t[o]+"' is not expected.",b(t,o))}{let a=o;if(o++,"!"===t[o]){o=h(t,o);continue}{let d=!1;"/"===t[o]&&(d=!0,o++);let p="";for(;o<t.length&&">"!==t[o]&&" "!==t[o]&&"\t"!==t[o]&&"\n"!==t[o]&&"\r"!==t[o];o++)p+=t[o];if(p=p.trim(),"/"===p[p.length-1]&&(p=p.substring(0,p.length-1),o--),!r(p)){let e;return e=0===p.trim().length?"Invalid space after '<'.":"Tag '"+p+"' is an invalid name.",x("InvalidTag",e,b(t,o))}const c=f(t,o);if(!1===c)return x("InvalidAttr","Attributes for '"+p+"' have open quote.",b(t,o));let N=c.value;if(o=c.index,"/"===N[N.length-1]){const i=o-N.length;N=N.substring(0,N.length-1);const s=g(N,e);if(!0!==s)return x(s.err.code,s.err.msg,b(t,i+s.err.line));n=!0}else if(d){if(!c.tagClosed)return x("InvalidTag","Closing tag '"+p+"' doesn't have proper closing.",b(t,o));if(N.trim().length>0)return x("InvalidTag","Closing tag '"+p+"' can't have attributes or invalid starting.",b(t,a));if(0===i.length)return x("InvalidTag","Closing tag '"+p+"' has not been opened.",b(t,a));{const e=i.pop();if(p!==e.tagName){let i=b(t,e.tagStartPos);return x("InvalidTag","Expected closing tag '"+e.tagName+"' (opened in line "+i.line+", col "+i.col+") instead of closing tag '"+p+"'.",b(t,a))}0==i.length&&(s=!0)}}else{const r=g(N,e);if(!0!==r)return x(r.err.code,r.err.msg,b(t,o-N.length+r.err.line));if(!0===s)return x("InvalidXml","Multiple possible root nodes found.",b(t,o));-1!==e.unpairedTags.indexOf(p)||i.push({tagName:p,tagStartPos:a}),n=!0}for(o++;o<t.length;o++)if("<"===t[o]){if("!"===t[o+1]){o++,o=h(t,o);continue}if("?"!==t[o+1])break;if(o=u(t,++o),o.err)return o}else if("&"===t[o]){const e=m(t,o);if(-1==e)return x("InvalidChar","char '&' is not expected.",b(t,o));o=e}else if(!0===s&&!l(t[o]))return x("InvalidXml","Extra text at the end",b(t,o));"<"===t[o]&&o--}}}return n?1==i.length?x("InvalidTag","Unclosed tag '"+i[0].tagName+"'.",b(t,i[0].tagStartPos)):!(i.length>0)||x("InvalidXml","Invalid '"+JSON.stringify(i.map((t=>t.tagName)),null,4).replace(/\r?\n/g,"")+"' found.",{line:1,col:1}):x("InvalidXml","Start tag expected.",1)}function l(t){return" "===t||"\t"===t||"\n"===t||"\r"===t}function u(t,e){const i=e;for(;e<t.length;e++)if("?"!=t[e]&&" "!=t[e]);else{const n=t.substr(i,e-i);if(e>5&&"xml"===n)return x("InvalidXml","XML declaration allowed only at the start of the document.",b(t,e));if("?"==t[e]&&">"==t[e+1]){e++;break}}return e}function h(t,e){if(t.length>e+5&&"-"===t[e+1]&&"-"===t[e+2]){for(e+=3;e<t.length;e++)if("-"===t[e]&&"-"===t[e+1]&&">"===t[e+2]){e+=2;break}}else if(t.length>e+8&&"D"===t[e+1]&&"O"===t[e+2]&&"C"===t[e+3]&&"T"===t[e+4]&&"Y"===t[e+5]&&"P"===t[e+6]&&"E"===t[e+7]){let i=1;for(e+=8;e<t.length;e++)if("<"===t[e])i++;else if(">"===t[e]&&(i--,0===i))break}else if(t.length>e+9&&"["===t[e+1]&&"C"===t[e+2]&&"D"===t[e+3]&&"A"===t[e+4]&&"T"===t[e+5]&&"A"===t[e+6]&&"["===t[e+7])for(e+=8;e<t.length;e++)if("]"===t[e]&&"]"===t[e+1]&&">"===t[e+2]){e+=2;break}return e}const d='"',p="'";function f(t,e){let i="",n="",s=!1;for(;e<t.length;e++){if(t[e]===d||t[e]===p)""===n?n=t[e]:n!==t[e]||(n="");else if(">"===t[e]&&""===n){s=!0;break}i+=t[e]}return""===n&&{value:i,index:e,tagClosed:s}}const c=new RegExp("(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['\"])(([\\s\\S])*?)\\5)?","g");function g(t,e){const i=s(t,c),n={};for(let t=0;t<i.length;t++){if(0===i[t][1].length)return x("InvalidAttr","Attribute '"+i[t][2]+"' has no space in starting.",E(i[t]));if(void 0!==i[t][3]&&void 0===i[t][4])return x("InvalidAttr","Attribute '"+i[t][2]+"' is without value.",E(i[t]));if(void 0===i[t][3]&&!e.allowBooleanAttributes)return x("InvalidAttr","boolean attribute '"+i[t][2]+"' is not allowed.",E(i[t]));const s=i[t][2];if(!N(s))return x("InvalidAttr","Attribute '"+s+"' is an invalid name.",E(i[t]));if(n.hasOwnProperty(s))return x("InvalidAttr","Attribute '"+s+"' is repeated.",E(i[t]));n[s]=1}return!0}function m(t,e){if(";"===t[++e])return-1;if("#"===t[e])return function(t,e){let i=/\d/;for("x"===t[e]&&(e++,i=/[\da-fA-F]/);e<t.length;e++){if(";"===t[e])return e;if(!t[e].match(i))break}return-1}(t,++e);let i=0;for(;e<t.length;e++,i++)if(!(t[e].match(/\w/)&&i<20)){if(";"===t[e])break;return-1}return e}function x(t,e,i){return{err:{code:t,msg:e,line:i.line||i,col:i.col}}}function N(t){return r(t)}function b(t,e){const i=t.substring(0,e).split(/\r?\n/);return{line:i.length,col:i[i.length-1].length+1}}function E(t){return t.startIndex+t[1].length}const v={preserveOrder:!1,attributeNamePrefix:"@_",attributesGroupName:!1,textNodeName:"#text",ignoreAttributes:!0,removeNSPrefix:!1,allowBooleanAttributes:!1,parseTagValue:!0,parseAttributeValue:!1,trimValues:!0,cdataPropName:!1,numberParseOptions:{hex:!0,leadingZeros:!0,eNotation:!0},tagValueProcessor:function(t,e){return e},attributeValueProcessor:function(t,e){return e},stopNodes:[],alwaysCreateTextNode:!1,isArray:()=>!1,commentPropName:!1,unpairedTags:[],processEntities:!0,htmlEntities:!1,ignoreDeclaration:!1,ignorePiTags:!1,transformTagName:!1,transformAttributeName:!1,updateTag:function(t,e,i){return t},captureMetaData:!1};let T;T="function"!=typeof Symbol?"@@xmlMetadata":Symbol("XML Node Metadata");class y{constructor(t){this.tagname=t,this.child=[],this[":@"]={}}add(t,e){"__proto__"===t&&(t="#__proto__"),this.child.push({[t]:e})}addChild(t,e){"__proto__"===t.tagname&&(t.tagname="#__proto__"),t[":@"]&&Object.keys(t[":@"]).length>0?this.child.push({[t.tagname]:t.child,":@":t[":@"]}):this.child.push({[t.tagname]:t.child}),void 0!==e&&(this.child[this.child.length-1][T]={startIndex:e})}static getMetaDataSymbol(){return T}}class w{constructor(t){this.suppressValidationErr=!t}readDocType(t,e){const i={};if("O"!==t[e+3]||"C"!==t[e+4]||"T"!==t[e+5]||"Y"!==t[e+6]||"P"!==t[e+7]||"E"!==t[e+8])throw new Error("Invalid Tag instead of DOCTYPE");{e+=9;let n=1,s=!1,r=!1,o="";for(;e<t.length;e++)if("<"!==t[e]||r)if(">"===t[e]){if(r?"-"===t[e-1]&&"-"===t[e-2]&&(r=!1,n--):n--,0===n)break}else"["===t[e]?s=!0:o+=t[e];else{if(s&&P(t,"!ENTITY",e)){let n,s;e+=7,[n,s,e]=this.readEntityExp(t,e+1,this.suppressValidationErr),-1===s.indexOf("&")&&(i[n]={regx:RegExp(`&${n};`,"g"),val:s})}else if(s&&P(t,"!ELEMENT",e)){e+=8;const{index:i}=this.readElementExp(t,e+1);e=i}else if(s&&P(t,"!ATTLIST",e))e+=8;else if(s&&P(t,"!NOTATION",e)){e+=9;const{index:i}=this.readNotationExp(t,e+1,this.suppressValidationErr);e=i}else{if(!P(t,"!--",e))throw new Error("Invalid DOCTYPE");r=!0}n++,o=""}if(0!==n)throw new Error("Unclosed DOCTYPE")}return{entities:i,i:e}}readEntityExp(t,e){e=I(t,e);let i="";for(;e<t.length&&!/\s/.test(t[e])&&'"'!==t[e]&&"'"!==t[e];)i+=t[e],e++;if(O(i),e=I(t,e),!this.suppressValidationErr){if("SYSTEM"===t.substring(e,e+6).toUpperCase())throw new Error("External entities are not supported");if("%"===t[e])throw new Error("Parameter entities are not supported")}let n="";return[e,n]=this.readIdentifierVal(t,e,"entity"),[i,n,--e]}readNotationExp(t,e){e=I(t,e);let i="";for(;e<t.length&&!/\s/.test(t[e]);)i+=t[e],e++;!this.suppressValidationErr&&O(i),e=I(t,e);const n=t.substring(e,e+6).toUpperCase();if(!this.suppressValidationErr&&"SYSTEM"!==n&&"PUBLIC"!==n)throw new Error(`Expected SYSTEM or PUBLIC, found "${n}"`);e+=n.length,e=I(t,e);let s=null,r=null;if("PUBLIC"===n)[e,s]=this.readIdentifierVal(t,e,"publicIdentifier"),'"'!==t[e=I(t,e)]&&"'"!==t[e]||([e,r]=this.readIdentifierVal(t,e,"systemIdentifier"));else if("SYSTEM"===n&&([e,r]=this.readIdentifierVal(t,e,"systemIdentifier"),!this.suppressValidationErr&&!r))throw new Error("Missing mandatory system identifier for SYSTEM notation");return{notationName:i,publicIdentifier:s,systemIdentifier:r,index:--e}}readIdentifierVal(t,e,i){let n="";const s=t[e];if('"'!==s&&"'"!==s)throw new Error(`Expected quoted string, found "${s}"`);for(e++;e<t.length&&t[e]!==s;)n+=t[e],e++;if(t[e]!==s)throw new Error(`Unterminated ${i} value`);return[++e,n]}readElementExp(t,e){e=I(t,e);let i="";for(;e<t.length&&!/\s/.test(t[e]);)i+=t[e],e++;if(!this.suppressValidationErr&&!r(i))throw new Error(`Invalid element name: "${i}"`);let n="";if("E"===t[e=I(t,e)]&&P(t,"MPTY",e))e+=4;else if("A"===t[e]&&P(t,"NY",e))e+=2;else if("("===t[e]){for(e++;e<t.length&&")"!==t[e];)n+=t[e],e++;if(")"!==t[e])throw new Error("Unterminated content model")}else if(!this.suppressValidationErr)throw new Error(`Invalid Element Expression, found "${t[e]}"`);return{elementName:i,contentModel:n.trim(),index:e}}readAttlistExp(t,e){e=I(t,e);let i="";for(;e<t.length&&!/\s/.test(t[e]);)i+=t[e],e++;O(i),e=I(t,e);let n="";for(;e<t.length&&!/\s/.test(t[e]);)n+=t[e],e++;if(!O(n))throw new Error(`Invalid attribute name: "${n}"`);e=I(t,e);let s="";if("NOTATION"===t.substring(e,e+8).toUpperCase()){if(s="NOTATION","("!==t[e=I(t,e+=8)])throw new Error(`Expected '(', found "${t[e]}"`);e++;let i=[];for(;e<t.length&&")"!==t[e];){let n="";for(;e<t.length&&"|"!==t[e]&&")"!==t[e];)n+=t[e],e++;if(n=n.trim(),!O(n))throw new Error(`Invalid notation name: "${n}"`);i.push(n),"|"===t[e]&&(e++,e=I(t,e))}if(")"!==t[e])throw new Error("Unterminated list of notations");e++,s+=" ("+i.join("|")+")"}else{for(;e<t.length&&!/\s/.test(t[e]);)s+=t[e],e++;const i=["CDATA","ID","IDREF","IDREFS","ENTITY","ENTITIES","NMTOKEN","NMTOKENS"];if(!this.suppressValidationErr&&!i.includes(s.toUpperCase()))throw new Error(`Invalid attribute type: "${s}"`)}e=I(t,e);let r="";return"#REQUIRED"===t.substring(e,e+8).toUpperCase()?(r="#REQUIRED",e+=8):"#IMPLIED"===t.substring(e,e+7).toUpperCase()?(r="#IMPLIED",e+=7):[e,r]=this.readIdentifierVal(t,e,"ATTLIST"),{elementName:i,attributeName:n,attributeType:s,defaultValue:r,index:e}}}const I=(t,e)=>{for(;e<t.length&&/\s/.test(t[e]);)e++;return e};function P(t,e,i){for(let n=0;n<e.length;n++)if(e[n]!==t[i+n+1])return!1;return!0}function O(t){if(r(t))return t;throw new Error(`Invalid entity name ${t}`)}const A=/^[-+]?0x[a-fA-F0-9]+$/,S=/^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/,C={hex:!0,leadingZeros:!0,decimalPoint:".",eNotation:!0};const V=/^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;function $(t){return"function"==typeof t?t:Array.isArray(t)?e=>{for(const i of t){if("string"==typeof i&&e===i)return!0;if(i instanceof RegExp&&i.test(e))return!0}}:()=>!1}class D{constructor(t){if(this.options=t,this.currentNode=null,this.tagsNodeStack=[],this.docTypeEntities={},this.lastEntities={apos:{regex:/&(apos|#39|#x27);/g,val:"'"},gt:{regex:/&(gt|#62|#x3E);/g,val:">"},lt:{regex:/&(lt|#60|#x3C);/g,val:"<"},quot:{regex:/&(quot|#34|#x22);/g,val:'"'}},this.ampEntity={regex:/&(amp|#38|#x26);/g,val:"&"},this.htmlEntities={space:{regex:/&(nbsp|#160);/g,val:" "},cent:{regex:/&(cent|#162);/g,val:"¢"},pound:{regex:/&(pound|#163);/g,val:"£"},yen:{regex:/&(yen|#165);/g,val:"¥"},euro:{regex:/&(euro|#8364);/g,val:"€"},copyright:{regex:/&(copy|#169);/g,val:"©"},reg:{regex:/&(reg|#174);/g,val:"®"},inr:{regex:/&(inr|#8377);/g,val:"₹"},num_dec:{regex:/&#([0-9]{1,7});/g,val:(t,e)=>String.fromCodePoint(Number.parseInt(e,10))},num_hex:{regex:/&#x([0-9a-fA-F]{1,6});/g,val:(t,e)=>String.fromCodePoint(Number.parseInt(e,16))}},this.addExternalEntities=j,this.parseXml=L,this.parseTextData=M,this.resolveNameSpace=F,this.buildAttributesMap=k,this.isItStopNode=Y,this.replaceEntitiesValue=B,this.readStopNodeData=W,this.saveTextToParentTag=R,this.addChild=U,this.ignoreAttributesFn=$(this.options.ignoreAttributes),this.options.stopNodes&&this.options.stopNodes.length>0){this.stopNodesExact=new Set,this.stopNodesWildcard=new Set;for(let t=0;t<this.options.stopNodes.length;t++){const e=this.options.stopNodes[t];"string"==typeof e&&(e.startsWith("*.")?this.stopNodesWildcard.add(e.substring(2)):this.stopNodesExact.add(e))}}}}function j(t){const e=Object.keys(t);for(let i=0;i<e.length;i++){const n=e[i];this.lastEntities[n]={regex:new RegExp("&"+n+";","g"),val:t[n]}}}function M(t,e,i,n,s,r,o){if(void 0!==t&&(this.options.trimValues&&!n&&(t=t.trim()),t.length>0)){o||(t=this.replaceEntitiesValue(t));const n=this.options.tagValueProcessor(e,t,i,s,r);return null==n?t:typeof n!=typeof t||n!==t?n:this.options.trimValues||t.trim()===t?q(t,this.options.parseTagValue,this.options.numberParseOptions):t}}function F(t){if(this.options.removeNSPrefix){const e=t.split(":"),i="/"===t.charAt(0)?"/":"";if("xmlns"===e[0])return"";2===e.length&&(t=i+e[1])}return t}const _=new RegExp("([^\\s=]+)\\s*(=\\s*(['\"])([\\s\\S]*?)\\3)?","gm");function k(t,e){if(!0!==this.options.ignoreAttributes&&"string"==typeof t){const i=s(t,_),n=i.length,r={};for(let t=0;t<n;t++){const n=this.resolveNameSpace(i[t][1]);if(this.ignoreAttributesFn(n,e))continue;let s=i[t][4],o=this.options.attributeNamePrefix+n;if(n.length)if(this.options.transformAttributeName&&(o=this.options.transformAttributeName(o)),"__proto__"===o&&(o="#__proto__"),void 0!==s){this.options.trimValues&&(s=s.trim()),s=this.replaceEntitiesValue(s);const t=this.options.attributeValueProcessor(n,s,e);r[o]=null==t?s:typeof t!=typeof s||t!==s?t:q(s,this.options.parseAttributeValue,this.options.numberParseOptions)}else this.options.allowBooleanAttributes&&(r[o]=!0)}if(!Object.keys(r).length)return;if(this.options.attributesGroupName){const t={};return t[this.options.attributesGroupName]=r,t}return r}}const L=function(t){t=t.replace(/\r\n?/g,"\n");const e=new y("!xml");let i=e,n="",s="";const r=new w(this.options.processEntities);for(let o=0;o<t.length;o++)if("<"===t[o])if("/"===t[o+1]){const e=G(t,">",o,"Closing Tag is not closed.");let r=t.substring(o+2,e).trim();if(this.options.removeNSPrefix){const t=r.indexOf(":");-1!==t&&(r=r.substr(t+1))}this.options.transformTagName&&(r=this.options.transformTagName(r)),i&&(n=this.saveTextToParentTag(n,i,s));const a=s.substring(s.lastIndexOf(".")+1);if(r&&-1!==this.options.unpairedTags.indexOf(r))throw new Error(`Unpaired tag can not be used as closing tag: </${r}>`);let l=0;a&&-1!==this.options.unpairedTags.indexOf(a)?(l=s.lastIndexOf(".",s.lastIndexOf(".")-1),this.tagsNodeStack.pop()):l=s.lastIndexOf("."),s=s.substring(0,l),i=this.tagsNodeStack.pop(),n="",o=e}else if("?"===t[o+1]){let e=X(t,o,!1,"?>");if(!e)throw new Error("Pi Tag is not closed.");if(n=this.saveTextToParentTag(n,i,s),this.options.ignoreDeclaration&&"?xml"===e.tagName||this.options.ignorePiTags);else{const t=new y(e.tagName);t.add(this.options.textNodeName,""),e.tagName!==e.tagExp&&e.attrExpPresent&&(t[":@"]=this.buildAttributesMap(e.tagExp,s)),this.addChild(i,t,s,o)}o=e.closeIndex+1}else if("!--"===t.substr(o+1,3)){const e=G(t,"--\x3e",o+4,"Comment is not closed.");if(this.options.commentPropName){const r=t.substring(o+4,e-2);n=this.saveTextToParentTag(n,i,s),i.add(this.options.commentPropName,[{[this.options.textNodeName]:r}])}o=e}else if("!D"===t.substr(o+1,2)){const e=r.readDocType(t,o);this.docTypeEntities=e.entities,o=e.i}else if("!["===t.substr(o+1,2)){const e=G(t,"]]>",o,"CDATA is not closed.")-2,r=t.substring(o+9,e);n=this.saveTextToParentTag(n,i,s);let a=this.parseTextData(r,i.tagname,s,!0,!1,!0,!0);null==a&&(a=""),this.options.cdataPropName?i.add(this.options.cdataPropName,[{[this.options.textNodeName]:r}]):i.add(this.options.textNodeName,a),o=e+2}else{let r=X(t,o,this.options.removeNSPrefix),a=r.tagName;const l=r.rawTagName;let u=r.tagExp,h=r.attrExpPresent,d=r.closeIndex;if(this.options.transformTagName){const t=this.options.transformTagName(a);u===a&&(u=t),a=t}i&&n&&"!xml"!==i.tagname&&(n=this.saveTextToParentTag(n,i,s,!1));const p=i;p&&-1!==this.options.unpairedTags.indexOf(p.tagname)&&(i=this.tagsNodeStack.pop(),s=s.substring(0,s.lastIndexOf("."))),a!==e.tagname&&(s+=s?"."+a:a);const f=o;if(this.isItStopNode(this.stopNodesExact,this.stopNodesWildcard,s,a)){let e="";if(u.length>0&&u.lastIndexOf("/")===u.length-1)"/"===a[a.length-1]?(a=a.substr(0,a.length-1),s=s.substr(0,s.length-1),u=a):u=u.substr(0,u.length-1),o=r.closeIndex;else if(-1!==this.options.unpairedTags.indexOf(a))o=r.closeIndex;else{const i=this.readStopNodeData(t,l,d+1);if(!i)throw new Error(`Unexpected end of ${l}`);o=i.i,e=i.tagContent}const n=new y(a);a!==u&&h&&(n[":@"]=this.buildAttributesMap(u,s)),e&&(e=this.parseTextData(e,a,s,!0,h,!0,!0)),s=s.substr(0,s.lastIndexOf(".")),n.add(this.options.textNodeName,e),this.addChild(i,n,s,f)}else{if(u.length>0&&u.lastIndexOf("/")===u.length-1){if("/"===a[a.length-1]?(a=a.substr(0,a.length-1),s=s.substr(0,s.length-1),u=a):u=u.substr(0,u.length-1),this.options.transformTagName){const t=this.options.transformTagName(a);u===a&&(u=t),a=t}const t=new y(a);a!==u&&h&&(t[":@"]=this.buildAttributesMap(u,s)),this.addChild(i,t,s,f),s=s.substr(0,s.lastIndexOf("."))}else{const t=new y(a);this.tagsNodeStack.push(i),a!==u&&h&&(t[":@"]=this.buildAttributesMap(u,s)),this.addChild(i,t,s,f),i=t}n="",o=d}}else n+=t[o];return e.child};function U(t,e,i,n){this.options.captureMetaData||(n=void 0);const s=this.options.updateTag(e.tagname,i,e[":@"]);!1===s||("string"==typeof s?(e.tagname=s,t.addChild(e,n)):t.addChild(e,n))}const B=function(t){if(this.options.processEntities){for(let e in this.docTypeEntities){const i=this.docTypeEntities[e];t=t.replace(i.regx,i.val)}for(let e in this.lastEntities){const i=this.lastEntities[e];t=t.replace(i.regex,i.val)}if(this.options.htmlEntities)for(let e in this.htmlEntities){const i=this.htmlEntities[e];t=t.replace(i.regex,i.val)}t=t.replace(this.ampEntity.regex,this.ampEntity.val)}return t};function R(t,e,i,n){return t&&(void 0===n&&(n=0===e.child.length),void 0!==(t=this.parseTextData(t,e.tagname,i,!1,!!e[":@"]&&0!==Object.keys(e[":@"]).length,n))&&""!==t&&e.add(this.options.textNodeName,t),t=""),t}function Y(t,e,i,n){return!(!e||!e.has(n))||!(!t||!t.has(i))}function G(t,e,i,n){const s=t.indexOf(e,i);if(-1===s)throw new Error(n);return s+e.length-1}function X(t,e,i,n=">"){const s=function(t,e,i=">"){let n,s="";for(let r=e;r<t.length;r++){let e=t[r];if(n)e===n&&(n="");else if('"'===e||"'"===e)n=e;else if(e===i[0]){if(!i[1])return{data:s,index:r};if(t[r+1]===i[1])return{data:s,index:r}}else"\t"===e&&(e=" ");s+=e}}(t,e+1,n);if(!s)return;let r=s.data;const o=s.index,a=r.search(/\s/);let l=r,u=!0;-1!==a&&(l=r.substring(0,a),r=r.substring(a+1).trimStart());const h=l;if(i){const t=l.indexOf(":");-1!==t&&(l=l.substr(t+1),u=l!==s.data.substr(t+1))}return{tagName:l,tagExp:r,closeIndex:o,attrExpPresent:u,rawTagName:h}}function W(t,e,i){const n=i;let s=1;for(;i<t.length;i++)if("<"===t[i])if("/"===t[i+1]){const r=G(t,">",i,`${e} is not closed`);if(t.substring(i+2,r).trim()===e&&(s--,0===s))return{tagContent:t.substring(n,i),i:r};i=r}else if("?"===t[i+1])i=G(t,"?>",i+1,"StopNode is not closed.");else if("!--"===t.substr(i+1,3))i=G(t,"--\x3e",i+3,"StopNode is not closed.");else if("!["===t.substr(i+1,2))i=G(t,"]]>",i,"StopNode is not closed.")-2;else{const n=X(t,i,">");n&&((n&&n.tagName)===e&&"/"!==n.tagExp[n.tagExp.length-1]&&s++,i=n.closeIndex)}}function q(t,e,i){if(e&&"string"==typeof t){const e=t.trim();return"true"===e||"false"!==e&&function(t,e={}){if(e=Object.assign({},C,e),!t||"string"!=typeof t)return t;let i=t.trim();if(void 0!==e.skipLike&&e.skipLike.test(i))return t;if("0"===t)return 0;if(e.hex&&A.test(i))return function(t){if(parseInt)return parseInt(t,16);if(Number.parseInt)return Number.parseInt(t,16);if(window&&window.parseInt)return window.parseInt(t,16);throw new Error("parseInt, Number.parseInt, window.parseInt are not supported")}(i);if(-1!==i.search(/.+[eE].+/))return function(t,e,i){if(!i.eNotation)return t;const n=e.match(V);if(n){let s=n[1]||"";const r=-1===n[3].indexOf("e")?"E":"e",o=n[2],a=s?t[o.length+1]===r:t[o.length]===r;return o.length>1&&a?t:1!==o.length||!n[3].startsWith(`.${r}`)&&n[3][0]!==r?i.leadingZeros&&!a?(e=(n[1]||"")+n[3],Number(e)):t:Number(e)}return t}(t,i,e);{const s=S.exec(i);if(s){const r=s[1]||"",o=s[2];let a=(n=s[3])&&-1!==n.indexOf(".")?("."===(n=n.replace(/0+$/,""))?n="0":"."===n[0]?n="0"+n:"."===n[n.length-1]&&(n=n.substring(0,n.length-1)),n):n;const l=r?"."===t[o.length+1]:"."===t[o.length];if(!e.leadingZeros&&(o.length>1||1===o.length&&!l))return t;{const n=Number(i),s=String(n);if(0===n||-0===n)return n;if(-1!==s.search(/[eE]/))return e.eNotation?n:t;if(-1!==i.indexOf("."))return"0"===s||s===a||s===`${r}${a}`?n:t;let l=o?a:i;return o?l===s||r+l===s?n:t:l===s||l===r+s?n:t}}return t}var n}(t,i)}return void 0!==t?t:""}const Z=y.getMetaDataSymbol();function K(t,e){return Q(t,e)}function Q(t,e,i){let n;const s={};for(let r=0;r<t.length;r++){const o=t[r],a=z(o);let l="";if(l=void 0===i?a:i+"."+a,a===e.textNodeName)void 0===n?n=o[a]:n+=""+o[a];else{if(void 0===a)continue;if(o[a]){let t=Q(o[a],e,l);const i=H(t,e);void 0!==o[Z]&&(t[Z]=o[Z]),o[":@"]?J(t,o[":@"],l,e):1!==Object.keys(t).length||void 0===t[e.textNodeName]||e.alwaysCreateTextNode?0===Object.keys(t).length&&(e.alwaysCreateTextNode?t[e.textNodeName]="":t=""):t=t[e.textNodeName],void 0!==s[a]&&s.hasOwnProperty(a)?(Array.isArray(s[a])||(s[a]=[s[a]]),s[a].push(t)):e.isArray(a,l,i)?s[a]=[t]:s[a]=t}}}return"string"==typeof n?n.length>0&&(s[e.textNodeName]=n):void 0!==n&&(s[e.textNodeName]=n),s}function z(t){const e=Object.keys(t);for(let t=0;t<e.length;t++){const i=e[t];if(":@"!==i)return i}}function J(t,e,i,n){if(e){const s=Object.keys(e),r=s.length;for(let o=0;o<r;o++){const r=s[o];n.isArray(r,i+"."+r,!0,!0)?t[r]=[e[r]]:t[r]=e[r]}}}function H(t,e){const{textNodeName:i}=e,n=Object.keys(t).length;return 0===n||!(1!==n||!t[i]&&"boolean"!=typeof t[i]&&0!==t[i])}class tt{constructor(t){this.externalEntities={},this.options=function(t){return Object.assign({},v,t)}(t)}parse(t,e){if("string"!=typeof t&&t.toString)t=t.toString();else if("string"!=typeof t)throw new Error("XML data is accepted in String or Bytes[] form.");if(e){!0===e&&(e={});const i=a(t,e);if(!0!==i)throw Error(`${i.err.msg}:${i.err.line}:${i.err.col}`)}const i=new D(this.options);i.addExternalEntities(this.externalEntities);const n=i.parseXml(t);return this.options.preserveOrder||void 0===n?n:K(n,this.options)}addEntity(t,e){if(-1!==e.indexOf("&"))throw new Error("Entity value can't have '&'");if(-1!==t.indexOf("&")||-1!==t.indexOf(";"))throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");if("&"===e)throw new Error("An entity with value '&' is not permitted");this.externalEntities[t]=e}static getMetaDataSymbol(){return y.getMetaDataSymbol()}}function et(t,e){let i="";return e.format&&e.indentBy.length>0&&(i="\n"),it(t,e,"",i)}function it(t,e,i,n){let s="",r=!1;for(let o=0;o<t.length;o++){const a=t[o],l=nt(a);if(void 0===l)continue;let u="";if(u=0===i.length?l:`${i}.${l}`,l===e.textNodeName){let t=a[l];rt(u,e)||(t=e.tagValueProcessor(l,t),t=ot(t,e)),r&&(s+=n),s+=t,r=!1;continue}if(l===e.cdataPropName){r&&(s+=n),s+=`<![CDATA[${a[l][0][e.textNodeName]}]]>`,r=!1;continue}if(l===e.commentPropName){s+=n+`\x3c!--${a[l][0][e.textNodeName]}--\x3e`,r=!0;continue}if("?"===l[0]){const t=st(a[":@"],e),i="?xml"===l?"":n;let o=a[l][0][e.textNodeName];o=0!==o.length?" "+o:"",s+=i+`<${l}${o}${t}?>`,r=!0;continue}let h=n;""!==h&&(h+=e.indentBy);const d=n+`<${l}${st(a[":@"],e)}`,p=it(a[l],e,u,h);-1!==e.unpairedTags.indexOf(l)?e.suppressUnpairedNode?s+=d+">":s+=d+"/>":p&&0!==p.length||!e.suppressEmptyNode?p&&p.endsWith(">")?s+=d+`>${p}${n}</${l}>`:(s+=d+">",p&&""!==n&&(p.includes("/>")||p.includes("</"))?s+=n+e.indentBy+p+n:s+=p,s+=`</${l}>`):s+=d+"/>",r=!0}return s}function nt(t){const e=Object.keys(t);for(let i=0;i<e.length;i++){const n=e[i];if(t.hasOwnProperty(n)&&":@"!==n)return n}}function st(t,e){let i="";if(t&&!e.ignoreAttributes)for(let n in t){if(!t.hasOwnProperty(n))continue;let s=e.attributeValueProcessor(n,t[n]);s=ot(s,e),!0===s&&e.suppressBooleanAttributes?i+=` ${n.substr(e.attributeNamePrefix.length)}`:i+=` ${n.substr(e.attributeNamePrefix.length)}="${s}"`}return i}function rt(t,e){let i=(t=t.substr(0,t.length-e.textNodeName.length-1)).substr(t.lastIndexOf(".")+1);for(let n in e.stopNodes)if(e.stopNodes[n]===t||e.stopNodes[n]==="*."+i)return!0;return!1}function ot(t,e){if(t&&t.length>0&&e.processEntities)for(let i=0;i<e.entities.length;i++){const n=e.entities[i];t=t.replace(n.regex,n.val)}return t}const at={attributeNamePrefix:"@_",attributesGroupName:!1,textNodeName:"#text",ignoreAttributes:!0,cdataPropName:!1,format:!1,indentBy:"  ",suppressEmptyNode:!1,suppressUnpairedNode:!0,suppressBooleanAttributes:!0,tagValueProcessor:function(t,e){return e},attributeValueProcessor:function(t,e){return e},preserveOrder:!1,commentPropName:!1,unpairedTags:[],entities:[{regex:new RegExp("&","g"),val:"&amp;"},{regex:new RegExp(">","g"),val:"&gt;"},{regex:new RegExp("<","g"),val:"&lt;"},{regex:new RegExp("'","g"),val:"&apos;"},{regex:new RegExp('"',"g"),val:"&quot;"}],processEntities:!0,stopNodes:[],oneListGroup:!1};function lt(t){this.options=Object.assign({},at,t),!0===this.options.ignoreAttributes||this.options.attributesGroupName?this.isAttribute=function(){return!1}:(this.ignoreAttributesFn=$(this.options.ignoreAttributes),this.attrPrefixLen=this.options.attributeNamePrefix.length,this.isAttribute=dt),this.processTextOrObjNode=ut,this.options.format?(this.indentate=ht,this.tagEndChar=">\n",this.newLine="\n"):(this.indentate=function(){return""},this.tagEndChar=">",this.newLine="")}function ut(t,e,i,n){const s=this.j2x(t,i+1,n.concat(e));return void 0!==t[this.options.textNodeName]&&1===Object.keys(t).length?this.buildTextValNode(t[this.options.textNodeName],e,s.attrStr,i):this.buildObjectNode(s.val,e,s.attrStr,i)}function ht(t){return this.options.indentBy.repeat(t)}function dt(t){return!(!t.startsWith(this.options.attributeNamePrefix)||t===this.options.textNodeName)&&t.substr(this.attrPrefixLen)}lt.prototype.build=function(t){return this.options.preserveOrder?et(t,this.options):(Array.isArray(t)&&this.options.arrayNodeName&&this.options.arrayNodeName.length>1&&(t={[this.options.arrayNodeName]:t}),this.j2x(t,0,[]).val)},lt.prototype.j2x=function(t,e,i){let n="",s="";const r=i.join(".");for(let o in t)if(Object.prototype.hasOwnProperty.call(t,o))if(void 0===t[o])this.isAttribute(o)&&(s+="");else if(null===t[o])this.isAttribute(o)||o===this.options.cdataPropName?s+="":"?"===o[0]?s+=this.indentate(e)+"<"+o+"?"+this.tagEndChar:s+=this.indentate(e)+"<"+o+"/"+this.tagEndChar;else if(t[o]instanceof Date)s+=this.buildTextValNode(t[o],o,"",e);else if("object"!=typeof t[o]){const i=this.isAttribute(o);if(i&&!this.ignoreAttributesFn(i,r))n+=this.buildAttrPairStr(i,""+t[o]);else if(!i)if(o===this.options.textNodeName){let e=this.options.tagValueProcessor(o,""+t[o]);s+=this.replaceEntitiesValue(e)}else s+=this.buildTextValNode(t[o],o,"",e)}else if(Array.isArray(t[o])){const n=t[o].length;let r="",a="";for(let l=0;l<n;l++){const n=t[o][l];if(void 0===n);else if(null===n)"?"===o[0]?s+=this.indentate(e)+"<"+o+"?"+this.tagEndChar:s+=this.indentate(e)+"<"+o+"/"+this.tagEndChar;else if("object"==typeof n)if(this.options.oneListGroup){const t=this.j2x(n,e+1,i.concat(o));r+=t.val,this.options.attributesGroupName&&n.hasOwnProperty(this.options.attributesGroupName)&&(a+=t.attrStr)}else r+=this.processTextOrObjNode(n,o,e,i);else if(this.options.oneListGroup){let t=this.options.tagValueProcessor(o,n);t=this.replaceEntitiesValue(t),r+=t}else r+=this.buildTextValNode(n,o,"",e)}this.options.oneListGroup&&(r=this.buildObjectNode(r,o,a,e)),s+=r}else if(this.options.attributesGroupName&&o===this.options.attributesGroupName){const e=Object.keys(t[o]),i=e.length;for(let s=0;s<i;s++)n+=this.buildAttrPairStr(e[s],""+t[o][e[s]])}else s+=this.processTextOrObjNode(t[o],o,e,i);return{attrStr:n,val:s}},lt.prototype.buildAttrPairStr=function(t,e){return e=this.options.attributeValueProcessor(t,""+e),e=this.replaceEntitiesValue(e),this.options.suppressBooleanAttributes&&"true"===e?" "+t:" "+t+'="'+e+'"'},lt.prototype.buildObjectNode=function(t,e,i,n){if(""===t)return"?"===e[0]?this.indentate(n)+"<"+e+i+"?"+this.tagEndChar:this.indentate(n)+"<"+e+i+this.closeTag(e)+this.tagEndChar;{let s="</"+e+this.tagEndChar,r="";return"?"===e[0]&&(r="?",s=""),!i&&""!==i||-1!==t.indexOf("<")?!1!==this.options.commentPropName&&e===this.options.commentPropName&&0===r.length?this.indentate(n)+`\x3c!--${t}--\x3e`+this.newLine:this.indentate(n)+"<"+e+i+r+this.tagEndChar+t+this.indentate(n)+s:this.indentate(n)+"<"+e+i+r+">"+t+s}},lt.prototype.closeTag=function(t){let e="";return-1!==this.options.unpairedTags.indexOf(t)?this.options.suppressUnpairedNode||(e="/"):e=this.options.suppressEmptyNode?"/":`></${t}`,e},lt.prototype.buildTextValNode=function(t,e,i,n){if(!1!==this.options.cdataPropName&&e===this.options.cdataPropName)return this.indentate(n)+`<![CDATA[${t}]]>`+this.newLine;if(!1!==this.options.commentPropName&&e===this.options.commentPropName)return this.indentate(n)+`\x3c!--${t}--\x3e`+this.newLine;if("?"===e[0])return this.indentate(n)+"<"+e+i+"?"+this.tagEndChar;{let s=this.options.tagValueProcessor(e,t);return s=this.replaceEntitiesValue(s),""===s?this.indentate(n)+"<"+e+i+this.closeTag(e)+this.tagEndChar:this.indentate(n)+"<"+e+i+">"+s+"</"+e+this.tagEndChar}},lt.prototype.replaceEntitiesValue=function(t){if(t&&t.length>0&&this.options.processEntities)for(let e=0;e<this.options.entities.length;e++){const i=this.options.entities[e];t=t.replace(i.regex,i.val)}return t};const pt={validate:a};module.exports=e})();
+(()=>{"use strict";var t={d:(e,n)=>{for(var i in n)t.o(n,i)&&!t.o(e,i)&&Object.defineProperty(e,i,{enumerable:!0,get:n[i]})},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r:t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})}},e={};t.r(e),t.d(e,{XMLBuilder:()=>gt,XMLParser:()=>it,XMLValidator:()=>xt});const n=":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD",i=new RegExp("^["+n+"]["+n+"\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$");function s(t,e){const n=[];let i=e.exec(t);for(;i;){const s=[];s.startIndex=e.lastIndex-i[0].length;const r=i.length;for(let t=0;t<r;t++)s.push(i[t]);n.push(s),i=e.exec(t)}return n}const r=function(t){return!(null==i.exec(t))},o={allowBooleanAttributes:!1,unpairedTags:[]};function a(t,e){e=Object.assign({},o,e);const n=[];let i=!1,s=!1;"\ufeff"===t[0]&&(t=t.substr(1));for(let r=0;r<t.length;r++)if("<"===t[r]&&"?"===t[r+1]){if(r+=2,r=u(t,r),r.err)return r}else{if("<"!==t[r]){if(l(t[r]))continue;return m("InvalidChar","char '"+t[r]+"' is not expected.",N(t,r))}{let o=r;if(r++,"!"===t[r]){r=d(t,r);continue}{let a=!1;"/"===t[r]&&(a=!0,r++);let h="";for(;r<t.length&&">"!==t[r]&&" "!==t[r]&&"\t"!==t[r]&&"\n"!==t[r]&&"\r"!==t[r];r++)h+=t[r];if(h=h.trim(),"/"===h[h.length-1]&&(h=h.substring(0,h.length-1),r--),!b(h)){let e;return e=0===h.trim().length?"Invalid space after '<'.":"Tag '"+h+"' is an invalid name.",m("InvalidTag",e,N(t,r))}const p=c(t,r);if(!1===p)return m("InvalidAttr","Attributes for '"+h+"' have open quote.",N(t,r));let f=p.value;if(r=p.index,"/"===f[f.length-1]){const n=r-f.length;f=f.substring(0,f.length-1);const s=g(f,e);if(!0!==s)return m(s.err.code,s.err.msg,N(t,n+s.err.line));i=!0}else if(a){if(!p.tagClosed)return m("InvalidTag","Closing tag '"+h+"' doesn't have proper closing.",N(t,r));if(f.trim().length>0)return m("InvalidTag","Closing tag '"+h+"' can't have attributes or invalid starting.",N(t,o));if(0===n.length)return m("InvalidTag","Closing tag '"+h+"' has not been opened.",N(t,o));{const e=n.pop();if(h!==e.tagName){let n=N(t,e.tagStartPos);return m("InvalidTag","Expected closing tag '"+e.tagName+"' (opened in line "+n.line+", col "+n.col+") instead of closing tag '"+h+"'.",N(t,o))}0==n.length&&(s=!0)}}else{const a=g(f,e);if(!0!==a)return m(a.err.code,a.err.msg,N(t,r-f.length+a.err.line));if(!0===s)return m("InvalidXml","Multiple possible root nodes found.",N(t,r));-1!==e.unpairedTags.indexOf(h)||n.push({tagName:h,tagStartPos:o}),i=!0}for(r++;r<t.length;r++)if("<"===t[r]){if("!"===t[r+1]){r++,r=d(t,r);continue}if("?"!==t[r+1])break;if(r=u(t,++r),r.err)return r}else if("&"===t[r]){const e=x(t,r);if(-1==e)return m("InvalidChar","char '&' is not expected.",N(t,r));r=e}else if(!0===s&&!l(t[r]))return m("InvalidXml","Extra text at the end",N(t,r));"<"===t[r]&&r--}}}return i?1==n.length?m("InvalidTag","Unclosed tag '"+n[0].tagName+"'.",N(t,n[0].tagStartPos)):!(n.length>0)||m("InvalidXml","Invalid '"+JSON.stringify(n.map(t=>t.tagName),null,4).replace(/\r?\n/g,"")+"' found.",{line:1,col:1}):m("InvalidXml","Start tag expected.",1)}function l(t){return" "===t||"\t"===t||"\n"===t||"\r"===t}function u(t,e){const n=e;for(;e<t.length;e++)if("?"==t[e]||" "==t[e]){const i=t.substr(n,e-n);if(e>5&&"xml"===i)return m("InvalidXml","XML declaration allowed only at the start of the document.",N(t,e));if("?"==t[e]&&">"==t[e+1]){e++;break}continue}return e}function d(t,e){if(t.length>e+5&&"-"===t[e+1]&&"-"===t[e+2]){for(e+=3;e<t.length;e++)if("-"===t[e]&&"-"===t[e+1]&&">"===t[e+2]){e+=2;break}}else if(t.length>e+8&&"D"===t[e+1]&&"O"===t[e+2]&&"C"===t[e+3]&&"T"===t[e+4]&&"Y"===t[e+5]&&"P"===t[e+6]&&"E"===t[e+7]){let n=1;for(e+=8;e<t.length;e++)if("<"===t[e])n++;else if(">"===t[e]&&(n--,0===n))break}else if(t.length>e+9&&"["===t[e+1]&&"C"===t[e+2]&&"D"===t[e+3]&&"A"===t[e+4]&&"T"===t[e+5]&&"A"===t[e+6]&&"["===t[e+7])for(e+=8;e<t.length;e++)if("]"===t[e]&&"]"===t[e+1]&&">"===t[e+2]){e+=2;break}return e}const h='"',p="'";function c(t,e){let n="",i="",s=!1;for(;e<t.length;e++){if(t[e]===h||t[e]===p)""===i?i=t[e]:i!==t[e]||(i="");else if(">"===t[e]&&""===i){s=!0;break}n+=t[e]}return""===i&&{value:n,index:e,tagClosed:s}}const f=new RegExp("(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['\"])(([\\s\\S])*?)\\5)?","g");function g(t,e){const n=s(t,f),i={};for(let t=0;t<n.length;t++){if(0===n[t][1].length)return m("InvalidAttr","Attribute '"+n[t][2]+"' has no space in starting.",y(n[t]));if(void 0!==n[t][3]&&void 0===n[t][4])return m("InvalidAttr","Attribute '"+n[t][2]+"' is without value.",y(n[t]));if(void 0===n[t][3]&&!e.allowBooleanAttributes)return m("InvalidAttr","boolean attribute '"+n[t][2]+"' is not allowed.",y(n[t]));const s=n[t][2];if(!E(s))return m("InvalidAttr","Attribute '"+s+"' is an invalid name.",y(n[t]));if(Object.prototype.hasOwnProperty.call(i,s))return m("InvalidAttr","Attribute '"+s+"' is repeated.",y(n[t]));i[s]=1}return!0}function x(t,e){if(";"===t[++e])return-1;if("#"===t[e])return function(t,e){let n=/\d/;for("x"===t[e]&&(e++,n=/[\da-fA-F]/);e<t.length;e++){if(";"===t[e])return e;if(!t[e].match(n))break}return-1}(t,++e);let n=0;for(;e<t.length;e++,n++)if(!(t[e].match(/\w/)&&n<20)){if(";"===t[e])break;return-1}return e}function m(t,e,n){return{err:{code:t,msg:e,line:n.line||n,col:n.col}}}function E(t){return r(t)}function b(t){return r(t)}function N(t,e){const n=t.substring(0,e).split(/\r?\n/);return{line:n.length,col:n[n.length-1].length+1}}function y(t){return t.startIndex+t[1].length}const T={preserveOrder:!1,attributeNamePrefix:"@_",attributesGroupName:!1,textNodeName:"#text",ignoreAttributes:!0,removeNSPrefix:!1,allowBooleanAttributes:!1,parseTagValue:!0,parseAttributeValue:!1,trimValues:!0,cdataPropName:!1,numberParseOptions:{hex:!0,leadingZeros:!0,eNotation:!0},tagValueProcessor:function(t,e){return e},attributeValueProcessor:function(t,e){return e},stopNodes:[],alwaysCreateTextNode:!1,isArray:()=>!1,commentPropName:!1,unpairedTags:[],processEntities:!0,htmlEntities:!1,ignoreDeclaration:!1,ignorePiTags:!1,transformTagName:!1,transformAttributeName:!1,updateTag:function(t,e,n){return t},captureMetaData:!1,maxNestedTags:100,strictReservedNames:!0};function w(t){return"boolean"==typeof t?{enabled:t,maxEntitySize:1e4,maxExpansionDepth:10,maxTotalExpansions:1e3,maxExpandedLength:1e5,allowedTags:null,tagFilter:null}:"object"==typeof t&&null!==t?{enabled:!1!==t.enabled,maxEntitySize:t.maxEntitySize??1e4,maxExpansionDepth:t.maxExpansionDepth??10,maxTotalExpansions:t.maxTotalExpansions??1e3,maxExpandedLength:t.maxExpandedLength??1e5,allowedTags:t.allowedTags??null,tagFilter:t.tagFilter??null}:w(!0)}const v=function(t){const e=Object.assign({},T,t);return e.processEntities=w(e.processEntities),e};let O;O="function"!=typeof Symbol?"@@xmlMetadata":Symbol("XML Node Metadata");class I{constructor(t){this.tagname=t,this.child=[],this[":@"]=Object.create(null)}add(t,e){"__proto__"===t&&(t="#__proto__"),this.child.push({[t]:e})}addChild(t,e){"__proto__"===t.tagname&&(t.tagname="#__proto__"),t[":@"]&&Object.keys(t[":@"]).length>0?this.child.push({[t.tagname]:t.child,":@":t[":@"]}):this.child.push({[t.tagname]:t.child}),void 0!==e&&(this.child[this.child.length-1][O]={startIndex:e})}static getMetaDataSymbol(){return O}}class P{constructor(t){this.suppressValidationErr=!t,this.options=t}readDocType(t,e){const n=Object.create(null);if("O"!==t[e+3]||"C"!==t[e+4]||"T"!==t[e+5]||"Y"!==t[e+6]||"P"!==t[e+7]||"E"!==t[e+8])throw new Error("Invalid Tag instead of DOCTYPE");{e+=9;let i=1,s=!1,r=!1,o="";for(;e<t.length;e++)if("<"!==t[e]||r)if(">"===t[e]){if(r?"-"===t[e-1]&&"-"===t[e-2]&&(r=!1,i--):i--,0===i)break}else"["===t[e]?s=!0:o+=t[e];else{if(s&&S(t,"!ENTITY",e)){let i,s;if(e+=7,[i,s,e]=this.readEntityExp(t,e+1,this.suppressValidationErr),-1===s.indexOf("&")){const t=i.replace(/[.\-+*:]/g,"\\.");n[i]={regx:RegExp(`&${t};`,"g"),val:s}}}else if(s&&S(t,"!ELEMENT",e)){e+=8;const{index:n}=this.readElementExp(t,e+1);e=n}else if(s&&S(t,"!ATTLIST",e))e+=8;else if(s&&S(t,"!NOTATION",e)){e+=9;const{index:n}=this.readNotationExp(t,e+1,this.suppressValidationErr);e=n}else{if(!S(t,"!--",e))throw new Error("Invalid DOCTYPE");r=!0}i++,o=""}if(0!==i)throw new Error("Unclosed DOCTYPE")}return{entities:n,i:e}}readEntityExp(t,e){e=A(t,e);let n="";for(;e<t.length&&!/\s/.test(t[e])&&'"'!==t[e]&&"'"!==t[e];)n+=t[e],e++;if(C(n),e=A(t,e),!this.suppressValidationErr){if("SYSTEM"===t.substring(e,e+6).toUpperCase())throw new Error("External entities are not supported");if("%"===t[e])throw new Error("Parameter entities are not supported")}let i="";if([e,i]=this.readIdentifierVal(t,e,"entity"),!1!==this.options.enabled&&this.options.maxEntitySize&&i.length>this.options.maxEntitySize)throw new Error(`Entity "${n}" size (${i.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`);return[n,i,--e]}readNotationExp(t,e){e=A(t,e);let n="";for(;e<t.length&&!/\s/.test(t[e]);)n+=t[e],e++;!this.suppressValidationErr&&C(n),e=A(t,e);const i=t.substring(e,e+6).toUpperCase();if(!this.suppressValidationErr&&"SYSTEM"!==i&&"PUBLIC"!==i)throw new Error(`Expected SYSTEM or PUBLIC, found "${i}"`);e+=i.length,e=A(t,e);let s=null,r=null;if("PUBLIC"===i)[e,s]=this.readIdentifierVal(t,e,"publicIdentifier"),'"'!==t[e=A(t,e)]&&"'"!==t[e]||([e,r]=this.readIdentifierVal(t,e,"systemIdentifier"));else if("SYSTEM"===i&&([e,r]=this.readIdentifierVal(t,e,"systemIdentifier"),!this.suppressValidationErr&&!r))throw new Error("Missing mandatory system identifier for SYSTEM notation");return{notationName:n,publicIdentifier:s,systemIdentifier:r,index:--e}}readIdentifierVal(t,e,n){let i="";const s=t[e];if('"'!==s&&"'"!==s)throw new Error(`Expected quoted string, found "${s}"`);for(e++;e<t.length&&t[e]!==s;)i+=t[e],e++;if(t[e]!==s)throw new Error(`Unterminated ${n} value`);return[++e,i]}readElementExp(t,e){e=A(t,e);let n="";for(;e<t.length&&!/\s/.test(t[e]);)n+=t[e],e++;if(!this.suppressValidationErr&&!r(n))throw new Error(`Invalid element name: "${n}"`);let i="";if("E"===t[e=A(t,e)]&&S(t,"MPTY",e))e+=4;else if("A"===t[e]&&S(t,"NY",e))e+=2;else if("("===t[e]){for(e++;e<t.length&&")"!==t[e];)i+=t[e],e++;if(")"!==t[e])throw new Error("Unterminated content model")}else if(!this.suppressValidationErr)throw new Error(`Invalid Element Expression, found "${t[e]}"`);return{elementName:n,contentModel:i.trim(),index:e}}readAttlistExp(t,e){e=A(t,e);let n="";for(;e<t.length&&!/\s/.test(t[e]);)n+=t[e],e++;C(n),e=A(t,e);let i="";for(;e<t.length&&!/\s/.test(t[e]);)i+=t[e],e++;if(!C(i))throw new Error(`Invalid attribute name: "${i}"`);e=A(t,e);let s="";if("NOTATION"===t.substring(e,e+8).toUpperCase()){if(s="NOTATION","("!==t[e=A(t,e+=8)])throw new Error(`Expected '(', found "${t[e]}"`);e++;let n=[];for(;e<t.length&&")"!==t[e];){let i="";for(;e<t.length&&"|"!==t[e]&&")"!==t[e];)i+=t[e],e++;if(i=i.trim(),!C(i))throw new Error(`Invalid notation name: "${i}"`);n.push(i),"|"===t[e]&&(e++,e=A(t,e))}if(")"!==t[e])throw new Error("Unterminated list of notations");e++,s+=" ("+n.join("|")+")"}else{for(;e<t.length&&!/\s/.test(t[e]);)s+=t[e],e++;const n=["CDATA","ID","IDREF","IDREFS","ENTITY","ENTITIES","NMTOKEN","NMTOKENS"];if(!this.suppressValidationErr&&!n.includes(s.toUpperCase()))throw new Error(`Invalid attribute type: "${s}"`)}e=A(t,e);let r="";return"#REQUIRED"===t.substring(e,e+8).toUpperCase()?(r="#REQUIRED",e+=8):"#IMPLIED"===t.substring(e,e+7).toUpperCase()?(r="#IMPLIED",e+=7):[e,r]=this.readIdentifierVal(t,e,"ATTLIST"),{elementName:n,attributeName:i,attributeType:s,defaultValue:r,index:e}}}const A=(t,e)=>{for(;e<t.length&&/\s/.test(t[e]);)e++;return e};function S(t,e,n){for(let i=0;i<e.length;i++)if(e[i]!==t[n+i+1])return!1;return!0}function C(t){if(r(t))return t;throw new Error(`Invalid entity name ${t}`)}const $=/^[-+]?0x[a-fA-F0-9]+$/,V=/^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/,D={hex:!0,leadingZeros:!0,decimalPoint:".",eNotation:!0};const j=/^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;class L{constructor(t){var e;if(this.options=t,this.currentNode=null,this.tagsNodeStack=[],this.docTypeEntities={},this.lastEntities={apos:{regex:/&(apos|#39|#x27);/g,val:"'"},gt:{regex:/&(gt|#62|#x3E);/g,val:">"},lt:{regex:/&(lt|#60|#x3C);/g,val:"<"},quot:{regex:/&(quot|#34|#x22);/g,val:'"'}},this.ampEntity={regex:/&(amp|#38|#x26);/g,val:"&"},this.htmlEntities={space:{regex:/&(nbsp|#160);/g,val:" "},cent:{regex:/&(cent|#162);/g,val:"¢"},pound:{regex:/&(pound|#163);/g,val:"£"},yen:{regex:/&(yen|#165);/g,val:"¥"},euro:{regex:/&(euro|#8364);/g,val:"€"},copyright:{regex:/&(copy|#169);/g,val:"©"},reg:{regex:/&(reg|#174);/g,val:"®"},inr:{regex:/&(inr|#8377);/g,val:"₹"},num_dec:{regex:/&#([0-9]{1,7});/g,val:(t,e)=>K(e,10,"&#")},num_hex:{regex:/&#x([0-9a-fA-F]{1,6});/g,val:(t,e)=>K(e,16,"&#x")}},this.addExternalEntities=F,this.parseXml=R,this.parseTextData=M,this.resolveNameSpace=k,this.buildAttributesMap=U,this.isItStopNode=X,this.replaceEntitiesValue=Y,this.readStopNodeData=q,this.saveTextToParentTag=G,this.addChild=B,this.ignoreAttributesFn="function"==typeof(e=this.options.ignoreAttributes)?e:Array.isArray(e)?t=>{for(const n of e){if("string"==typeof n&&t===n)return!0;if(n instanceof RegExp&&n.test(t))return!0}}:()=>!1,this.entityExpansionCount=0,this.currentExpandedLength=0,this.options.stopNodes&&this.options.stopNodes.length>0){this.stopNodesExact=new Set,this.stopNodesWildcard=new Set;for(let t=0;t<this.options.stopNodes.length;t++){const e=this.options.stopNodes[t];"string"==typeof e&&(e.startsWith("*.")?this.stopNodesWildcard.add(e.substring(2)):this.stopNodesExact.add(e))}}}}function F(t){const e=Object.keys(t);for(let n=0;n<e.length;n++){const i=e[n],s=i.replace(/[.\-+*:]/g,"\\.");this.lastEntities[i]={regex:new RegExp("&"+s+";","g"),val:t[i]}}}function M(t,e,n,i,s,r,o){if(void 0!==t&&(this.options.trimValues&&!i&&(t=t.trim()),t.length>0)){o||(t=this.replaceEntitiesValue(t,e,n));const i=this.options.tagValueProcessor(e,t,n,s,r);return null==i?t:typeof i!=typeof t||i!==t?i:this.options.trimValues||t.trim()===t?Z(t,this.options.parseTagValue,this.options.numberParseOptions):t}}function k(t){if(this.options.removeNSPrefix){const e=t.split(":"),n="/"===t.charAt(0)?"/":"";if("xmlns"===e[0])return"";2===e.length&&(t=n+e[1])}return t}const _=new RegExp("([^\\s=]+)\\s*(=\\s*(['\"])([\\s\\S]*?)\\3)?","gm");function U(t,e,n){if(!0!==this.options.ignoreAttributes&&"string"==typeof t){const i=s(t,_),r=i.length,o={};for(let t=0;t<r;t++){const s=this.resolveNameSpace(i[t][1]);if(this.ignoreAttributesFn(s,e))continue;let r=i[t][4],a=this.options.attributeNamePrefix+s;if(s.length)if(this.options.transformAttributeName&&(a=this.options.transformAttributeName(a)),"__proto__"===a&&(a="#__proto__"),void 0!==r){this.options.trimValues&&(r=r.trim()),r=this.replaceEntitiesValue(r,n,e);const t=this.options.attributeValueProcessor(s,r,e);o[a]=null==t?r:typeof t!=typeof r||t!==r?t:Z(r,this.options.parseAttributeValue,this.options.numberParseOptions)}else this.options.allowBooleanAttributes&&(o[a]=!0)}if(!Object.keys(o).length)return;if(this.options.attributesGroupName){const t={};return t[this.options.attributesGroupName]=o,t}return o}}const R=function(t){t=t.replace(/\r\n?/g,"\n");const e=new I("!xml");let n=e,i="",s="";this.entityExpansionCount=0,this.currentExpandedLength=0;const r=new P(this.options.processEntities);for(let o=0;o<t.length;o++)if("<"===t[o])if("/"===t[o+1]){const e=z(t,">",o,"Closing Tag is not closed.");let r=t.substring(o+2,e).trim();if(this.options.removeNSPrefix){const t=r.indexOf(":");-1!==t&&(r=r.substr(t+1))}this.options.transformTagName&&(r=this.options.transformTagName(r)),n&&(i=this.saveTextToParentTag(i,n,s));const a=s.substring(s.lastIndexOf(".")+1);if(r&&-1!==this.options.unpairedTags.indexOf(r))throw new Error(`Unpaired tag can not be used as closing tag: </${r}>`);let l=0;a&&-1!==this.options.unpairedTags.indexOf(a)?(l=s.lastIndexOf(".",s.lastIndexOf(".")-1),this.tagsNodeStack.pop()):l=s.lastIndexOf("."),s=s.substring(0,l),n=this.tagsNodeStack.pop(),i="",o=e}else if("?"===t[o+1]){let e=W(t,o,!1,"?>");if(!e)throw new Error("Pi Tag is not closed.");if(i=this.saveTextToParentTag(i,n,s),this.options.ignoreDeclaration&&"?xml"===e.tagName||this.options.ignorePiTags);else{const t=new I(e.tagName);t.add(this.options.textNodeName,""),e.tagName!==e.tagExp&&e.attrExpPresent&&(t[":@"]=this.buildAttributesMap(e.tagExp,s,e.tagName)),this.addChild(n,t,s,o)}o=e.closeIndex+1}else if("!--"===t.substr(o+1,3)){const e=z(t,"--\x3e",o+4,"Comment is not closed.");if(this.options.commentPropName){const r=t.substring(o+4,e-2);i=this.saveTextToParentTag(i,n,s),n.add(this.options.commentPropName,[{[this.options.textNodeName]:r}])}o=e}else if("!D"===t.substr(o+1,2)){const e=r.readDocType(t,o);this.docTypeEntities=e.entities,o=e.i}else if("!["===t.substr(o+1,2)){const e=z(t,"]]>",o,"CDATA is not closed.")-2,r=t.substring(o+9,e);i=this.saveTextToParentTag(i,n,s);let a=this.parseTextData(r,n.tagname,s,!0,!1,!0,!0);null==a&&(a=""),this.options.cdataPropName?n.add(this.options.cdataPropName,[{[this.options.textNodeName]:r}]):n.add(this.options.textNodeName,a),o=e+2}else{let r=W(t,o,this.options.removeNSPrefix),a=r.tagName;const l=r.rawTagName;let u=r.tagExp,d=r.attrExpPresent,h=r.closeIndex;if(this.options.transformTagName){const t=this.options.transformTagName(a);u===a&&(u=t),a=t}if(this.options.strictReservedNames&&(a===this.options.commentPropName||a===this.options.cdataPropName))throw new Error(`Invalid tag name: ${a}`);n&&i&&"!xml"!==n.tagname&&(i=this.saveTextToParentTag(i,n,s,!1));const p=n;p&&-1!==this.options.unpairedTags.indexOf(p.tagname)&&(n=this.tagsNodeStack.pop(),s=s.substring(0,s.lastIndexOf("."))),a!==e.tagname&&(s+=s?"."+a:a);const c=o;if(this.isItStopNode(this.stopNodesExact,this.stopNodesWildcard,s,a)){let e="";if(u.length>0&&u.lastIndexOf("/")===u.length-1)"/"===a[a.length-1]?(a=a.substr(0,a.length-1),s=s.substr(0,s.length-1),u=a):u=u.substr(0,u.length-1),o=r.closeIndex;else if(-1!==this.options.unpairedTags.indexOf(a))o=r.closeIndex;else{const n=this.readStopNodeData(t,l,h+1);if(!n)throw new Error(`Unexpected end of ${l}`);o=n.i,e=n.tagContent}const i=new I(a);a!==u&&d&&(i[":@"]=this.buildAttributesMap(u,s,a)),e&&(e=this.parseTextData(e,a,s,!0,d,!0,!0)),s=s.substr(0,s.lastIndexOf(".")),i.add(this.options.textNodeName,e),this.addChild(n,i,s,c)}else{if(u.length>0&&u.lastIndexOf("/")===u.length-1){if("/"===a[a.length-1]?(a=a.substr(0,a.length-1),s=s.substr(0,s.length-1),u=a):u=u.substr(0,u.length-1),this.options.transformTagName){const t=this.options.transformTagName(a);u===a&&(u=t),a=t}const t=new I(a);a!==u&&d&&(t[":@"]=this.buildAttributesMap(u,s,a)),this.addChild(n,t,s,c),s=s.substr(0,s.lastIndexOf("."))}else{if(-1!==this.options.unpairedTags.indexOf(a)){const t=new I(a);a!==u&&d&&(t[":@"]=this.buildAttributesMap(u,s)),this.addChild(n,t,s,c),s=s.substr(0,s.lastIndexOf(".")),o=r.closeIndex;continue}{const t=new I(a);if(this.tagsNodeStack.length>this.options.maxNestedTags)throw new Error("Maximum nested tags exceeded");this.tagsNodeStack.push(n),a!==u&&d&&(t[":@"]=this.buildAttributesMap(u,s,a)),this.addChild(n,t,s,c),n=t}}i="",o=h}}else i+=t[o];return e.child};function B(t,e,n,i){this.options.captureMetaData||(i=void 0);const s=this.options.updateTag(e.tagname,n,e[":@"]);!1===s||("string"==typeof s?(e.tagname=s,t.addChild(e,i)):t.addChild(e,i))}const Y=function(t,e,n){if(-1===t.indexOf("&"))return t;const i=this.options.processEntities;if(!i.enabled)return t;if(i.allowedTags&&!i.allowedTags.includes(e))return t;if(i.tagFilter&&!i.tagFilter(e,n))return t;for(let e in this.docTypeEntities){const n=this.docTypeEntities[e],s=t.match(n.regx);if(s){if(this.entityExpansionCount+=s.length,i.maxTotalExpansions&&this.entityExpansionCount>i.maxTotalExpansions)throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${i.maxTotalExpansions}`);const e=t.length;if(t=t.replace(n.regx,n.val),i.maxExpandedLength&&(this.currentExpandedLength+=t.length-e,this.currentExpandedLength>i.maxExpandedLength))throw new Error(`Total expanded content size exceeded: ${this.currentExpandedLength} > ${i.maxExpandedLength}`)}}if(-1===t.indexOf("&"))return t;for(let e in this.lastEntities){const n=this.lastEntities[e];t=t.replace(n.regex,n.val)}if(-1===t.indexOf("&"))return t;if(this.options.htmlEntities)for(let e in this.htmlEntities){const n=this.htmlEntities[e];t=t.replace(n.regex,n.val)}return t.replace(this.ampEntity.regex,this.ampEntity.val)};function G(t,e,n,i){return t&&(void 0===i&&(i=0===e.child.length),void 0!==(t=this.parseTextData(t,e.tagname,n,!1,!!e[":@"]&&0!==Object.keys(e[":@"]).length,i))&&""!==t&&e.add(this.options.textNodeName,t),t=""),t}function X(t,e,n,i){return!(!e||!e.has(i))||!(!t||!t.has(n))}function z(t,e,n,i){const s=t.indexOf(e,n);if(-1===s)throw new Error(i);return s+e.length-1}function W(t,e,n,i=">"){const s=function(t,e,n=">"){let i,s="";for(let r=e;r<t.length;r++){let e=t[r];if(i)e===i&&(i="");else if('"'===e||"'"===e)i=e;else if(e===n[0]){if(!n[1])return{data:s,index:r};if(t[r+1]===n[1])return{data:s,index:r}}else"\t"===e&&(e=" ");s+=e}}(t,e+1,i);if(!s)return;let r=s.data;const o=s.index,a=r.search(/\s/);let l=r,u=!0;-1!==a&&(l=r.substring(0,a),r=r.substring(a+1).trimStart());const d=l;if(n){const t=l.indexOf(":");-1!==t&&(l=l.substr(t+1),u=l!==s.data.substr(t+1))}return{tagName:l,tagExp:r,closeIndex:o,attrExpPresent:u,rawTagName:d}}function q(t,e,n){const i=n;let s=1;for(;n<t.length;n++)if("<"===t[n])if("/"===t[n+1]){const r=z(t,">",n,`${e} is not closed`);if(t.substring(n+2,r).trim()===e&&(s--,0===s))return{tagContent:t.substring(i,n),i:r};n=r}else if("?"===t[n+1])n=z(t,"?>",n+1,"StopNode is not closed.");else if("!--"===t.substr(n+1,3))n=z(t,"--\x3e",n+3,"StopNode is not closed.");else if("!["===t.substr(n+1,2))n=z(t,"]]>",n,"StopNode is not closed.")-2;else{const i=W(t,n,">");i&&((i&&i.tagName)===e&&"/"!==i.tagExp[i.tagExp.length-1]&&s++,n=i.closeIndex)}}function Z(t,e,n){if(e&&"string"==typeof t){const e=t.trim();return"true"===e||"false"!==e&&function(t,e={}){if(e=Object.assign({},D,e),!t||"string"!=typeof t)return t;let n=t.trim();if(void 0!==e.skipLike&&e.skipLike.test(n))return t;if("0"===t)return 0;if(e.hex&&$.test(n))return function(t){if(parseInt)return parseInt(t,16);if(Number.parseInt)return Number.parseInt(t,16);if(window&&window.parseInt)return window.parseInt(t,16);throw new Error("parseInt, Number.parseInt, window.parseInt are not supported")}(n);if(n.includes("e")||n.includes("E"))return function(t,e,n){if(!n.eNotation)return t;const i=e.match(j);if(i){let s=i[1]||"";const r=-1===i[3].indexOf("e")?"E":"e",o=i[2],a=s?t[o.length+1]===r:t[o.length]===r;return o.length>1&&a?t:1!==o.length||!i[3].startsWith(`.${r}`)&&i[3][0]!==r?n.leadingZeros&&!a?(e=(i[1]||"")+i[3],Number(e)):t:Number(e)}return t}(t,n,e);{const s=V.exec(n);if(s){const r=s[1]||"",o=s[2];let a=(i=s[3])&&-1!==i.indexOf(".")?("."===(i=i.replace(/0+$/,""))?i="0":"."===i[0]?i="0"+i:"."===i[i.length-1]&&(i=i.substring(0,i.length-1)),i):i;const l=r?"."===t[o.length+1]:"."===t[o.length];if(!e.leadingZeros&&(o.length>1||1===o.length&&!l))return t;{const i=Number(n),s=String(i);if(0===i)return i;if(-1!==s.search(/[eE]/))return e.eNotation?i:t;if(-1!==n.indexOf("."))return"0"===s||s===a||s===`${r}${a}`?i:t;let l=o?a:n;return o?l===s||r+l===s?i:t:l===s||l===r+s?i:t}}return t}var i}(t,n)}return void 0!==t?t:""}function K(t,e,n){const i=Number.parseInt(t,e);return i>=0&&i<=1114111?String.fromCodePoint(i):n+t+";"}const Q=I.getMetaDataSymbol();function J(t,e){return H(t,e)}function H(t,e,n){let i;const s={};for(let r=0;r<t.length;r++){const o=t[r],a=tt(o);let l="";if(l=void 0===n?a:n+"."+a,a===e.textNodeName)void 0===i?i=o[a]:i+=""+o[a];else{if(void 0===a)continue;if(o[a]){let t=H(o[a],e,l);const n=nt(t,e);o[":@"]?et(t,o[":@"],l,e):1!==Object.keys(t).length||void 0===t[e.textNodeName]||e.alwaysCreateTextNode?0===Object.keys(t).length&&(e.alwaysCreateTextNode?t[e.textNodeName]="":t=""):t=t[e.textNodeName],void 0!==o[Q]&&"object"==typeof t&&null!==t&&(t[Q]=o[Q]),void 0!==s[a]&&Object.prototype.hasOwnProperty.call(s,a)?(Array.isArray(s[a])||(s[a]=[s[a]]),s[a].push(t)):e.isArray(a,l,n)?s[a]=[t]:s[a]=t}}}return"string"==typeof i?i.length>0&&(s[e.textNodeName]=i):void 0!==i&&(s[e.textNodeName]=i),s}function tt(t){const e=Object.keys(t);for(let t=0;t<e.length;t++){const n=e[t];if(":@"!==n)return n}}function et(t,e,n,i){if(e){const s=Object.keys(e),r=s.length;for(let o=0;o<r;o++){const r=s[o];i.isArray(r,n+"."+r,!0,!0)?t[r]=[e[r]]:t[r]=e[r]}}}function nt(t,e){const{textNodeName:n}=e,i=Object.keys(t).length;return 0===i||!(1!==i||!t[n]&&"boolean"!=typeof t[n]&&0!==t[n])}class it{constructor(t){this.externalEntities={},this.options=v(t)}parse(t,e){if("string"!=typeof t&&t.toString)t=t.toString();else if("string"!=typeof t)throw new Error("XML data is accepted in String or Bytes[] form.");if(e){!0===e&&(e={});const n=a(t,e);if(!0!==n)throw Error(`${n.err.msg}:${n.err.line}:${n.err.col}`)}const n=new L(this.options);n.addExternalEntities(this.externalEntities);const i=n.parseXml(t);return this.options.preserveOrder||void 0===i?i:J(i,this.options)}addEntity(t,e){if(-1!==e.indexOf("&"))throw new Error("Entity value can't have '&'");if(-1!==t.indexOf("&")||-1!==t.indexOf(";"))throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");if("&"===e)throw new Error("An entity with value '&' is not permitted");this.externalEntities[t]=e}static getMetaDataSymbol(){return I.getMetaDataSymbol()}}function st(t,e){let n="";return e.format&&e.indentBy.length>0&&(n="\n"),rt(t,e,"",n)}function rt(t,e,n,i){let s="",r=!1;if(!Array.isArray(t)){if(null!=t){let n=t.toString();return n=ut(n,e),n}return""}for(let o=0;o<t.length;o++){const a=t[o],l=ot(a);if(void 0===l)continue;let u="";if(u=0===n.length?l:`${n}.${l}`,l===e.textNodeName){let t=a[l];lt(u,e)||(t=e.tagValueProcessor(l,t),t=ut(t,e)),r&&(s+=i),s+=t,r=!1;continue}if(l===e.cdataPropName){r&&(s+=i),s+=`<![CDATA[${a[l][0][e.textNodeName]}]]>`,r=!1;continue}if(l===e.commentPropName){s+=i+`\x3c!--${a[l][0][e.textNodeName]}--\x3e`,r=!0;continue}if("?"===l[0]){const t=at(a[":@"],e),n="?xml"===l?"":i;let o=a[l][0][e.textNodeName];o=0!==o.length?" "+o:"",s+=n+`<${l}${o}${t}?>`,r=!0;continue}let d=i;""!==d&&(d+=e.indentBy);const h=i+`<${l}${at(a[":@"],e)}`,p=rt(a[l],e,u,d);-1!==e.unpairedTags.indexOf(l)?e.suppressUnpairedNode?s+=h+">":s+=h+"/>":p&&0!==p.length||!e.suppressEmptyNode?p&&p.endsWith(">")?s+=h+`>${p}${i}</${l}>`:(s+=h+">",p&&""!==i&&(p.includes("/>")||p.includes("</"))?s+=i+e.indentBy+p+i:s+=p,s+=`</${l}>`):s+=h+"/>",r=!0}return s}function ot(t){const e=Object.keys(t);for(let n=0;n<e.length;n++){const i=e[n];if(Object.prototype.hasOwnProperty.call(t,i)&&":@"!==i)return i}}function at(t,e){let n="";if(t&&!e.ignoreAttributes)for(let i in t){if(!Object.prototype.hasOwnProperty.call(t,i))continue;let s=e.attributeValueProcessor(i,t[i]);s=ut(s,e),!0===s&&e.suppressBooleanAttributes?n+=` ${i.substr(e.attributeNamePrefix.length)}`:n+=` ${i.substr(e.attributeNamePrefix.length)}="${s}"`}return n}function lt(t,e){let n=(t=t.substr(0,t.length-e.textNodeName.length-1)).substr(t.lastIndexOf(".")+1);for(let i in e.stopNodes)if(e.stopNodes[i]===t||e.stopNodes[i]==="*."+n)return!0;return!1}function ut(t,e){if(t&&t.length>0&&e.processEntities)for(let n=0;n<e.entities.length;n++){const i=e.entities[n];t=t.replace(i.regex,i.val)}return t}const dt={attributeNamePrefix:"@_",attributesGroupName:!1,textNodeName:"#text",ignoreAttributes:!0,cdataPropName:!1,format:!1,indentBy:"  ",suppressEmptyNode:!1,suppressUnpairedNode:!0,suppressBooleanAttributes:!0,tagValueProcessor:function(t,e){return e},attributeValueProcessor:function(t,e){return e},preserveOrder:!1,commentPropName:!1,unpairedTags:[],entities:[{regex:new RegExp("&","g"),val:"&amp;"},{regex:new RegExp(">","g"),val:"&gt;"},{regex:new RegExp("<","g"),val:"&lt;"},{regex:new RegExp("'","g"),val:"&apos;"},{regex:new RegExp('"',"g"),val:"&quot;"}],processEntities:!0,stopNodes:[],oneListGroup:!1};function ht(t){var e;this.options=Object.assign({},dt,t),!0===this.options.ignoreAttributes||this.options.attributesGroupName?this.isAttribute=function(){return!1}:(this.ignoreAttributesFn="function"==typeof(e=this.options.ignoreAttributes)?e:Array.isArray(e)?t=>{for(const n of e){if("string"==typeof n&&t===n)return!0;if(n instanceof RegExp&&n.test(t))return!0}}:()=>!1,this.attrPrefixLen=this.options.attributeNamePrefix.length,this.isAttribute=ft),this.processTextOrObjNode=pt,this.options.format?(this.indentate=ct,this.tagEndChar=">\n",this.newLine="\n"):(this.indentate=function(){return""},this.tagEndChar=">",this.newLine="")}function pt(t,e,n,i){const s=this.j2x(t,n+1,i.concat(e));return void 0!==t[this.options.textNodeName]&&1===Object.keys(t).length?this.buildTextValNode(t[this.options.textNodeName],e,s.attrStr,n):this.buildObjectNode(s.val,e,s.attrStr,n)}function ct(t){return this.options.indentBy.repeat(t)}function ft(t){return!(!t.startsWith(this.options.attributeNamePrefix)||t===this.options.textNodeName)&&t.substr(this.attrPrefixLen)}ht.prototype.build=function(t){return this.options.preserveOrder?st(t,this.options):(Array.isArray(t)&&this.options.arrayNodeName&&this.options.arrayNodeName.length>1&&(t={[this.options.arrayNodeName]:t}),this.j2x(t,0,[]).val)},ht.prototype.j2x=function(t,e,n){let i="",s="";const r=n.join(".");for(let o in t)if(Object.prototype.hasOwnProperty.call(t,o))if(void 0===t[o])this.isAttribute(o)&&(s+="");else if(null===t[o])this.isAttribute(o)||o===this.options.cdataPropName?s+="":"?"===o[0]?s+=this.indentate(e)+"<"+o+"?"+this.tagEndChar:s+=this.indentate(e)+"<"+o+"/"+this.tagEndChar;else if(t[o]instanceof Date)s+=this.buildTextValNode(t[o],o,"",e);else if("object"!=typeof t[o]){const n=this.isAttribute(o);if(n&&!this.ignoreAttributesFn(n,r))i+=this.buildAttrPairStr(n,""+t[o]);else if(!n)if(o===this.options.textNodeName){let e=this.options.tagValueProcessor(o,""+t[o]);s+=this.replaceEntitiesValue(e)}else s+=this.buildTextValNode(t[o],o,"",e)}else if(Array.isArray(t[o])){const i=t[o].length;let r="",a="";for(let l=0;l<i;l++){const i=t[o][l];if(void 0===i);else if(null===i)"?"===o[0]?s+=this.indentate(e)+"<"+o+"?"+this.tagEndChar:s+=this.indentate(e)+"<"+o+"/"+this.tagEndChar;else if("object"==typeof i)if(this.options.oneListGroup){const t=this.j2x(i,e+1,n.concat(o));r+=t.val,this.options.attributesGroupName&&i.hasOwnProperty(this.options.attributesGroupName)&&(a+=t.attrStr)}else r+=this.processTextOrObjNode(i,o,e,n);else if(this.options.oneListGroup){let t=this.options.tagValueProcessor(o,i);t=this.replaceEntitiesValue(t),r+=t}else r+=this.buildTextValNode(i,o,"",e)}this.options.oneListGroup&&(r=this.buildObjectNode(r,o,a,e)),s+=r}else if(this.options.attributesGroupName&&o===this.options.attributesGroupName){const e=Object.keys(t[o]),n=e.length;for(let s=0;s<n;s++)i+=this.buildAttrPairStr(e[s],""+t[o][e[s]])}else s+=this.processTextOrObjNode(t[o],o,e,n);return{attrStr:i,val:s}},ht.prototype.buildAttrPairStr=function(t,e){return e=this.options.attributeValueProcessor(t,""+e),e=this.replaceEntitiesValue(e),this.options.suppressBooleanAttributes&&"true"===e?" "+t:" "+t+'="'+e+'"'},ht.prototype.buildObjectNode=function(t,e,n,i){if(""===t)return"?"===e[0]?this.indentate(i)+"<"+e+n+"?"+this.tagEndChar:this.indentate(i)+"<"+e+n+this.closeTag(e)+this.tagEndChar;{let s="</"+e+this.tagEndChar,r="";return"?"===e[0]&&(r="?",s=""),!n&&""!==n||-1!==t.indexOf("<")?!1!==this.options.commentPropName&&e===this.options.commentPropName&&0===r.length?this.indentate(i)+`\x3c!--${t}--\x3e`+this.newLine:this.indentate(i)+"<"+e+n+r+this.tagEndChar+t+this.indentate(i)+s:this.indentate(i)+"<"+e+n+r+">"+t+s}},ht.prototype.closeTag=function(t){let e="";return-1!==this.options.unpairedTags.indexOf(t)?this.options.suppressUnpairedNode||(e="/"):e=this.options.suppressEmptyNode?"/":`></${t}`,e},ht.prototype.buildTextValNode=function(t,e,n,i){if(!1!==this.options.cdataPropName&&e===this.options.cdataPropName)return this.indentate(i)+`<![CDATA[${t}]]>`+this.newLine;if(!1!==this.options.commentPropName&&e===this.options.commentPropName)return this.indentate(i)+`\x3c!--${t}--\x3e`+this.newLine;if("?"===e[0])return this.indentate(i)+"<"+e+n+"?"+this.tagEndChar;{let s=this.options.tagValueProcessor(e,t);return s=this.replaceEntitiesValue(s),""===s?this.indentate(i)+"<"+e+n+this.closeTag(e)+this.tagEndChar:this.indentate(i)+"<"+e+n+">"+s+"</"+e+this.tagEndChar}},ht.prototype.replaceEntitiesValue=function(t){if(t&&t.length>0&&this.options.processEntities)for(let e=0;e<this.options.entities.length;e++){const n=this.options.entities[e];t=t.replace(n.regex,n.val)}return t};const gt=ht,xt={validate:a};module.exports=e})();
 
 /***/ }),
 
diff --git a/dist/setup/index.js b/dist/setup/index.js
index 6a30bfa..1047dd2 100644
--- a/dist/setup/index.js
+++ b/dist/setup/index.js
@@ -5357,7 +5357,7 @@ const http = __importStar(__nccwpck_require__(13685));
 const https = __importStar(__nccwpck_require__(95687));
 const pm = __importStar(__nccwpck_require__(4977));
 const tunnel = __importStar(__nccwpck_require__(74294));
-const undici_1 = __nccwpck_require__(41773);
+const undici_1 = __nccwpck_require__(88498);
 var HttpCodes;
 (function (HttpCodes) {
     HttpCodes[HttpCodes["OK"] = 200] = "OK";
@@ -5475,7 +5475,7 @@ class HttpClient {
         this._maxRetries = 1;
         this._keepAlive = false;
         this._disposed = false;
-        this.userAgent = userAgent;
+        this.userAgent = this._getUserAgentWithOrchestrationId(userAgent);
         this.handlers = handlers || [];
         this.requestOptions = requestOptions;
         if (requestOptions) {
@@ -5955,6 +5955,17 @@ class HttpClient {
         }
         return proxyAgent;
     }
+    _getUserAgentWithOrchestrationId(userAgent) {
+        const baseUserAgent = userAgent || 'actions/http-client';
+        const orchId = process.env['ACTIONS_ORCHESTRATION_ID'];
+        if (orchId) {
+            // Sanitize the orchestration ID to ensure it contains only valid characters
+            // Valid characters: 0-9, a-z, _, -, .
+            const sanitizedId = orchId.replace(/[^a-z0-9_.-]/gi, '_');
+            return `${baseUserAgent} actions_orchestration_id/${sanitizedId}`;
+        }
+        return baseUserAgent;
+    }
     _performExponentialBackoff(retryNumber) {
         return __awaiter(this, void 0, void 0, function* () {
             retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
@@ -8333,6 +8344,27409 @@ function coerce (version, options) {
 }
 
 
+/***/ }),
+
+/***/ 88498:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const Client = __nccwpck_require__(6655)
+const Dispatcher = __nccwpck_require__(51927)
+const Pool = __nccwpck_require__(11795)
+const BalancedPool = __nccwpck_require__(74086)
+const Agent = __nccwpck_require__(83421)
+const ProxyAgent = __nccwpck_require__(54372)
+const EnvHttpProxyAgent = __nccwpck_require__(4803)
+const RetryAgent = __nccwpck_require__(46811)
+const errors = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { InvalidArgumentError } = errors
+const api = __nccwpck_require__(24575)
+const buildConnector = __nccwpck_require__(20123)
+const MockClient = __nccwpck_require__(32144)
+const MockAgent = __nccwpck_require__(56549)
+const MockPool = __nccwpck_require__(92565)
+const mockErrors = __nccwpck_require__(54331)
+const RetryHandler = __nccwpck_require__(61465)
+const { getGlobalDispatcher, setGlobalDispatcher } = __nccwpck_require__(72354)
+const DecoratorHandler = __nccwpck_require__(7004)
+const RedirectHandler = __nccwpck_require__(59470)
+const createRedirectInterceptor = __nccwpck_require__(11115)
+
+Object.assign(Dispatcher.prototype, api)
+
+module.exports.Dispatcher = Dispatcher
+module.exports.Client = Client
+module.exports.Pool = Pool
+module.exports.BalancedPool = BalancedPool
+module.exports.Agent = Agent
+module.exports.ProxyAgent = ProxyAgent
+module.exports.EnvHttpProxyAgent = EnvHttpProxyAgent
+module.exports.RetryAgent = RetryAgent
+module.exports.RetryHandler = RetryHandler
+
+module.exports.DecoratorHandler = DecoratorHandler
+module.exports.RedirectHandler = RedirectHandler
+module.exports.createRedirectInterceptor = createRedirectInterceptor
+module.exports.interceptors = {
+  redirect: __nccwpck_require__(42370),
+  retry: __nccwpck_require__(66080),
+  dump: __nccwpck_require__(3199),
+  dns: __nccwpck_require__(42462)
+}
+
+module.exports.buildConnector = buildConnector
+module.exports.errors = errors
+module.exports.util = {
+  parseHeaders: util.parseHeaders,
+  headerNameToString: util.headerNameToString
+}
+
+function makeDispatcher (fn) {
+  return (url, opts, handler) => {
+    if (typeof opts === 'function') {
+      handler = opts
+      opts = null
+    }
+
+    if (!url || (typeof url !== 'string' && typeof url !== 'object' && !(url instanceof URL))) {
+      throw new InvalidArgumentError('invalid url')
+    }
+
+    if (opts != null && typeof opts !== 'object') {
+      throw new InvalidArgumentError('invalid opts')
+    }
+
+    if (opts && opts.path != null) {
+      if (typeof opts.path !== 'string') {
+        throw new InvalidArgumentError('invalid opts.path')
+      }
+
+      let path = opts.path
+      if (!opts.path.startsWith('/')) {
+        path = `/${path}`
+      }
+
+      url = new URL(util.parseOrigin(url).origin + path)
+    } else {
+      if (!opts) {
+        opts = typeof url === 'object' ? url : {}
+      }
+
+      url = util.parseURL(url)
+    }
+
+    const { agent, dispatcher = getGlobalDispatcher() } = opts
+
+    if (agent) {
+      throw new InvalidArgumentError('unsupported opts.agent. Did you mean opts.client?')
+    }
+
+    return fn.call(dispatcher, {
+      ...opts,
+      origin: url.origin,
+      path: url.search ? `${url.pathname}${url.search}` : url.pathname,
+      method: opts.method || (opts.body ? 'PUT' : 'GET')
+    }, handler)
+  }
+}
+
+module.exports.setGlobalDispatcher = setGlobalDispatcher
+module.exports.getGlobalDispatcher = getGlobalDispatcher
+
+const fetchImpl = (__nccwpck_require__(31158).fetch)
+module.exports.fetch = async function fetch (init, options = undefined) {
+  try {
+    return await fetchImpl(init, options)
+  } catch (err) {
+    if (err && typeof err === 'object') {
+      Error.captureStackTrace(err)
+    }
+
+    throw err
+  }
+}
+module.exports.Headers = __nccwpck_require__(24997).Headers
+module.exports.Response = __nccwpck_require__(33139).Response
+module.exports.Request = __nccwpck_require__(13925).Request
+module.exports.FormData = __nccwpck_require__(4923).FormData
+module.exports.File = globalThis.File ?? (__nccwpck_require__(72254).File)
+module.exports.FileReader = __nccwpck_require__(70923).FileReader
+
+const { setGlobalOrigin, getGlobalOrigin } = __nccwpck_require__(71332)
+
+module.exports.setGlobalOrigin = setGlobalOrigin
+module.exports.getGlobalOrigin = getGlobalOrigin
+
+const { CacheStorage } = __nccwpck_require__(12130)
+const { kConstruct } = __nccwpck_require__(90053)
+
+// Cache & CacheStorage are tightly coupled with fetch. Even if it may run
+// in an older version of Node, it doesn't have any use without fetch.
+module.exports.caches = new CacheStorage(kConstruct)
+
+const { deleteCookie, getCookies, getSetCookies, setCookie } = __nccwpck_require__(57705)
+
+module.exports.deleteCookie = deleteCookie
+module.exports.getCookies = getCookies
+module.exports.getSetCookies = getSetCookies
+module.exports.setCookie = setCookie
+
+const { parseMIMEType, serializeAMimeType } = __nccwpck_require__(86954)
+
+module.exports.parseMIMEType = parseMIMEType
+module.exports.serializeAMimeType = serializeAMimeType
+
+const { CloseEvent, ErrorEvent, MessageEvent } = __nccwpck_require__(15135)
+module.exports.WebSocket = __nccwpck_require__(75860).WebSocket
+module.exports.CloseEvent = CloseEvent
+module.exports.ErrorEvent = ErrorEvent
+module.exports.MessageEvent = MessageEvent
+
+module.exports.request = makeDispatcher(api.request)
+module.exports.stream = makeDispatcher(api.stream)
+module.exports.pipeline = makeDispatcher(api.pipeline)
+module.exports.connect = makeDispatcher(api.connect)
+module.exports.upgrade = makeDispatcher(api.upgrade)
+
+module.exports.MockClient = MockClient
+module.exports.MockPool = MockPool
+module.exports.MockAgent = MockAgent
+module.exports.mockErrors = mockErrors
+
+const { EventSource } = __nccwpck_require__(62205)
+
+module.exports.EventSource = EventSource
+
+
+/***/ }),
+
+/***/ 30703:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+const { addAbortListener } = __nccwpck_require__(94407)
+const { RequestAbortedError } = __nccwpck_require__(22174)
+
+const kListener = Symbol('kListener')
+const kSignal = Symbol('kSignal')
+
+function abort (self) {
+  if (self.abort) {
+    self.abort(self[kSignal]?.reason)
+  } else {
+    self.reason = self[kSignal]?.reason ?? new RequestAbortedError()
+  }
+  removeSignal(self)
+}
+
+function addSignal (self, signal) {
+  self.reason = null
+
+  self[kSignal] = null
+  self[kListener] = null
+
+  if (!signal) {
+    return
+  }
+
+  if (signal.aborted) {
+    abort(self)
+    return
+  }
+
+  self[kSignal] = signal
+  self[kListener] = () => {
+    abort(self)
+  }
+
+  addAbortListener(self[kSignal], self[kListener])
+}
+
+function removeSignal (self) {
+  if (!self[kSignal]) {
+    return
+  }
+
+  if ('removeEventListener' in self[kSignal]) {
+    self[kSignal].removeEventListener('abort', self[kListener])
+  } else {
+    self[kSignal].removeListener('abort', self[kListener])
+  }
+
+  self[kSignal] = null
+  self[kListener] = null
+}
+
+module.exports = {
+  addSignal,
+  removeSignal
+}
+
+
+/***/ }),
+
+/***/ 7636:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+const { AsyncResource } = __nccwpck_require__(92761)
+const { InvalidArgumentError, SocketError } = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { addSignal, removeSignal } = __nccwpck_require__(30703)
+
+class ConnectHandler extends AsyncResource {
+  constructor (opts, callback) {
+    if (!opts || typeof opts !== 'object') {
+      throw new InvalidArgumentError('invalid opts')
+    }
+
+    if (typeof callback !== 'function') {
+      throw new InvalidArgumentError('invalid callback')
+    }
+
+    const { signal, opaque, responseHeaders } = opts
+
+    if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
+      throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
+    }
+
+    super('UNDICI_CONNECT')
+
+    this.opaque = opaque || null
+    this.responseHeaders = responseHeaders || null
+    this.callback = callback
+    this.abort = null
+
+    addSignal(this, signal)
+  }
+
+  onConnect (abort, context) {
+    if (this.reason) {
+      abort(this.reason)
+      return
+    }
+
+    assert(this.callback)
+
+    this.abort = abort
+    this.context = context
+  }
+
+  onHeaders () {
+    throw new SocketError('bad connect', null)
+  }
+
+  onUpgrade (statusCode, rawHeaders, socket) {
+    const { callback, opaque, context } = this
+
+    removeSignal(this)
+
+    this.callback = null
+
+    let headers = rawHeaders
+    // Indicates is an HTTP2Session
+    if (headers != null) {
+      headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+    }
+
+    this.runInAsyncScope(callback, null, null, {
+      statusCode,
+      headers,
+      socket,
+      opaque,
+      context
+    })
+  }
+
+  onError (err) {
+    const { callback, opaque } = this
+
+    removeSignal(this)
+
+    if (callback) {
+      this.callback = null
+      queueMicrotask(() => {
+        this.runInAsyncScope(callback, null, err, { opaque })
+      })
+    }
+  }
+}
+
+function connect (opts, callback) {
+  if (callback === undefined) {
+    return new Promise((resolve, reject) => {
+      connect.call(this, opts, (err, data) => {
+        return err ? reject(err) : resolve(data)
+      })
+    })
+  }
+
+  try {
+    const connectHandler = new ConnectHandler(opts, callback)
+    this.dispatch({ ...opts, method: 'CONNECT' }, connectHandler)
+  } catch (err) {
+    if (typeof callback !== 'function') {
+      throw err
+    }
+    const opaque = opts?.opaque
+    queueMicrotask(() => callback(err, { opaque }))
+  }
+}
+
+module.exports = connect
+
+
+/***/ }),
+
+/***/ 94375:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  Readable,
+  Duplex,
+  PassThrough
+} = __nccwpck_require__(84492)
+const {
+  InvalidArgumentError,
+  InvalidReturnValueError,
+  RequestAbortedError
+} = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { AsyncResource } = __nccwpck_require__(92761)
+const { addSignal, removeSignal } = __nccwpck_require__(30703)
+const assert = __nccwpck_require__(98061)
+
+const kResume = Symbol('resume')
+
+class PipelineRequest extends Readable {
+  constructor () {
+    super({ autoDestroy: true })
+
+    this[kResume] = null
+  }
+
+  _read () {
+    const { [kResume]: resume } = this
+
+    if (resume) {
+      this[kResume] = null
+      resume()
+    }
+  }
+
+  _destroy (err, callback) {
+    this._read()
+
+    callback(err)
+  }
+}
+
+class PipelineResponse extends Readable {
+  constructor (resume) {
+    super({ autoDestroy: true })
+    this[kResume] = resume
+  }
+
+  _read () {
+    this[kResume]()
+  }
+
+  _destroy (err, callback) {
+    if (!err && !this._readableState.endEmitted) {
+      err = new RequestAbortedError()
+    }
+
+    callback(err)
+  }
+}
+
+class PipelineHandler extends AsyncResource {
+  constructor (opts, handler) {
+    if (!opts || typeof opts !== 'object') {
+      throw new InvalidArgumentError('invalid opts')
+    }
+
+    if (typeof handler !== 'function') {
+      throw new InvalidArgumentError('invalid handler')
+    }
+
+    const { signal, method, opaque, onInfo, responseHeaders } = opts
+
+    if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
+      throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
+    }
+
+    if (method === 'CONNECT') {
+      throw new InvalidArgumentError('invalid method')
+    }
+
+    if (onInfo && typeof onInfo !== 'function') {
+      throw new InvalidArgumentError('invalid onInfo callback')
+    }
+
+    super('UNDICI_PIPELINE')
+
+    this.opaque = opaque || null
+    this.responseHeaders = responseHeaders || null
+    this.handler = handler
+    this.abort = null
+    this.context = null
+    this.onInfo = onInfo || null
+
+    this.req = new PipelineRequest().on('error', util.nop)
+
+    this.ret = new Duplex({
+      readableObjectMode: opts.objectMode,
+      autoDestroy: true,
+      read: () => {
+        const { body } = this
+
+        if (body?.resume) {
+          body.resume()
+        }
+      },
+      write: (chunk, encoding, callback) => {
+        const { req } = this
+
+        if (req.push(chunk, encoding) || req._readableState.destroyed) {
+          callback()
+        } else {
+          req[kResume] = callback
+        }
+      },
+      destroy: (err, callback) => {
+        const { body, req, res, ret, abort } = this
+
+        if (!err && !ret._readableState.endEmitted) {
+          err = new RequestAbortedError()
+        }
+
+        if (abort && err) {
+          abort()
+        }
+
+        util.destroy(body, err)
+        util.destroy(req, err)
+        util.destroy(res, err)
+
+        removeSignal(this)
+
+        callback(err)
+      }
+    }).on('prefinish', () => {
+      const { req } = this
+
+      // Node < 15 does not call _final in same tick.
+      req.push(null)
+    })
+
+    this.res = null
+
+    addSignal(this, signal)
+  }
+
+  onConnect (abort, context) {
+    const { ret, res } = this
+
+    if (this.reason) {
+      abort(this.reason)
+      return
+    }
+
+    assert(!res, 'pipeline cannot be retried')
+    assert(!ret.destroyed)
+
+    this.abort = abort
+    this.context = context
+  }
+
+  onHeaders (statusCode, rawHeaders, resume) {
+    const { opaque, handler, context } = this
+
+    if (statusCode < 200) {
+      if (this.onInfo) {
+        const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+        this.onInfo({ statusCode, headers })
+      }
+      return
+    }
+
+    this.res = new PipelineResponse(resume)
+
+    let body
+    try {
+      this.handler = null
+      const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+      body = this.runInAsyncScope(handler, null, {
+        statusCode,
+        headers,
+        opaque,
+        body: this.res,
+        context
+      })
+    } catch (err) {
+      this.res.on('error', util.nop)
+      throw err
+    }
+
+    if (!body || typeof body.on !== 'function') {
+      throw new InvalidReturnValueError('expected Readable')
+    }
+
+    body
+      .on('data', (chunk) => {
+        const { ret, body } = this
+
+        if (!ret.push(chunk) && body.pause) {
+          body.pause()
+        }
+      })
+      .on('error', (err) => {
+        const { ret } = this
+
+        util.destroy(ret, err)
+      })
+      .on('end', () => {
+        const { ret } = this
+
+        ret.push(null)
+      })
+      .on('close', () => {
+        const { ret } = this
+
+        if (!ret._readableState.ended) {
+          util.destroy(ret, new RequestAbortedError())
+        }
+      })
+
+    this.body = body
+  }
+
+  onData (chunk) {
+    const { res } = this
+    return res.push(chunk)
+  }
+
+  onComplete (trailers) {
+    const { res } = this
+    res.push(null)
+  }
+
+  onError (err) {
+    const { ret } = this
+    this.handler = null
+    util.destroy(ret, err)
+  }
+}
+
+function pipeline (opts, handler) {
+  try {
+    const pipelineHandler = new PipelineHandler(opts, handler)
+    this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler)
+    return pipelineHandler.ret
+  } catch (err) {
+    return new PassThrough().destroy(err)
+  }
+}
+
+module.exports = pipeline
+
+
+/***/ }),
+
+/***/ 20310:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+const { Readable } = __nccwpck_require__(64054)
+const { InvalidArgumentError, RequestAbortedError } = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { getResolveErrorBodyCallback } = __nccwpck_require__(45141)
+const { AsyncResource } = __nccwpck_require__(92761)
+
+class RequestHandler extends AsyncResource {
+  constructor (opts, callback) {
+    if (!opts || typeof opts !== 'object') {
+      throw new InvalidArgumentError('invalid opts')
+    }
+
+    const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError, highWaterMark } = opts
+
+    try {
+      if (typeof callback !== 'function') {
+        throw new InvalidArgumentError('invalid callback')
+      }
+
+      if (highWaterMark && (typeof highWaterMark !== 'number' || highWaterMark < 0)) {
+        throw new InvalidArgumentError('invalid highWaterMark')
+      }
+
+      if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
+        throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
+      }
+
+      if (method === 'CONNECT') {
+        throw new InvalidArgumentError('invalid method')
+      }
+
+      if (onInfo && typeof onInfo !== 'function') {
+        throw new InvalidArgumentError('invalid onInfo callback')
+      }
+
+      super('UNDICI_REQUEST')
+    } catch (err) {
+      if (util.isStream(body)) {
+        util.destroy(body.on('error', util.nop), err)
+      }
+      throw err
+    }
+
+    this.method = method
+    this.responseHeaders = responseHeaders || null
+    this.opaque = opaque || null
+    this.callback = callback
+    this.res = null
+    this.abort = null
+    this.body = body
+    this.trailers = {}
+    this.context = null
+    this.onInfo = onInfo || null
+    this.throwOnError = throwOnError
+    this.highWaterMark = highWaterMark
+    this.signal = signal
+    this.reason = null
+    this.removeAbortListener = null
+
+    if (util.isStream(body)) {
+      body.on('error', (err) => {
+        this.onError(err)
+      })
+    }
+
+    if (this.signal) {
+      if (this.signal.aborted) {
+        this.reason = this.signal.reason ?? new RequestAbortedError()
+      } else {
+        this.removeAbortListener = util.addAbortListener(this.signal, () => {
+          this.reason = this.signal.reason ?? new RequestAbortedError()
+          if (this.res) {
+            util.destroy(this.res.on('error', util.nop), this.reason)
+          } else if (this.abort) {
+            this.abort(this.reason)
+          }
+
+          if (this.removeAbortListener) {
+            this.res?.off('close', this.removeAbortListener)
+            this.removeAbortListener()
+            this.removeAbortListener = null
+          }
+        })
+      }
+    }
+  }
+
+  onConnect (abort, context) {
+    if (this.reason) {
+      abort(this.reason)
+      return
+    }
+
+    assert(this.callback)
+
+    this.abort = abort
+    this.context = context
+  }
+
+  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
+    const { callback, opaque, abort, context, responseHeaders, highWaterMark } = this
+
+    const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+
+    if (statusCode < 200) {
+      if (this.onInfo) {
+        this.onInfo({ statusCode, headers })
+      }
+      return
+    }
+
+    const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers
+    const contentType = parsedHeaders['content-type']
+    const contentLength = parsedHeaders['content-length']
+    const res = new Readable({
+      resume,
+      abort,
+      contentType,
+      contentLength: this.method !== 'HEAD' && contentLength
+        ? Number(contentLength)
+        : null,
+      highWaterMark
+    })
+
+    if (this.removeAbortListener) {
+      res.on('close', this.removeAbortListener)
+    }
+
+    this.callback = null
+    this.res = res
+    if (callback !== null) {
+      if (this.throwOnError && statusCode >= 400) {
+        this.runInAsyncScope(getResolveErrorBodyCallback, null,
+          { callback, body: res, contentType, statusCode, statusMessage, headers }
+        )
+      } else {
+        this.runInAsyncScope(callback, null, null, {
+          statusCode,
+          headers,
+          trailers: this.trailers,
+          opaque,
+          body: res,
+          context
+        })
+      }
+    }
+  }
+
+  onData (chunk) {
+    return this.res.push(chunk)
+  }
+
+  onComplete (trailers) {
+    util.parseHeaders(trailers, this.trailers)
+    this.res.push(null)
+  }
+
+  onError (err) {
+    const { res, callback, body, opaque } = this
+
+    if (callback) {
+      // TODO: Does this need queueMicrotask?
+      this.callback = null
+      queueMicrotask(() => {
+        this.runInAsyncScope(callback, null, err, { opaque })
+      })
+    }
+
+    if (res) {
+      this.res = null
+      // Ensure all queued handlers are invoked before destroying res.
+      queueMicrotask(() => {
+        util.destroy(res, err)
+      })
+    }
+
+    if (body) {
+      this.body = null
+      util.destroy(body, err)
+    }
+
+    if (this.removeAbortListener) {
+      res?.off('close', this.removeAbortListener)
+      this.removeAbortListener()
+      this.removeAbortListener = null
+    }
+  }
+}
+
+function request (opts, callback) {
+  if (callback === undefined) {
+    return new Promise((resolve, reject) => {
+      request.call(this, opts, (err, data) => {
+        return err ? reject(err) : resolve(data)
+      })
+    })
+  }
+
+  try {
+    this.dispatch(opts, new RequestHandler(opts, callback))
+  } catch (err) {
+    if (typeof callback !== 'function') {
+      throw err
+    }
+    const opaque = opts?.opaque
+    queueMicrotask(() => callback(err, { opaque }))
+  }
+}
+
+module.exports = request
+module.exports.RequestHandler = RequestHandler
+
+
+/***/ }),
+
+/***/ 55784:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+const { finished, PassThrough } = __nccwpck_require__(84492)
+const { InvalidArgumentError, InvalidReturnValueError } = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { getResolveErrorBodyCallback } = __nccwpck_require__(45141)
+const { AsyncResource } = __nccwpck_require__(92761)
+const { addSignal, removeSignal } = __nccwpck_require__(30703)
+
+class StreamHandler extends AsyncResource {
+  constructor (opts, factory, callback) {
+    if (!opts || typeof opts !== 'object') {
+      throw new InvalidArgumentError('invalid opts')
+    }
+
+    const { signal, method, opaque, body, onInfo, responseHeaders, throwOnError } = opts
+
+    try {
+      if (typeof callback !== 'function') {
+        throw new InvalidArgumentError('invalid callback')
+      }
+
+      if (typeof factory !== 'function') {
+        throw new InvalidArgumentError('invalid factory')
+      }
+
+      if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
+        throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
+      }
+
+      if (method === 'CONNECT') {
+        throw new InvalidArgumentError('invalid method')
+      }
+
+      if (onInfo && typeof onInfo !== 'function') {
+        throw new InvalidArgumentError('invalid onInfo callback')
+      }
+
+      super('UNDICI_STREAM')
+    } catch (err) {
+      if (util.isStream(body)) {
+        util.destroy(body.on('error', util.nop), err)
+      }
+      throw err
+    }
+
+    this.responseHeaders = responseHeaders || null
+    this.opaque = opaque || null
+    this.factory = factory
+    this.callback = callback
+    this.res = null
+    this.abort = null
+    this.context = null
+    this.trailers = null
+    this.body = body
+    this.onInfo = onInfo || null
+    this.throwOnError = throwOnError || false
+
+    if (util.isStream(body)) {
+      body.on('error', (err) => {
+        this.onError(err)
+      })
+    }
+
+    addSignal(this, signal)
+  }
+
+  onConnect (abort, context) {
+    if (this.reason) {
+      abort(this.reason)
+      return
+    }
+
+    assert(this.callback)
+
+    this.abort = abort
+    this.context = context
+  }
+
+  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
+    const { factory, opaque, context, callback, responseHeaders } = this
+
+    const headers = responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+
+    if (statusCode < 200) {
+      if (this.onInfo) {
+        this.onInfo({ statusCode, headers })
+      }
+      return
+    }
+
+    this.factory = null
+
+    let res
+
+    if (this.throwOnError && statusCode >= 400) {
+      const parsedHeaders = responseHeaders === 'raw' ? util.parseHeaders(rawHeaders) : headers
+      const contentType = parsedHeaders['content-type']
+      res = new PassThrough()
+
+      this.callback = null
+      this.runInAsyncScope(getResolveErrorBodyCallback, null,
+        { callback, body: res, contentType, statusCode, statusMessage, headers }
+      )
+    } else {
+      if (factory === null) {
+        return
+      }
+
+      res = this.runInAsyncScope(factory, null, {
+        statusCode,
+        headers,
+        opaque,
+        context
+      })
+
+      if (
+        !res ||
+        typeof res.write !== 'function' ||
+        typeof res.end !== 'function' ||
+        typeof res.on !== 'function'
+      ) {
+        throw new InvalidReturnValueError('expected Writable')
+      }
+
+      // TODO: Avoid finished. It registers an unnecessary amount of listeners.
+      finished(res, { readable: false }, (err) => {
+        const { callback, res, opaque, trailers, abort } = this
+
+        this.res = null
+        if (err || !res.readable) {
+          util.destroy(res, err)
+        }
+
+        this.callback = null
+        this.runInAsyncScope(callback, null, err || null, { opaque, trailers })
+
+        if (err) {
+          abort()
+        }
+      })
+    }
+
+    res.on('drain', resume)
+
+    this.res = res
+
+    const needDrain = res.writableNeedDrain !== undefined
+      ? res.writableNeedDrain
+      : res._writableState?.needDrain
+
+    return needDrain !== true
+  }
+
+  onData (chunk) {
+    const { res } = this
+
+    return res ? res.write(chunk) : true
+  }
+
+  onComplete (trailers) {
+    const { res } = this
+
+    removeSignal(this)
+
+    if (!res) {
+      return
+    }
+
+    this.trailers = util.parseHeaders(trailers)
+
+    res.end()
+  }
+
+  onError (err) {
+    const { res, callback, opaque, body } = this
+
+    removeSignal(this)
+
+    this.factory = null
+
+    if (res) {
+      this.res = null
+      util.destroy(res, err)
+    } else if (callback) {
+      this.callback = null
+      queueMicrotask(() => {
+        this.runInAsyncScope(callback, null, err, { opaque })
+      })
+    }
+
+    if (body) {
+      this.body = null
+      util.destroy(body, err)
+    }
+  }
+}
+
+function stream (opts, factory, callback) {
+  if (callback === undefined) {
+    return new Promise((resolve, reject) => {
+      stream.call(this, opts, factory, (err, data) => {
+        return err ? reject(err) : resolve(data)
+      })
+    })
+  }
+
+  try {
+    this.dispatch(opts, new StreamHandler(opts, factory, callback))
+  } catch (err) {
+    if (typeof callback !== 'function') {
+      throw err
+    }
+    const opaque = opts?.opaque
+    queueMicrotask(() => callback(err, { opaque }))
+  }
+}
+
+module.exports = stream
+
+
+/***/ }),
+
+/***/ 73629:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { InvalidArgumentError, SocketError } = __nccwpck_require__(22174)
+const { AsyncResource } = __nccwpck_require__(92761)
+const util = __nccwpck_require__(94407)
+const { addSignal, removeSignal } = __nccwpck_require__(30703)
+const assert = __nccwpck_require__(98061)
+
+class UpgradeHandler extends AsyncResource {
+  constructor (opts, callback) {
+    if (!opts || typeof opts !== 'object') {
+      throw new InvalidArgumentError('invalid opts')
+    }
+
+    if (typeof callback !== 'function') {
+      throw new InvalidArgumentError('invalid callback')
+    }
+
+    const { signal, opaque, responseHeaders } = opts
+
+    if (signal && typeof signal.on !== 'function' && typeof signal.addEventListener !== 'function') {
+      throw new InvalidArgumentError('signal must be an EventEmitter or EventTarget')
+    }
+
+    super('UNDICI_UPGRADE')
+
+    this.responseHeaders = responseHeaders || null
+    this.opaque = opaque || null
+    this.callback = callback
+    this.abort = null
+    this.context = null
+
+    addSignal(this, signal)
+  }
+
+  onConnect (abort, context) {
+    if (this.reason) {
+      abort(this.reason)
+      return
+    }
+
+    assert(this.callback)
+
+    this.abort = abort
+    this.context = null
+  }
+
+  onHeaders () {
+    throw new SocketError('bad upgrade', null)
+  }
+
+  onUpgrade (statusCode, rawHeaders, socket) {
+    assert(statusCode === 101)
+
+    const { callback, opaque, context } = this
+
+    removeSignal(this)
+
+    this.callback = null
+    const headers = this.responseHeaders === 'raw' ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders)
+    this.runInAsyncScope(callback, null, null, {
+      headers,
+      socket,
+      opaque,
+      context
+    })
+  }
+
+  onError (err) {
+    const { callback, opaque } = this
+
+    removeSignal(this)
+
+    if (callback) {
+      this.callback = null
+      queueMicrotask(() => {
+        this.runInAsyncScope(callback, null, err, { opaque })
+      })
+    }
+  }
+}
+
+function upgrade (opts, callback) {
+  if (callback === undefined) {
+    return new Promise((resolve, reject) => {
+      upgrade.call(this, opts, (err, data) => {
+        return err ? reject(err) : resolve(data)
+      })
+    })
+  }
+
+  try {
+    const upgradeHandler = new UpgradeHandler(opts, callback)
+    this.dispatch({
+      ...opts,
+      method: opts.method || 'GET',
+      upgrade: opts.protocol || 'Websocket'
+    }, upgradeHandler)
+  } catch (err) {
+    if (typeof callback !== 'function') {
+      throw err
+    }
+    const opaque = opts?.opaque
+    queueMicrotask(() => callback(err, { opaque }))
+  }
+}
+
+module.exports = upgrade
+
+
+/***/ }),
+
+/***/ 24575:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+module.exports.request = __nccwpck_require__(20310)
+module.exports.stream = __nccwpck_require__(55784)
+module.exports.pipeline = __nccwpck_require__(94375)
+module.exports.upgrade = __nccwpck_require__(73629)
+module.exports.connect = __nccwpck_require__(7636)
+
+
+/***/ }),
+
+/***/ 64054:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// Ported from https://github.com/nodejs/undici/pull/907
+
+
+
+const assert = __nccwpck_require__(98061)
+const { Readable } = __nccwpck_require__(84492)
+const { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { ReadableStreamFrom } = __nccwpck_require__(94407)
+
+const kConsume = Symbol('kConsume')
+const kReading = Symbol('kReading')
+const kBody = Symbol('kBody')
+const kAbort = Symbol('kAbort')
+const kContentType = Symbol('kContentType')
+const kContentLength = Symbol('kContentLength')
+
+const noop = () => {}
+
+class BodyReadable extends Readable {
+  constructor ({
+    resume,
+    abort,
+    contentType = '',
+    contentLength,
+    highWaterMark = 64 * 1024 // Same as nodejs fs streams.
+  }) {
+    super({
+      autoDestroy: true,
+      read: resume,
+      highWaterMark
+    })
+
+    this._readableState.dataEmitted = false
+
+    this[kAbort] = abort
+    this[kConsume] = null
+    this[kBody] = null
+    this[kContentType] = contentType
+    this[kContentLength] = contentLength
+
+    // Is stream being consumed through Readable API?
+    // This is an optimization so that we avoid checking
+    // for 'data' and 'readable' listeners in the hot path
+    // inside push().
+    this[kReading] = false
+  }
+
+  destroy (err) {
+    if (!err && !this._readableState.endEmitted) {
+      err = new RequestAbortedError()
+    }
+
+    if (err) {
+      this[kAbort]()
+    }
+
+    return super.destroy(err)
+  }
+
+  _destroy (err, callback) {
+    // Workaround for Node "bug". If the stream is destroyed in same
+    // tick as it is created, then a user who is waiting for a
+    // promise (i.e micro tick) for installing a 'error' listener will
+    // never get a chance and will always encounter an unhandled exception.
+    if (!this[kReading]) {
+      setImmediate(() => {
+        callback(err)
+      })
+    } else {
+      callback(err)
+    }
+  }
+
+  on (ev, ...args) {
+    if (ev === 'data' || ev === 'readable') {
+      this[kReading] = true
+    }
+    return super.on(ev, ...args)
+  }
+
+  addListener (ev, ...args) {
+    return this.on(ev, ...args)
+  }
+
+  off (ev, ...args) {
+    const ret = super.off(ev, ...args)
+    if (ev === 'data' || ev === 'readable') {
+      this[kReading] = (
+        this.listenerCount('data') > 0 ||
+        this.listenerCount('readable') > 0
+      )
+    }
+    return ret
+  }
+
+  removeListener (ev, ...args) {
+    return this.off(ev, ...args)
+  }
+
+  push (chunk) {
+    if (this[kConsume] && chunk !== null) {
+      consumePush(this[kConsume], chunk)
+      return this[kReading] ? super.push(chunk) : true
+    }
+    return super.push(chunk)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-text
+  async text () {
+    return consume(this, 'text')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-json
+  async json () {
+    return consume(this, 'json')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-blob
+  async blob () {
+    return consume(this, 'blob')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-bytes
+  async bytes () {
+    return consume(this, 'bytes')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-arraybuffer
+  async arrayBuffer () {
+    return consume(this, 'arrayBuffer')
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-formdata
+  async formData () {
+    // TODO: Implement.
+    throw new NotSupportedError()
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-bodyused
+  get bodyUsed () {
+    return util.isDisturbed(this)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-body-body
+  get body () {
+    if (!this[kBody]) {
+      this[kBody] = ReadableStreamFrom(this)
+      if (this[kConsume]) {
+        // TODO: Is this the best way to force a lock?
+        this[kBody].getReader() // Ensure stream is locked.
+        assert(this[kBody].locked)
+      }
+    }
+    return this[kBody]
+  }
+
+  async dump (opts) {
+    let limit = Number.isFinite(opts?.limit) ? opts.limit : 128 * 1024
+    const signal = opts?.signal
+
+    if (signal != null && (typeof signal !== 'object' || !('aborted' in signal))) {
+      throw new InvalidArgumentError('signal must be an AbortSignal')
+    }
+
+    signal?.throwIfAborted()
+
+    if (this._readableState.closeEmitted) {
+      return null
+    }
+
+    return await new Promise((resolve, reject) => {
+      if (this[kContentLength] > limit) {
+        this.destroy(new AbortError())
+      }
+
+      const onAbort = () => {
+        this.destroy(signal.reason ?? new AbortError())
+      }
+      signal?.addEventListener('abort', onAbort)
+
+      this
+        .on('close', function () {
+          signal?.removeEventListener('abort', onAbort)
+          if (signal?.aborted) {
+            reject(signal.reason ?? new AbortError())
+          } else {
+            resolve(null)
+          }
+        })
+        .on('error', noop)
+        .on('data', function (chunk) {
+          limit -= chunk.length
+          if (limit <= 0) {
+            this.destroy()
+          }
+        })
+        .resume()
+    })
+  }
+}
+
+// https://streams.spec.whatwg.org/#readablestream-locked
+function isLocked (self) {
+  // Consume is an implicit lock.
+  return (self[kBody] && self[kBody].locked === true) || self[kConsume]
+}
+
+// https://fetch.spec.whatwg.org/#body-unusable
+function isUnusable (self) {
+  return util.isDisturbed(self) || isLocked(self)
+}
+
+async function consume (stream, type) {
+  assert(!stream[kConsume])
+
+  return new Promise((resolve, reject) => {
+    if (isUnusable(stream)) {
+      const rState = stream._readableState
+      if (rState.destroyed && rState.closeEmitted === false) {
+        stream
+          .on('error', err => {
+            reject(err)
+          })
+          .on('close', () => {
+            reject(new TypeError('unusable'))
+          })
+      } else {
+        reject(rState.errored ?? new TypeError('unusable'))
+      }
+    } else {
+      queueMicrotask(() => {
+        stream[kConsume] = {
+          type,
+          stream,
+          resolve,
+          reject,
+          length: 0,
+          body: []
+        }
+
+        stream
+          .on('error', function (err) {
+            consumeFinish(this[kConsume], err)
+          })
+          .on('close', function () {
+            if (this[kConsume].body !== null) {
+              consumeFinish(this[kConsume], new RequestAbortedError())
+            }
+          })
+
+        consumeStart(stream[kConsume])
+      })
+    }
+  })
+}
+
+function consumeStart (consume) {
+  if (consume.body === null) {
+    return
+  }
+
+  const { _readableState: state } = consume.stream
+
+  if (state.bufferIndex) {
+    const start = state.bufferIndex
+    const end = state.buffer.length
+    for (let n = start; n < end; n++) {
+      consumePush(consume, state.buffer[n])
+    }
+  } else {
+    for (const chunk of state.buffer) {
+      consumePush(consume, chunk)
+    }
+  }
+
+  if (state.endEmitted) {
+    consumeEnd(this[kConsume])
+  } else {
+    consume.stream.on('end', function () {
+      consumeEnd(this[kConsume])
+    })
+  }
+
+  consume.stream.resume()
+
+  while (consume.stream.read() != null) {
+    // Loop
+  }
+}
+
+/**
+ * @param {Buffer[]} chunks
+ * @param {number} length
+ */
+function chunksDecode (chunks, length) {
+  if (chunks.length === 0 || length === 0) {
+    return ''
+  }
+  const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks, length)
+  const bufferLength = buffer.length
+
+  // Skip BOM.
+  const start =
+    bufferLength > 2 &&
+    buffer[0] === 0xef &&
+    buffer[1] === 0xbb &&
+    buffer[2] === 0xbf
+      ? 3
+      : 0
+  return buffer.utf8Slice(start, bufferLength)
+}
+
+/**
+ * @param {Buffer[]} chunks
+ * @param {number} length
+ * @returns {Uint8Array}
+ */
+function chunksConcat (chunks, length) {
+  if (chunks.length === 0 || length === 0) {
+    return new Uint8Array(0)
+  }
+  if (chunks.length === 1) {
+    // fast-path
+    return new Uint8Array(chunks[0])
+  }
+  const buffer = new Uint8Array(Buffer.allocUnsafeSlow(length).buffer)
+
+  let offset = 0
+  for (let i = 0; i < chunks.length; ++i) {
+    const chunk = chunks[i]
+    buffer.set(chunk, offset)
+    offset += chunk.length
+  }
+
+  return buffer
+}
+
+function consumeEnd (consume) {
+  const { type, body, resolve, stream, length } = consume
+
+  try {
+    if (type === 'text') {
+      resolve(chunksDecode(body, length))
+    } else if (type === 'json') {
+      resolve(JSON.parse(chunksDecode(body, length)))
+    } else if (type === 'arrayBuffer') {
+      resolve(chunksConcat(body, length).buffer)
+    } else if (type === 'blob') {
+      resolve(new Blob(body, { type: stream[kContentType] }))
+    } else if (type === 'bytes') {
+      resolve(chunksConcat(body, length))
+    }
+
+    consumeFinish(consume)
+  } catch (err) {
+    stream.destroy(err)
+  }
+}
+
+function consumePush (consume, chunk) {
+  consume.length += chunk.length
+  consume.body.push(chunk)
+}
+
+function consumeFinish (consume, err) {
+  if (consume.body === null) {
+    return
+  }
+
+  if (err) {
+    consume.reject(err)
+  } else {
+    consume.resolve()
+  }
+
+  consume.type = null
+  consume.stream = null
+  consume.resolve = null
+  consume.reject = null
+  consume.length = 0
+  consume.body = null
+}
+
+module.exports = { Readable: BodyReadable, chunksDecode }
+
+
+/***/ }),
+
+/***/ 45141:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+const assert = __nccwpck_require__(98061)
+const {
+  ResponseStatusCodeError
+} = __nccwpck_require__(22174)
+
+const { chunksDecode } = __nccwpck_require__(64054)
+const CHUNK_LIMIT = 128 * 1024
+
+async function getResolveErrorBodyCallback ({ callback, body, contentType, statusCode, statusMessage, headers }) {
+  assert(body)
+
+  let chunks = []
+  let length = 0
+
+  try {
+    for await (const chunk of body) {
+      chunks.push(chunk)
+      length += chunk.length
+      if (length > CHUNK_LIMIT) {
+        chunks = []
+        length = 0
+        break
+      }
+    }
+  } catch {
+    chunks = []
+    length = 0
+    // Do nothing....
+  }
+
+  const message = `Response status code ${statusCode}${statusMessage ? `: ${statusMessage}` : ''}`
+
+  if (statusCode === 204 || !contentType || !length) {
+    queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers)))
+    return
+  }
+
+  const stackTraceLimit = Error.stackTraceLimit
+  Error.stackTraceLimit = 0
+  let payload
+
+  try {
+    if (isContentTypeApplicationJson(contentType)) {
+      payload = JSON.parse(chunksDecode(chunks, length))
+    } else if (isContentTypeText(contentType)) {
+      payload = chunksDecode(chunks, length)
+    }
+  } catch {
+    // process in a callback to avoid throwing in the microtask queue
+  } finally {
+    Error.stackTraceLimit = stackTraceLimit
+  }
+  queueMicrotask(() => callback(new ResponseStatusCodeError(message, statusCode, headers, payload)))
+}
+
+const isContentTypeApplicationJson = (contentType) => {
+  return (
+    contentType.length > 15 &&
+    contentType[11] === '/' &&
+    contentType[0] === 'a' &&
+    contentType[1] === 'p' &&
+    contentType[2] === 'p' &&
+    contentType[3] === 'l' &&
+    contentType[4] === 'i' &&
+    contentType[5] === 'c' &&
+    contentType[6] === 'a' &&
+    contentType[7] === 't' &&
+    contentType[8] === 'i' &&
+    contentType[9] === 'o' &&
+    contentType[10] === 'n' &&
+    contentType[12] === 'j' &&
+    contentType[13] === 's' &&
+    contentType[14] === 'o' &&
+    contentType[15] === 'n'
+  )
+}
+
+const isContentTypeText = (contentType) => {
+  return (
+    contentType.length > 4 &&
+    contentType[4] === '/' &&
+    contentType[0] === 't' &&
+    contentType[1] === 'e' &&
+    contentType[2] === 'x' &&
+    contentType[3] === 't'
+  )
+}
+
+module.exports = {
+  getResolveErrorBodyCallback,
+  isContentTypeApplicationJson,
+  isContentTypeText
+}
+
+
+/***/ }),
+
+/***/ 20123:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const net = __nccwpck_require__(87503)
+const assert = __nccwpck_require__(98061)
+const util = __nccwpck_require__(94407)
+const { InvalidArgumentError, ConnectTimeoutError } = __nccwpck_require__(22174)
+const timers = __nccwpck_require__(48413)
+
+function noop () {}
+
+let tls // include tls conditionally since it is not always available
+
+// TODO: session re-use does not wait for the first
+// connection to resolve the session and might therefore
+// resolve the same servername multiple times even when
+// re-use is enabled.
+
+let SessionCache
+// FIXME: remove workaround when the Node bug is fixed
+// https://github.com/nodejs/node/issues/49344#issuecomment-1741776308
+if (global.FinalizationRegistry && !(process.env.NODE_V8_COVERAGE || process.env.UNDICI_NO_FG)) {
+  SessionCache = class WeakSessionCache {
+    constructor (maxCachedSessions) {
+      this._maxCachedSessions = maxCachedSessions
+      this._sessionCache = new Map()
+      this._sessionRegistry = new global.FinalizationRegistry((key) => {
+        if (this._sessionCache.size < this._maxCachedSessions) {
+          return
+        }
+
+        const ref = this._sessionCache.get(key)
+        if (ref !== undefined && ref.deref() === undefined) {
+          this._sessionCache.delete(key)
+        }
+      })
+    }
+
+    get (sessionKey) {
+      const ref = this._sessionCache.get(sessionKey)
+      return ref ? ref.deref() : null
+    }
+
+    set (sessionKey, session) {
+      if (this._maxCachedSessions === 0) {
+        return
+      }
+
+      this._sessionCache.set(sessionKey, new WeakRef(session))
+      this._sessionRegistry.register(session, sessionKey)
+    }
+  }
+} else {
+  SessionCache = class SimpleSessionCache {
+    constructor (maxCachedSessions) {
+      this._maxCachedSessions = maxCachedSessions
+      this._sessionCache = new Map()
+    }
+
+    get (sessionKey) {
+      return this._sessionCache.get(sessionKey)
+    }
+
+    set (sessionKey, session) {
+      if (this._maxCachedSessions === 0) {
+        return
+      }
+
+      if (this._sessionCache.size >= this._maxCachedSessions) {
+        // remove the oldest session
+        const { value: oldestKey } = this._sessionCache.keys().next()
+        this._sessionCache.delete(oldestKey)
+      }
+
+      this._sessionCache.set(sessionKey, session)
+    }
+  }
+}
+
+function buildConnector ({ allowH2, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
+  if (maxCachedSessions != null && (!Number.isInteger(maxCachedSessions) || maxCachedSessions < 0)) {
+    throw new InvalidArgumentError('maxCachedSessions must be a positive integer or zero')
+  }
+
+  const options = { path: socketPath, ...opts }
+  const sessionCache = new SessionCache(maxCachedSessions == null ? 100 : maxCachedSessions)
+  timeout = timeout == null ? 10e3 : timeout
+  allowH2 = allowH2 != null ? allowH2 : false
+  return function connect ({ hostname, host, protocol, port, servername, localAddress, httpSocket }, callback) {
+    let socket
+    if (protocol === 'https:') {
+      if (!tls) {
+        tls = __nccwpck_require__(31764)
+      }
+      servername = servername || options.servername || util.getServerName(host) || null
+
+      const sessionKey = servername || hostname
+      assert(sessionKey)
+
+      const session = customSession || sessionCache.get(sessionKey) || null
+
+      port = port || 443
+
+      socket = tls.connect({
+        highWaterMark: 16384, // TLS in node can't have bigger HWM anyway...
+        ...options,
+        servername,
+        session,
+        localAddress,
+        // TODO(HTTP/2): Add support for h2c
+        ALPNProtocols: allowH2 ? ['http/1.1', 'h2'] : ['http/1.1'],
+        socket: httpSocket, // upgrade socket connection
+        port,
+        host: hostname
+      })
+
+      socket
+        .on('session', function (session) {
+          // TODO (fix): Can a session become invalid once established? Don't think so?
+          sessionCache.set(sessionKey, session)
+        })
+    } else {
+      assert(!httpSocket, 'httpSocket can only be sent on TLS update')
+
+      port = port || 80
+
+      socket = net.connect({
+        highWaterMark: 64 * 1024, // Same as nodejs fs streams.
+        ...options,
+        localAddress,
+        port,
+        host: hostname
+      })
+    }
+
+    // Set TCP keep alive options on the socket here instead of in connect() for the case of assigning the socket
+    if (options.keepAlive == null || options.keepAlive) {
+      const keepAliveInitialDelay = options.keepAliveInitialDelay === undefined ? 60e3 : options.keepAliveInitialDelay
+      socket.setKeepAlive(true, keepAliveInitialDelay)
+    }
+
+    const clearConnectTimeout = setupConnectTimeout(new WeakRef(socket), { timeout, hostname, port })
+
+    socket
+      .setNoDelay(true)
+      .once(protocol === 'https:' ? 'secureConnect' : 'connect', function () {
+        queueMicrotask(clearConnectTimeout)
+
+        if (callback) {
+          const cb = callback
+          callback = null
+          cb(null, this)
+        }
+      })
+      .on('error', function (err) {
+        queueMicrotask(clearConnectTimeout)
+
+        if (callback) {
+          const cb = callback
+          callback = null
+          cb(err)
+        }
+      })
+
+    return socket
+  }
+}
+
+/**
+ * @param {WeakRef<net.Socket>} socketWeakRef
+ * @param {object} opts
+ * @param {number} opts.timeout
+ * @param {string} opts.hostname
+ * @param {number} opts.port
+ * @returns {() => void}
+ */
+const setupConnectTimeout = process.platform === 'win32'
+  ? (socketWeakRef, opts) => {
+      if (!opts.timeout) {
+        return noop
+      }
+
+      let s1 = null
+      let s2 = null
+      const fastTimer = timers.setFastTimeout(() => {
+      // setImmediate is added to make sure that we prioritize socket error events over timeouts
+        s1 = setImmediate(() => {
+        // Windows needs an extra setImmediate probably due to implementation differences in the socket logic
+          s2 = setImmediate(() => onConnectTimeout(socketWeakRef.deref(), opts))
+        })
+      }, opts.timeout)
+      return () => {
+        timers.clearFastTimeout(fastTimer)
+        clearImmediate(s1)
+        clearImmediate(s2)
+      }
+    }
+  : (socketWeakRef, opts) => {
+      if (!opts.timeout) {
+        return noop
+      }
+
+      let s1 = null
+      const fastTimer = timers.setFastTimeout(() => {
+      // setImmediate is added to make sure that we prioritize socket error events over timeouts
+        s1 = setImmediate(() => {
+          onConnectTimeout(socketWeakRef.deref(), opts)
+        })
+      }, opts.timeout)
+      return () => {
+        timers.clearFastTimeout(fastTimer)
+        clearImmediate(s1)
+      }
+    }
+
+/**
+ * @param {net.Socket} socket
+ * @param {object} opts
+ * @param {number} opts.timeout
+ * @param {string} opts.hostname
+ * @param {number} opts.port
+ */
+function onConnectTimeout (socket, opts) {
+  // The socket could be already garbage collected
+  if (socket == null) {
+    return
+  }
+
+  let message = 'Connect Timeout Error'
+  if (Array.isArray(socket.autoSelectFamilyAttemptedAddresses)) {
+    message += ` (attempted addresses: ${socket.autoSelectFamilyAttemptedAddresses.join(', ')},`
+  } else {
+    message += ` (attempted address: ${opts.hostname}:${opts.port},`
+  }
+
+  message += ` timeout: ${opts.timeout}ms)`
+
+  util.destroy(socket, new ConnectTimeoutError(message))
+}
+
+module.exports = buildConnector
+
+
+/***/ }),
+
+/***/ 2029:
+/***/ ((module) => {
+
+"use strict";
+
+
+/** @type {Record<string, string | undefined>} */
+const headerNameLowerCasedRecord = {}
+
+// https://developer.mozilla.org/docs/Web/HTTP/Headers
+const wellknownHeaderNames = [
+  'Accept',
+  'Accept-Encoding',
+  'Accept-Language',
+  'Accept-Ranges',
+  'Access-Control-Allow-Credentials',
+  'Access-Control-Allow-Headers',
+  'Access-Control-Allow-Methods',
+  'Access-Control-Allow-Origin',
+  'Access-Control-Expose-Headers',
+  'Access-Control-Max-Age',
+  'Access-Control-Request-Headers',
+  'Access-Control-Request-Method',
+  'Age',
+  'Allow',
+  'Alt-Svc',
+  'Alt-Used',
+  'Authorization',
+  'Cache-Control',
+  'Clear-Site-Data',
+  'Connection',
+  'Content-Disposition',
+  'Content-Encoding',
+  'Content-Language',
+  'Content-Length',
+  'Content-Location',
+  'Content-Range',
+  'Content-Security-Policy',
+  'Content-Security-Policy-Report-Only',
+  'Content-Type',
+  'Cookie',
+  'Cross-Origin-Embedder-Policy',
+  'Cross-Origin-Opener-Policy',
+  'Cross-Origin-Resource-Policy',
+  'Date',
+  'Device-Memory',
+  'Downlink',
+  'ECT',
+  'ETag',
+  'Expect',
+  'Expect-CT',
+  'Expires',
+  'Forwarded',
+  'From',
+  'Host',
+  'If-Match',
+  'If-Modified-Since',
+  'If-None-Match',
+  'If-Range',
+  'If-Unmodified-Since',
+  'Keep-Alive',
+  'Last-Modified',
+  'Link',
+  'Location',
+  'Max-Forwards',
+  'Origin',
+  'Permissions-Policy',
+  'Pragma',
+  'Proxy-Authenticate',
+  'Proxy-Authorization',
+  'RTT',
+  'Range',
+  'Referer',
+  'Referrer-Policy',
+  'Refresh',
+  'Retry-After',
+  'Sec-WebSocket-Accept',
+  'Sec-WebSocket-Extensions',
+  'Sec-WebSocket-Key',
+  'Sec-WebSocket-Protocol',
+  'Sec-WebSocket-Version',
+  'Server',
+  'Server-Timing',
+  'Service-Worker-Allowed',
+  'Service-Worker-Navigation-Preload',
+  'Set-Cookie',
+  'SourceMap',
+  'Strict-Transport-Security',
+  'Supports-Loading-Mode',
+  'TE',
+  'Timing-Allow-Origin',
+  'Trailer',
+  'Transfer-Encoding',
+  'Upgrade',
+  'Upgrade-Insecure-Requests',
+  'User-Agent',
+  'Vary',
+  'Via',
+  'WWW-Authenticate',
+  'X-Content-Type-Options',
+  'X-DNS-Prefetch-Control',
+  'X-Frame-Options',
+  'X-Permitted-Cross-Domain-Policies',
+  'X-Powered-By',
+  'X-Requested-With',
+  'X-XSS-Protection'
+]
+
+for (let i = 0; i < wellknownHeaderNames.length; ++i) {
+  const key = wellknownHeaderNames[i]
+  const lowerCasedKey = key.toLowerCase()
+  headerNameLowerCasedRecord[key] = headerNameLowerCasedRecord[lowerCasedKey] =
+    lowerCasedKey
+}
+
+// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
+Object.setPrototypeOf(headerNameLowerCasedRecord, null)
+
+module.exports = {
+  wellknownHeaderNames,
+  headerNameLowerCasedRecord
+}
+
+
+/***/ }),
+
+/***/ 8627:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const diagnosticsChannel = __nccwpck_require__(65714)
+const util = __nccwpck_require__(47261)
+
+const undiciDebugLog = util.debuglog('undici')
+const fetchDebuglog = util.debuglog('fetch')
+const websocketDebuglog = util.debuglog('websocket')
+let isClientSet = false
+const channels = {
+  // Client
+  beforeConnect: diagnosticsChannel.channel('undici:client:beforeConnect'),
+  connected: diagnosticsChannel.channel('undici:client:connected'),
+  connectError: diagnosticsChannel.channel('undici:client:connectError'),
+  sendHeaders: diagnosticsChannel.channel('undici:client:sendHeaders'),
+  // Request
+  create: diagnosticsChannel.channel('undici:request:create'),
+  bodySent: diagnosticsChannel.channel('undici:request:bodySent'),
+  headers: diagnosticsChannel.channel('undici:request:headers'),
+  trailers: diagnosticsChannel.channel('undici:request:trailers'),
+  error: diagnosticsChannel.channel('undici:request:error'),
+  // WebSocket
+  open: diagnosticsChannel.channel('undici:websocket:open'),
+  close: diagnosticsChannel.channel('undici:websocket:close'),
+  socketError: diagnosticsChannel.channel('undici:websocket:socket_error'),
+  ping: diagnosticsChannel.channel('undici:websocket:ping'),
+  pong: diagnosticsChannel.channel('undici:websocket:pong')
+}
+
+if (undiciDebugLog.enabled || fetchDebuglog.enabled) {
+  const debuglog = fetchDebuglog.enabled ? fetchDebuglog : undiciDebugLog
+
+  // Track all Client events
+  diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(evt => {
+    const {
+      connectParams: { version, protocol, port, host }
+    } = evt
+    debuglog(
+      'connecting to %s using %s%s',
+      `${host}${port ? `:${port}` : ''}`,
+      protocol,
+      version
+    )
+  })
+
+  diagnosticsChannel.channel('undici:client:connected').subscribe(evt => {
+    const {
+      connectParams: { version, protocol, port, host }
+    } = evt
+    debuglog(
+      'connected to %s using %s%s',
+      `${host}${port ? `:${port}` : ''}`,
+      protocol,
+      version
+    )
+  })
+
+  diagnosticsChannel.channel('undici:client:connectError').subscribe(evt => {
+    const {
+      connectParams: { version, protocol, port, host },
+      error
+    } = evt
+    debuglog(
+      'connection to %s using %s%s errored - %s',
+      `${host}${port ? `:${port}` : ''}`,
+      protocol,
+      version,
+      error.message
+    )
+  })
+
+  diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(evt => {
+    const {
+      request: { method, path, origin }
+    } = evt
+    debuglog('sending request to %s %s/%s', method, origin, path)
+  })
+
+  // Track Request events
+  diagnosticsChannel.channel('undici:request:headers').subscribe(evt => {
+    const {
+      request: { method, path, origin },
+      response: { statusCode }
+    } = evt
+    debuglog(
+      'received response to %s %s/%s - HTTP %d',
+      method,
+      origin,
+      path,
+      statusCode
+    )
+  })
+
+  diagnosticsChannel.channel('undici:request:trailers').subscribe(evt => {
+    const {
+      request: { method, path, origin }
+    } = evt
+    debuglog('trailers received from %s %s/%s', method, origin, path)
+  })
+
+  diagnosticsChannel.channel('undici:request:error').subscribe(evt => {
+    const {
+      request: { method, path, origin },
+      error
+    } = evt
+    debuglog(
+      'request to %s %s/%s errored - %s',
+      method,
+      origin,
+      path,
+      error.message
+    )
+  })
+
+  isClientSet = true
+}
+
+if (websocketDebuglog.enabled) {
+  if (!isClientSet) {
+    const debuglog = undiciDebugLog.enabled ? undiciDebugLog : websocketDebuglog
+    diagnosticsChannel.channel('undici:client:beforeConnect').subscribe(evt => {
+      const {
+        connectParams: { version, protocol, port, host }
+      } = evt
+      debuglog(
+        'connecting to %s%s using %s%s',
+        host,
+        port ? `:${port}` : '',
+        protocol,
+        version
+      )
+    })
+
+    diagnosticsChannel.channel('undici:client:connected').subscribe(evt => {
+      const {
+        connectParams: { version, protocol, port, host }
+      } = evt
+      debuglog(
+        'connected to %s%s using %s%s',
+        host,
+        port ? `:${port}` : '',
+        protocol,
+        version
+      )
+    })
+
+    diagnosticsChannel.channel('undici:client:connectError').subscribe(evt => {
+      const {
+        connectParams: { version, protocol, port, host },
+        error
+      } = evt
+      debuglog(
+        'connection to %s%s using %s%s errored - %s',
+        host,
+        port ? `:${port}` : '',
+        protocol,
+        version,
+        error.message
+      )
+    })
+
+    diagnosticsChannel.channel('undici:client:sendHeaders').subscribe(evt => {
+      const {
+        request: { method, path, origin }
+      } = evt
+      debuglog('sending request to %s %s/%s', method, origin, path)
+    })
+  }
+
+  // Track all WebSocket events
+  diagnosticsChannel.channel('undici:websocket:open').subscribe(evt => {
+    const {
+      address: { address, port }
+    } = evt
+    websocketDebuglog('connection opened %s%s', address, port ? `:${port}` : '')
+  })
+
+  diagnosticsChannel.channel('undici:websocket:close').subscribe(evt => {
+    const { websocket, code, reason } = evt
+    websocketDebuglog(
+      'closed connection to %s - %s %s',
+      websocket.url,
+      code,
+      reason
+    )
+  })
+
+  diagnosticsChannel.channel('undici:websocket:socket_error').subscribe(err => {
+    websocketDebuglog('connection errored - %s', err.message)
+  })
+
+  diagnosticsChannel.channel('undici:websocket:ping').subscribe(evt => {
+    websocketDebuglog('ping received')
+  })
+
+  diagnosticsChannel.channel('undici:websocket:pong').subscribe(evt => {
+    websocketDebuglog('pong received')
+  })
+}
+
+module.exports = {
+  channels
+}
+
+
+/***/ }),
+
+/***/ 22174:
+/***/ ((module) => {
+
+"use strict";
+
+
+const kUndiciError = Symbol.for('undici.error.UND_ERR')
+class UndiciError extends Error {
+  constructor (message) {
+    super(message)
+    this.name = 'UndiciError'
+    this.code = 'UND_ERR'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kUndiciError] === true
+  }
+
+  [kUndiciError] = true
+}
+
+const kConnectTimeoutError = Symbol.for('undici.error.UND_ERR_CONNECT_TIMEOUT')
+class ConnectTimeoutError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'ConnectTimeoutError'
+    this.message = message || 'Connect Timeout Error'
+    this.code = 'UND_ERR_CONNECT_TIMEOUT'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kConnectTimeoutError] === true
+  }
+
+  [kConnectTimeoutError] = true
+}
+
+const kHeadersTimeoutError = Symbol.for('undici.error.UND_ERR_HEADERS_TIMEOUT')
+class HeadersTimeoutError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'HeadersTimeoutError'
+    this.message = message || 'Headers Timeout Error'
+    this.code = 'UND_ERR_HEADERS_TIMEOUT'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kHeadersTimeoutError] === true
+  }
+
+  [kHeadersTimeoutError] = true
+}
+
+const kHeadersOverflowError = Symbol.for('undici.error.UND_ERR_HEADERS_OVERFLOW')
+class HeadersOverflowError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'HeadersOverflowError'
+    this.message = message || 'Headers Overflow Error'
+    this.code = 'UND_ERR_HEADERS_OVERFLOW'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kHeadersOverflowError] === true
+  }
+
+  [kHeadersOverflowError] = true
+}
+
+const kBodyTimeoutError = Symbol.for('undici.error.UND_ERR_BODY_TIMEOUT')
+class BodyTimeoutError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'BodyTimeoutError'
+    this.message = message || 'Body Timeout Error'
+    this.code = 'UND_ERR_BODY_TIMEOUT'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kBodyTimeoutError] === true
+  }
+
+  [kBodyTimeoutError] = true
+}
+
+const kResponseStatusCodeError = Symbol.for('undici.error.UND_ERR_RESPONSE_STATUS_CODE')
+class ResponseStatusCodeError extends UndiciError {
+  constructor (message, statusCode, headers, body) {
+    super(message)
+    this.name = 'ResponseStatusCodeError'
+    this.message = message || 'Response Status Code Error'
+    this.code = 'UND_ERR_RESPONSE_STATUS_CODE'
+    this.body = body
+    this.status = statusCode
+    this.statusCode = statusCode
+    this.headers = headers
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kResponseStatusCodeError] === true
+  }
+
+  [kResponseStatusCodeError] = true
+}
+
+const kInvalidArgumentError = Symbol.for('undici.error.UND_ERR_INVALID_ARG')
+class InvalidArgumentError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'InvalidArgumentError'
+    this.message = message || 'Invalid Argument Error'
+    this.code = 'UND_ERR_INVALID_ARG'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kInvalidArgumentError] === true
+  }
+
+  [kInvalidArgumentError] = true
+}
+
+const kInvalidReturnValueError = Symbol.for('undici.error.UND_ERR_INVALID_RETURN_VALUE')
+class InvalidReturnValueError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'InvalidReturnValueError'
+    this.message = message || 'Invalid Return Value Error'
+    this.code = 'UND_ERR_INVALID_RETURN_VALUE'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kInvalidReturnValueError] === true
+  }
+
+  [kInvalidReturnValueError] = true
+}
+
+const kAbortError = Symbol.for('undici.error.UND_ERR_ABORT')
+class AbortError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'AbortError'
+    this.message = message || 'The operation was aborted'
+    this.code = 'UND_ERR_ABORT'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kAbortError] === true
+  }
+
+  [kAbortError] = true
+}
+
+const kRequestAbortedError = Symbol.for('undici.error.UND_ERR_ABORTED')
+class RequestAbortedError extends AbortError {
+  constructor (message) {
+    super(message)
+    this.name = 'AbortError'
+    this.message = message || 'Request aborted'
+    this.code = 'UND_ERR_ABORTED'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kRequestAbortedError] === true
+  }
+
+  [kRequestAbortedError] = true
+}
+
+const kInformationalError = Symbol.for('undici.error.UND_ERR_INFO')
+class InformationalError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'InformationalError'
+    this.message = message || 'Request information'
+    this.code = 'UND_ERR_INFO'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kInformationalError] === true
+  }
+
+  [kInformationalError] = true
+}
+
+const kRequestContentLengthMismatchError = Symbol.for('undici.error.UND_ERR_REQ_CONTENT_LENGTH_MISMATCH')
+class RequestContentLengthMismatchError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'RequestContentLengthMismatchError'
+    this.message = message || 'Request body length does not match content-length header'
+    this.code = 'UND_ERR_REQ_CONTENT_LENGTH_MISMATCH'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kRequestContentLengthMismatchError] === true
+  }
+
+  [kRequestContentLengthMismatchError] = true
+}
+
+const kResponseContentLengthMismatchError = Symbol.for('undici.error.UND_ERR_RES_CONTENT_LENGTH_MISMATCH')
+class ResponseContentLengthMismatchError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'ResponseContentLengthMismatchError'
+    this.message = message || 'Response body length does not match content-length header'
+    this.code = 'UND_ERR_RES_CONTENT_LENGTH_MISMATCH'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kResponseContentLengthMismatchError] === true
+  }
+
+  [kResponseContentLengthMismatchError] = true
+}
+
+const kClientDestroyedError = Symbol.for('undici.error.UND_ERR_DESTROYED')
+class ClientDestroyedError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'ClientDestroyedError'
+    this.message = message || 'The client is destroyed'
+    this.code = 'UND_ERR_DESTROYED'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kClientDestroyedError] === true
+  }
+
+  [kClientDestroyedError] = true
+}
+
+const kClientClosedError = Symbol.for('undici.error.UND_ERR_CLOSED')
+class ClientClosedError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'ClientClosedError'
+    this.message = message || 'The client is closed'
+    this.code = 'UND_ERR_CLOSED'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kClientClosedError] === true
+  }
+
+  [kClientClosedError] = true
+}
+
+const kSocketError = Symbol.for('undici.error.UND_ERR_SOCKET')
+class SocketError extends UndiciError {
+  constructor (message, socket) {
+    super(message)
+    this.name = 'SocketError'
+    this.message = message || 'Socket error'
+    this.code = 'UND_ERR_SOCKET'
+    this.socket = socket
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kSocketError] === true
+  }
+
+  [kSocketError] = true
+}
+
+const kNotSupportedError = Symbol.for('undici.error.UND_ERR_NOT_SUPPORTED')
+class NotSupportedError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'NotSupportedError'
+    this.message = message || 'Not supported error'
+    this.code = 'UND_ERR_NOT_SUPPORTED'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kNotSupportedError] === true
+  }
+
+  [kNotSupportedError] = true
+}
+
+const kBalancedPoolMissingUpstreamError = Symbol.for('undici.error.UND_ERR_BPL_MISSING_UPSTREAM')
+class BalancedPoolMissingUpstreamError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'MissingUpstreamError'
+    this.message = message || 'No upstream has been added to the BalancedPool'
+    this.code = 'UND_ERR_BPL_MISSING_UPSTREAM'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kBalancedPoolMissingUpstreamError] === true
+  }
+
+  [kBalancedPoolMissingUpstreamError] = true
+}
+
+const kHTTPParserError = Symbol.for('undici.error.UND_ERR_HTTP_PARSER')
+class HTTPParserError extends Error {
+  constructor (message, code, data) {
+    super(message)
+    this.name = 'HTTPParserError'
+    this.code = code ? `HPE_${code}` : undefined
+    this.data = data ? data.toString() : undefined
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kHTTPParserError] === true
+  }
+
+  [kHTTPParserError] = true
+}
+
+const kResponseExceededMaxSizeError = Symbol.for('undici.error.UND_ERR_RES_EXCEEDED_MAX_SIZE')
+class ResponseExceededMaxSizeError extends UndiciError {
+  constructor (message) {
+    super(message)
+    this.name = 'ResponseExceededMaxSizeError'
+    this.message = message || 'Response content exceeded max size'
+    this.code = 'UND_ERR_RES_EXCEEDED_MAX_SIZE'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kResponseExceededMaxSizeError] === true
+  }
+
+  [kResponseExceededMaxSizeError] = true
+}
+
+const kRequestRetryError = Symbol.for('undici.error.UND_ERR_REQ_RETRY')
+class RequestRetryError extends UndiciError {
+  constructor (message, code, { headers, data }) {
+    super(message)
+    this.name = 'RequestRetryError'
+    this.message = message || 'Request retry error'
+    this.code = 'UND_ERR_REQ_RETRY'
+    this.statusCode = code
+    this.data = data
+    this.headers = headers
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kRequestRetryError] === true
+  }
+
+  [kRequestRetryError] = true
+}
+
+const kResponseError = Symbol.for('undici.error.UND_ERR_RESPONSE')
+class ResponseError extends UndiciError {
+  constructor (message, code, { headers, data }) {
+    super(message)
+    this.name = 'ResponseError'
+    this.message = message || 'Response error'
+    this.code = 'UND_ERR_RESPONSE'
+    this.statusCode = code
+    this.data = data
+    this.headers = headers
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kResponseError] === true
+  }
+
+  [kResponseError] = true
+}
+
+const kSecureProxyConnectionError = Symbol.for('undici.error.UND_ERR_PRX_TLS')
+class SecureProxyConnectionError extends UndiciError {
+  constructor (cause, message, options) {
+    super(message, { cause, ...(options ?? {}) })
+    this.name = 'SecureProxyConnectionError'
+    this.message = message || 'Secure Proxy Connection failed'
+    this.code = 'UND_ERR_PRX_TLS'
+    this.cause = cause
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kSecureProxyConnectionError] === true
+  }
+
+  [kSecureProxyConnectionError] = true
+}
+
+module.exports = {
+  AbortError,
+  HTTPParserError,
+  UndiciError,
+  HeadersTimeoutError,
+  HeadersOverflowError,
+  BodyTimeoutError,
+  RequestContentLengthMismatchError,
+  ConnectTimeoutError,
+  ResponseStatusCodeError,
+  InvalidArgumentError,
+  InvalidReturnValueError,
+  RequestAbortedError,
+  ClientDestroyedError,
+  ClientClosedError,
+  InformationalError,
+  SocketError,
+  NotSupportedError,
+  ResponseContentLengthMismatchError,
+  BalancedPoolMissingUpstreamError,
+  ResponseExceededMaxSizeError,
+  RequestRetryError,
+  ResponseError,
+  SecureProxyConnectionError
+}
+
+
+/***/ }),
+
+/***/ 25829:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  InvalidArgumentError,
+  NotSupportedError
+} = __nccwpck_require__(22174)
+const assert = __nccwpck_require__(98061)
+const {
+  isValidHTTPToken,
+  isValidHeaderValue,
+  isStream,
+  destroy,
+  isBuffer,
+  isFormDataLike,
+  isIterable,
+  isBlobLike,
+  buildURL,
+  validateHandler,
+  getServerName,
+  normalizedMethodRecords
+} = __nccwpck_require__(94407)
+const { channels } = __nccwpck_require__(8627)
+const { headerNameLowerCasedRecord } = __nccwpck_require__(2029)
+
+// Verifies that a given path is valid does not contain control chars \x00 to \x20
+const invalidPathRegex = /[^\u0021-\u00ff]/
+
+const kHandler = Symbol('handler')
+
+class Request {
+  constructor (origin, {
+    path,
+    method,
+    body,
+    headers,
+    query,
+    idempotent,
+    blocking,
+    upgrade,
+    headersTimeout,
+    bodyTimeout,
+    reset,
+    throwOnError,
+    expectContinue,
+    servername
+  }, handler) {
+    if (typeof path !== 'string') {
+      throw new InvalidArgumentError('path must be a string')
+    } else if (
+      path[0] !== '/' &&
+      !(path.startsWith('http://') || path.startsWith('https://')) &&
+      method !== 'CONNECT'
+    ) {
+      throw new InvalidArgumentError('path must be an absolute URL or start with a slash')
+    } else if (invalidPathRegex.test(path)) {
+      throw new InvalidArgumentError('invalid request path')
+    }
+
+    if (typeof method !== 'string') {
+      throw new InvalidArgumentError('method must be a string')
+    } else if (normalizedMethodRecords[method] === undefined && !isValidHTTPToken(method)) {
+      throw new InvalidArgumentError('invalid request method')
+    }
+
+    if (upgrade && typeof upgrade !== 'string') {
+      throw new InvalidArgumentError('upgrade must be a string')
+    }
+
+    if (headersTimeout != null && (!Number.isFinite(headersTimeout) || headersTimeout < 0)) {
+      throw new InvalidArgumentError('invalid headersTimeout')
+    }
+
+    if (bodyTimeout != null && (!Number.isFinite(bodyTimeout) || bodyTimeout < 0)) {
+      throw new InvalidArgumentError('invalid bodyTimeout')
+    }
+
+    if (reset != null && typeof reset !== 'boolean') {
+      throw new InvalidArgumentError('invalid reset')
+    }
+
+    if (expectContinue != null && typeof expectContinue !== 'boolean') {
+      throw new InvalidArgumentError('invalid expectContinue')
+    }
+
+    this.headersTimeout = headersTimeout
+
+    this.bodyTimeout = bodyTimeout
+
+    this.throwOnError = throwOnError === true
+
+    this.method = method
+
+    this.abort = null
+
+    if (body == null) {
+      this.body = null
+    } else if (isStream(body)) {
+      this.body = body
+
+      const rState = this.body._readableState
+      if (!rState || !rState.autoDestroy) {
+        this.endHandler = function autoDestroy () {
+          destroy(this)
+        }
+        this.body.on('end', this.endHandler)
+      }
+
+      this.errorHandler = err => {
+        if (this.abort) {
+          this.abort(err)
+        } else {
+          this.error = err
+        }
+      }
+      this.body.on('error', this.errorHandler)
+    } else if (isBuffer(body)) {
+      this.body = body.byteLength ? body : null
+    } else if (ArrayBuffer.isView(body)) {
+      this.body = body.buffer.byteLength ? Buffer.from(body.buffer, body.byteOffset, body.byteLength) : null
+    } else if (body instanceof ArrayBuffer) {
+      this.body = body.byteLength ? Buffer.from(body) : null
+    } else if (typeof body === 'string') {
+      this.body = body.length ? Buffer.from(body) : null
+    } else if (isFormDataLike(body) || isIterable(body) || isBlobLike(body)) {
+      this.body = body
+    } else {
+      throw new InvalidArgumentError('body must be a string, a Buffer, a Readable stream, an iterable, or an async iterable')
+    }
+
+    this.completed = false
+
+    this.aborted = false
+
+    this.upgrade = upgrade || null
+
+    this.path = query ? buildURL(path, query) : path
+
+    this.origin = origin
+
+    this.idempotent = idempotent == null
+      ? method === 'HEAD' || method === 'GET'
+      : idempotent
+
+    this.blocking = blocking == null ? false : blocking
+
+    this.reset = reset == null ? null : reset
+
+    this.host = null
+
+    this.contentLength = null
+
+    this.contentType = null
+
+    this.headers = []
+
+    // Only for H2
+    this.expectContinue = expectContinue != null ? expectContinue : false
+
+    if (Array.isArray(headers)) {
+      if (headers.length % 2 !== 0) {
+        throw new InvalidArgumentError('headers array must be even')
+      }
+      for (let i = 0; i < headers.length; i += 2) {
+        processHeader(this, headers[i], headers[i + 1])
+      }
+    } else if (headers && typeof headers === 'object') {
+      if (headers[Symbol.iterator]) {
+        for (const header of headers) {
+          if (!Array.isArray(header) || header.length !== 2) {
+            throw new InvalidArgumentError('headers must be in key-value pair format')
+          }
+          processHeader(this, header[0], header[1])
+        }
+      } else {
+        const keys = Object.keys(headers)
+        for (let i = 0; i < keys.length; ++i) {
+          processHeader(this, keys[i], headers[keys[i]])
+        }
+      }
+    } else if (headers != null) {
+      throw new InvalidArgumentError('headers must be an object or an array')
+    }
+
+    validateHandler(handler, method, upgrade)
+
+    this.servername = servername || getServerName(this.host)
+
+    this[kHandler] = handler
+
+    if (channels.create.hasSubscribers) {
+      channels.create.publish({ request: this })
+    }
+  }
+
+  onBodySent (chunk) {
+    if (this[kHandler].onBodySent) {
+      try {
+        return this[kHandler].onBodySent(chunk)
+      } catch (err) {
+        this.abort(err)
+      }
+    }
+  }
+
+  onRequestSent () {
+    if (channels.bodySent.hasSubscribers) {
+      channels.bodySent.publish({ request: this })
+    }
+
+    if (this[kHandler].onRequestSent) {
+      try {
+        return this[kHandler].onRequestSent()
+      } catch (err) {
+        this.abort(err)
+      }
+    }
+  }
+
+  onConnect (abort) {
+    assert(!this.aborted)
+    assert(!this.completed)
+
+    if (this.error) {
+      abort(this.error)
+    } else {
+      this.abort = abort
+      return this[kHandler].onConnect(abort)
+    }
+  }
+
+  onResponseStarted () {
+    return this[kHandler].onResponseStarted?.()
+  }
+
+  onHeaders (statusCode, headers, resume, statusText) {
+    assert(!this.aborted)
+    assert(!this.completed)
+
+    if (channels.headers.hasSubscribers) {
+      channels.headers.publish({ request: this, response: { statusCode, headers, statusText } })
+    }
+
+    try {
+      return this[kHandler].onHeaders(statusCode, headers, resume, statusText)
+    } catch (err) {
+      this.abort(err)
+    }
+  }
+
+  onData (chunk) {
+    assert(!this.aborted)
+    assert(!this.completed)
+
+    try {
+      return this[kHandler].onData(chunk)
+    } catch (err) {
+      this.abort(err)
+      return false
+    }
+  }
+
+  onUpgrade (statusCode, headers, socket) {
+    assert(!this.aborted)
+    assert(!this.completed)
+
+    return this[kHandler].onUpgrade(statusCode, headers, socket)
+  }
+
+  onComplete (trailers) {
+    this.onFinally()
+
+    assert(!this.aborted)
+
+    this.completed = true
+    if (channels.trailers.hasSubscribers) {
+      channels.trailers.publish({ request: this, trailers })
+    }
+
+    try {
+      return this[kHandler].onComplete(trailers)
+    } catch (err) {
+      // TODO (fix): This might be a bad idea?
+      this.onError(err)
+    }
+  }
+
+  onError (error) {
+    this.onFinally()
+
+    if (channels.error.hasSubscribers) {
+      channels.error.publish({ request: this, error })
+    }
+
+    if (this.aborted) {
+      return
+    }
+    this.aborted = true
+
+    return this[kHandler].onError(error)
+  }
+
+  onFinally () {
+    if (this.errorHandler) {
+      this.body.off('error', this.errorHandler)
+      this.errorHandler = null
+    }
+
+    if (this.endHandler) {
+      this.body.off('end', this.endHandler)
+      this.endHandler = null
+    }
+  }
+
+  addHeader (key, value) {
+    processHeader(this, key, value)
+    return this
+  }
+}
+
+function processHeader (request, key, val) {
+  if (val && (typeof val === 'object' && !Array.isArray(val))) {
+    throw new InvalidArgumentError(`invalid ${key} header`)
+  } else if (val === undefined) {
+    return
+  }
+
+  let headerName = headerNameLowerCasedRecord[key]
+
+  if (headerName === undefined) {
+    headerName = key.toLowerCase()
+    if (headerNameLowerCasedRecord[headerName] === undefined && !isValidHTTPToken(headerName)) {
+      throw new InvalidArgumentError('invalid header key')
+    }
+  }
+
+  if (Array.isArray(val)) {
+    const arr = []
+    for (let i = 0; i < val.length; i++) {
+      if (typeof val[i] === 'string') {
+        if (!isValidHeaderValue(val[i])) {
+          throw new InvalidArgumentError(`invalid ${key} header`)
+        }
+        arr.push(val[i])
+      } else if (val[i] === null) {
+        arr.push('')
+      } else if (typeof val[i] === 'object') {
+        throw new InvalidArgumentError(`invalid ${key} header`)
+      } else {
+        arr.push(`${val[i]}`)
+      }
+    }
+    val = arr
+  } else if (typeof val === 'string') {
+    if (!isValidHeaderValue(val)) {
+      throw new InvalidArgumentError(`invalid ${key} header`)
+    }
+  } else if (val === null) {
+    val = ''
+  } else {
+    val = `${val}`
+  }
+
+  if (request.host === null && headerName === 'host') {
+    if (typeof val !== 'string') {
+      throw new InvalidArgumentError('invalid host header')
+    }
+    // Consumed by Client
+    request.host = val
+  } else if (request.contentLength === null && headerName === 'content-length') {
+    request.contentLength = parseInt(val, 10)
+    if (!Number.isFinite(request.contentLength)) {
+      throw new InvalidArgumentError('invalid content-length header')
+    }
+  } else if (request.contentType === null && headerName === 'content-type') {
+    request.contentType = val
+    request.headers.push(key, val)
+  } else if (headerName === 'transfer-encoding' || headerName === 'keep-alive' || headerName === 'upgrade') {
+    throw new InvalidArgumentError(`invalid ${headerName} header`)
+  } else if (headerName === 'connection') {
+    const value = typeof val === 'string' ? val.toLowerCase() : null
+    if (value !== 'close' && value !== 'keep-alive') {
+      throw new InvalidArgumentError('invalid connection header')
+    }
+
+    if (value === 'close') {
+      request.reset = true
+    }
+  } else if (headerName === 'expect') {
+    throw new NotSupportedError('expect header not supported')
+  } else {
+    request.headers.push(key, val)
+  }
+}
+
+module.exports = Request
+
+
+/***/ }),
+
+/***/ 5392:
+/***/ ((module) => {
+
+module.exports = {
+  kClose: Symbol('close'),
+  kDestroy: Symbol('destroy'),
+  kDispatch: Symbol('dispatch'),
+  kUrl: Symbol('url'),
+  kWriting: Symbol('writing'),
+  kResuming: Symbol('resuming'),
+  kQueue: Symbol('queue'),
+  kConnect: Symbol('connect'),
+  kConnecting: Symbol('connecting'),
+  kKeepAliveDefaultTimeout: Symbol('default keep alive timeout'),
+  kKeepAliveMaxTimeout: Symbol('max keep alive timeout'),
+  kKeepAliveTimeoutThreshold: Symbol('keep alive timeout threshold'),
+  kKeepAliveTimeoutValue: Symbol('keep alive timeout'),
+  kKeepAlive: Symbol('keep alive'),
+  kHeadersTimeout: Symbol('headers timeout'),
+  kBodyTimeout: Symbol('body timeout'),
+  kServerName: Symbol('server name'),
+  kLocalAddress: Symbol('local address'),
+  kHost: Symbol('host'),
+  kNoRef: Symbol('no ref'),
+  kBodyUsed: Symbol('used'),
+  kBody: Symbol('abstracted request body'),
+  kRunning: Symbol('running'),
+  kBlocking: Symbol('blocking'),
+  kPending: Symbol('pending'),
+  kSize: Symbol('size'),
+  kBusy: Symbol('busy'),
+  kQueued: Symbol('queued'),
+  kFree: Symbol('free'),
+  kConnected: Symbol('connected'),
+  kClosed: Symbol('closed'),
+  kNeedDrain: Symbol('need drain'),
+  kReset: Symbol('reset'),
+  kDestroyed: Symbol.for('nodejs.stream.destroyed'),
+  kResume: Symbol('resume'),
+  kOnError: Symbol('on error'),
+  kMaxHeadersSize: Symbol('max headers size'),
+  kRunningIdx: Symbol('running index'),
+  kPendingIdx: Symbol('pending index'),
+  kError: Symbol('error'),
+  kClients: Symbol('clients'),
+  kClient: Symbol('client'),
+  kParser: Symbol('parser'),
+  kOnDestroyed: Symbol('destroy callbacks'),
+  kPipelining: Symbol('pipelining'),
+  kSocket: Symbol('socket'),
+  kHostHeader: Symbol('host header'),
+  kConnector: Symbol('connector'),
+  kStrictContentLength: Symbol('strict content length'),
+  kMaxRedirections: Symbol('maxRedirections'),
+  kMaxRequests: Symbol('maxRequestsPerClient'),
+  kProxy: Symbol('proxy agent options'),
+  kCounter: Symbol('socket request counter'),
+  kInterceptors: Symbol('dispatch interceptors'),
+  kMaxResponseSize: Symbol('max response size'),
+  kHTTP2Session: Symbol('http2Session'),
+  kHTTP2SessionState: Symbol('http2Session state'),
+  kRetryHandlerDefaultRetry: Symbol('retry agent default retry'),
+  kConstruct: Symbol('constructable'),
+  kListeners: Symbol('listeners'),
+  kHTTPContext: Symbol('http context'),
+  kMaxConcurrentStreams: Symbol('max concurrent streams'),
+  kNoProxyAgent: Symbol('no proxy agent'),
+  kHttpProxyAgent: Symbol('http proxy agent'),
+  kHttpsProxyAgent: Symbol('https proxy agent')
+}
+
+
+/***/ }),
+
+/***/ 69574:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  wellknownHeaderNames,
+  headerNameLowerCasedRecord
+} = __nccwpck_require__(2029)
+
+class TstNode {
+  /** @type {any} */
+  value = null
+  /** @type {null | TstNode} */
+  left = null
+  /** @type {null | TstNode} */
+  middle = null
+  /** @type {null | TstNode} */
+  right = null
+  /** @type {number} */
+  code
+  /**
+   * @param {string} key
+   * @param {any} value
+   * @param {number} index
+   */
+  constructor (key, value, index) {
+    if (index === undefined || index >= key.length) {
+      throw new TypeError('Unreachable')
+    }
+    const code = this.code = key.charCodeAt(index)
+    // check code is ascii string
+    if (code > 0x7F) {
+      throw new TypeError('key must be ascii string')
+    }
+    if (key.length !== ++index) {
+      this.middle = new TstNode(key, value, index)
+    } else {
+      this.value = value
+    }
+  }
+
+  /**
+   * @param {string} key
+   * @param {any} value
+   */
+  add (key, value) {
+    const length = key.length
+    if (length === 0) {
+      throw new TypeError('Unreachable')
+    }
+    let index = 0
+    let node = this
+    while (true) {
+      const code = key.charCodeAt(index)
+      // check code is ascii string
+      if (code > 0x7F) {
+        throw new TypeError('key must be ascii string')
+      }
+      if (node.code === code) {
+        if (length === ++index) {
+          node.value = value
+          break
+        } else if (node.middle !== null) {
+          node = node.middle
+        } else {
+          node.middle = new TstNode(key, value, index)
+          break
+        }
+      } else if (node.code < code) {
+        if (node.left !== null) {
+          node = node.left
+        } else {
+          node.left = new TstNode(key, value, index)
+          break
+        }
+      } else if (node.right !== null) {
+        node = node.right
+      } else {
+        node.right = new TstNode(key, value, index)
+        break
+      }
+    }
+  }
+
+  /**
+   * @param {Uint8Array} key
+   * @return {TstNode | null}
+   */
+  search (key) {
+    const keylength = key.length
+    let index = 0
+    let node = this
+    while (node !== null && index < keylength) {
+      let code = key[index]
+      // A-Z
+      // First check if it is bigger than 0x5a.
+      // Lowercase letters have higher char codes than uppercase ones.
+      // Also we assume that headers will mostly contain lowercase characters.
+      if (code <= 0x5a && code >= 0x41) {
+        // Lowercase for uppercase.
+        code |= 32
+      }
+      while (node !== null) {
+        if (code === node.code) {
+          if (keylength === ++index) {
+            // Returns Node since it is the last key.
+            return node
+          }
+          node = node.middle
+          break
+        }
+        node = node.code < code ? node.left : node.right
+      }
+    }
+    return null
+  }
+}
+
+class TernarySearchTree {
+  /** @type {TstNode | null} */
+  node = null
+
+  /**
+   * @param {string} key
+   * @param {any} value
+   * */
+  insert (key, value) {
+    if (this.node === null) {
+      this.node = new TstNode(key, value, 0)
+    } else {
+      this.node.add(key, value)
+    }
+  }
+
+  /**
+   * @param {Uint8Array} key
+   * @return {any}
+   */
+  lookup (key) {
+    return this.node?.search(key)?.value ?? null
+  }
+}
+
+const tree = new TernarySearchTree()
+
+for (let i = 0; i < wellknownHeaderNames.length; ++i) {
+  const key = headerNameLowerCasedRecord[wellknownHeaderNames[i]]
+  tree.insert(key, key)
+}
+
+module.exports = {
+  TernarySearchTree,
+  tree
+}
+
+
+/***/ }),
+
+/***/ 94407:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+const { kDestroyed, kBodyUsed, kListeners, kBody } = __nccwpck_require__(5392)
+const { IncomingMessage } = __nccwpck_require__(88849)
+const stream = __nccwpck_require__(84492)
+const net = __nccwpck_require__(87503)
+const { Blob } = __nccwpck_require__(72254)
+const nodeUtil = __nccwpck_require__(47261)
+const { stringify } = __nccwpck_require__(39630)
+const { EventEmitter: EE } = __nccwpck_require__(15673)
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+const { headerNameLowerCasedRecord } = __nccwpck_require__(2029)
+const { tree } = __nccwpck_require__(69574)
+
+const [nodeMajor, nodeMinor] = process.versions.node.split('.').map(v => Number(v))
+
+class BodyAsyncIterable {
+  constructor (body) {
+    this[kBody] = body
+    this[kBodyUsed] = false
+  }
+
+  async * [Symbol.asyncIterator] () {
+    assert(!this[kBodyUsed], 'disturbed')
+    this[kBodyUsed] = true
+    yield * this[kBody]
+  }
+}
+
+function wrapRequestBody (body) {
+  if (isStream(body)) {
+    // TODO (fix): Provide some way for the user to cache the file to e.g. /tmp
+    // so that it can be dispatched again?
+    // TODO (fix): Do we need 100-expect support to provide a way to do this properly?
+    if (bodyLength(body) === 0) {
+      body
+        .on('data', function () {
+          assert(false)
+        })
+    }
+
+    if (typeof body.readableDidRead !== 'boolean') {
+      body[kBodyUsed] = false
+      EE.prototype.on.call(body, 'data', function () {
+        this[kBodyUsed] = true
+      })
+    }
+
+    return body
+  } else if (body && typeof body.pipeTo === 'function') {
+    // TODO (fix): We can't access ReadableStream internal state
+    // to determine whether or not it has been disturbed. This is just
+    // a workaround.
+    return new BodyAsyncIterable(body)
+  } else if (
+    body &&
+    typeof body !== 'string' &&
+    !ArrayBuffer.isView(body) &&
+    isIterable(body)
+  ) {
+    // TODO: Should we allow re-using iterable if !this.opts.idempotent
+    // or through some other flag?
+    return new BodyAsyncIterable(body)
+  } else {
+    return body
+  }
+}
+
+function nop () {}
+
+function isStream (obj) {
+  return obj && typeof obj === 'object' && typeof obj.pipe === 'function' && typeof obj.on === 'function'
+}
+
+// based on https://github.com/node-fetch/fetch-blob/blob/8ab587d34080de94140b54f07168451e7d0b655e/index.js#L229-L241 (MIT License)
+function isBlobLike (object) {
+  if (object === null) {
+    return false
+  } else if (object instanceof Blob) {
+    return true
+  } else if (typeof object !== 'object') {
+    return false
+  } else {
+    const sTag = object[Symbol.toStringTag]
+
+    return (sTag === 'Blob' || sTag === 'File') && (
+      ('stream' in object && typeof object.stream === 'function') ||
+      ('arrayBuffer' in object && typeof object.arrayBuffer === 'function')
+    )
+  }
+}
+
+function buildURL (url, queryParams) {
+  if (url.includes('?') || url.includes('#')) {
+    throw new Error('Query params cannot be passed when url already contains "?" or "#".')
+  }
+
+  const stringified = stringify(queryParams)
+
+  if (stringified) {
+    url += '?' + stringified
+  }
+
+  return url
+}
+
+function isValidPort (port) {
+  const value = parseInt(port, 10)
+  return (
+    value === Number(port) &&
+    value >= 0 &&
+    value <= 65535
+  )
+}
+
+function isHttpOrHttpsPrefixed (value) {
+  return (
+    value != null &&
+    value[0] === 'h' &&
+    value[1] === 't' &&
+    value[2] === 't' &&
+    value[3] === 'p' &&
+    (
+      value[4] === ':' ||
+      (
+        value[4] === 's' &&
+        value[5] === ':'
+      )
+    )
+  )
+}
+
+function parseURL (url) {
+  if (typeof url === 'string') {
+    url = new URL(url)
+
+    if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
+      throw new InvalidArgumentError('Invalid URL protocol: the URL must start with `http:` or `https:`.')
+    }
+
+    return url
+  }
+
+  if (!url || typeof url !== 'object') {
+    throw new InvalidArgumentError('Invalid URL: The URL argument must be a non-null object.')
+  }
+
+  if (!(url instanceof URL)) {
+    if (url.port != null && url.port !== '' && isValidPort(url.port) === false) {
+      throw new InvalidArgumentError('Invalid URL: port must be a valid integer or a string representation of an integer.')
+    }
+
+    if (url.path != null && typeof url.path !== 'string') {
+      throw new InvalidArgumentError('Invalid URL path: the path must be a string or null/undefined.')
+    }
+
+    if (url.pathname != null && typeof url.pathname !== 'string') {
+      throw new InvalidArgumentError('Invalid URL pathname: the pathname must be a string or null/undefined.')
+    }
+
+    if (url.hostname != null && typeof url.hostname !== 'string') {
+      throw new InvalidArgumentError('Invalid URL hostname: the hostname must be a string or null/undefined.')
+    }
+
+    if (url.origin != null && typeof url.origin !== 'string') {
+      throw new InvalidArgumentError('Invalid URL origin: the origin must be a string or null/undefined.')
+    }
+
+    if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
+      throw new InvalidArgumentError('Invalid URL protocol: the URL must start with `http:` or `https:`.')
+    }
+
+    const port = url.port != null
+      ? url.port
+      : (url.protocol === 'https:' ? 443 : 80)
+    let origin = url.origin != null
+      ? url.origin
+      : `${url.protocol || ''}//${url.hostname || ''}:${port}`
+    let path = url.path != null
+      ? url.path
+      : `${url.pathname || ''}${url.search || ''}`
+
+    if (origin[origin.length - 1] === '/') {
+      origin = origin.slice(0, origin.length - 1)
+    }
+
+    if (path && path[0] !== '/') {
+      path = `/${path}`
+    }
+    // new URL(path, origin) is unsafe when `path` contains an absolute URL
+    // From https://developer.mozilla.org/en-US/docs/Web/API/URL/URL:
+    // If first parameter is a relative URL, second param is required, and will be used as the base URL.
+    // If first parameter is an absolute URL, a given second param will be ignored.
+    return new URL(`${origin}${path}`)
+  }
+
+  if (!isHttpOrHttpsPrefixed(url.origin || url.protocol)) {
+    throw new InvalidArgumentError('Invalid URL protocol: the URL must start with `http:` or `https:`.')
+  }
+
+  return url
+}
+
+function parseOrigin (url) {
+  url = parseURL(url)
+
+  if (url.pathname !== '/' || url.search || url.hash) {
+    throw new InvalidArgumentError('invalid url')
+  }
+
+  return url
+}
+
+function getHostname (host) {
+  if (host[0] === '[') {
+    const idx = host.indexOf(']')
+
+    assert(idx !== -1)
+    return host.substring(1, idx)
+  }
+
+  const idx = host.indexOf(':')
+  if (idx === -1) return host
+
+  return host.substring(0, idx)
+}
+
+// IP addresses are not valid server names per RFC6066
+// > Currently, the only server names supported are DNS hostnames
+function getServerName (host) {
+  if (!host) {
+    return null
+  }
+
+  assert(typeof host === 'string')
+
+  const servername = getHostname(host)
+  if (net.isIP(servername)) {
+    return ''
+  }
+
+  return servername
+}
+
+function deepClone (obj) {
+  return JSON.parse(JSON.stringify(obj))
+}
+
+function isAsyncIterable (obj) {
+  return !!(obj != null && typeof obj[Symbol.asyncIterator] === 'function')
+}
+
+function isIterable (obj) {
+  return !!(obj != null && (typeof obj[Symbol.iterator] === 'function' || typeof obj[Symbol.asyncIterator] === 'function'))
+}
+
+function bodyLength (body) {
+  if (body == null) {
+    return 0
+  } else if (isStream(body)) {
+    const state = body._readableState
+    return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length)
+      ? state.length
+      : null
+  } else if (isBlobLike(body)) {
+    return body.size != null ? body.size : null
+  } else if (isBuffer(body)) {
+    return body.byteLength
+  }
+
+  return null
+}
+
+function isDestroyed (body) {
+  return body && !!(body.destroyed || body[kDestroyed] || (stream.isDestroyed?.(body)))
+}
+
+function destroy (stream, err) {
+  if (stream == null || !isStream(stream) || isDestroyed(stream)) {
+    return
+  }
+
+  if (typeof stream.destroy === 'function') {
+    if (Object.getPrototypeOf(stream).constructor === IncomingMessage) {
+      // See: https://github.com/nodejs/node/pull/38505/files
+      stream.socket = null
+    }
+
+    stream.destroy(err)
+  } else if (err) {
+    queueMicrotask(() => {
+      stream.emit('error', err)
+    })
+  }
+
+  if (stream.destroyed !== true) {
+    stream[kDestroyed] = true
+  }
+}
+
+const KEEPALIVE_TIMEOUT_EXPR = /timeout=(\d+)/
+function parseKeepAliveTimeout (val) {
+  const m = val.toString().match(KEEPALIVE_TIMEOUT_EXPR)
+  return m ? parseInt(m[1], 10) * 1000 : null
+}
+
+/**
+ * Retrieves a header name and returns its lowercase value.
+ * @param {string | Buffer} value Header name
+ * @returns {string}
+ */
+function headerNameToString (value) {
+  return typeof value === 'string'
+    ? headerNameLowerCasedRecord[value] ?? value.toLowerCase()
+    : tree.lookup(value) ?? value.toString('latin1').toLowerCase()
+}
+
+/**
+ * Receive the buffer as a string and return its lowercase value.
+ * @param {Buffer} value Header name
+ * @returns {string}
+ */
+function bufferToLowerCasedHeaderName (value) {
+  return tree.lookup(value) ?? value.toString('latin1').toLowerCase()
+}
+
+/**
+ * @param {Record<string, string | string[]> | (Buffer | string | (Buffer | string)[])[]} headers
+ * @param {Record<string, string | string[]>} [obj]
+ * @returns {Record<string, string | string[]>}
+ */
+function parseHeaders (headers, obj) {
+  if (obj === undefined) obj = {}
+  for (let i = 0; i < headers.length; i += 2) {
+    const key = headerNameToString(headers[i])
+    let val = obj[key]
+
+    if (val) {
+      if (typeof val === 'string') {
+        val = [val]
+        obj[key] = val
+      }
+      val.push(headers[i + 1].toString('utf8'))
+    } else {
+      const headersValue = headers[i + 1]
+      if (typeof headersValue === 'string') {
+        obj[key] = headersValue
+      } else {
+        obj[key] = Array.isArray(headersValue) ? headersValue.map(x => x.toString('utf8')) : headersValue.toString('utf8')
+      }
+    }
+  }
+
+  // See https://github.com/nodejs/node/pull/46528
+  if ('content-length' in obj && 'content-disposition' in obj) {
+    obj['content-disposition'] = Buffer.from(obj['content-disposition']).toString('latin1')
+  }
+
+  return obj
+}
+
+function parseRawHeaders (headers) {
+  const len = headers.length
+  const ret = new Array(len)
+
+  let hasContentLength = false
+  let contentDispositionIdx = -1
+  let key
+  let val
+  let kLen = 0
+
+  for (let n = 0; n < headers.length; n += 2) {
+    key = headers[n]
+    val = headers[n + 1]
+
+    typeof key !== 'string' && (key = key.toString())
+    typeof val !== 'string' && (val = val.toString('utf8'))
+
+    kLen = key.length
+    if (kLen === 14 && key[7] === '-' && (key === 'content-length' || key.toLowerCase() === 'content-length')) {
+      hasContentLength = true
+    } else if (kLen === 19 && key[7] === '-' && (key === 'content-disposition' || key.toLowerCase() === 'content-disposition')) {
+      contentDispositionIdx = n + 1
+    }
+    ret[n] = key
+    ret[n + 1] = val
+  }
+
+  // See https://github.com/nodejs/node/pull/46528
+  if (hasContentLength && contentDispositionIdx !== -1) {
+    ret[contentDispositionIdx] = Buffer.from(ret[contentDispositionIdx]).toString('latin1')
+  }
+
+  return ret
+}
+
+function isBuffer (buffer) {
+  // See, https://github.com/mcollina/undici/pull/319
+  return buffer instanceof Uint8Array || Buffer.isBuffer(buffer)
+}
+
+function validateHandler (handler, method, upgrade) {
+  if (!handler || typeof handler !== 'object') {
+    throw new InvalidArgumentError('handler must be an object')
+  }
+
+  if (typeof handler.onConnect !== 'function') {
+    throw new InvalidArgumentError('invalid onConnect method')
+  }
+
+  if (typeof handler.onError !== 'function') {
+    throw new InvalidArgumentError('invalid onError method')
+  }
+
+  if (typeof handler.onBodySent !== 'function' && handler.onBodySent !== undefined) {
+    throw new InvalidArgumentError('invalid onBodySent method')
+  }
+
+  if (upgrade || method === 'CONNECT') {
+    if (typeof handler.onUpgrade !== 'function') {
+      throw new InvalidArgumentError('invalid onUpgrade method')
+    }
+  } else {
+    if (typeof handler.onHeaders !== 'function') {
+      throw new InvalidArgumentError('invalid onHeaders method')
+    }
+
+    if (typeof handler.onData !== 'function') {
+      throw new InvalidArgumentError('invalid onData method')
+    }
+
+    if (typeof handler.onComplete !== 'function') {
+      throw new InvalidArgumentError('invalid onComplete method')
+    }
+  }
+}
+
+// A body is disturbed if it has been read from and it cannot
+// be re-used without losing state or data.
+function isDisturbed (body) {
+  // TODO (fix): Why is body[kBodyUsed] needed?
+  return !!(body && (stream.isDisturbed(body) || body[kBodyUsed]))
+}
+
+function isErrored (body) {
+  return !!(body && stream.isErrored(body))
+}
+
+function isReadable (body) {
+  return !!(body && stream.isReadable(body))
+}
+
+function getSocketInfo (socket) {
+  return {
+    localAddress: socket.localAddress,
+    localPort: socket.localPort,
+    remoteAddress: socket.remoteAddress,
+    remotePort: socket.remotePort,
+    remoteFamily: socket.remoteFamily,
+    timeout: socket.timeout,
+    bytesWritten: socket.bytesWritten,
+    bytesRead: socket.bytesRead
+  }
+}
+
+/** @type {globalThis['ReadableStream']} */
+function ReadableStreamFrom (iterable) {
+  // We cannot use ReadableStream.from here because it does not return a byte stream.
+
+  let iterator
+  return new ReadableStream(
+    {
+      async start () {
+        iterator = iterable[Symbol.asyncIterator]()
+      },
+      async pull (controller) {
+        const { done, value } = await iterator.next()
+        if (done) {
+          queueMicrotask(() => {
+            controller.close()
+            controller.byobRequest?.respond(0)
+          })
+        } else {
+          const buf = Buffer.isBuffer(value) ? value : Buffer.from(value)
+          if (buf.byteLength) {
+            controller.enqueue(new Uint8Array(buf))
+          }
+        }
+        return controller.desiredSize > 0
+      },
+      async cancel (reason) {
+        await iterator.return()
+      },
+      type: 'bytes'
+    }
+  )
+}
+
+// The chunk should be a FormData instance and contains
+// all the required methods.
+function isFormDataLike (object) {
+  return (
+    object &&
+    typeof object === 'object' &&
+    typeof object.append === 'function' &&
+    typeof object.delete === 'function' &&
+    typeof object.get === 'function' &&
+    typeof object.getAll === 'function' &&
+    typeof object.has === 'function' &&
+    typeof object.set === 'function' &&
+    object[Symbol.toStringTag] === 'FormData'
+  )
+}
+
+function addAbortListener (signal, listener) {
+  if ('addEventListener' in signal) {
+    signal.addEventListener('abort', listener, { once: true })
+    return () => signal.removeEventListener('abort', listener)
+  }
+  signal.addListener('abort', listener)
+  return () => signal.removeListener('abort', listener)
+}
+
+const hasToWellFormed = typeof String.prototype.toWellFormed === 'function'
+const hasIsWellFormed = typeof String.prototype.isWellFormed === 'function'
+
+/**
+ * @param {string} val
+ */
+function toUSVString (val) {
+  return hasToWellFormed ? `${val}`.toWellFormed() : nodeUtil.toUSVString(val)
+}
+
+/**
+ * @param {string} val
+ */
+// TODO: move this to webidl
+function isUSVString (val) {
+  return hasIsWellFormed ? `${val}`.isWellFormed() : toUSVString(val) === `${val}`
+}
+
+/**
+ * @see https://tools.ietf.org/html/rfc7230#section-3.2.6
+ * @param {number} c
+ */
+function isTokenCharCode (c) {
+  switch (c) {
+    case 0x22:
+    case 0x28:
+    case 0x29:
+    case 0x2c:
+    case 0x2f:
+    case 0x3a:
+    case 0x3b:
+    case 0x3c:
+    case 0x3d:
+    case 0x3e:
+    case 0x3f:
+    case 0x40:
+    case 0x5b:
+    case 0x5c:
+    case 0x5d:
+    case 0x7b:
+    case 0x7d:
+      // DQUOTE and "(),/:;<=>?@[\]{}"
+      return false
+    default:
+      // VCHAR %x21-7E
+      return c >= 0x21 && c <= 0x7e
+  }
+}
+
+/**
+ * @param {string} characters
+ */
+function isValidHTTPToken (characters) {
+  if (characters.length === 0) {
+    return false
+  }
+  for (let i = 0; i < characters.length; ++i) {
+    if (!isTokenCharCode(characters.charCodeAt(i))) {
+      return false
+    }
+  }
+  return true
+}
+
+// headerCharRegex have been lifted from
+// https://github.com/nodejs/node/blob/main/lib/_http_common.js
+
+/**
+ * Matches if val contains an invalid field-vchar
+ *  field-value    = *( field-content / obs-fold )
+ *  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+ *  field-vchar    = VCHAR / obs-text
+ */
+const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/
+
+/**
+ * @param {string} characters
+ */
+function isValidHeaderValue (characters) {
+  return !headerCharRegex.test(characters)
+}
+
+// Parsed accordingly to RFC 9110
+// https://www.rfc-editor.org/rfc/rfc9110#field.content-range
+function parseRangeHeader (range) {
+  if (range == null || range === '') return { start: 0, end: null, size: null }
+
+  const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null
+  return m
+    ? {
+        start: parseInt(m[1]),
+        end: m[2] ? parseInt(m[2]) : null,
+        size: m[3] ? parseInt(m[3]) : null
+      }
+    : null
+}
+
+function addListener (obj, name, listener) {
+  const listeners = (obj[kListeners] ??= [])
+  listeners.push([name, listener])
+  obj.on(name, listener)
+  return obj
+}
+
+function removeAllListeners (obj) {
+  for (const [name, listener] of obj[kListeners] ?? []) {
+    obj.removeListener(name, listener)
+  }
+  obj[kListeners] = null
+}
+
+function errorRequest (client, request, err) {
+  try {
+    request.onError(err)
+    assert(request.aborted)
+  } catch (err) {
+    client.emit('error', err)
+  }
+}
+
+const kEnumerableProperty = Object.create(null)
+kEnumerableProperty.enumerable = true
+
+const normalizedMethodRecordsBase = {
+  delete: 'DELETE',
+  DELETE: 'DELETE',
+  get: 'GET',
+  GET: 'GET',
+  head: 'HEAD',
+  HEAD: 'HEAD',
+  options: 'OPTIONS',
+  OPTIONS: 'OPTIONS',
+  post: 'POST',
+  POST: 'POST',
+  put: 'PUT',
+  PUT: 'PUT'
+}
+
+const normalizedMethodRecords = {
+  ...normalizedMethodRecordsBase,
+  patch: 'patch',
+  PATCH: 'PATCH'
+}
+
+// Note: object prototypes should not be able to be referenced. e.g. `Object#hasOwnProperty`.
+Object.setPrototypeOf(normalizedMethodRecordsBase, null)
+Object.setPrototypeOf(normalizedMethodRecords, null)
+
+module.exports = {
+  kEnumerableProperty,
+  nop,
+  isDisturbed,
+  isErrored,
+  isReadable,
+  toUSVString,
+  isUSVString,
+  isBlobLike,
+  parseOrigin,
+  parseURL,
+  getServerName,
+  isStream,
+  isIterable,
+  isAsyncIterable,
+  isDestroyed,
+  headerNameToString,
+  bufferToLowerCasedHeaderName,
+  addListener,
+  removeAllListeners,
+  errorRequest,
+  parseRawHeaders,
+  parseHeaders,
+  parseKeepAliveTimeout,
+  destroy,
+  bodyLength,
+  deepClone,
+  ReadableStreamFrom,
+  isBuffer,
+  validateHandler,
+  getSocketInfo,
+  isFormDataLike,
+  buildURL,
+  addAbortListener,
+  isValidHTTPToken,
+  isValidHeaderValue,
+  isTokenCharCode,
+  parseRangeHeader,
+  normalizedMethodRecordsBase,
+  normalizedMethodRecords,
+  isValidPort,
+  isHttpOrHttpsPrefixed,
+  nodeMajor,
+  nodeMinor,
+  safeHTTPMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
+  wrapRequestBody
+}
+
+
+/***/ }),
+
+/***/ 83421:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+const { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = __nccwpck_require__(5392)
+const DispatcherBase = __nccwpck_require__(68838)
+const Pool = __nccwpck_require__(11795)
+const Client = __nccwpck_require__(6655)
+const util = __nccwpck_require__(94407)
+const createRedirectInterceptor = __nccwpck_require__(11115)
+
+const kOnConnect = Symbol('onConnect')
+const kOnDisconnect = Symbol('onDisconnect')
+const kOnConnectionError = Symbol('onConnectionError')
+const kMaxRedirections = Symbol('maxRedirections')
+const kOnDrain = Symbol('onDrain')
+const kFactory = Symbol('factory')
+const kOptions = Symbol('options')
+
+function defaultFactory (origin, opts) {
+  return opts && opts.connections === 1
+    ? new Client(origin, opts)
+    : new Pool(origin, opts)
+}
+
+class Agent extends DispatcherBase {
+  constructor ({ factory = defaultFactory, maxRedirections = 0, connect, ...options } = {}) {
+    super()
+
+    if (typeof factory !== 'function') {
+      throw new InvalidArgumentError('factory must be a function.')
+    }
+
+    if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
+      throw new InvalidArgumentError('connect must be a function or an object')
+    }
+
+    if (!Number.isInteger(maxRedirections) || maxRedirections < 0) {
+      throw new InvalidArgumentError('maxRedirections must be a positive number')
+    }
+
+    if (connect && typeof connect !== 'function') {
+      connect = { ...connect }
+    }
+
+    this[kInterceptors] = options.interceptors?.Agent && Array.isArray(options.interceptors.Agent)
+      ? options.interceptors.Agent
+      : [createRedirectInterceptor({ maxRedirections })]
+
+    this[kOptions] = { ...util.deepClone(options), connect }
+    this[kOptions].interceptors = options.interceptors
+      ? { ...options.interceptors }
+      : undefined
+    this[kMaxRedirections] = maxRedirections
+    this[kFactory] = factory
+    this[kClients] = new Map()
+
+    this[kOnDrain] = (origin, targets) => {
+      this.emit('drain', origin, [this, ...targets])
+    }
+
+    this[kOnConnect] = (origin, targets) => {
+      this.emit('connect', origin, [this, ...targets])
+    }
+
+    this[kOnDisconnect] = (origin, targets, err) => {
+      this.emit('disconnect', origin, [this, ...targets], err)
+    }
+
+    this[kOnConnectionError] = (origin, targets, err) => {
+      this.emit('connectionError', origin, [this, ...targets], err)
+    }
+  }
+
+  get [kRunning] () {
+    let ret = 0
+    for (const client of this[kClients].values()) {
+      ret += client[kRunning]
+    }
+    return ret
+  }
+
+  [kDispatch] (opts, handler) {
+    let key
+    if (opts.origin && (typeof opts.origin === 'string' || opts.origin instanceof URL)) {
+      key = String(opts.origin)
+    } else {
+      throw new InvalidArgumentError('opts.origin must be a non-empty string or URL.')
+    }
+
+    let dispatcher = this[kClients].get(key)
+
+    if (!dispatcher) {
+      dispatcher = this[kFactory](opts.origin, this[kOptions])
+        .on('drain', this[kOnDrain])
+        .on('connect', this[kOnConnect])
+        .on('disconnect', this[kOnDisconnect])
+        .on('connectionError', this[kOnConnectionError])
+
+      // This introduces a tiny memory leak, as dispatchers are never removed from the map.
+      // TODO(mcollina): remove te timer when the client/pool do not have any more
+      // active connections.
+      this[kClients].set(key, dispatcher)
+    }
+
+    return dispatcher.dispatch(opts, handler)
+  }
+
+  async [kClose] () {
+    const closePromises = []
+    for (const client of this[kClients].values()) {
+      closePromises.push(client.close())
+    }
+    this[kClients].clear()
+
+    await Promise.all(closePromises)
+  }
+
+  async [kDestroy] (err) {
+    const destroyPromises = []
+    for (const client of this[kClients].values()) {
+      destroyPromises.push(client.destroy(err))
+    }
+    this[kClients].clear()
+
+    await Promise.all(destroyPromises)
+  }
+}
+
+module.exports = Agent
+
+
+/***/ }),
+
+/***/ 74086:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  BalancedPoolMissingUpstreamError,
+  InvalidArgumentError
+} = __nccwpck_require__(22174)
+const {
+  PoolBase,
+  kClients,
+  kNeedDrain,
+  kAddClient,
+  kRemoveClient,
+  kGetDispatcher
+} = __nccwpck_require__(37128)
+const Pool = __nccwpck_require__(11795)
+const { kUrl, kInterceptors } = __nccwpck_require__(5392)
+const { parseOrigin } = __nccwpck_require__(94407)
+const kFactory = Symbol('factory')
+
+const kOptions = Symbol('options')
+const kGreatestCommonDivisor = Symbol('kGreatestCommonDivisor')
+const kCurrentWeight = Symbol('kCurrentWeight')
+const kIndex = Symbol('kIndex')
+const kWeight = Symbol('kWeight')
+const kMaxWeightPerServer = Symbol('kMaxWeightPerServer')
+const kErrorPenalty = Symbol('kErrorPenalty')
+
+/**
+ * Calculate the greatest common divisor of two numbers by
+ * using the Euclidean algorithm.
+ *
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+function getGreatestCommonDivisor (a, b) {
+  if (a === 0) return b
+
+  while (b !== 0) {
+    const t = b
+    b = a % b
+    a = t
+  }
+  return a
+}
+
+function defaultFactory (origin, opts) {
+  return new Pool(origin, opts)
+}
+
+class BalancedPool extends PoolBase {
+  constructor (upstreams = [], { factory = defaultFactory, ...opts } = {}) {
+    super()
+
+    this[kOptions] = opts
+    this[kIndex] = -1
+    this[kCurrentWeight] = 0
+
+    this[kMaxWeightPerServer] = this[kOptions].maxWeightPerServer || 100
+    this[kErrorPenalty] = this[kOptions].errorPenalty || 15
+
+    if (!Array.isArray(upstreams)) {
+      upstreams = [upstreams]
+    }
+
+    if (typeof factory !== 'function') {
+      throw new InvalidArgumentError('factory must be a function.')
+    }
+
+    this[kInterceptors] = opts.interceptors?.BalancedPool && Array.isArray(opts.interceptors.BalancedPool)
+      ? opts.interceptors.BalancedPool
+      : []
+    this[kFactory] = factory
+
+    for (const upstream of upstreams) {
+      this.addUpstream(upstream)
+    }
+    this._updateBalancedPoolStats()
+  }
+
+  addUpstream (upstream) {
+    const upstreamOrigin = parseOrigin(upstream).origin
+
+    if (this[kClients].find((pool) => (
+      pool[kUrl].origin === upstreamOrigin &&
+      pool.closed !== true &&
+      pool.destroyed !== true
+    ))) {
+      return this
+    }
+    const pool = this[kFactory](upstreamOrigin, Object.assign({}, this[kOptions]))
+
+    this[kAddClient](pool)
+    pool.on('connect', () => {
+      pool[kWeight] = Math.min(this[kMaxWeightPerServer], pool[kWeight] + this[kErrorPenalty])
+    })
+
+    pool.on('connectionError', () => {
+      pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty])
+      this._updateBalancedPoolStats()
+    })
+
+    pool.on('disconnect', (...args) => {
+      const err = args[2]
+      if (err && err.code === 'UND_ERR_SOCKET') {
+        // decrease the weight of the pool.
+        pool[kWeight] = Math.max(1, pool[kWeight] - this[kErrorPenalty])
+        this._updateBalancedPoolStats()
+      }
+    })
+
+    for (const client of this[kClients]) {
+      client[kWeight] = this[kMaxWeightPerServer]
+    }
+
+    this._updateBalancedPoolStats()
+
+    return this
+  }
+
+  _updateBalancedPoolStats () {
+    let result = 0
+    for (let i = 0; i < this[kClients].length; i++) {
+      result = getGreatestCommonDivisor(this[kClients][i][kWeight], result)
+    }
+
+    this[kGreatestCommonDivisor] = result
+  }
+
+  removeUpstream (upstream) {
+    const upstreamOrigin = parseOrigin(upstream).origin
+
+    const pool = this[kClients].find((pool) => (
+      pool[kUrl].origin === upstreamOrigin &&
+      pool.closed !== true &&
+      pool.destroyed !== true
+    ))
+
+    if (pool) {
+      this[kRemoveClient](pool)
+    }
+
+    return this
+  }
+
+  get upstreams () {
+    return this[kClients]
+      .filter(dispatcher => dispatcher.closed !== true && dispatcher.destroyed !== true)
+      .map((p) => p[kUrl].origin)
+  }
+
+  [kGetDispatcher] () {
+    // We validate that pools is greater than 0,
+    // otherwise we would have to wait until an upstream
+    // is added, which might never happen.
+    if (this[kClients].length === 0) {
+      throw new BalancedPoolMissingUpstreamError()
+    }
+
+    const dispatcher = this[kClients].find(dispatcher => (
+      !dispatcher[kNeedDrain] &&
+      dispatcher.closed !== true &&
+      dispatcher.destroyed !== true
+    ))
+
+    if (!dispatcher) {
+      return
+    }
+
+    const allClientsBusy = this[kClients].map(pool => pool[kNeedDrain]).reduce((a, b) => a && b, true)
+
+    if (allClientsBusy) {
+      return
+    }
+
+    let counter = 0
+
+    let maxWeightIndex = this[kClients].findIndex(pool => !pool[kNeedDrain])
+
+    while (counter++ < this[kClients].length) {
+      this[kIndex] = (this[kIndex] + 1) % this[kClients].length
+      const pool = this[kClients][this[kIndex]]
+
+      // find pool index with the largest weight
+      if (pool[kWeight] > this[kClients][maxWeightIndex][kWeight] && !pool[kNeedDrain]) {
+        maxWeightIndex = this[kIndex]
+      }
+
+      // decrease the current weight every `this[kClients].length`.
+      if (this[kIndex] === 0) {
+        // Set the current weight to the next lower weight.
+        this[kCurrentWeight] = this[kCurrentWeight] - this[kGreatestCommonDivisor]
+
+        if (this[kCurrentWeight] <= 0) {
+          this[kCurrentWeight] = this[kMaxWeightPerServer]
+        }
+      }
+      if (pool[kWeight] >= this[kCurrentWeight] && (!pool[kNeedDrain])) {
+        return pool
+      }
+    }
+
+    this[kCurrentWeight] = this[kClients][maxWeightIndex][kWeight]
+    this[kIndex] = maxWeightIndex
+    return this[kClients][maxWeightIndex]
+  }
+}
+
+module.exports = BalancedPool
+
+
+/***/ }),
+
+/***/ 73619:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+/* global WebAssembly */
+
+const assert = __nccwpck_require__(98061)
+const util = __nccwpck_require__(94407)
+const { channels } = __nccwpck_require__(8627)
+const timers = __nccwpck_require__(48413)
+const {
+  RequestContentLengthMismatchError,
+  ResponseContentLengthMismatchError,
+  RequestAbortedError,
+  HeadersTimeoutError,
+  HeadersOverflowError,
+  SocketError,
+  InformationalError,
+  BodyTimeoutError,
+  HTTPParserError,
+  ResponseExceededMaxSizeError
+} = __nccwpck_require__(22174)
+const {
+  kUrl,
+  kReset,
+  kClient,
+  kParser,
+  kBlocking,
+  kRunning,
+  kPending,
+  kSize,
+  kWriting,
+  kQueue,
+  kNoRef,
+  kKeepAliveDefaultTimeout,
+  kHostHeader,
+  kPendingIdx,
+  kRunningIdx,
+  kError,
+  kPipelining,
+  kSocket,
+  kKeepAliveTimeoutValue,
+  kMaxHeadersSize,
+  kKeepAliveMaxTimeout,
+  kKeepAliveTimeoutThreshold,
+  kHeadersTimeout,
+  kBodyTimeout,
+  kStrictContentLength,
+  kMaxRequests,
+  kCounter,
+  kMaxResponseSize,
+  kOnError,
+  kResume,
+  kHTTPContext
+} = __nccwpck_require__(5392)
+
+const constants = __nccwpck_require__(59086)
+const EMPTY_BUF = Buffer.alloc(0)
+const FastBuffer = Buffer[Symbol.species]
+const addListener = util.addListener
+const removeAllListeners = util.removeAllListeners
+
+let extractBody
+
+async function lazyllhttp () {
+  const llhttpWasmData = process.env.JEST_WORKER_ID ? __nccwpck_require__(91475) : undefined
+
+  let mod
+  try {
+    mod = await WebAssembly.compile(__nccwpck_require__(27784))
+  } catch (e) {
+    /* istanbul ignore next */
+
+    // We could check if the error was caused by the simd option not
+    // being enabled, but the occurring of this other error
+    // * https://github.com/emscripten-core/emscripten/issues/11495
+    // got me to remove that check to avoid breaking Node 12.
+    mod = await WebAssembly.compile(llhttpWasmData || __nccwpck_require__(91475))
+  }
+
+  return await WebAssembly.instantiate(mod, {
+    env: {
+      /* eslint-disable camelcase */
+
+      wasm_on_url: (p, at, len) => {
+        /* istanbul ignore next */
+        return 0
+      },
+      wasm_on_status: (p, at, len) => {
+        assert(currentParser.ptr === p)
+        const start = at - currentBufferPtr + currentBufferRef.byteOffset
+        return currentParser.onStatus(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
+      },
+      wasm_on_message_begin: (p) => {
+        assert(currentParser.ptr === p)
+        return currentParser.onMessageBegin() || 0
+      },
+      wasm_on_header_field: (p, at, len) => {
+        assert(currentParser.ptr === p)
+        const start = at - currentBufferPtr + currentBufferRef.byteOffset
+        return currentParser.onHeaderField(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
+      },
+      wasm_on_header_value: (p, at, len) => {
+        assert(currentParser.ptr === p)
+        const start = at - currentBufferPtr + currentBufferRef.byteOffset
+        return currentParser.onHeaderValue(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
+      },
+      wasm_on_headers_complete: (p, statusCode, upgrade, shouldKeepAlive) => {
+        assert(currentParser.ptr === p)
+        return currentParser.onHeadersComplete(statusCode, Boolean(upgrade), Boolean(shouldKeepAlive)) || 0
+      },
+      wasm_on_body: (p, at, len) => {
+        assert(currentParser.ptr === p)
+        const start = at - currentBufferPtr + currentBufferRef.byteOffset
+        return currentParser.onBody(new FastBuffer(currentBufferRef.buffer, start, len)) || 0
+      },
+      wasm_on_message_complete: (p) => {
+        assert(currentParser.ptr === p)
+        return currentParser.onMessageComplete() || 0
+      }
+
+      /* eslint-enable camelcase */
+    }
+  })
+}
+
+let llhttpInstance = null
+let llhttpPromise = lazyllhttp()
+llhttpPromise.catch()
+
+let currentParser = null
+let currentBufferRef = null
+let currentBufferSize = 0
+let currentBufferPtr = null
+
+const USE_NATIVE_TIMER = 0
+const USE_FAST_TIMER = 1
+
+// Use fast timers for headers and body to take eventual event loop
+// latency into account.
+const TIMEOUT_HEADERS = 2 | USE_FAST_TIMER
+const TIMEOUT_BODY = 4 | USE_FAST_TIMER
+
+// Use native timers to ignore event loop latency for keep-alive
+// handling.
+const TIMEOUT_KEEP_ALIVE = 8 | USE_NATIVE_TIMER
+
+class Parser {
+  constructor (client, socket, { exports }) {
+    assert(Number.isFinite(client[kMaxHeadersSize]) && client[kMaxHeadersSize] > 0)
+
+    this.llhttp = exports
+    this.ptr = this.llhttp.llhttp_alloc(constants.TYPE.RESPONSE)
+    this.client = client
+    this.socket = socket
+    this.timeout = null
+    this.timeoutValue = null
+    this.timeoutType = null
+    this.statusCode = null
+    this.statusText = ''
+    this.upgrade = false
+    this.headers = []
+    this.headersSize = 0
+    this.headersMaxSize = client[kMaxHeadersSize]
+    this.shouldKeepAlive = false
+    this.paused = false
+    this.resume = this.resume.bind(this)
+
+    this.bytesRead = 0
+
+    this.keepAlive = ''
+    this.contentLength = ''
+    this.connection = ''
+    this.maxResponseSize = client[kMaxResponseSize]
+  }
+
+  setTimeout (delay, type) {
+    // If the existing timer and the new timer are of different timer type
+    // (fast or native) or have different delay, we need to clear the existing
+    // timer and set a new one.
+    if (
+      delay !== this.timeoutValue ||
+      (type & USE_FAST_TIMER) ^ (this.timeoutType & USE_FAST_TIMER)
+    ) {
+      // If a timeout is already set, clear it with clearTimeout of the fast
+      // timer implementation, as it can clear fast and native timers.
+      if (this.timeout) {
+        timers.clearTimeout(this.timeout)
+        this.timeout = null
+      }
+
+      if (delay) {
+        if (type & USE_FAST_TIMER) {
+          this.timeout = timers.setFastTimeout(onParserTimeout, delay, new WeakRef(this))
+        } else {
+          this.timeout = setTimeout(onParserTimeout, delay, new WeakRef(this))
+          this.timeout.unref()
+        }
+      }
+
+      this.timeoutValue = delay
+    } else if (this.timeout) {
+      // istanbul ignore else: only for jest
+      if (this.timeout.refresh) {
+        this.timeout.refresh()
+      }
+    }
+
+    this.timeoutType = type
+  }
+
+  resume () {
+    if (this.socket.destroyed || !this.paused) {
+      return
+    }
+
+    assert(this.ptr != null)
+    assert(currentParser == null)
+
+    this.llhttp.llhttp_resume(this.ptr)
+
+    assert(this.timeoutType === TIMEOUT_BODY)
+    if (this.timeout) {
+      // istanbul ignore else: only for jest
+      if (this.timeout.refresh) {
+        this.timeout.refresh()
+      }
+    }
+
+    this.paused = false
+    this.execute(this.socket.read() || EMPTY_BUF) // Flush parser.
+    this.readMore()
+  }
+
+  readMore () {
+    while (!this.paused && this.ptr) {
+      const chunk = this.socket.read()
+      if (chunk === null) {
+        break
+      }
+      this.execute(chunk)
+    }
+  }
+
+  execute (data) {
+    assert(this.ptr != null)
+    assert(currentParser == null)
+    assert(!this.paused)
+
+    const { socket, llhttp } = this
+
+    if (data.length > currentBufferSize) {
+      if (currentBufferPtr) {
+        llhttp.free(currentBufferPtr)
+      }
+      currentBufferSize = Math.ceil(data.length / 4096) * 4096
+      currentBufferPtr = llhttp.malloc(currentBufferSize)
+    }
+
+    new Uint8Array(llhttp.memory.buffer, currentBufferPtr, currentBufferSize).set(data)
+
+    // Call `execute` on the wasm parser.
+    // We pass the `llhttp_parser` pointer address, the pointer address of buffer view data,
+    // and finally the length of bytes to parse.
+    // The return value is an error code or `constants.ERROR.OK`.
+    try {
+      let ret
+
+      try {
+        currentBufferRef = data
+        currentParser = this
+        ret = llhttp.llhttp_execute(this.ptr, currentBufferPtr, data.length)
+        /* eslint-disable-next-line no-useless-catch */
+      } catch (err) {
+        /* istanbul ignore next: difficult to make a test case for */
+        throw err
+      } finally {
+        currentParser = null
+        currentBufferRef = null
+      }
+
+      const offset = llhttp.llhttp_get_error_pos(this.ptr) - currentBufferPtr
+
+      if (ret === constants.ERROR.PAUSED_UPGRADE) {
+        this.onUpgrade(data.slice(offset))
+      } else if (ret === constants.ERROR.PAUSED) {
+        this.paused = true
+        socket.unshift(data.slice(offset))
+      } else if (ret !== constants.ERROR.OK) {
+        const ptr = llhttp.llhttp_get_error_reason(this.ptr)
+        let message = ''
+        /* istanbul ignore else: difficult to make a test case for */
+        if (ptr) {
+          const len = new Uint8Array(llhttp.memory.buffer, ptr).indexOf(0)
+          message =
+            'Response does not match the HTTP/1.1 protocol (' +
+            Buffer.from(llhttp.memory.buffer, ptr, len).toString() +
+            ')'
+        }
+        throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset))
+      }
+    } catch (err) {
+      util.destroy(socket, err)
+    }
+  }
+
+  destroy () {
+    assert(this.ptr != null)
+    assert(currentParser == null)
+
+    this.llhttp.llhttp_free(this.ptr)
+    this.ptr = null
+
+    this.timeout && timers.clearTimeout(this.timeout)
+    this.timeout = null
+    this.timeoutValue = null
+    this.timeoutType = null
+
+    this.paused = false
+  }
+
+  onStatus (buf) {
+    this.statusText = buf.toString()
+  }
+
+  onMessageBegin () {
+    const { socket, client } = this
+
+    /* istanbul ignore next: difficult to make a test case for */
+    if (socket.destroyed) {
+      return -1
+    }
+
+    const request = client[kQueue][client[kRunningIdx]]
+    if (!request) {
+      return -1
+    }
+    request.onResponseStarted()
+  }
+
+  onHeaderField (buf) {
+    const len = this.headers.length
+
+    if ((len & 1) === 0) {
+      this.headers.push(buf)
+    } else {
+      this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf])
+    }
+
+    this.trackHeader(buf.length)
+  }
+
+  onHeaderValue (buf) {
+    let len = this.headers.length
+
+    if ((len & 1) === 1) {
+      this.headers.push(buf)
+      len += 1
+    } else {
+      this.headers[len - 1] = Buffer.concat([this.headers[len - 1], buf])
+    }
+
+    const key = this.headers[len - 2]
+    if (key.length === 10) {
+      const headerName = util.bufferToLowerCasedHeaderName(key)
+      if (headerName === 'keep-alive') {
+        this.keepAlive += buf.toString()
+      } else if (headerName === 'connection') {
+        this.connection += buf.toString()
+      }
+    } else if (key.length === 14 && util.bufferToLowerCasedHeaderName(key) === 'content-length') {
+      this.contentLength += buf.toString()
+    }
+
+    this.trackHeader(buf.length)
+  }
+
+  trackHeader (len) {
+    this.headersSize += len
+    if (this.headersSize >= this.headersMaxSize) {
+      util.destroy(this.socket, new HeadersOverflowError())
+    }
+  }
+
+  onUpgrade (head) {
+    const { upgrade, client, socket, headers, statusCode } = this
+
+    assert(upgrade)
+    assert(client[kSocket] === socket)
+    assert(!socket.destroyed)
+    assert(!this.paused)
+    assert((headers.length & 1) === 0)
+
+    const request = client[kQueue][client[kRunningIdx]]
+    assert(request)
+    assert(request.upgrade || request.method === 'CONNECT')
+
+    this.statusCode = null
+    this.statusText = ''
+    this.shouldKeepAlive = null
+
+    this.headers = []
+    this.headersSize = 0
+
+    socket.unshift(head)
+
+    socket[kParser].destroy()
+    socket[kParser] = null
+
+    socket[kClient] = null
+    socket[kError] = null
+
+    removeAllListeners(socket)
+
+    client[kSocket] = null
+    client[kHTTPContext] = null // TODO (fix): This is hacky...
+    client[kQueue][client[kRunningIdx]++] = null
+    client.emit('disconnect', client[kUrl], [client], new InformationalError('upgrade'))
+
+    try {
+      request.onUpgrade(statusCode, headers, socket)
+    } catch (err) {
+      util.destroy(socket, err)
+    }
+
+    client[kResume]()
+  }
+
+  onHeadersComplete (statusCode, upgrade, shouldKeepAlive) {
+    const { client, socket, headers, statusText } = this
+
+    /* istanbul ignore next: difficult to make a test case for */
+    if (socket.destroyed) {
+      return -1
+    }
+
+    const request = client[kQueue][client[kRunningIdx]]
+
+    /* istanbul ignore next: difficult to make a test case for */
+    if (!request) {
+      return -1
+    }
+
+    assert(!this.upgrade)
+    assert(this.statusCode < 200)
+
+    if (statusCode === 100) {
+      util.destroy(socket, new SocketError('bad response', util.getSocketInfo(socket)))
+      return -1
+    }
+
+    /* this can only happen if server is misbehaving */
+    if (upgrade && !request.upgrade) {
+      util.destroy(socket, new SocketError('bad upgrade', util.getSocketInfo(socket)))
+      return -1
+    }
+
+    assert(this.timeoutType === TIMEOUT_HEADERS)
+
+    this.statusCode = statusCode
+    this.shouldKeepAlive = (
+      shouldKeepAlive ||
+      // Override llhttp value which does not allow keepAlive for HEAD.
+      (request.method === 'HEAD' && !socket[kReset] && this.connection.toLowerCase() === 'keep-alive')
+    )
+
+    if (this.statusCode >= 200) {
+      const bodyTimeout = request.bodyTimeout != null
+        ? request.bodyTimeout
+        : client[kBodyTimeout]
+      this.setTimeout(bodyTimeout, TIMEOUT_BODY)
+    } else if (this.timeout) {
+      // istanbul ignore else: only for jest
+      if (this.timeout.refresh) {
+        this.timeout.refresh()
+      }
+    }
+
+    if (request.method === 'CONNECT') {
+      assert(client[kRunning] === 1)
+      this.upgrade = true
+      return 2
+    }
+
+    if (upgrade) {
+      assert(client[kRunning] === 1)
+      this.upgrade = true
+      return 2
+    }
+
+    assert((this.headers.length & 1) === 0)
+    this.headers = []
+    this.headersSize = 0
+
+    if (this.shouldKeepAlive && client[kPipelining]) {
+      const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null
+
+      if (keepAliveTimeout != null) {
+        const timeout = Math.min(
+          keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
+          client[kKeepAliveMaxTimeout]
+        )
+        if (timeout <= 0) {
+          socket[kReset] = true
+        } else {
+          client[kKeepAliveTimeoutValue] = timeout
+        }
+      } else {
+        client[kKeepAliveTimeoutValue] = client[kKeepAliveDefaultTimeout]
+      }
+    } else {
+      // Stop more requests from being dispatched.
+      socket[kReset] = true
+    }
+
+    const pause = request.onHeaders(statusCode, headers, this.resume, statusText) === false
+
+    if (request.aborted) {
+      return -1
+    }
+
+    if (request.method === 'HEAD') {
+      return 1
+    }
+
+    if (statusCode < 200) {
+      return 1
+    }
+
+    if (socket[kBlocking]) {
+      socket[kBlocking] = false
+      client[kResume]()
+    }
+
+    return pause ? constants.ERROR.PAUSED : 0
+  }
+
+  onBody (buf) {
+    const { client, socket, statusCode, maxResponseSize } = this
+
+    if (socket.destroyed) {
+      return -1
+    }
+
+    const request = client[kQueue][client[kRunningIdx]]
+    assert(request)
+
+    assert(this.timeoutType === TIMEOUT_BODY)
+    if (this.timeout) {
+      // istanbul ignore else: only for jest
+      if (this.timeout.refresh) {
+        this.timeout.refresh()
+      }
+    }
+
+    assert(statusCode >= 200)
+
+    if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
+      util.destroy(socket, new ResponseExceededMaxSizeError())
+      return -1
+    }
+
+    this.bytesRead += buf.length
+
+    if (request.onData(buf) === false) {
+      return constants.ERROR.PAUSED
+    }
+  }
+
+  onMessageComplete () {
+    const { client, socket, statusCode, upgrade, headers, contentLength, bytesRead, shouldKeepAlive } = this
+
+    if (socket.destroyed && (!statusCode || shouldKeepAlive)) {
+      return -1
+    }
+
+    if (upgrade) {
+      return
+    }
+
+    assert(statusCode >= 100)
+    assert((this.headers.length & 1) === 0)
+
+    const request = client[kQueue][client[kRunningIdx]]
+    assert(request)
+
+    this.statusCode = null
+    this.statusText = ''
+    this.bytesRead = 0
+    this.contentLength = ''
+    this.keepAlive = ''
+    this.connection = ''
+
+    this.headers = []
+    this.headersSize = 0
+
+    if (statusCode < 200) {
+      return
+    }
+
+    /* istanbul ignore next: should be handled by llhttp? */
+    if (request.method !== 'HEAD' && contentLength && bytesRead !== parseInt(contentLength, 10)) {
+      util.destroy(socket, new ResponseContentLengthMismatchError())
+      return -1
+    }
+
+    request.onComplete(headers)
+
+    client[kQueue][client[kRunningIdx]++] = null
+
+    if (socket[kWriting]) {
+      assert(client[kRunning] === 0)
+      // Response completed before request.
+      util.destroy(socket, new InformationalError('reset'))
+      return constants.ERROR.PAUSED
+    } else if (!shouldKeepAlive) {
+      util.destroy(socket, new InformationalError('reset'))
+      return constants.ERROR.PAUSED
+    } else if (socket[kReset] && client[kRunning] === 0) {
+      // Destroy socket once all requests have completed.
+      // The request at the tail of the pipeline is the one
+      // that requested reset and no further requests should
+      // have been queued since then.
+      util.destroy(socket, new InformationalError('reset'))
+      return constants.ERROR.PAUSED
+    } else if (client[kPipelining] == null || client[kPipelining] === 1) {
+      // We must wait a full event loop cycle to reuse this socket to make sure
+      // that non-spec compliant servers are not closing the connection even if they
+      // said they won't.
+      setImmediate(() => client[kResume]())
+    } else {
+      client[kResume]()
+    }
+  }
+}
+
+function onParserTimeout (parser) {
+  const { socket, timeoutType, client, paused } = parser.deref()
+
+  /* istanbul ignore else */
+  if (timeoutType === TIMEOUT_HEADERS) {
+    if (!socket[kWriting] || socket.writableNeedDrain || client[kRunning] > 1) {
+      assert(!paused, 'cannot be paused while waiting for headers')
+      util.destroy(socket, new HeadersTimeoutError())
+    }
+  } else if (timeoutType === TIMEOUT_BODY) {
+    if (!paused) {
+      util.destroy(socket, new BodyTimeoutError())
+    }
+  } else if (timeoutType === TIMEOUT_KEEP_ALIVE) {
+    assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue])
+    util.destroy(socket, new InformationalError('socket idle timeout'))
+  }
+}
+
+async function connectH1 (client, socket) {
+  client[kSocket] = socket
+
+  if (!llhttpInstance) {
+    llhttpInstance = await llhttpPromise
+    llhttpPromise = null
+  }
+
+  socket[kNoRef] = false
+  socket[kWriting] = false
+  socket[kReset] = false
+  socket[kBlocking] = false
+  socket[kParser] = new Parser(client, socket, llhttpInstance)
+
+  addListener(socket, 'error', function (err) {
+    assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
+
+    const parser = this[kParser]
+
+    // On Mac OS, we get an ECONNRESET even if there is a full body to be forwarded
+    // to the user.
+    if (err.code === 'ECONNRESET' && parser.statusCode && !parser.shouldKeepAlive) {
+      // We treat all incoming data so for as a valid response.
+      parser.onMessageComplete()
+      return
+    }
+
+    this[kError] = err
+
+    this[kClient][kOnError](err)
+  })
+  addListener(socket, 'readable', function () {
+    const parser = this[kParser]
+
+    if (parser) {
+      parser.readMore()
+    }
+  })
+  addListener(socket, 'end', function () {
+    const parser = this[kParser]
+
+    if (parser.statusCode && !parser.shouldKeepAlive) {
+      // We treat all incoming data so far as a valid response.
+      parser.onMessageComplete()
+      return
+    }
+
+    util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
+  })
+  addListener(socket, 'close', function () {
+    const client = this[kClient]
+    const parser = this[kParser]
+
+    if (parser) {
+      if (!this[kError] && parser.statusCode && !parser.shouldKeepAlive) {
+        // We treat all incoming data so far as a valid response.
+        parser.onMessageComplete()
+      }
+
+      this[kParser].destroy()
+      this[kParser] = null
+    }
+
+    const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
+
+    client[kSocket] = null
+    client[kHTTPContext] = null // TODO (fix): This is hacky...
+
+    if (client.destroyed) {
+      assert(client[kPending] === 0)
+
+      // Fail entire queue.
+      const requests = client[kQueue].splice(client[kRunningIdx])
+      for (let i = 0; i < requests.length; i++) {
+        const request = requests[i]
+        util.errorRequest(client, request, err)
+      }
+    } else if (client[kRunning] > 0 && err.code !== 'UND_ERR_INFO') {
+      // Fail head of pipeline.
+      const request = client[kQueue][client[kRunningIdx]]
+      client[kQueue][client[kRunningIdx]++] = null
+
+      util.errorRequest(client, request, err)
+    }
+
+    client[kPendingIdx] = client[kRunningIdx]
+
+    assert(client[kRunning] === 0)
+
+    client.emit('disconnect', client[kUrl], [client], err)
+
+    client[kResume]()
+  })
+
+  let closed = false
+  socket.on('close', () => {
+    closed = true
+  })
+
+  return {
+    version: 'h1',
+    defaultPipelining: 1,
+    write (...args) {
+      return writeH1(client, ...args)
+    },
+    resume () {
+      resumeH1(client)
+    },
+    destroy (err, callback) {
+      if (closed) {
+        queueMicrotask(callback)
+      } else {
+        socket.destroy(err).on('close', callback)
+      }
+    },
+    get destroyed () {
+      return socket.destroyed
+    },
+    busy (request) {
+      if (socket[kWriting] || socket[kReset] || socket[kBlocking]) {
+        return true
+      }
+
+      if (request) {
+        if (client[kRunning] > 0 && !request.idempotent) {
+          // Non-idempotent request cannot be retried.
+          // Ensure that no other requests are inflight and
+          // could cause failure.
+          return true
+        }
+
+        if (client[kRunning] > 0 && (request.upgrade || request.method === 'CONNECT')) {
+          // Don't dispatch an upgrade until all preceding requests have completed.
+          // A misbehaving server might upgrade the connection before all pipelined
+          // request has completed.
+          return true
+        }
+
+        if (client[kRunning] > 0 && util.bodyLength(request.body) !== 0 &&
+          (util.isStream(request.body) || util.isAsyncIterable(request.body) || util.isFormDataLike(request.body))) {
+          // Request with stream or iterator body can error while other requests
+          // are inflight and indirectly error those as well.
+          // Ensure this doesn't happen by waiting for inflight
+          // to complete before dispatching.
+
+          // Request with stream or iterator body cannot be retried.
+          // Ensure that no other requests are inflight and
+          // could cause failure.
+          return true
+        }
+      }
+
+      return false
+    }
+  }
+}
+
+function resumeH1 (client) {
+  const socket = client[kSocket]
+
+  if (socket && !socket.destroyed) {
+    if (client[kSize] === 0) {
+      if (!socket[kNoRef] && socket.unref) {
+        socket.unref()
+        socket[kNoRef] = true
+      }
+    } else if (socket[kNoRef] && socket.ref) {
+      socket.ref()
+      socket[kNoRef] = false
+    }
+
+    if (client[kSize] === 0) {
+      if (socket[kParser].timeoutType !== TIMEOUT_KEEP_ALIVE) {
+        socket[kParser].setTimeout(client[kKeepAliveTimeoutValue], TIMEOUT_KEEP_ALIVE)
+      }
+    } else if (client[kRunning] > 0 && socket[kParser].statusCode < 200) {
+      if (socket[kParser].timeoutType !== TIMEOUT_HEADERS) {
+        const request = client[kQueue][client[kRunningIdx]]
+        const headersTimeout = request.headersTimeout != null
+          ? request.headersTimeout
+          : client[kHeadersTimeout]
+        socket[kParser].setTimeout(headersTimeout, TIMEOUT_HEADERS)
+      }
+    }
+  }
+}
+
+// https://www.rfc-editor.org/rfc/rfc7230#section-3.3.2
+function shouldSendContentLength (method) {
+  return method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS' && method !== 'TRACE' && method !== 'CONNECT'
+}
+
+function writeH1 (client, request) {
+  const { method, path, host, upgrade, blocking, reset } = request
+
+  let { body, headers, contentLength } = request
+
+  // https://tools.ietf.org/html/rfc7231#section-4.3.1
+  // https://tools.ietf.org/html/rfc7231#section-4.3.2
+  // https://tools.ietf.org/html/rfc7231#section-4.3.5
+
+  // Sending a payload body on a request that does not
+  // expect it can cause undefined behavior on some
+  // servers and corrupt connection state. Do not
+  // re-use the connection for further requests.
+
+  const expectsPayload = (
+    method === 'PUT' ||
+    method === 'POST' ||
+    method === 'PATCH' ||
+    method === 'QUERY' ||
+    method === 'PROPFIND' ||
+    method === 'PROPPATCH'
+  )
+
+  if (util.isFormDataLike(body)) {
+    if (!extractBody) {
+      extractBody = (__nccwpck_require__(23291).extractBody)
+    }
+
+    const [bodyStream, contentType] = extractBody(body)
+    if (request.contentType == null) {
+      headers.push('content-type', contentType)
+    }
+    body = bodyStream.stream
+    contentLength = bodyStream.length
+  } else if (util.isBlobLike(body) && request.contentType == null && body.type) {
+    headers.push('content-type', body.type)
+  }
+
+  if (body && typeof body.read === 'function') {
+    // Try to read EOF in order to get length.
+    body.read(0)
+  }
+
+  const bodyLength = util.bodyLength(body)
+
+  contentLength = bodyLength ?? contentLength
+
+  if (contentLength === null) {
+    contentLength = request.contentLength
+  }
+
+  if (contentLength === 0 && !expectsPayload) {
+    // https://tools.ietf.org/html/rfc7230#section-3.3.2
+    // A user agent SHOULD NOT send a Content-Length header field when
+    // the request message does not contain a payload body and the method
+    // semantics do not anticipate such a body.
+
+    contentLength = null
+  }
+
+  // https://github.com/nodejs/undici/issues/2046
+  // A user agent may send a Content-Length header with 0 value, this should be allowed.
+  if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength !== null && request.contentLength !== contentLength) {
+    if (client[kStrictContentLength]) {
+      util.errorRequest(client, request, new RequestContentLengthMismatchError())
+      return false
+    }
+
+    process.emitWarning(new RequestContentLengthMismatchError())
+  }
+
+  const socket = client[kSocket]
+
+  const abort = (err) => {
+    if (request.aborted || request.completed) {
+      return
+    }
+
+    util.errorRequest(client, request, err || new RequestAbortedError())
+
+    util.destroy(body)
+    util.destroy(socket, new InformationalError('aborted'))
+  }
+
+  try {
+    request.onConnect(abort)
+  } catch (err) {
+    util.errorRequest(client, request, err)
+  }
+
+  if (request.aborted) {
+    return false
+  }
+
+  if (method === 'HEAD') {
+    // https://github.com/mcollina/undici/issues/258
+    // Close after a HEAD request to interop with misbehaving servers
+    // that may send a body in the response.
+
+    socket[kReset] = true
+  }
+
+  if (upgrade || method === 'CONNECT') {
+    // On CONNECT or upgrade, block pipeline from dispatching further
+    // requests on this connection.
+
+    socket[kReset] = true
+  }
+
+  if (reset != null) {
+    socket[kReset] = reset
+  }
+
+  if (client[kMaxRequests] && socket[kCounter]++ >= client[kMaxRequests]) {
+    socket[kReset] = true
+  }
+
+  if (blocking) {
+    socket[kBlocking] = true
+  }
+
+  let header = `${method} ${path} HTTP/1.1\r\n`
+
+  if (typeof host === 'string') {
+    header += `host: ${host}\r\n`
+  } else {
+    header += client[kHostHeader]
+  }
+
+  if (upgrade) {
+    header += `connection: upgrade\r\nupgrade: ${upgrade}\r\n`
+  } else if (client[kPipelining] && !socket[kReset]) {
+    header += 'connection: keep-alive\r\n'
+  } else {
+    header += 'connection: close\r\n'
+  }
+
+  if (Array.isArray(headers)) {
+    for (let n = 0; n < headers.length; n += 2) {
+      const key = headers[n + 0]
+      const val = headers[n + 1]
+
+      if (Array.isArray(val)) {
+        for (let i = 0; i < val.length; i++) {
+          header += `${key}: ${val[i]}\r\n`
+        }
+      } else {
+        header += `${key}: ${val}\r\n`
+      }
+    }
+  }
+
+  if (channels.sendHeaders.hasSubscribers) {
+    channels.sendHeaders.publish({ request, headers: header, socket })
+  }
+
+  /* istanbul ignore else: assertion */
+  if (!body || bodyLength === 0) {
+    writeBuffer(abort, null, client, request, socket, contentLength, header, expectsPayload)
+  } else if (util.isBuffer(body)) {
+    writeBuffer(abort, body, client, request, socket, contentLength, header, expectsPayload)
+  } else if (util.isBlobLike(body)) {
+    if (typeof body.stream === 'function') {
+      writeIterable(abort, body.stream(), client, request, socket, contentLength, header, expectsPayload)
+    } else {
+      writeBlob(abort, body, client, request, socket, contentLength, header, expectsPayload)
+    }
+  } else if (util.isStream(body)) {
+    writeStream(abort, body, client, request, socket, contentLength, header, expectsPayload)
+  } else if (util.isIterable(body)) {
+    writeIterable(abort, body, client, request, socket, contentLength, header, expectsPayload)
+  } else {
+    assert(false)
+  }
+
+  return true
+}
+
+function writeStream (abort, body, client, request, socket, contentLength, header, expectsPayload) {
+  assert(contentLength !== 0 || client[kRunning] === 0, 'stream body cannot be pipelined')
+
+  let finished = false
+
+  const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header })
+
+  const onData = function (chunk) {
+    if (finished) {
+      return
+    }
+
+    try {
+      if (!writer.write(chunk) && this.pause) {
+        this.pause()
+      }
+    } catch (err) {
+      util.destroy(this, err)
+    }
+  }
+  const onDrain = function () {
+    if (finished) {
+      return
+    }
+
+    if (body.resume) {
+      body.resume()
+    }
+  }
+  const onClose = function () {
+    // 'close' might be emitted *before* 'error' for
+    // broken streams. Wait a tick to avoid this case.
+    queueMicrotask(() => {
+      // It's only safe to remove 'error' listener after
+      // 'close'.
+      body.removeListener('error', onFinished)
+    })
+
+    if (!finished) {
+      const err = new RequestAbortedError()
+      queueMicrotask(() => onFinished(err))
+    }
+  }
+  const onFinished = function (err) {
+    if (finished) {
+      return
+    }
+
+    finished = true
+
+    assert(socket.destroyed || (socket[kWriting] && client[kRunning] <= 1))
+
+    socket
+      .off('drain', onDrain)
+      .off('error', onFinished)
+
+    body
+      .removeListener('data', onData)
+      .removeListener('end', onFinished)
+      .removeListener('close', onClose)
+
+    if (!err) {
+      try {
+        writer.end()
+      } catch (er) {
+        err = er
+      }
+    }
+
+    writer.destroy(err)
+
+    if (err && (err.code !== 'UND_ERR_INFO' || err.message !== 'reset')) {
+      util.destroy(body, err)
+    } else {
+      util.destroy(body)
+    }
+  }
+
+  body
+    .on('data', onData)
+    .on('end', onFinished)
+    .on('error', onFinished)
+    .on('close', onClose)
+
+  if (body.resume) {
+    body.resume()
+  }
+
+  socket
+    .on('drain', onDrain)
+    .on('error', onFinished)
+
+  if (body.errorEmitted ?? body.errored) {
+    setImmediate(() => onFinished(body.errored))
+  } else if (body.endEmitted ?? body.readableEnded) {
+    setImmediate(() => onFinished(null))
+  }
+
+  if (body.closeEmitted ?? body.closed) {
+    setImmediate(onClose)
+  }
+}
+
+function writeBuffer (abort, body, client, request, socket, contentLength, header, expectsPayload) {
+  try {
+    if (!body) {
+      if (contentLength === 0) {
+        socket.write(`${header}content-length: 0\r\n\r\n`, 'latin1')
+      } else {
+        assert(contentLength === null, 'no body must not have content length')
+        socket.write(`${header}\r\n`, 'latin1')
+      }
+    } else if (util.isBuffer(body)) {
+      assert(contentLength === body.byteLength, 'buffer body must have content length')
+
+      socket.cork()
+      socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1')
+      socket.write(body)
+      socket.uncork()
+      request.onBodySent(body)
+
+      if (!expectsPayload && request.reset !== false) {
+        socket[kReset] = true
+      }
+    }
+    request.onRequestSent()
+
+    client[kResume]()
+  } catch (err) {
+    abort(err)
+  }
+}
+
+async function writeBlob (abort, body, client, request, socket, contentLength, header, expectsPayload) {
+  assert(contentLength === body.size, 'blob body must have content length')
+
+  try {
+    if (contentLength != null && contentLength !== body.size) {
+      throw new RequestContentLengthMismatchError()
+    }
+
+    const buffer = Buffer.from(await body.arrayBuffer())
+
+    socket.cork()
+    socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1')
+    socket.write(buffer)
+    socket.uncork()
+
+    request.onBodySent(buffer)
+    request.onRequestSent()
+
+    if (!expectsPayload && request.reset !== false) {
+      socket[kReset] = true
+    }
+
+    client[kResume]()
+  } catch (err) {
+    abort(err)
+  }
+}
+
+async function writeIterable (abort, body, client, request, socket, contentLength, header, expectsPayload) {
+  assert(contentLength !== 0 || client[kRunning] === 0, 'iterator body cannot be pipelined')
+
+  let callback = null
+  function onDrain () {
+    if (callback) {
+      const cb = callback
+      callback = null
+      cb()
+    }
+  }
+
+  const waitForDrain = () => new Promise((resolve, reject) => {
+    assert(callback === null)
+
+    if (socket[kError]) {
+      reject(socket[kError])
+    } else {
+      callback = resolve
+    }
+  })
+
+  socket
+    .on('close', onDrain)
+    .on('drain', onDrain)
+
+  const writer = new AsyncWriter({ abort, socket, request, contentLength, client, expectsPayload, header })
+  try {
+    // It's up to the user to somehow abort the async iterable.
+    for await (const chunk of body) {
+      if (socket[kError]) {
+        throw socket[kError]
+      }
+
+      if (!writer.write(chunk)) {
+        await waitForDrain()
+      }
+    }
+
+    writer.end()
+  } catch (err) {
+    writer.destroy(err)
+  } finally {
+    socket
+      .off('close', onDrain)
+      .off('drain', onDrain)
+  }
+}
+
+class AsyncWriter {
+  constructor ({ abort, socket, request, contentLength, client, expectsPayload, header }) {
+    this.socket = socket
+    this.request = request
+    this.contentLength = contentLength
+    this.client = client
+    this.bytesWritten = 0
+    this.expectsPayload = expectsPayload
+    this.header = header
+    this.abort = abort
+
+    socket[kWriting] = true
+  }
+
+  write (chunk) {
+    const { socket, request, contentLength, client, bytesWritten, expectsPayload, header } = this
+
+    if (socket[kError]) {
+      throw socket[kError]
+    }
+
+    if (socket.destroyed) {
+      return false
+    }
+
+    const len = Buffer.byteLength(chunk)
+    if (!len) {
+      return true
+    }
+
+    // We should defer writing chunks.
+    if (contentLength !== null && bytesWritten + len > contentLength) {
+      if (client[kStrictContentLength]) {
+        throw new RequestContentLengthMismatchError()
+      }
+
+      process.emitWarning(new RequestContentLengthMismatchError())
+    }
+
+    socket.cork()
+
+    if (bytesWritten === 0) {
+      if (!expectsPayload && request.reset !== false) {
+        socket[kReset] = true
+      }
+
+      if (contentLength === null) {
+        socket.write(`${header}transfer-encoding: chunked\r\n`, 'latin1')
+      } else {
+        socket.write(`${header}content-length: ${contentLength}\r\n\r\n`, 'latin1')
+      }
+    }
+
+    if (contentLength === null) {
+      socket.write(`\r\n${len.toString(16)}\r\n`, 'latin1')
+    }
+
+    this.bytesWritten += len
+
+    const ret = socket.write(chunk)
+
+    socket.uncork()
+
+    request.onBodySent(chunk)
+
+    if (!ret) {
+      if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
+        // istanbul ignore else: only for jest
+        if (socket[kParser].timeout.refresh) {
+          socket[kParser].timeout.refresh()
+        }
+      }
+    }
+
+    return ret
+  }
+
+  end () {
+    const { socket, contentLength, client, bytesWritten, expectsPayload, header, request } = this
+    request.onRequestSent()
+
+    socket[kWriting] = false
+
+    if (socket[kError]) {
+      throw socket[kError]
+    }
+
+    if (socket.destroyed) {
+      return
+    }
+
+    if (bytesWritten === 0) {
+      if (expectsPayload) {
+        // https://tools.ietf.org/html/rfc7230#section-3.3.2
+        // A user agent SHOULD send a Content-Length in a request message when
+        // no Transfer-Encoding is sent and the request method defines a meaning
+        // for an enclosed payload body.
+
+        socket.write(`${header}content-length: 0\r\n\r\n`, 'latin1')
+      } else {
+        socket.write(`${header}\r\n`, 'latin1')
+      }
+    } else if (contentLength === null) {
+      socket.write('\r\n0\r\n\r\n', 'latin1')
+    }
+
+    if (contentLength !== null && bytesWritten !== contentLength) {
+      if (client[kStrictContentLength]) {
+        throw new RequestContentLengthMismatchError()
+      } else {
+        process.emitWarning(new RequestContentLengthMismatchError())
+      }
+    }
+
+    if (socket[kParser].timeout && socket[kParser].timeoutType === TIMEOUT_HEADERS) {
+      // istanbul ignore else: only for jest
+      if (socket[kParser].timeout.refresh) {
+        socket[kParser].timeout.refresh()
+      }
+    }
+
+    client[kResume]()
+  }
+
+  destroy (err) {
+    const { socket, client, abort } = this
+
+    socket[kWriting] = false
+
+    if (err) {
+      assert(client[kRunning] <= 1, 'pipeline should only contain this request')
+      abort(err)
+    }
+  }
+}
+
+module.exports = connectH1
+
+
+/***/ }),
+
+/***/ 77162:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+const { pipeline } = __nccwpck_require__(84492)
+const util = __nccwpck_require__(94407)
+const {
+  RequestContentLengthMismatchError,
+  RequestAbortedError,
+  SocketError,
+  InformationalError
+} = __nccwpck_require__(22174)
+const {
+  kUrl,
+  kReset,
+  kClient,
+  kRunning,
+  kPending,
+  kQueue,
+  kPendingIdx,
+  kRunningIdx,
+  kError,
+  kSocket,
+  kStrictContentLength,
+  kOnError,
+  kMaxConcurrentStreams,
+  kHTTP2Session,
+  kResume,
+  kSize,
+  kHTTPContext
+} = __nccwpck_require__(5392)
+
+const kOpenStreams = Symbol('open streams')
+
+let extractBody
+
+// Experimental
+let h2ExperimentalWarned = false
+
+/** @type {import('http2')} */
+let http2
+try {
+  http2 = __nccwpck_require__(42725)
+} catch {
+  // @ts-ignore
+  http2 = { constants: {} }
+}
+
+const {
+  constants: {
+    HTTP2_HEADER_AUTHORITY,
+    HTTP2_HEADER_METHOD,
+    HTTP2_HEADER_PATH,
+    HTTP2_HEADER_SCHEME,
+    HTTP2_HEADER_CONTENT_LENGTH,
+    HTTP2_HEADER_EXPECT,
+    HTTP2_HEADER_STATUS
+  }
+} = http2
+
+function parseH2Headers (headers) {
+  const result = []
+
+  for (const [name, value] of Object.entries(headers)) {
+    // h2 may concat the header value by array
+    // e.g. Set-Cookie
+    if (Array.isArray(value)) {
+      for (const subvalue of value) {
+        // we need to provide each header value of header name
+        // because the headers handler expect name-value pair
+        result.push(Buffer.from(name), Buffer.from(subvalue))
+      }
+    } else {
+      result.push(Buffer.from(name), Buffer.from(value))
+    }
+  }
+
+  return result
+}
+
+async function connectH2 (client, socket) {
+  client[kSocket] = socket
+
+  if (!h2ExperimentalWarned) {
+    h2ExperimentalWarned = true
+    process.emitWarning('H2 support is experimental, expect them to change at any time.', {
+      code: 'UNDICI-H2'
+    })
+  }
+
+  const session = http2.connect(client[kUrl], {
+    createConnection: () => socket,
+    peerMaxConcurrentStreams: client[kMaxConcurrentStreams]
+  })
+
+  session[kOpenStreams] = 0
+  session[kClient] = client
+  session[kSocket] = socket
+
+  util.addListener(session, 'error', onHttp2SessionError)
+  util.addListener(session, 'frameError', onHttp2FrameError)
+  util.addListener(session, 'end', onHttp2SessionEnd)
+  util.addListener(session, 'goaway', onHTTP2GoAway)
+  util.addListener(session, 'close', function () {
+    const { [kClient]: client } = this
+    const { [kSocket]: socket } = client
+
+    const err = this[kSocket][kError] || this[kError] || new SocketError('closed', util.getSocketInfo(socket))
+
+    client[kHTTP2Session] = null
+
+    if (client.destroyed) {
+      assert(client[kPending] === 0)
+
+      // Fail entire queue.
+      const requests = client[kQueue].splice(client[kRunningIdx])
+      for (let i = 0; i < requests.length; i++) {
+        const request = requests[i]
+        util.errorRequest(client, request, err)
+      }
+    }
+  })
+
+  session.unref()
+
+  client[kHTTP2Session] = session
+  socket[kHTTP2Session] = session
+
+  util.addListener(socket, 'error', function (err) {
+    assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
+
+    this[kError] = err
+
+    this[kClient][kOnError](err)
+  })
+
+  util.addListener(socket, 'end', function () {
+    util.destroy(this, new SocketError('other side closed', util.getSocketInfo(this)))
+  })
+
+  util.addListener(socket, 'close', function () {
+    const err = this[kError] || new SocketError('closed', util.getSocketInfo(this))
+
+    client[kSocket] = null
+
+    if (this[kHTTP2Session] != null) {
+      this[kHTTP2Session].destroy(err)
+    }
+
+    client[kPendingIdx] = client[kRunningIdx]
+
+    assert(client[kRunning] === 0)
+
+    client.emit('disconnect', client[kUrl], [client], err)
+
+    client[kResume]()
+  })
+
+  let closed = false
+  socket.on('close', () => {
+    closed = true
+  })
+
+  return {
+    version: 'h2',
+    defaultPipelining: Infinity,
+    write (...args) {
+      return writeH2(client, ...args)
+    },
+    resume () {
+      resumeH2(client)
+    },
+    destroy (err, callback) {
+      if (closed) {
+        queueMicrotask(callback)
+      } else {
+        // Destroying the socket will trigger the session close
+        socket.destroy(err).on('close', callback)
+      }
+    },
+    get destroyed () {
+      return socket.destroyed
+    },
+    busy () {
+      return false
+    }
+  }
+}
+
+function resumeH2 (client) {
+  const socket = client[kSocket]
+
+  if (socket?.destroyed === false) {
+    if (client[kSize] === 0 && client[kMaxConcurrentStreams] === 0) {
+      socket.unref()
+      client[kHTTP2Session].unref()
+    } else {
+      socket.ref()
+      client[kHTTP2Session].ref()
+    }
+  }
+}
+
+function onHttp2SessionError (err) {
+  assert(err.code !== 'ERR_TLS_CERT_ALTNAME_INVALID')
+
+  this[kSocket][kError] = err
+  this[kClient][kOnError](err)
+}
+
+function onHttp2FrameError (type, code, id) {
+  if (id === 0) {
+    const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`)
+    this[kSocket][kError] = err
+    this[kClient][kOnError](err)
+  }
+}
+
+function onHttp2SessionEnd () {
+  const err = new SocketError('other side closed', util.getSocketInfo(this[kSocket]))
+  this.destroy(err)
+  util.destroy(this[kSocket], err)
+}
+
+/**
+ * This is the root cause of #3011
+ * We need to handle GOAWAY frames properly, and trigger the session close
+ * along with the socket right away
+ */
+function onHTTP2GoAway (code) {
+  // We cannot recover, so best to close the session and the socket
+  const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${code}`, util.getSocketInfo(this))
+  const client = this[kClient]
+
+  client[kSocket] = null
+  client[kHTTPContext] = null
+
+  if (this[kHTTP2Session] != null) {
+    this[kHTTP2Session].destroy(err)
+    this[kHTTP2Session] = null
+  }
+
+  util.destroy(this[kSocket], err)
+
+  // Fail head of pipeline.
+  if (client[kRunningIdx] < client[kQueue].length) {
+    const request = client[kQueue][client[kRunningIdx]]
+    client[kQueue][client[kRunningIdx]++] = null
+    util.errorRequest(client, request, err)
+    client[kPendingIdx] = client[kRunningIdx]
+  }
+
+  assert(client[kRunning] === 0)
+
+  client.emit('disconnect', client[kUrl], [client], err)
+
+  client[kResume]()
+}
+
+// https://www.rfc-editor.org/rfc/rfc7230#section-3.3.2
+function shouldSendContentLength (method) {
+  return method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS' && method !== 'TRACE' && method !== 'CONNECT'
+}
+
+function writeH2 (client, request) {
+  const session = client[kHTTP2Session]
+  const { method, path, host, upgrade, expectContinue, signal, headers: reqHeaders } = request
+  let { body } = request
+
+  if (upgrade) {
+    util.errorRequest(client, request, new Error('Upgrade not supported for H2'))
+    return false
+  }
+
+  const headers = {}
+  for (let n = 0; n < reqHeaders.length; n += 2) {
+    const key = reqHeaders[n + 0]
+    const val = reqHeaders[n + 1]
+
+    if (Array.isArray(val)) {
+      for (let i = 0; i < val.length; i++) {
+        if (headers[key]) {
+          headers[key] += `,${val[i]}`
+        } else {
+          headers[key] = val[i]
+        }
+      }
+    } else {
+      headers[key] = val
+    }
+  }
+
+  /** @type {import('node:http2').ClientHttp2Stream} */
+  let stream
+
+  const { hostname, port } = client[kUrl]
+
+  headers[HTTP2_HEADER_AUTHORITY] = host || `${hostname}${port ? `:${port}` : ''}`
+  headers[HTTP2_HEADER_METHOD] = method
+
+  const abort = (err) => {
+    if (request.aborted || request.completed) {
+      return
+    }
+
+    err = err || new RequestAbortedError()
+
+    util.errorRequest(client, request, err)
+
+    if (stream != null) {
+      util.destroy(stream, err)
+    }
+
+    // We do not destroy the socket as we can continue using the session
+    // the stream get's destroyed and the session remains to create new streams
+    util.destroy(body, err)
+    client[kQueue][client[kRunningIdx]++] = null
+    client[kResume]()
+  }
+
+  try {
+    // We are already connected, streams are pending.
+    // We can call on connect, and wait for abort
+    request.onConnect(abort)
+  } catch (err) {
+    util.errorRequest(client, request, err)
+  }
+
+  if (request.aborted) {
+    return false
+  }
+
+  if (method === 'CONNECT') {
+    session.ref()
+    // We are already connected, streams are pending, first request
+    // will create a new stream. We trigger a request to create the stream and wait until
+    // `ready` event is triggered
+    // We disabled endStream to allow the user to write to the stream
+    stream = session.request(headers, { endStream: false, signal })
+
+    if (stream.id && !stream.pending) {
+      request.onUpgrade(null, null, stream)
+      ++session[kOpenStreams]
+      client[kQueue][client[kRunningIdx]++] = null
+    } else {
+      stream.once('ready', () => {
+        request.onUpgrade(null, null, stream)
+        ++session[kOpenStreams]
+        client[kQueue][client[kRunningIdx]++] = null
+      })
+    }
+
+    stream.once('close', () => {
+      session[kOpenStreams] -= 1
+      if (session[kOpenStreams] === 0) session.unref()
+    })
+
+    return true
+  }
+
+  // https://tools.ietf.org/html/rfc7540#section-8.3
+  // :path and :scheme headers must be omitted when sending CONNECT
+
+  headers[HTTP2_HEADER_PATH] = path
+  headers[HTTP2_HEADER_SCHEME] = 'https'
+
+  // https://tools.ietf.org/html/rfc7231#section-4.3.1
+  // https://tools.ietf.org/html/rfc7231#section-4.3.2
+  // https://tools.ietf.org/html/rfc7231#section-4.3.5
+
+  // Sending a payload body on a request that does not
+  // expect it can cause undefined behavior on some
+  // servers and corrupt connection state. Do not
+  // re-use the connection for further requests.
+
+  const expectsPayload = (
+    method === 'PUT' ||
+    method === 'POST' ||
+    method === 'PATCH'
+  )
+
+  if (body && typeof body.read === 'function') {
+    // Try to read EOF in order to get length.
+    body.read(0)
+  }
+
+  let contentLength = util.bodyLength(body)
+
+  if (util.isFormDataLike(body)) {
+    extractBody ??= (__nccwpck_require__(23291).extractBody)
+
+    const [bodyStream, contentType] = extractBody(body)
+    headers['content-type'] = contentType
+
+    body = bodyStream.stream
+    contentLength = bodyStream.length
+  }
+
+  if (contentLength == null) {
+    contentLength = request.contentLength
+  }
+
+  if (contentLength === 0 || !expectsPayload) {
+    // https://tools.ietf.org/html/rfc7230#section-3.3.2
+    // A user agent SHOULD NOT send a Content-Length header field when
+    // the request message does not contain a payload body and the method
+    // semantics do not anticipate such a body.
+
+    contentLength = null
+  }
+
+  // https://github.com/nodejs/undici/issues/2046
+  // A user agent may send a Content-Length header with 0 value, this should be allowed.
+  if (shouldSendContentLength(method) && contentLength > 0 && request.contentLength != null && request.contentLength !== contentLength) {
+    if (client[kStrictContentLength]) {
+      util.errorRequest(client, request, new RequestContentLengthMismatchError())
+      return false
+    }
+
+    process.emitWarning(new RequestContentLengthMismatchError())
+  }
+
+  if (contentLength != null) {
+    assert(body, 'no body must not have content length')
+    headers[HTTP2_HEADER_CONTENT_LENGTH] = `${contentLength}`
+  }
+
+  session.ref()
+
+  const shouldEndStream = method === 'GET' || method === 'HEAD' || body === null
+  if (expectContinue) {
+    headers[HTTP2_HEADER_EXPECT] = '100-continue'
+    stream = session.request(headers, { endStream: shouldEndStream, signal })
+
+    stream.once('continue', writeBodyH2)
+  } else {
+    stream = session.request(headers, {
+      endStream: shouldEndStream,
+      signal
+    })
+    writeBodyH2()
+  }
+
+  // Increment counter as we have new streams open
+  ++session[kOpenStreams]
+
+  stream.once('response', headers => {
+    const { [HTTP2_HEADER_STATUS]: statusCode, ...realHeaders } = headers
+    request.onResponseStarted()
+
+    // Due to the stream nature, it is possible we face a race condition
+    // where the stream has been assigned, but the request has been aborted
+    // the request remains in-flight and headers hasn't been received yet
+    // for those scenarios, best effort is to destroy the stream immediately
+    // as there's no value to keep it open.
+    if (request.aborted) {
+      const err = new RequestAbortedError()
+      util.errorRequest(client, request, err)
+      util.destroy(stream, err)
+      return
+    }
+
+    if (request.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream.resume.bind(stream), '') === false) {
+      stream.pause()
+    }
+
+    stream.on('data', (chunk) => {
+      if (request.onData(chunk) === false) {
+        stream.pause()
+      }
+    })
+  })
+
+  stream.once('end', () => {
+    // When state is null, it means we haven't consumed body and the stream still do not have
+    // a state.
+    // Present specially when using pipeline or stream
+    if (stream.state?.state == null || stream.state.state < 6) {
+      request.onComplete([])
+    }
+
+    if (session[kOpenStreams] === 0) {
+      // Stream is closed or half-closed-remote (6), decrement counter and cleanup
+      // It does not have sense to continue working with the stream as we do not
+      // have yet RST_STREAM support on client-side
+
+      session.unref()
+    }
+
+    abort(new InformationalError('HTTP/2: stream half-closed (remote)'))
+    client[kQueue][client[kRunningIdx]++] = null
+    client[kPendingIdx] = client[kRunningIdx]
+    client[kResume]()
+  })
+
+  stream.once('close', () => {
+    session[kOpenStreams] -= 1
+    if (session[kOpenStreams] === 0) {
+      session.unref()
+    }
+  })
+
+  stream.once('error', function (err) {
+    abort(err)
+  })
+
+  stream.once('frameError', (type, code) => {
+    abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`))
+  })
+
+  // stream.on('aborted', () => {
+  //   // TODO(HTTP/2): Support aborted
+  // })
+
+  // stream.on('timeout', () => {
+  //   // TODO(HTTP/2): Support timeout
+  // })
+
+  // stream.on('push', headers => {
+  //   // TODO(HTTP/2): Support push
+  // })
+
+  // stream.on('trailers', headers => {
+  //   // TODO(HTTP/2): Support trailers
+  // })
+
+  return true
+
+  function writeBodyH2 () {
+    /* istanbul ignore else: assertion */
+    if (!body || contentLength === 0) {
+      writeBuffer(
+        abort,
+        stream,
+        null,
+        client,
+        request,
+        client[kSocket],
+        contentLength,
+        expectsPayload
+      )
+    } else if (util.isBuffer(body)) {
+      writeBuffer(
+        abort,
+        stream,
+        body,
+        client,
+        request,
+        client[kSocket],
+        contentLength,
+        expectsPayload
+      )
+    } else if (util.isBlobLike(body)) {
+      if (typeof body.stream === 'function') {
+        writeIterable(
+          abort,
+          stream,
+          body.stream(),
+          client,
+          request,
+          client[kSocket],
+          contentLength,
+          expectsPayload
+        )
+      } else {
+        writeBlob(
+          abort,
+          stream,
+          body,
+          client,
+          request,
+          client[kSocket],
+          contentLength,
+          expectsPayload
+        )
+      }
+    } else if (util.isStream(body)) {
+      writeStream(
+        abort,
+        client[kSocket],
+        expectsPayload,
+        stream,
+        body,
+        client,
+        request,
+        contentLength
+      )
+    } else if (util.isIterable(body)) {
+      writeIterable(
+        abort,
+        stream,
+        body,
+        client,
+        request,
+        client[kSocket],
+        contentLength,
+        expectsPayload
+      )
+    } else {
+      assert(false)
+    }
+  }
+}
+
+function writeBuffer (abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
+  try {
+    if (body != null && util.isBuffer(body)) {
+      assert(contentLength === body.byteLength, 'buffer body must have content length')
+      h2stream.cork()
+      h2stream.write(body)
+      h2stream.uncork()
+      h2stream.end()
+
+      request.onBodySent(body)
+    }
+
+    if (!expectsPayload) {
+      socket[kReset] = true
+    }
+
+    request.onRequestSent()
+    client[kResume]()
+  } catch (error) {
+    abort(error)
+  }
+}
+
+function writeStream (abort, socket, expectsPayload, h2stream, body, client, request, contentLength) {
+  assert(contentLength !== 0 || client[kRunning] === 0, 'stream body cannot be pipelined')
+
+  // For HTTP/2, is enough to pipe the stream
+  const pipe = pipeline(
+    body,
+    h2stream,
+    (err) => {
+      if (err) {
+        util.destroy(pipe, err)
+        abort(err)
+      } else {
+        util.removeAllListeners(pipe)
+        request.onRequestSent()
+
+        if (!expectsPayload) {
+          socket[kReset] = true
+        }
+
+        client[kResume]()
+      }
+    }
+  )
+
+  util.addListener(pipe, 'data', onPipeData)
+
+  function onPipeData (chunk) {
+    request.onBodySent(chunk)
+  }
+}
+
+async function writeBlob (abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
+  assert(contentLength === body.size, 'blob body must have content length')
+
+  try {
+    if (contentLength != null && contentLength !== body.size) {
+      throw new RequestContentLengthMismatchError()
+    }
+
+    const buffer = Buffer.from(await body.arrayBuffer())
+
+    h2stream.cork()
+    h2stream.write(buffer)
+    h2stream.uncork()
+    h2stream.end()
+
+    request.onBodySent(buffer)
+    request.onRequestSent()
+
+    if (!expectsPayload) {
+      socket[kReset] = true
+    }
+
+    client[kResume]()
+  } catch (err) {
+    abort(err)
+  }
+}
+
+async function writeIterable (abort, h2stream, body, client, request, socket, contentLength, expectsPayload) {
+  assert(contentLength !== 0 || client[kRunning] === 0, 'iterator body cannot be pipelined')
+
+  let callback = null
+  function onDrain () {
+    if (callback) {
+      const cb = callback
+      callback = null
+      cb()
+    }
+  }
+
+  const waitForDrain = () => new Promise((resolve, reject) => {
+    assert(callback === null)
+
+    if (socket[kError]) {
+      reject(socket[kError])
+    } else {
+      callback = resolve
+    }
+  })
+
+  h2stream
+    .on('close', onDrain)
+    .on('drain', onDrain)
+
+  try {
+    // It's up to the user to somehow abort the async iterable.
+    for await (const chunk of body) {
+      if (socket[kError]) {
+        throw socket[kError]
+      }
+
+      const res = h2stream.write(chunk)
+      request.onBodySent(chunk)
+      if (!res) {
+        await waitForDrain()
+      }
+    }
+
+    h2stream.end()
+
+    request.onRequestSent()
+
+    if (!expectsPayload) {
+      socket[kReset] = true
+    }
+
+    client[kResume]()
+  } catch (err) {
+    abort(err)
+  } finally {
+    h2stream
+      .off('close', onDrain)
+      .off('drain', onDrain)
+  }
+}
+
+module.exports = connectH2
+
+
+/***/ }),
+
+/***/ 6655:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// @ts-check
+
+
+
+const assert = __nccwpck_require__(98061)
+const net = __nccwpck_require__(87503)
+const http = __nccwpck_require__(88849)
+const util = __nccwpck_require__(94407)
+const { channels } = __nccwpck_require__(8627)
+const Request = __nccwpck_require__(25829)
+const DispatcherBase = __nccwpck_require__(68838)
+const {
+  InvalidArgumentError,
+  InformationalError,
+  ClientDestroyedError
+} = __nccwpck_require__(22174)
+const buildConnector = __nccwpck_require__(20123)
+const {
+  kUrl,
+  kServerName,
+  kClient,
+  kBusy,
+  kConnect,
+  kResuming,
+  kRunning,
+  kPending,
+  kSize,
+  kQueue,
+  kConnected,
+  kConnecting,
+  kNeedDrain,
+  kKeepAliveDefaultTimeout,
+  kHostHeader,
+  kPendingIdx,
+  kRunningIdx,
+  kError,
+  kPipelining,
+  kKeepAliveTimeoutValue,
+  kMaxHeadersSize,
+  kKeepAliveMaxTimeout,
+  kKeepAliveTimeoutThreshold,
+  kHeadersTimeout,
+  kBodyTimeout,
+  kStrictContentLength,
+  kConnector,
+  kMaxRedirections,
+  kMaxRequests,
+  kCounter,
+  kClose,
+  kDestroy,
+  kDispatch,
+  kInterceptors,
+  kLocalAddress,
+  kMaxResponseSize,
+  kOnError,
+  kHTTPContext,
+  kMaxConcurrentStreams,
+  kResume
+} = __nccwpck_require__(5392)
+const connectH1 = __nccwpck_require__(73619)
+const connectH2 = __nccwpck_require__(77162)
+let deprecatedInterceptorWarned = false
+
+const kClosedResolve = Symbol('kClosedResolve')
+
+const noop = () => {}
+
+function getPipelining (client) {
+  return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1
+}
+
+/**
+ * @type {import('../../types/client.js').default}
+ */
+class Client extends DispatcherBase {
+  /**
+   *
+   * @param {string|URL} url
+   * @param {import('../../types/client.js').Client.Options} options
+   */
+  constructor (url, {
+    interceptors,
+    maxHeaderSize,
+    headersTimeout,
+    socketTimeout,
+    requestTimeout,
+    connectTimeout,
+    bodyTimeout,
+    idleTimeout,
+    keepAlive,
+    keepAliveTimeout,
+    maxKeepAliveTimeout,
+    keepAliveMaxTimeout,
+    keepAliveTimeoutThreshold,
+    socketPath,
+    pipelining,
+    tls,
+    strictContentLength,
+    maxCachedSessions,
+    maxRedirections,
+    connect,
+    maxRequestsPerClient,
+    localAddress,
+    maxResponseSize,
+    autoSelectFamily,
+    autoSelectFamilyAttemptTimeout,
+    // h2
+    maxConcurrentStreams,
+    allowH2
+  } = {}) {
+    super()
+
+    if (keepAlive !== undefined) {
+      throw new InvalidArgumentError('unsupported keepAlive, use pipelining=0 instead')
+    }
+
+    if (socketTimeout !== undefined) {
+      throw new InvalidArgumentError('unsupported socketTimeout, use headersTimeout & bodyTimeout instead')
+    }
+
+    if (requestTimeout !== undefined) {
+      throw new InvalidArgumentError('unsupported requestTimeout, use headersTimeout & bodyTimeout instead')
+    }
+
+    if (idleTimeout !== undefined) {
+      throw new InvalidArgumentError('unsupported idleTimeout, use keepAliveTimeout instead')
+    }
+
+    if (maxKeepAliveTimeout !== undefined) {
+      throw new InvalidArgumentError('unsupported maxKeepAliveTimeout, use keepAliveMaxTimeout instead')
+    }
+
+    if (maxHeaderSize != null && !Number.isFinite(maxHeaderSize)) {
+      throw new InvalidArgumentError('invalid maxHeaderSize')
+    }
+
+    if (socketPath != null && typeof socketPath !== 'string') {
+      throw new InvalidArgumentError('invalid socketPath')
+    }
+
+    if (connectTimeout != null && (!Number.isFinite(connectTimeout) || connectTimeout < 0)) {
+      throw new InvalidArgumentError('invalid connectTimeout')
+    }
+
+    if (keepAliveTimeout != null && (!Number.isFinite(keepAliveTimeout) || keepAliveTimeout <= 0)) {
+      throw new InvalidArgumentError('invalid keepAliveTimeout')
+    }
+
+    if (keepAliveMaxTimeout != null && (!Number.isFinite(keepAliveMaxTimeout) || keepAliveMaxTimeout <= 0)) {
+      throw new InvalidArgumentError('invalid keepAliveMaxTimeout')
+    }
+
+    if (keepAliveTimeoutThreshold != null && !Number.isFinite(keepAliveTimeoutThreshold)) {
+      throw new InvalidArgumentError('invalid keepAliveTimeoutThreshold')
+    }
+
+    if (headersTimeout != null && (!Number.isInteger(headersTimeout) || headersTimeout < 0)) {
+      throw new InvalidArgumentError('headersTimeout must be a positive integer or zero')
+    }
+
+    if (bodyTimeout != null && (!Number.isInteger(bodyTimeout) || bodyTimeout < 0)) {
+      throw new InvalidArgumentError('bodyTimeout must be a positive integer or zero')
+    }
+
+    if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
+      throw new InvalidArgumentError('connect must be a function or an object')
+    }
+
+    if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
+      throw new InvalidArgumentError('maxRedirections must be a positive number')
+    }
+
+    if (maxRequestsPerClient != null && (!Number.isInteger(maxRequestsPerClient) || maxRequestsPerClient < 0)) {
+      throw new InvalidArgumentError('maxRequestsPerClient must be a positive number')
+    }
+
+    if (localAddress != null && (typeof localAddress !== 'string' || net.isIP(localAddress) === 0)) {
+      throw new InvalidArgumentError('localAddress must be valid string IP address')
+    }
+
+    if (maxResponseSize != null && (!Number.isInteger(maxResponseSize) || maxResponseSize < -1)) {
+      throw new InvalidArgumentError('maxResponseSize must be a positive number')
+    }
+
+    if (
+      autoSelectFamilyAttemptTimeout != null &&
+      (!Number.isInteger(autoSelectFamilyAttemptTimeout) || autoSelectFamilyAttemptTimeout < -1)
+    ) {
+      throw new InvalidArgumentError('autoSelectFamilyAttemptTimeout must be a positive number')
+    }
+
+    // h2
+    if (allowH2 != null && typeof allowH2 !== 'boolean') {
+      throw new InvalidArgumentError('allowH2 must be a valid boolean value')
+    }
+
+    if (maxConcurrentStreams != null && (typeof maxConcurrentStreams !== 'number' || maxConcurrentStreams < 1)) {
+      throw new InvalidArgumentError('maxConcurrentStreams must be a positive integer, greater than 0')
+    }
+
+    if (typeof connect !== 'function') {
+      connect = buildConnector({
+        ...tls,
+        maxCachedSessions,
+        allowH2,
+        socketPath,
+        timeout: connectTimeout,
+        ...(autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
+        ...connect
+      })
+    }
+
+    if (interceptors?.Client && Array.isArray(interceptors.Client)) {
+      this[kInterceptors] = interceptors.Client
+      if (!deprecatedInterceptorWarned) {
+        deprecatedInterceptorWarned = true
+        process.emitWarning('Client.Options#interceptor is deprecated. Use Dispatcher#compose instead.', {
+          code: 'UNDICI-CLIENT-INTERCEPTOR-DEPRECATED'
+        })
+      }
+    } else {
+      this[kInterceptors] = [createRedirectInterceptor({ maxRedirections })]
+    }
+
+    this[kUrl] = util.parseOrigin(url)
+    this[kConnector] = connect
+    this[kPipelining] = pipelining != null ? pipelining : 1
+    this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize
+    this[kKeepAliveDefaultTimeout] = keepAliveTimeout == null ? 4e3 : keepAliveTimeout
+    this[kKeepAliveMaxTimeout] = keepAliveMaxTimeout == null ? 600e3 : keepAliveMaxTimeout
+    this[kKeepAliveTimeoutThreshold] = keepAliveTimeoutThreshold == null ? 2e3 : keepAliveTimeoutThreshold
+    this[kKeepAliveTimeoutValue] = this[kKeepAliveDefaultTimeout]
+    this[kServerName] = null
+    this[kLocalAddress] = localAddress != null ? localAddress : null
+    this[kResuming] = 0 // 0, idle, 1, scheduled, 2 resuming
+    this[kNeedDrain] = 0 // 0, idle, 1, scheduled, 2 resuming
+    this[kHostHeader] = `host: ${this[kUrl].hostname}${this[kUrl].port ? `:${this[kUrl].port}` : ''}\r\n`
+    this[kBodyTimeout] = bodyTimeout != null ? bodyTimeout : 300e3
+    this[kHeadersTimeout] = headersTimeout != null ? headersTimeout : 300e3
+    this[kStrictContentLength] = strictContentLength == null ? true : strictContentLength
+    this[kMaxRedirections] = maxRedirections
+    this[kMaxRequests] = maxRequestsPerClient
+    this[kClosedResolve] = null
+    this[kMaxResponseSize] = maxResponseSize > -1 ? maxResponseSize : -1
+    this[kMaxConcurrentStreams] = maxConcurrentStreams != null ? maxConcurrentStreams : 100 // Max peerConcurrentStreams for a Node h2 server
+    this[kHTTPContext] = null
+
+    // kQueue is built up of 3 sections separated by
+    // the kRunningIdx and kPendingIdx indices.
+    // |   complete   |   running   |   pending   |
+    //                ^ kRunningIdx ^ kPendingIdx ^ kQueue.length
+    // kRunningIdx points to the first running element.
+    // kPendingIdx points to the first pending element.
+    // This implements a fast queue with an amortized
+    // time of O(1).
+
+    this[kQueue] = []
+    this[kRunningIdx] = 0
+    this[kPendingIdx] = 0
+
+    this[kResume] = (sync) => resume(this, sync)
+    this[kOnError] = (err) => onError(this, err)
+  }
+
+  get pipelining () {
+    return this[kPipelining]
+  }
+
+  set pipelining (value) {
+    this[kPipelining] = value
+    this[kResume](true)
+  }
+
+  get [kPending] () {
+    return this[kQueue].length - this[kPendingIdx]
+  }
+
+  get [kRunning] () {
+    return this[kPendingIdx] - this[kRunningIdx]
+  }
+
+  get [kSize] () {
+    return this[kQueue].length - this[kRunningIdx]
+  }
+
+  get [kConnected] () {
+    return !!this[kHTTPContext] && !this[kConnecting] && !this[kHTTPContext].destroyed
+  }
+
+  get [kBusy] () {
+    return Boolean(
+      this[kHTTPContext]?.busy(null) ||
+      (this[kSize] >= (getPipelining(this) || 1)) ||
+      this[kPending] > 0
+    )
+  }
+
+  /* istanbul ignore: only used for test */
+  [kConnect] (cb) {
+    connect(this)
+    this.once('connect', cb)
+  }
+
+  [kDispatch] (opts, handler) {
+    const origin = opts.origin || this[kUrl].origin
+    const request = new Request(origin, opts, handler)
+
+    this[kQueue].push(request)
+    if (this[kResuming]) {
+      // Do nothing.
+    } else if (util.bodyLength(request.body) == null && util.isIterable(request.body)) {
+      // Wait a tick in case stream/iterator is ended in the same tick.
+      this[kResuming] = 1
+      queueMicrotask(() => resume(this))
+    } else {
+      this[kResume](true)
+    }
+
+    if (this[kResuming] && this[kNeedDrain] !== 2 && this[kBusy]) {
+      this[kNeedDrain] = 2
+    }
+
+    return this[kNeedDrain] < 2
+  }
+
+  async [kClose] () {
+    // TODO: for H2 we need to gracefully flush the remaining enqueued
+    // request and close each stream.
+    return new Promise((resolve) => {
+      if (this[kSize]) {
+        this[kClosedResolve] = resolve
+      } else {
+        resolve(null)
+      }
+    })
+  }
+
+  async [kDestroy] (err) {
+    return new Promise((resolve) => {
+      const requests = this[kQueue].splice(this[kPendingIdx])
+      for (let i = 0; i < requests.length; i++) {
+        const request = requests[i]
+        util.errorRequest(this, request, err)
+      }
+
+      const callback = () => {
+        if (this[kClosedResolve]) {
+          // TODO (fix): Should we error here with ClientDestroyedError?
+          this[kClosedResolve]()
+          this[kClosedResolve] = null
+        }
+        resolve(null)
+      }
+
+      if (this[kHTTPContext]) {
+        this[kHTTPContext].destroy(err, callback)
+        this[kHTTPContext] = null
+      } else {
+        queueMicrotask(callback)
+      }
+
+      this[kResume]()
+    })
+  }
+}
+
+const createRedirectInterceptor = __nccwpck_require__(11115)
+
+function onError (client, err) {
+  if (
+    client[kRunning] === 0 &&
+    err.code !== 'UND_ERR_INFO' &&
+    err.code !== 'UND_ERR_SOCKET'
+  ) {
+    // Error is not caused by running request and not a recoverable
+    // socket error.
+
+    assert(client[kPendingIdx] === client[kRunningIdx])
+
+    const requests = client[kQueue].splice(client[kRunningIdx])
+
+    for (let i = 0; i < requests.length; i++) {
+      const request = requests[i]
+      util.errorRequest(client, request, err)
+    }
+    assert(client[kSize] === 0)
+  }
+}
+
+/**
+ * @param {Client} client
+ * @returns
+ */
+async function connect (client) {
+  assert(!client[kConnecting])
+  assert(!client[kHTTPContext])
+
+  let { host, hostname, protocol, port } = client[kUrl]
+
+  // Resolve ipv6
+  if (hostname[0] === '[') {
+    const idx = hostname.indexOf(']')
+
+    assert(idx !== -1)
+    const ip = hostname.substring(1, idx)
+
+    assert(net.isIP(ip))
+    hostname = ip
+  }
+
+  client[kConnecting] = true
+
+  if (channels.beforeConnect.hasSubscribers) {
+    channels.beforeConnect.publish({
+      connectParams: {
+        host,
+        hostname,
+        protocol,
+        port,
+        version: client[kHTTPContext]?.version,
+        servername: client[kServerName],
+        localAddress: client[kLocalAddress]
+      },
+      connector: client[kConnector]
+    })
+  }
+
+  try {
+    const socket = await new Promise((resolve, reject) => {
+      client[kConnector]({
+        host,
+        hostname,
+        protocol,
+        port,
+        servername: client[kServerName],
+        localAddress: client[kLocalAddress]
+      }, (err, socket) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(socket)
+        }
+      })
+    })
+
+    if (client.destroyed) {
+      util.destroy(socket.on('error', noop), new ClientDestroyedError())
+      return
+    }
+
+    assert(socket)
+
+    try {
+      client[kHTTPContext] = socket.alpnProtocol === 'h2'
+        ? await connectH2(client, socket)
+        : await connectH1(client, socket)
+    } catch (err) {
+      socket.destroy().on('error', noop)
+      throw err
+    }
+
+    client[kConnecting] = false
+
+    socket[kCounter] = 0
+    socket[kMaxRequests] = client[kMaxRequests]
+    socket[kClient] = client
+    socket[kError] = null
+
+    if (channels.connected.hasSubscribers) {
+      channels.connected.publish({
+        connectParams: {
+          host,
+          hostname,
+          protocol,
+          port,
+          version: client[kHTTPContext]?.version,
+          servername: client[kServerName],
+          localAddress: client[kLocalAddress]
+        },
+        connector: client[kConnector],
+        socket
+      })
+    }
+    client.emit('connect', client[kUrl], [client])
+  } catch (err) {
+    if (client.destroyed) {
+      return
+    }
+
+    client[kConnecting] = false
+
+    if (channels.connectError.hasSubscribers) {
+      channels.connectError.publish({
+        connectParams: {
+          host,
+          hostname,
+          protocol,
+          port,
+          version: client[kHTTPContext]?.version,
+          servername: client[kServerName],
+          localAddress: client[kLocalAddress]
+        },
+        connector: client[kConnector],
+        error: err
+      })
+    }
+
+    if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
+      assert(client[kRunning] === 0)
+      while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
+        const request = client[kQueue][client[kPendingIdx]++]
+        util.errorRequest(client, request, err)
+      }
+    } else {
+      onError(client, err)
+    }
+
+    client.emit('connectionError', client[kUrl], [client], err)
+  }
+
+  client[kResume]()
+}
+
+function emitDrain (client) {
+  client[kNeedDrain] = 0
+  client.emit('drain', client[kUrl], [client])
+}
+
+function resume (client, sync) {
+  if (client[kResuming] === 2) {
+    return
+  }
+
+  client[kResuming] = 2
+
+  _resume(client, sync)
+  client[kResuming] = 0
+
+  if (client[kRunningIdx] > 256) {
+    client[kQueue].splice(0, client[kRunningIdx])
+    client[kPendingIdx] -= client[kRunningIdx]
+    client[kRunningIdx] = 0
+  }
+}
+
+function _resume (client, sync) {
+  while (true) {
+    if (client.destroyed) {
+      assert(client[kPending] === 0)
+      return
+    }
+
+    if (client[kClosedResolve] && !client[kSize]) {
+      client[kClosedResolve]()
+      client[kClosedResolve] = null
+      return
+    }
+
+    if (client[kHTTPContext]) {
+      client[kHTTPContext].resume()
+    }
+
+    if (client[kBusy]) {
+      client[kNeedDrain] = 2
+    } else if (client[kNeedDrain] === 2) {
+      if (sync) {
+        client[kNeedDrain] = 1
+        queueMicrotask(() => emitDrain(client))
+      } else {
+        emitDrain(client)
+      }
+      continue
+    }
+
+    if (client[kPending] === 0) {
+      return
+    }
+
+    if (client[kRunning] >= (getPipelining(client) || 1)) {
+      return
+    }
+
+    const request = client[kQueue][client[kPendingIdx]]
+
+    if (client[kUrl].protocol === 'https:' && client[kServerName] !== request.servername) {
+      if (client[kRunning] > 0) {
+        return
+      }
+
+      client[kServerName] = request.servername
+      client[kHTTPContext]?.destroy(new InformationalError('servername changed'), () => {
+        client[kHTTPContext] = null
+        resume(client)
+      })
+    }
+
+    if (client[kConnecting]) {
+      return
+    }
+
+    if (!client[kHTTPContext]) {
+      connect(client)
+      return
+    }
+
+    if (client[kHTTPContext].destroyed) {
+      return
+    }
+
+    if (client[kHTTPContext].busy(request)) {
+      return
+    }
+
+    if (!request.aborted && client[kHTTPContext].write(request)) {
+      client[kPendingIdx]++
+    } else {
+      client[kQueue].splice(client[kPendingIdx], 1)
+    }
+  }
+}
+
+module.exports = Client
+
+
+/***/ }),
+
+/***/ 68838:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const Dispatcher = __nccwpck_require__(51927)
+const {
+  ClientDestroyedError,
+  ClientClosedError,
+  InvalidArgumentError
+} = __nccwpck_require__(22174)
+const { kDestroy, kClose, kClosed, kDestroyed, kDispatch, kInterceptors } = __nccwpck_require__(5392)
+
+const kOnDestroyed = Symbol('onDestroyed')
+const kOnClosed = Symbol('onClosed')
+const kInterceptedDispatch = Symbol('Intercepted Dispatch')
+
+class DispatcherBase extends Dispatcher {
+  constructor () {
+    super()
+
+    this[kDestroyed] = false
+    this[kOnDestroyed] = null
+    this[kClosed] = false
+    this[kOnClosed] = []
+  }
+
+  get destroyed () {
+    return this[kDestroyed]
+  }
+
+  get closed () {
+    return this[kClosed]
+  }
+
+  get interceptors () {
+    return this[kInterceptors]
+  }
+
+  set interceptors (newInterceptors) {
+    if (newInterceptors) {
+      for (let i = newInterceptors.length - 1; i >= 0; i--) {
+        const interceptor = this[kInterceptors][i]
+        if (typeof interceptor !== 'function') {
+          throw new InvalidArgumentError('interceptor must be an function')
+        }
+      }
+    }
+
+    this[kInterceptors] = newInterceptors
+  }
+
+  close (callback) {
+    if (callback === undefined) {
+      return new Promise((resolve, reject) => {
+        this.close((err, data) => {
+          return err ? reject(err) : resolve(data)
+        })
+      })
+    }
+
+    if (typeof callback !== 'function') {
+      throw new InvalidArgumentError('invalid callback')
+    }
+
+    if (this[kDestroyed]) {
+      queueMicrotask(() => callback(new ClientDestroyedError(), null))
+      return
+    }
+
+    if (this[kClosed]) {
+      if (this[kOnClosed]) {
+        this[kOnClosed].push(callback)
+      } else {
+        queueMicrotask(() => callback(null, null))
+      }
+      return
+    }
+
+    this[kClosed] = true
+    this[kOnClosed].push(callback)
+
+    const onClosed = () => {
+      const callbacks = this[kOnClosed]
+      this[kOnClosed] = null
+      for (let i = 0; i < callbacks.length; i++) {
+        callbacks[i](null, null)
+      }
+    }
+
+    // Should not error.
+    this[kClose]()
+      .then(() => this.destroy())
+      .then(() => {
+        queueMicrotask(onClosed)
+      })
+  }
+
+  destroy (err, callback) {
+    if (typeof err === 'function') {
+      callback = err
+      err = null
+    }
+
+    if (callback === undefined) {
+      return new Promise((resolve, reject) => {
+        this.destroy(err, (err, data) => {
+          return err ? /* istanbul ignore next: should never error */ reject(err) : resolve(data)
+        })
+      })
+    }
+
+    if (typeof callback !== 'function') {
+      throw new InvalidArgumentError('invalid callback')
+    }
+
+    if (this[kDestroyed]) {
+      if (this[kOnDestroyed]) {
+        this[kOnDestroyed].push(callback)
+      } else {
+        queueMicrotask(() => callback(null, null))
+      }
+      return
+    }
+
+    if (!err) {
+      err = new ClientDestroyedError()
+    }
+
+    this[kDestroyed] = true
+    this[kOnDestroyed] = this[kOnDestroyed] || []
+    this[kOnDestroyed].push(callback)
+
+    const onDestroyed = () => {
+      const callbacks = this[kOnDestroyed]
+      this[kOnDestroyed] = null
+      for (let i = 0; i < callbacks.length; i++) {
+        callbacks[i](null, null)
+      }
+    }
+
+    // Should not error.
+    this[kDestroy](err).then(() => {
+      queueMicrotask(onDestroyed)
+    })
+  }
+
+  [kInterceptedDispatch] (opts, handler) {
+    if (!this[kInterceptors] || this[kInterceptors].length === 0) {
+      this[kInterceptedDispatch] = this[kDispatch]
+      return this[kDispatch](opts, handler)
+    }
+
+    let dispatch = this[kDispatch].bind(this)
+    for (let i = this[kInterceptors].length - 1; i >= 0; i--) {
+      dispatch = this[kInterceptors][i](dispatch)
+    }
+    this[kInterceptedDispatch] = dispatch
+    return dispatch(opts, handler)
+  }
+
+  dispatch (opts, handler) {
+    if (!handler || typeof handler !== 'object') {
+      throw new InvalidArgumentError('handler must be an object')
+    }
+
+    try {
+      if (!opts || typeof opts !== 'object') {
+        throw new InvalidArgumentError('opts must be an object.')
+      }
+
+      if (this[kDestroyed] || this[kOnDestroyed]) {
+        throw new ClientDestroyedError()
+      }
+
+      if (this[kClosed]) {
+        throw new ClientClosedError()
+      }
+
+      return this[kInterceptedDispatch](opts, handler)
+    } catch (err) {
+      if (typeof handler.onError !== 'function') {
+        throw new InvalidArgumentError('invalid onError method')
+      }
+
+      handler.onError(err)
+
+      return false
+    }
+  }
+}
+
+module.exports = DispatcherBase
+
+
+/***/ }),
+
+/***/ 51927:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const EventEmitter = __nccwpck_require__(15673)
+
+class Dispatcher extends EventEmitter {
+  dispatch () {
+    throw new Error('not implemented')
+  }
+
+  close () {
+    throw new Error('not implemented')
+  }
+
+  destroy () {
+    throw new Error('not implemented')
+  }
+
+  compose (...args) {
+    // So we handle [interceptor1, interceptor2] or interceptor1, interceptor2, ...
+    const interceptors = Array.isArray(args[0]) ? args[0] : args
+    let dispatch = this.dispatch.bind(this)
+
+    for (const interceptor of interceptors) {
+      if (interceptor == null) {
+        continue
+      }
+
+      if (typeof interceptor !== 'function') {
+        throw new TypeError(`invalid interceptor, expected function received ${typeof interceptor}`)
+      }
+
+      dispatch = interceptor(dispatch)
+
+      if (dispatch == null || typeof dispatch !== 'function' || dispatch.length !== 2) {
+        throw new TypeError('invalid interceptor')
+      }
+    }
+
+    return new ComposedDispatcher(this, dispatch)
+  }
+}
+
+class ComposedDispatcher extends Dispatcher {
+  #dispatcher = null
+  #dispatch = null
+
+  constructor (dispatcher, dispatch) {
+    super()
+    this.#dispatcher = dispatcher
+    this.#dispatch = dispatch
+  }
+
+  dispatch (...args) {
+    this.#dispatch(...args)
+  }
+
+  close (...args) {
+    return this.#dispatcher.close(...args)
+  }
+
+  destroy (...args) {
+    return this.#dispatcher.destroy(...args)
+  }
+}
+
+module.exports = Dispatcher
+
+
+/***/ }),
+
+/***/ 4803:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const DispatcherBase = __nccwpck_require__(68838)
+const { kClose, kDestroy, kClosed, kDestroyed, kDispatch, kNoProxyAgent, kHttpProxyAgent, kHttpsProxyAgent } = __nccwpck_require__(5392)
+const ProxyAgent = __nccwpck_require__(54372)
+const Agent = __nccwpck_require__(83421)
+
+const DEFAULT_PORTS = {
+  'http:': 80,
+  'https:': 443
+}
+
+let experimentalWarned = false
+
+class EnvHttpProxyAgent extends DispatcherBase {
+  #noProxyValue = null
+  #noProxyEntries = null
+  #opts = null
+
+  constructor (opts = {}) {
+    super()
+    this.#opts = opts
+
+    if (!experimentalWarned) {
+      experimentalWarned = true
+      process.emitWarning('EnvHttpProxyAgent is experimental, expect them to change at any time.', {
+        code: 'UNDICI-EHPA'
+      })
+    }
+
+    const { httpProxy, httpsProxy, noProxy, ...agentOpts } = opts
+
+    this[kNoProxyAgent] = new Agent(agentOpts)
+
+    const HTTP_PROXY = httpProxy ?? process.env.http_proxy ?? process.env.HTTP_PROXY
+    if (HTTP_PROXY) {
+      this[kHttpProxyAgent] = new ProxyAgent({ ...agentOpts, uri: HTTP_PROXY })
+    } else {
+      this[kHttpProxyAgent] = this[kNoProxyAgent]
+    }
+
+    const HTTPS_PROXY = httpsProxy ?? process.env.https_proxy ?? process.env.HTTPS_PROXY
+    if (HTTPS_PROXY) {
+      this[kHttpsProxyAgent] = new ProxyAgent({ ...agentOpts, uri: HTTPS_PROXY })
+    } else {
+      this[kHttpsProxyAgent] = this[kHttpProxyAgent]
+    }
+
+    this.#parseNoProxy()
+  }
+
+  [kDispatch] (opts, handler) {
+    const url = new URL(opts.origin)
+    const agent = this.#getProxyAgentForUrl(url)
+    return agent.dispatch(opts, handler)
+  }
+
+  async [kClose] () {
+    await this[kNoProxyAgent].close()
+    if (!this[kHttpProxyAgent][kClosed]) {
+      await this[kHttpProxyAgent].close()
+    }
+    if (!this[kHttpsProxyAgent][kClosed]) {
+      await this[kHttpsProxyAgent].close()
+    }
+  }
+
+  async [kDestroy] (err) {
+    await this[kNoProxyAgent].destroy(err)
+    if (!this[kHttpProxyAgent][kDestroyed]) {
+      await this[kHttpProxyAgent].destroy(err)
+    }
+    if (!this[kHttpsProxyAgent][kDestroyed]) {
+      await this[kHttpsProxyAgent].destroy(err)
+    }
+  }
+
+  #getProxyAgentForUrl (url) {
+    let { protocol, host: hostname, port } = url
+
+    // Stripping ports in this way instead of using parsedUrl.hostname to make
+    // sure that the brackets around IPv6 addresses are kept.
+    hostname = hostname.replace(/:\d*$/, '').toLowerCase()
+    port = Number.parseInt(port, 10) || DEFAULT_PORTS[protocol] || 0
+    if (!this.#shouldProxy(hostname, port)) {
+      return this[kNoProxyAgent]
+    }
+    if (protocol === 'https:') {
+      return this[kHttpsProxyAgent]
+    }
+    return this[kHttpProxyAgent]
+  }
+
+  #shouldProxy (hostname, port) {
+    if (this.#noProxyChanged) {
+      this.#parseNoProxy()
+    }
+
+    if (this.#noProxyEntries.length === 0) {
+      return true // Always proxy if NO_PROXY is not set or empty.
+    }
+    if (this.#noProxyValue === '*') {
+      return false // Never proxy if wildcard is set.
+    }
+
+    for (let i = 0; i < this.#noProxyEntries.length; i++) {
+      const entry = this.#noProxyEntries[i]
+      if (entry.port && entry.port !== port) {
+        continue // Skip if ports don't match.
+      }
+      if (!/^[.*]/.test(entry.hostname)) {
+        // No wildcards, so don't proxy only if there is not an exact match.
+        if (hostname === entry.hostname) {
+          return false
+        }
+      } else {
+        // Don't proxy if the hostname ends with the no_proxy host.
+        if (hostname.endsWith(entry.hostname.replace(/^\*/, ''))) {
+          return false
+        }
+      }
+    }
+
+    return true
+  }
+
+  #parseNoProxy () {
+    const noProxyValue = this.#opts.noProxy ?? this.#noProxyEnv
+    const noProxySplit = noProxyValue.split(/[,\s]/)
+    const noProxyEntries = []
+
+    for (let i = 0; i < noProxySplit.length; i++) {
+      const entry = noProxySplit[i]
+      if (!entry) {
+        continue
+      }
+      const parsed = entry.match(/^(.+):(\d+)$/)
+      noProxyEntries.push({
+        hostname: (parsed ? parsed[1] : entry).toLowerCase(),
+        port: parsed ? Number.parseInt(parsed[2], 10) : 0
+      })
+    }
+
+    this.#noProxyValue = noProxyValue
+    this.#noProxyEntries = noProxyEntries
+  }
+
+  get #noProxyChanged () {
+    if (this.#opts.noProxy !== undefined) {
+      return false
+    }
+    return this.#noProxyValue !== this.#noProxyEnv
+  }
+
+  get #noProxyEnv () {
+    return process.env.no_proxy ?? process.env.NO_PROXY ?? ''
+  }
+}
+
+module.exports = EnvHttpProxyAgent
+
+
+/***/ }),
+
+/***/ 82285:
+/***/ ((module) => {
+
+"use strict";
+/* eslint-disable */
+
+
+
+// Extracted from node/lib/internal/fixed_queue.js
+
+// Currently optimal queue size, tested on V8 6.0 - 6.6. Must be power of two.
+const kSize = 2048;
+const kMask = kSize - 1;
+
+// The FixedQueue is implemented as a singly-linked list of fixed-size
+// circular buffers. It looks something like this:
+//
+//  head                                                       tail
+//    |                                                          |
+//    v                                                          v
+// +-----------+ <-----\       +-----------+ <------\         +-----------+
+// |  [null]   |        \----- |   next    |         \------- |   next    |
+// +-----------+               +-----------+                  +-----------+
+// |   item    | <-- bottom    |   item    | <-- bottom       |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |       bottom --> |   item    |
+// |   item    |               |   item    |                  |   item    |
+// |    ...    |               |    ...    |                  |    ...    |
+// |   item    |               |   item    |                  |   item    |
+// |   item    |               |   item    |                  |   item    |
+// |  [empty]  | <-- top       |   item    |                  |   item    |
+// |  [empty]  |               |   item    |                  |   item    |
+// |  [empty]  |               |  [empty]  | <-- top  top --> |  [empty]  |
+// +-----------+               +-----------+                  +-----------+
+//
+// Or, if there is only one circular buffer, it looks something
+// like either of these:
+//
+//  head   tail                                 head   tail
+//    |     |                                     |     |
+//    v     v                                     v     v
+// +-----------+                               +-----------+
+// |  [null]   |                               |  [null]   |
+// +-----------+                               +-----------+
+// |  [empty]  |                               |   item    |
+// |  [empty]  |                               |   item    |
+// |   item    | <-- bottom            top --> |  [empty]  |
+// |   item    |                               |  [empty]  |
+// |  [empty]  | <-- top            bottom --> |   item    |
+// |  [empty]  |                               |   item    |
+// +-----------+                               +-----------+
+//
+// Adding a value means moving `top` forward by one, removing means
+// moving `bottom` forward by one. After reaching the end, the queue
+// wraps around.
+//
+// When `top === bottom` the current queue is empty and when
+// `top + 1 === bottom` it's full. This wastes a single space of storage
+// but allows much quicker checks.
+
+class FixedCircularBuffer {
+  constructor() {
+    this.bottom = 0;
+    this.top = 0;
+    this.list = new Array(kSize);
+    this.next = null;
+  }
+
+  isEmpty() {
+    return this.top === this.bottom;
+  }
+
+  isFull() {
+    return ((this.top + 1) & kMask) === this.bottom;
+  }
+
+  push(data) {
+    this.list[this.top] = data;
+    this.top = (this.top + 1) & kMask;
+  }
+
+  shift() {
+    const nextItem = this.list[this.bottom];
+    if (nextItem === undefined)
+      return null;
+    this.list[this.bottom] = undefined;
+    this.bottom = (this.bottom + 1) & kMask;
+    return nextItem;
+  }
+}
+
+module.exports = class FixedQueue {
+  constructor() {
+    this.head = this.tail = new FixedCircularBuffer();
+  }
+
+  isEmpty() {
+    return this.head.isEmpty();
+  }
+
+  push(data) {
+    if (this.head.isFull()) {
+      // Head is full: Creates a new queue, sets the old queue's `.next` to it,
+      // and sets it as the new main queue.
+      this.head = this.head.next = new FixedCircularBuffer();
+    }
+    this.head.push(data);
+  }
+
+  shift() {
+    const tail = this.tail;
+    const next = tail.shift();
+    if (tail.isEmpty() && tail.next !== null) {
+      // If there is another queue, it forms the new tail.
+      this.tail = tail.next;
+    }
+    return next;
+  }
+};
+
+
+/***/ }),
+
+/***/ 37128:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const DispatcherBase = __nccwpck_require__(68838)
+const FixedQueue = __nccwpck_require__(82285)
+const { kConnected, kSize, kRunning, kPending, kQueued, kBusy, kFree, kUrl, kClose, kDestroy, kDispatch } = __nccwpck_require__(5392)
+const PoolStats = __nccwpck_require__(28292)
+
+const kClients = Symbol('clients')
+const kNeedDrain = Symbol('needDrain')
+const kQueue = Symbol('queue')
+const kClosedResolve = Symbol('closed resolve')
+const kOnDrain = Symbol('onDrain')
+const kOnConnect = Symbol('onConnect')
+const kOnDisconnect = Symbol('onDisconnect')
+const kOnConnectionError = Symbol('onConnectionError')
+const kGetDispatcher = Symbol('get dispatcher')
+const kAddClient = Symbol('add client')
+const kRemoveClient = Symbol('remove client')
+const kStats = Symbol('stats')
+
+class PoolBase extends DispatcherBase {
+  constructor () {
+    super()
+
+    this[kQueue] = new FixedQueue()
+    this[kClients] = []
+    this[kQueued] = 0
+
+    const pool = this
+
+    this[kOnDrain] = function onDrain (origin, targets) {
+      const queue = pool[kQueue]
+
+      let needDrain = false
+
+      while (!needDrain) {
+        const item = queue.shift()
+        if (!item) {
+          break
+        }
+        pool[kQueued]--
+        needDrain = !this.dispatch(item.opts, item.handler)
+      }
+
+      this[kNeedDrain] = needDrain
+
+      if (!this[kNeedDrain] && pool[kNeedDrain]) {
+        pool[kNeedDrain] = false
+        pool.emit('drain', origin, [pool, ...targets])
+      }
+
+      if (pool[kClosedResolve] && queue.isEmpty()) {
+        Promise
+          .all(pool[kClients].map(c => c.close()))
+          .then(pool[kClosedResolve])
+      }
+    }
+
+    this[kOnConnect] = (origin, targets) => {
+      pool.emit('connect', origin, [pool, ...targets])
+    }
+
+    this[kOnDisconnect] = (origin, targets, err) => {
+      pool.emit('disconnect', origin, [pool, ...targets], err)
+    }
+
+    this[kOnConnectionError] = (origin, targets, err) => {
+      pool.emit('connectionError', origin, [pool, ...targets], err)
+    }
+
+    this[kStats] = new PoolStats(this)
+  }
+
+  get [kBusy] () {
+    return this[kNeedDrain]
+  }
+
+  get [kConnected] () {
+    return this[kClients].filter(client => client[kConnected]).length
+  }
+
+  get [kFree] () {
+    return this[kClients].filter(client => client[kConnected] && !client[kNeedDrain]).length
+  }
+
+  get [kPending] () {
+    let ret = this[kQueued]
+    for (const { [kPending]: pending } of this[kClients]) {
+      ret += pending
+    }
+    return ret
+  }
+
+  get [kRunning] () {
+    let ret = 0
+    for (const { [kRunning]: running } of this[kClients]) {
+      ret += running
+    }
+    return ret
+  }
+
+  get [kSize] () {
+    let ret = this[kQueued]
+    for (const { [kSize]: size } of this[kClients]) {
+      ret += size
+    }
+    return ret
+  }
+
+  get stats () {
+    return this[kStats]
+  }
+
+  async [kClose] () {
+    if (this[kQueue].isEmpty()) {
+      await Promise.all(this[kClients].map(c => c.close()))
+    } else {
+      await new Promise((resolve) => {
+        this[kClosedResolve] = resolve
+      })
+    }
+  }
+
+  async [kDestroy] (err) {
+    while (true) {
+      const item = this[kQueue].shift()
+      if (!item) {
+        break
+      }
+      item.handler.onError(err)
+    }
+
+    await Promise.all(this[kClients].map(c => c.destroy(err)))
+  }
+
+  [kDispatch] (opts, handler) {
+    const dispatcher = this[kGetDispatcher]()
+
+    if (!dispatcher) {
+      this[kNeedDrain] = true
+      this[kQueue].push({ opts, handler })
+      this[kQueued]++
+    } else if (!dispatcher.dispatch(opts, handler)) {
+      dispatcher[kNeedDrain] = true
+      this[kNeedDrain] = !this[kGetDispatcher]()
+    }
+
+    return !this[kNeedDrain]
+  }
+
+  [kAddClient] (client) {
+    client
+      .on('drain', this[kOnDrain])
+      .on('connect', this[kOnConnect])
+      .on('disconnect', this[kOnDisconnect])
+      .on('connectionError', this[kOnConnectionError])
+
+    this[kClients].push(client)
+
+    if (this[kNeedDrain]) {
+      queueMicrotask(() => {
+        if (this[kNeedDrain]) {
+          this[kOnDrain](client[kUrl], [this, client])
+        }
+      })
+    }
+
+    return this
+  }
+
+  [kRemoveClient] (client) {
+    client.close(() => {
+      const idx = this[kClients].indexOf(client)
+      if (idx !== -1) {
+        this[kClients].splice(idx, 1)
+      }
+    })
+
+    this[kNeedDrain] = this[kClients].some(dispatcher => (
+      !dispatcher[kNeedDrain] &&
+      dispatcher.closed !== true &&
+      dispatcher.destroyed !== true
+    ))
+  }
+}
+
+module.exports = {
+  PoolBase,
+  kClients,
+  kNeedDrain,
+  kAddClient,
+  kRemoveClient,
+  kGetDispatcher
+}
+
+
+/***/ }),
+
+/***/ 28292:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+const { kFree, kConnected, kPending, kQueued, kRunning, kSize } = __nccwpck_require__(5392)
+const kPool = Symbol('pool')
+
+class PoolStats {
+  constructor (pool) {
+    this[kPool] = pool
+  }
+
+  get connected () {
+    return this[kPool][kConnected]
+  }
+
+  get free () {
+    return this[kPool][kFree]
+  }
+
+  get pending () {
+    return this[kPool][kPending]
+  }
+
+  get queued () {
+    return this[kPool][kQueued]
+  }
+
+  get running () {
+    return this[kPool][kRunning]
+  }
+
+  get size () {
+    return this[kPool][kSize]
+  }
+}
+
+module.exports = PoolStats
+
+
+/***/ }),
+
+/***/ 11795:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  PoolBase,
+  kClients,
+  kNeedDrain,
+  kAddClient,
+  kGetDispatcher
+} = __nccwpck_require__(37128)
+const Client = __nccwpck_require__(6655)
+const {
+  InvalidArgumentError
+} = __nccwpck_require__(22174)
+const util = __nccwpck_require__(94407)
+const { kUrl, kInterceptors } = __nccwpck_require__(5392)
+const buildConnector = __nccwpck_require__(20123)
+
+const kOptions = Symbol('options')
+const kConnections = Symbol('connections')
+const kFactory = Symbol('factory')
+
+function defaultFactory (origin, opts) {
+  return new Client(origin, opts)
+}
+
+class Pool extends PoolBase {
+  constructor (origin, {
+    connections,
+    factory = defaultFactory,
+    connect,
+    connectTimeout,
+    tls,
+    maxCachedSessions,
+    socketPath,
+    autoSelectFamily,
+    autoSelectFamilyAttemptTimeout,
+    allowH2,
+    ...options
+  } = {}) {
+    super()
+
+    if (connections != null && (!Number.isFinite(connections) || connections < 0)) {
+      throw new InvalidArgumentError('invalid connections')
+    }
+
+    if (typeof factory !== 'function') {
+      throw new InvalidArgumentError('factory must be a function.')
+    }
+
+    if (connect != null && typeof connect !== 'function' && typeof connect !== 'object') {
+      throw new InvalidArgumentError('connect must be a function or an object')
+    }
+
+    if (typeof connect !== 'function') {
+      connect = buildConnector({
+        ...tls,
+        maxCachedSessions,
+        allowH2,
+        socketPath,
+        timeout: connectTimeout,
+        ...(autoSelectFamily ? { autoSelectFamily, autoSelectFamilyAttemptTimeout } : undefined),
+        ...connect
+      })
+    }
+
+    this[kInterceptors] = options.interceptors?.Pool && Array.isArray(options.interceptors.Pool)
+      ? options.interceptors.Pool
+      : []
+    this[kConnections] = connections || null
+    this[kUrl] = util.parseOrigin(origin)
+    this[kOptions] = { ...util.deepClone(options), connect, allowH2 }
+    this[kOptions].interceptors = options.interceptors
+      ? { ...options.interceptors }
+      : undefined
+    this[kFactory] = factory
+
+    this.on('connectionError', (origin, targets, error) => {
+      // If a connection error occurs, we remove the client from the pool,
+      // and emit a connectionError event. They will not be re-used.
+      // Fixes https://github.com/nodejs/undici/issues/3895
+      for (const target of targets) {
+        // Do not use kRemoveClient here, as it will close the client,
+        // but the client cannot be closed in this state.
+        const idx = this[kClients].indexOf(target)
+        if (idx !== -1) {
+          this[kClients].splice(idx, 1)
+        }
+      }
+    })
+  }
+
+  [kGetDispatcher] () {
+    for (const client of this[kClients]) {
+      if (!client[kNeedDrain]) {
+        return client
+      }
+    }
+
+    if (!this[kConnections] || this[kClients].length < this[kConnections]) {
+      const dispatcher = this[kFactory](this[kUrl], this[kOptions])
+      this[kAddClient](dispatcher)
+      return dispatcher
+    }
+  }
+}
+
+module.exports = Pool
+
+
+/***/ }),
+
+/***/ 54372:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kProxy, kClose, kDestroy, kDispatch, kInterceptors } = __nccwpck_require__(5392)
+const { URL } = __nccwpck_require__(41041)
+const Agent = __nccwpck_require__(83421)
+const Pool = __nccwpck_require__(11795)
+const DispatcherBase = __nccwpck_require__(68838)
+const { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = __nccwpck_require__(22174)
+const buildConnector = __nccwpck_require__(20123)
+const Client = __nccwpck_require__(6655)
+
+const kAgent = Symbol('proxy agent')
+const kClient = Symbol('proxy client')
+const kProxyHeaders = Symbol('proxy headers')
+const kRequestTls = Symbol('request tls settings')
+const kProxyTls = Symbol('proxy tls settings')
+const kConnectEndpoint = Symbol('connect endpoint function')
+const kTunnelProxy = Symbol('tunnel proxy')
+
+function defaultProtocolPort (protocol) {
+  return protocol === 'https:' ? 443 : 80
+}
+
+function defaultFactory (origin, opts) {
+  return new Pool(origin, opts)
+}
+
+const noop = () => {}
+
+function defaultAgentFactory (origin, opts) {
+  if (opts.connections === 1) {
+    return new Client(origin, opts)
+  }
+  return new Pool(origin, opts)
+}
+
+class Http1ProxyWrapper extends DispatcherBase {
+  #client
+
+  constructor (proxyUrl, { headers = {}, connect, factory }) {
+    super()
+    if (!proxyUrl) {
+      throw new InvalidArgumentError('Proxy URL is mandatory')
+    }
+
+    this[kProxyHeaders] = headers
+    if (factory) {
+      this.#client = factory(proxyUrl, { connect })
+    } else {
+      this.#client = new Client(proxyUrl, { connect })
+    }
+  }
+
+  [kDispatch] (opts, handler) {
+    const onHeaders = handler.onHeaders
+    handler.onHeaders = function (statusCode, data, resume) {
+      if (statusCode === 407) {
+        if (typeof handler.onError === 'function') {
+          handler.onError(new InvalidArgumentError('Proxy Authentication Required (407)'))
+        }
+        return
+      }
+      if (onHeaders) onHeaders.call(this, statusCode, data, resume)
+    }
+
+    // Rewrite request as an HTTP1 Proxy request, without tunneling.
+    const {
+      origin,
+      path = '/',
+      headers = {}
+    } = opts
+
+    opts.path = origin + path
+
+    if (!('host' in headers) && !('Host' in headers)) {
+      const { host } = new URL(origin)
+      headers.host = host
+    }
+    opts.headers = { ...this[kProxyHeaders], ...headers }
+
+    return this.#client[kDispatch](opts, handler)
+  }
+
+  async [kClose] () {
+    return this.#client.close()
+  }
+
+  async [kDestroy] (err) {
+    return this.#client.destroy(err)
+  }
+}
+
+class ProxyAgent extends DispatcherBase {
+  constructor (opts) {
+    super()
+
+    if (!opts || (typeof opts === 'object' && !(opts instanceof URL) && !opts.uri)) {
+      throw new InvalidArgumentError('Proxy uri is mandatory')
+    }
+
+    const { clientFactory = defaultFactory } = opts
+    if (typeof clientFactory !== 'function') {
+      throw new InvalidArgumentError('Proxy opts.clientFactory must be a function.')
+    }
+
+    const { proxyTunnel = true } = opts
+
+    const url = this.#getUrl(opts)
+    const { href, origin, port, protocol, username, password, hostname: proxyHostname } = url
+
+    this[kProxy] = { uri: href, protocol }
+    this[kInterceptors] = opts.interceptors?.ProxyAgent && Array.isArray(opts.interceptors.ProxyAgent)
+      ? opts.interceptors.ProxyAgent
+      : []
+    this[kRequestTls] = opts.requestTls
+    this[kProxyTls] = opts.proxyTls
+    this[kProxyHeaders] = opts.headers || {}
+    this[kTunnelProxy] = proxyTunnel
+
+    if (opts.auth && opts.token) {
+      throw new InvalidArgumentError('opts.auth cannot be used in combination with opts.token')
+    } else if (opts.auth) {
+      /* @deprecated in favour of opts.token */
+      this[kProxyHeaders]['proxy-authorization'] = `Basic ${opts.auth}`
+    } else if (opts.token) {
+      this[kProxyHeaders]['proxy-authorization'] = opts.token
+    } else if (username && password) {
+      this[kProxyHeaders]['proxy-authorization'] = `Basic ${Buffer.from(`${decodeURIComponent(username)}:${decodeURIComponent(password)}`).toString('base64')}`
+    }
+
+    const connect = buildConnector({ ...opts.proxyTls })
+    this[kConnectEndpoint] = buildConnector({ ...opts.requestTls })
+
+    const agentFactory = opts.factory || defaultAgentFactory
+    const factory = (origin, options) => {
+      const { protocol } = new URL(origin)
+      if (!this[kTunnelProxy] && protocol === 'http:' && this[kProxy].protocol === 'http:') {
+        return new Http1ProxyWrapper(this[kProxy].uri, {
+          headers: this[kProxyHeaders],
+          connect,
+          factory: agentFactory
+        })
+      }
+      return agentFactory(origin, options)
+    }
+    this[kClient] = clientFactory(url, { connect })
+    this[kAgent] = new Agent({
+      ...opts,
+      factory,
+      connect: async (opts, callback) => {
+        let requestedPath = opts.host
+        if (!opts.port) {
+          requestedPath += `:${defaultProtocolPort(opts.protocol)}`
+        }
+        try {
+          const { socket, statusCode } = await this[kClient].connect({
+            origin,
+            port,
+            path: requestedPath,
+            signal: opts.signal,
+            headers: {
+              ...this[kProxyHeaders],
+              host: opts.host
+            },
+            servername: this[kProxyTls]?.servername || proxyHostname
+          })
+          if (statusCode !== 200) {
+            socket.on('error', noop).destroy()
+            callback(new RequestAbortedError(`Proxy response (${statusCode}) !== 200 when HTTP Tunneling`))
+          }
+          if (opts.protocol !== 'https:') {
+            callback(null, socket)
+            return
+          }
+          let servername
+          if (this[kRequestTls]) {
+            servername = this[kRequestTls].servername
+          } else {
+            servername = opts.servername
+          }
+          this[kConnectEndpoint]({ ...opts, servername, httpSocket: socket }, callback)
+        } catch (err) {
+          if (err.code === 'ERR_TLS_CERT_ALTNAME_INVALID') {
+            // Throw a custom error to avoid loop in client.js#connect
+            callback(new SecureProxyConnectionError(err))
+          } else {
+            callback(err)
+          }
+        }
+      }
+    })
+  }
+
+  dispatch (opts, handler) {
+    const headers = buildHeaders(opts.headers)
+    throwIfProxyAuthIsSent(headers)
+
+    if (headers && !('host' in headers) && !('Host' in headers)) {
+      const { host } = new URL(opts.origin)
+      headers.host = host
+    }
+
+    return this[kAgent].dispatch(
+      {
+        ...opts,
+        headers
+      },
+      handler
+    )
+  }
+
+  /**
+   * @param {import('../types/proxy-agent').ProxyAgent.Options | string | URL} opts
+   * @returns {URL}
+   */
+  #getUrl (opts) {
+    if (typeof opts === 'string') {
+      return new URL(opts)
+    } else if (opts instanceof URL) {
+      return opts
+    } else {
+      return new URL(opts.uri)
+    }
+  }
+
+  async [kClose] () {
+    await this[kAgent].close()
+    await this[kClient].close()
+  }
+
+  async [kDestroy] () {
+    await this[kAgent].destroy()
+    await this[kClient].destroy()
+  }
+}
+
+/**
+ * @param {string[] | Record<string, string>} headers
+ * @returns {Record<string, string>}
+ */
+function buildHeaders (headers) {
+  // When using undici.fetch, the headers list is stored
+  // as an array.
+  if (Array.isArray(headers)) {
+    /** @type {Record<string, string>} */
+    const headersPair = {}
+
+    for (let i = 0; i < headers.length; i += 2) {
+      headersPair[headers[i]] = headers[i + 1]
+    }
+
+    return headersPair
+  }
+
+  return headers
+}
+
+/**
+ * @param {Record<string, string>} headers
+ *
+ * Previous versions of ProxyAgent suggests the Proxy-Authorization in request headers
+ * Nevertheless, it was changed and to avoid a security vulnerability by end users
+ * this check was created.
+ * It should be removed in the next major version for performance reasons
+ */
+function throwIfProxyAuthIsSent (headers) {
+  const existProxyAuth = headers && Object.keys(headers)
+    .find((key) => key.toLowerCase() === 'proxy-authorization')
+  if (existProxyAuth) {
+    throw new InvalidArgumentError('Proxy-Authorization should be sent in ProxyAgent constructor')
+  }
+}
+
+module.exports = ProxyAgent
+
+
+/***/ }),
+
+/***/ 46811:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const Dispatcher = __nccwpck_require__(51927)
+const RetryHandler = __nccwpck_require__(61465)
+
+class RetryAgent extends Dispatcher {
+  #agent = null
+  #options = null
+  constructor (agent, options = {}) {
+    super(options)
+    this.#agent = agent
+    this.#options = options
+  }
+
+  dispatch (opts, handler) {
+    const retry = new RetryHandler({
+      ...opts,
+      retryOptions: this.#options
+    }, {
+      dispatch: this.#agent.dispatch.bind(this.#agent),
+      handler
+    })
+    return this.#agent.dispatch(opts, retry)
+  }
+
+  close () {
+    return this.#agent.close()
+  }
+
+  destroy () {
+    return this.#agent.destroy()
+  }
+}
+
+module.exports = RetryAgent
+
+
+/***/ }),
+
+/***/ 72354:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+// We include a version number for the Dispatcher API. In case of breaking changes,
+// this version number must be increased to avoid conflicts.
+const globalDispatcher = Symbol.for('undici.globalDispatcher.1')
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+const Agent = __nccwpck_require__(83421)
+
+if (getGlobalDispatcher() === undefined) {
+  setGlobalDispatcher(new Agent())
+}
+
+function setGlobalDispatcher (agent) {
+  if (!agent || typeof agent.dispatch !== 'function') {
+    throw new InvalidArgumentError('Argument agent must implement Agent')
+  }
+  Object.defineProperty(globalThis, globalDispatcher, {
+    value: agent,
+    writable: true,
+    enumerable: false,
+    configurable: false
+  })
+}
+
+function getGlobalDispatcher () {
+  return globalThis[globalDispatcher]
+}
+
+module.exports = {
+  setGlobalDispatcher,
+  getGlobalDispatcher
+}
+
+
+/***/ }),
+
+/***/ 7004:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = class DecoratorHandler {
+  #handler
+
+  constructor (handler) {
+    if (typeof handler !== 'object' || handler === null) {
+      throw new TypeError('handler must be an object')
+    }
+    this.#handler = handler
+  }
+
+  onConnect (...args) {
+    return this.#handler.onConnect?.(...args)
+  }
+
+  onError (...args) {
+    return this.#handler.onError?.(...args)
+  }
+
+  onUpgrade (...args) {
+    return this.#handler.onUpgrade?.(...args)
+  }
+
+  onResponseStarted (...args) {
+    return this.#handler.onResponseStarted?.(...args)
+  }
+
+  onHeaders (...args) {
+    return this.#handler.onHeaders?.(...args)
+  }
+
+  onData (...args) {
+    return this.#handler.onData?.(...args)
+  }
+
+  onComplete (...args) {
+    return this.#handler.onComplete?.(...args)
+  }
+
+  onBodySent (...args) {
+    return this.#handler.onBodySent?.(...args)
+  }
+}
+
+
+/***/ }),
+
+/***/ 59470:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const util = __nccwpck_require__(94407)
+const { kBodyUsed } = __nccwpck_require__(5392)
+const assert = __nccwpck_require__(98061)
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+const EE = __nccwpck_require__(15673)
+
+const redirectableStatusCodes = [300, 301, 302, 303, 307, 308]
+
+const kBody = Symbol('body')
+
+class BodyAsyncIterable {
+  constructor (body) {
+    this[kBody] = body
+    this[kBodyUsed] = false
+  }
+
+  async * [Symbol.asyncIterator] () {
+    assert(!this[kBodyUsed], 'disturbed')
+    this[kBodyUsed] = true
+    yield * this[kBody]
+  }
+}
+
+class RedirectHandler {
+  constructor (dispatch, maxRedirections, opts, handler) {
+    if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
+      throw new InvalidArgumentError('maxRedirections must be a positive number')
+    }
+
+    util.validateHandler(handler, opts.method, opts.upgrade)
+
+    this.dispatch = dispatch
+    this.location = null
+    this.abort = null
+    this.opts = { ...opts, maxRedirections: 0 } // opts must be a copy
+    this.maxRedirections = maxRedirections
+    this.handler = handler
+    this.history = []
+    this.redirectionLimitReached = false
+
+    if (util.isStream(this.opts.body)) {
+      // TODO (fix): Provide some way for the user to cache the file to e.g. /tmp
+      // so that it can be dispatched again?
+      // TODO (fix): Do we need 100-expect support to provide a way to do this properly?
+      if (util.bodyLength(this.opts.body) === 0) {
+        this.opts.body
+          .on('data', function () {
+            assert(false)
+          })
+      }
+
+      if (typeof this.opts.body.readableDidRead !== 'boolean') {
+        this.opts.body[kBodyUsed] = false
+        EE.prototype.on.call(this.opts.body, 'data', function () {
+          this[kBodyUsed] = true
+        })
+      }
+    } else if (this.opts.body && typeof this.opts.body.pipeTo === 'function') {
+      // TODO (fix): We can't access ReadableStream internal state
+      // to determine whether or not it has been disturbed. This is just
+      // a workaround.
+      this.opts.body = new BodyAsyncIterable(this.opts.body)
+    } else if (
+      this.opts.body &&
+      typeof this.opts.body !== 'string' &&
+      !ArrayBuffer.isView(this.opts.body) &&
+      util.isIterable(this.opts.body)
+    ) {
+      // TODO: Should we allow re-using iterable if !this.opts.idempotent
+      // or through some other flag?
+      this.opts.body = new BodyAsyncIterable(this.opts.body)
+    }
+  }
+
+  onConnect (abort) {
+    this.abort = abort
+    this.handler.onConnect(abort, { history: this.history })
+  }
+
+  onUpgrade (statusCode, headers, socket) {
+    this.handler.onUpgrade(statusCode, headers, socket)
+  }
+
+  onError (error) {
+    this.handler.onError(error)
+  }
+
+  onHeaders (statusCode, headers, resume, statusText) {
+    this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body)
+      ? null
+      : parseLocation(statusCode, headers)
+
+    if (this.opts.throwOnMaxRedirect && this.history.length >= this.maxRedirections) {
+      if (this.request) {
+        this.request.abort(new Error('max redirects'))
+      }
+
+      this.redirectionLimitReached = true
+      this.abort(new Error('max redirects'))
+      return
+    }
+
+    if (this.opts.origin) {
+      this.history.push(new URL(this.opts.path, this.opts.origin))
+    }
+
+    if (!this.location) {
+      return this.handler.onHeaders(statusCode, headers, resume, statusText)
+    }
+
+    const { origin, pathname, search } = util.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)))
+    const path = search ? `${pathname}${search}` : pathname
+
+    // Remove headers referring to the original URL.
+    // By default it is Host only, unless it's a 303 (see below), which removes also all Content-* headers.
+    // https://tools.ietf.org/html/rfc7231#section-6.4
+    this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin)
+    this.opts.path = path
+    this.opts.origin = origin
+    this.opts.maxRedirections = 0
+    this.opts.query = null
+
+    // https://tools.ietf.org/html/rfc7231#section-6.4.4
+    // In case of HTTP 303, always replace method to be either HEAD or GET
+    if (statusCode === 303 && this.opts.method !== 'HEAD') {
+      this.opts.method = 'GET'
+      this.opts.body = null
+    }
+  }
+
+  onData (chunk) {
+    if (this.location) {
+      /*
+        https://tools.ietf.org/html/rfc7231#section-6.4
+
+        TLDR: undici always ignores 3xx response bodies.
+
+        Redirection is used to serve the requested resource from another URL, so it is assumes that
+        no body is generated (and thus can be ignored). Even though generating a body is not prohibited.
+
+        For status 301, 302, 303, 307 and 308 (the latter from RFC 7238), the specs mention that the body usually
+        (which means it's optional and not mandated) contain just an hyperlink to the value of
+        the Location response header, so the body can be ignored safely.
+
+        For status 300, which is "Multiple Choices", the spec mentions both generating a Location
+        response header AND a response body with the other possible location to follow.
+        Since the spec explicitly chooses not to specify a format for such body and leave it to
+        servers and browsers implementors, we ignore the body as there is no specified way to eventually parse it.
+      */
+    } else {
+      return this.handler.onData(chunk)
+    }
+  }
+
+  onComplete (trailers) {
+    if (this.location) {
+      /*
+        https://tools.ietf.org/html/rfc7231#section-6.4
+
+        TLDR: undici always ignores 3xx response trailers as they are not expected in case of redirections
+        and neither are useful if present.
+
+        See comment on onData method above for more detailed information.
+      */
+
+      this.location = null
+      this.abort = null
+
+      this.dispatch(this.opts, this)
+    } else {
+      this.handler.onComplete(trailers)
+    }
+  }
+
+  onBodySent (chunk) {
+    if (this.handler.onBodySent) {
+      this.handler.onBodySent(chunk)
+    }
+  }
+}
+
+function parseLocation (statusCode, headers) {
+  if (redirectableStatusCodes.indexOf(statusCode) === -1) {
+    return null
+  }
+
+  for (let i = 0; i < headers.length; i += 2) {
+    if (headers[i].length === 8 && util.headerNameToString(headers[i]) === 'location') {
+      return headers[i + 1]
+    }
+  }
+}
+
+// https://tools.ietf.org/html/rfc7231#section-6.4.4
+function shouldRemoveHeader (header, removeContent, unknownOrigin) {
+  if (header.length === 4) {
+    return util.headerNameToString(header) === 'host'
+  }
+  if (removeContent && util.headerNameToString(header).startsWith('content-')) {
+    return true
+  }
+  if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) {
+    const name = util.headerNameToString(header)
+    return name === 'authorization' || name === 'cookie' || name === 'proxy-authorization'
+  }
+  return false
+}
+
+// https://tools.ietf.org/html/rfc7231#section-6.4
+function cleanRequestHeaders (headers, removeContent, unknownOrigin) {
+  const ret = []
+  if (Array.isArray(headers)) {
+    for (let i = 0; i < headers.length; i += 2) {
+      if (!shouldRemoveHeader(headers[i], removeContent, unknownOrigin)) {
+        ret.push(headers[i], headers[i + 1])
+      }
+    }
+  } else if (headers && typeof headers === 'object') {
+    for (const key of Object.keys(headers)) {
+      if (!shouldRemoveHeader(key, removeContent, unknownOrigin)) {
+        ret.push(key, headers[key])
+      }
+    }
+  } else {
+    assert(headers == null, 'headers must be an object or an array')
+  }
+  return ret
+}
+
+module.exports = RedirectHandler
+
+
+/***/ }),
+
+/***/ 61465:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const assert = __nccwpck_require__(98061)
+
+const { kRetryHandlerDefaultRetry } = __nccwpck_require__(5392)
+const { RequestRetryError } = __nccwpck_require__(22174)
+const {
+  isDisturbed,
+  parseHeaders,
+  parseRangeHeader,
+  wrapRequestBody
+} = __nccwpck_require__(94407)
+
+function calculateRetryAfterHeader (retryAfter) {
+  const current = Date.now()
+  return new Date(retryAfter).getTime() - current
+}
+
+class RetryHandler {
+  constructor (opts, handlers) {
+    const { retryOptions, ...dispatchOpts } = opts
+    const {
+      // Retry scoped
+      retry: retryFn,
+      maxRetries,
+      maxTimeout,
+      minTimeout,
+      timeoutFactor,
+      // Response scoped
+      methods,
+      errorCodes,
+      retryAfter,
+      statusCodes
+    } = retryOptions ?? {}
+
+    this.dispatch = handlers.dispatch
+    this.handler = handlers.handler
+    this.opts = { ...dispatchOpts, body: wrapRequestBody(opts.body) }
+    this.abort = null
+    this.aborted = false
+    this.retryOpts = {
+      retry: retryFn ?? RetryHandler[kRetryHandlerDefaultRetry],
+      retryAfter: retryAfter ?? true,
+      maxTimeout: maxTimeout ?? 30 * 1000, // 30s,
+      minTimeout: minTimeout ?? 500, // .5s
+      timeoutFactor: timeoutFactor ?? 2,
+      maxRetries: maxRetries ?? 5,
+      // What errors we should retry
+      methods: methods ?? ['GET', 'HEAD', 'OPTIONS', 'PUT', 'DELETE', 'TRACE'],
+      // Indicates which errors to retry
+      statusCodes: statusCodes ?? [500, 502, 503, 504, 429],
+      // List of errors to retry
+      errorCodes: errorCodes ?? [
+        'ECONNRESET',
+        'ECONNREFUSED',
+        'ENOTFOUND',
+        'ENETDOWN',
+        'ENETUNREACH',
+        'EHOSTDOWN',
+        'EHOSTUNREACH',
+        'EPIPE',
+        'UND_ERR_SOCKET'
+      ]
+    }
+
+    this.retryCount = 0
+    this.retryCountCheckpoint = 0
+    this.start = 0
+    this.end = null
+    this.etag = null
+    this.resume = null
+
+    // Handle possible onConnect duplication
+    this.handler.onConnect(reason => {
+      this.aborted = true
+      if (this.abort) {
+        this.abort(reason)
+      } else {
+        this.reason = reason
+      }
+    })
+  }
+
+  onRequestSent () {
+    if (this.handler.onRequestSent) {
+      this.handler.onRequestSent()
+    }
+  }
+
+  onUpgrade (statusCode, headers, socket) {
+    if (this.handler.onUpgrade) {
+      this.handler.onUpgrade(statusCode, headers, socket)
+    }
+  }
+
+  onConnect (abort) {
+    if (this.aborted) {
+      abort(this.reason)
+    } else {
+      this.abort = abort
+    }
+  }
+
+  onBodySent (chunk) {
+    if (this.handler.onBodySent) return this.handler.onBodySent(chunk)
+  }
+
+  static [kRetryHandlerDefaultRetry] (err, { state, opts }, cb) {
+    const { statusCode, code, headers } = err
+    const { method, retryOptions } = opts
+    const {
+      maxRetries,
+      minTimeout,
+      maxTimeout,
+      timeoutFactor,
+      statusCodes,
+      errorCodes,
+      methods
+    } = retryOptions
+    const { counter } = state
+
+    // Any code that is not a Undici's originated and allowed to retry
+    if (code && code !== 'UND_ERR_REQ_RETRY' && !errorCodes.includes(code)) {
+      cb(err)
+      return
+    }
+
+    // If a set of method are provided and the current method is not in the list
+    if (Array.isArray(methods) && !methods.includes(method)) {
+      cb(err)
+      return
+    }
+
+    // If a set of status code are provided and the current status code is not in the list
+    if (
+      statusCode != null &&
+      Array.isArray(statusCodes) &&
+      !statusCodes.includes(statusCode)
+    ) {
+      cb(err)
+      return
+    }
+
+    // If we reached the max number of retries
+    if (counter > maxRetries) {
+      cb(err)
+      return
+    }
+
+    let retryAfterHeader = headers?.['retry-after']
+    if (retryAfterHeader) {
+      retryAfterHeader = Number(retryAfterHeader)
+      retryAfterHeader = Number.isNaN(retryAfterHeader)
+        ? calculateRetryAfterHeader(retryAfterHeader)
+        : retryAfterHeader * 1e3 // Retry-After is in seconds
+    }
+
+    const retryTimeout =
+      retryAfterHeader > 0
+        ? Math.min(retryAfterHeader, maxTimeout)
+        : Math.min(minTimeout * timeoutFactor ** (counter - 1), maxTimeout)
+
+    setTimeout(() => cb(null), retryTimeout)
+  }
+
+  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
+    const headers = parseHeaders(rawHeaders)
+
+    this.retryCount += 1
+
+    if (statusCode >= 300) {
+      if (this.retryOpts.statusCodes.includes(statusCode) === false) {
+        return this.handler.onHeaders(
+          statusCode,
+          rawHeaders,
+          resume,
+          statusMessage
+        )
+      } else {
+        this.abort(
+          new RequestRetryError('Request failed', statusCode, {
+            headers,
+            data: {
+              count: this.retryCount
+            }
+          })
+        )
+        return false
+      }
+    }
+
+    // Checkpoint for resume from where we left it
+    if (this.resume != null) {
+      this.resume = null
+
+      // Only Partial Content 206 supposed to provide Content-Range,
+      // any other status code that partially consumed the payload
+      // should not be retry because it would result in downstream
+      // wrongly concatanete multiple responses.
+      if (statusCode !== 206 && (this.start > 0 || statusCode !== 200)) {
+        this.abort(
+          new RequestRetryError('server does not support the range header and the payload was partially consumed', statusCode, {
+            headers,
+            data: { count: this.retryCount }
+          })
+        )
+        return false
+      }
+
+      const contentRange = parseRangeHeader(headers['content-range'])
+      // If no content range
+      if (!contentRange) {
+        this.abort(
+          new RequestRetryError('Content-Range mismatch', statusCode, {
+            headers,
+            data: { count: this.retryCount }
+          })
+        )
+        return false
+      }
+
+      // Let's start with a weak etag check
+      if (this.etag != null && this.etag !== headers.etag) {
+        this.abort(
+          new RequestRetryError('ETag mismatch', statusCode, {
+            headers,
+            data: { count: this.retryCount }
+          })
+        )
+        return false
+      }
+
+      const { start, size, end = size - 1 } = contentRange
+
+      assert(this.start === start, 'content-range mismatch')
+      assert(this.end == null || this.end === end, 'content-range mismatch')
+
+      this.resume = resume
+      return true
+    }
+
+    if (this.end == null) {
+      if (statusCode === 206) {
+        // First time we receive 206
+        const range = parseRangeHeader(headers['content-range'])
+
+        if (range == null) {
+          return this.handler.onHeaders(
+            statusCode,
+            rawHeaders,
+            resume,
+            statusMessage
+          )
+        }
+
+        const { start, size, end = size - 1 } = range
+        assert(
+          start != null && Number.isFinite(start),
+          'content-range mismatch'
+        )
+        assert(end != null && Number.isFinite(end), 'invalid content-length')
+
+        this.start = start
+        this.end = end
+      }
+
+      // We make our best to checkpoint the body for further range headers
+      if (this.end == null) {
+        const contentLength = headers['content-length']
+        this.end = contentLength != null ? Number(contentLength) - 1 : null
+      }
+
+      assert(Number.isFinite(this.start))
+      assert(
+        this.end == null || Number.isFinite(this.end),
+        'invalid content-length'
+      )
+
+      this.resume = resume
+      this.etag = headers.etag != null ? headers.etag : null
+
+      // Weak etags are not useful for comparison nor cache
+      // for instance not safe to assume if the response is byte-per-byte
+      // equal
+      if (this.etag != null && this.etag.startsWith('W/')) {
+        this.etag = null
+      }
+
+      return this.handler.onHeaders(
+        statusCode,
+        rawHeaders,
+        resume,
+        statusMessage
+      )
+    }
+
+    const err = new RequestRetryError('Request failed', statusCode, {
+      headers,
+      data: { count: this.retryCount }
+    })
+
+    this.abort(err)
+
+    return false
+  }
+
+  onData (chunk) {
+    this.start += chunk.length
+
+    return this.handler.onData(chunk)
+  }
+
+  onComplete (rawTrailers) {
+    this.retryCount = 0
+    return this.handler.onComplete(rawTrailers)
+  }
+
+  onError (err) {
+    if (this.aborted || isDisturbed(this.opts.body)) {
+      return this.handler.onError(err)
+    }
+
+    // We reconcile in case of a mix between network errors
+    // and server error response
+    if (this.retryCount - this.retryCountCheckpoint > 0) {
+      // We count the difference between the last checkpoint and the current retry count
+      this.retryCount =
+        this.retryCountCheckpoint +
+        (this.retryCount - this.retryCountCheckpoint)
+    } else {
+      this.retryCount += 1
+    }
+
+    this.retryOpts.retry(
+      err,
+      {
+        state: { counter: this.retryCount },
+        opts: { retryOptions: this.retryOpts, ...this.opts }
+      },
+      onRetry.bind(this)
+    )
+
+    function onRetry (err) {
+      if (err != null || this.aborted || isDisturbed(this.opts.body)) {
+        return this.handler.onError(err)
+      }
+
+      if (this.start !== 0) {
+        const headers = { range: `bytes=${this.start}-${this.end ?? ''}` }
+
+        // Weak etag check - weak etags will make comparison algorithms never match
+        if (this.etag != null) {
+          headers['if-match'] = this.etag
+        }
+
+        this.opts = {
+          ...this.opts,
+          headers: {
+            ...this.opts.headers,
+            ...headers
+          }
+        }
+      }
+
+      try {
+        this.retryCountCheckpoint = this.retryCount
+        this.dispatch(this.opts, this)
+      } catch (err) {
+        this.handler.onError(err)
+      }
+    }
+  }
+}
+
+module.exports = RetryHandler
+
+
+/***/ }),
+
+/***/ 42462:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const { isIP } = __nccwpck_require__(87503)
+const { lookup } = __nccwpck_require__(30604)
+const DecoratorHandler = __nccwpck_require__(7004)
+const { InvalidArgumentError, InformationalError } = __nccwpck_require__(22174)
+const maxInt = Math.pow(2, 31) - 1
+
+class DNSInstance {
+  #maxTTL = 0
+  #maxItems = 0
+  #records = new Map()
+  dualStack = true
+  affinity = null
+  lookup = null
+  pick = null
+
+  constructor (opts) {
+    this.#maxTTL = opts.maxTTL
+    this.#maxItems = opts.maxItems
+    this.dualStack = opts.dualStack
+    this.affinity = opts.affinity
+    this.lookup = opts.lookup ?? this.#defaultLookup
+    this.pick = opts.pick ?? this.#defaultPick
+  }
+
+  get full () {
+    return this.#records.size === this.#maxItems
+  }
+
+  runLookup (origin, opts, cb) {
+    const ips = this.#records.get(origin.hostname)
+
+    // If full, we just return the origin
+    if (ips == null && this.full) {
+      cb(null, origin.origin)
+      return
+    }
+
+    const newOpts = {
+      affinity: this.affinity,
+      dualStack: this.dualStack,
+      lookup: this.lookup,
+      pick: this.pick,
+      ...opts.dns,
+      maxTTL: this.#maxTTL,
+      maxItems: this.#maxItems
+    }
+
+    // If no IPs we lookup
+    if (ips == null) {
+      this.lookup(origin, newOpts, (err, addresses) => {
+        if (err || addresses == null || addresses.length === 0) {
+          cb(err ?? new InformationalError('No DNS entries found'))
+          return
+        }
+
+        this.setRecords(origin, addresses)
+        const records = this.#records.get(origin.hostname)
+
+        const ip = this.pick(
+          origin,
+          records,
+          newOpts.affinity
+        )
+
+        let port
+        if (typeof ip.port === 'number') {
+          port = `:${ip.port}`
+        } else if (origin.port !== '') {
+          port = `:${origin.port}`
+        } else {
+          port = ''
+        }
+
+        cb(
+          null,
+          `${origin.protocol}//${
+            ip.family === 6 ? `[${ip.address}]` : ip.address
+          }${port}`
+        )
+      })
+    } else {
+      // If there's IPs we pick
+      const ip = this.pick(
+        origin,
+        ips,
+        newOpts.affinity
+      )
+
+      // If no IPs we lookup - deleting old records
+      if (ip == null) {
+        this.#records.delete(origin.hostname)
+        this.runLookup(origin, opts, cb)
+        return
+      }
+
+      let port
+      if (typeof ip.port === 'number') {
+        port = `:${ip.port}`
+      } else if (origin.port !== '') {
+        port = `:${origin.port}`
+      } else {
+        port = ''
+      }
+
+      cb(
+        null,
+        `${origin.protocol}//${
+          ip.family === 6 ? `[${ip.address}]` : ip.address
+        }${port}`
+      )
+    }
+  }
+
+  #defaultLookup (origin, opts, cb) {
+    lookup(
+      origin.hostname,
+      {
+        all: true,
+        family: this.dualStack === false ? this.affinity : 0,
+        order: 'ipv4first'
+      },
+      (err, addresses) => {
+        if (err) {
+          return cb(err)
+        }
+
+        const results = new Map()
+
+        for (const addr of addresses) {
+          // On linux we found duplicates, we attempt to remove them with
+          // the latest record
+          results.set(`${addr.address}:${addr.family}`, addr)
+        }
+
+        cb(null, results.values())
+      }
+    )
+  }
+
+  #defaultPick (origin, hostnameRecords, affinity) {
+    let ip = null
+    const { records, offset } = hostnameRecords
+
+    let family
+    if (this.dualStack) {
+      if (affinity == null) {
+        // Balance between ip families
+        if (offset == null || offset === maxInt) {
+          hostnameRecords.offset = 0
+          affinity = 4
+        } else {
+          hostnameRecords.offset++
+          affinity = (hostnameRecords.offset & 1) === 1 ? 6 : 4
+        }
+      }
+
+      if (records[affinity] != null && records[affinity].ips.length > 0) {
+        family = records[affinity]
+      } else {
+        family = records[affinity === 4 ? 6 : 4]
+      }
+    } else {
+      family = records[affinity]
+    }
+
+    // If no IPs we return null
+    if (family == null || family.ips.length === 0) {
+      return ip
+    }
+
+    if (family.offset == null || family.offset === maxInt) {
+      family.offset = 0
+    } else {
+      family.offset++
+    }
+
+    const position = family.offset % family.ips.length
+    ip = family.ips[position] ?? null
+
+    if (ip == null) {
+      return ip
+    }
+
+    if (Date.now() - ip.timestamp > ip.ttl) { // record TTL is already in ms
+      // We delete expired records
+      // It is possible that they have different TTL, so we manage them individually
+      family.ips.splice(position, 1)
+      return this.pick(origin, hostnameRecords, affinity)
+    }
+
+    return ip
+  }
+
+  setRecords (origin, addresses) {
+    const timestamp = Date.now()
+    const records = { records: { 4: null, 6: null } }
+    for (const record of addresses) {
+      record.timestamp = timestamp
+      if (typeof record.ttl === 'number') {
+        // The record TTL is expected to be in ms
+        record.ttl = Math.min(record.ttl, this.#maxTTL)
+      } else {
+        record.ttl = this.#maxTTL
+      }
+
+      const familyRecords = records.records[record.family] ?? { ips: [] }
+
+      familyRecords.ips.push(record)
+      records.records[record.family] = familyRecords
+    }
+
+    this.#records.set(origin.hostname, records)
+  }
+
+  getHandler (meta, opts) {
+    return new DNSDispatchHandler(this, meta, opts)
+  }
+}
+
+class DNSDispatchHandler extends DecoratorHandler {
+  #state = null
+  #opts = null
+  #dispatch = null
+  #handler = null
+  #origin = null
+
+  constructor (state, { origin, handler, dispatch }, opts) {
+    super(handler)
+    this.#origin = origin
+    this.#handler = handler
+    this.#opts = { ...opts }
+    this.#state = state
+    this.#dispatch = dispatch
+  }
+
+  onError (err) {
+    switch (err.code) {
+      case 'ETIMEDOUT':
+      case 'ECONNREFUSED': {
+        if (this.#state.dualStack) {
+          // We delete the record and retry
+          this.#state.runLookup(this.#origin, this.#opts, (err, newOrigin) => {
+            if (err) {
+              return this.#handler.onError(err)
+            }
+
+            const dispatchOpts = {
+              ...this.#opts,
+              origin: newOrigin
+            }
+
+            this.#dispatch(dispatchOpts, this)
+          })
+
+          // if dual-stack disabled, we error out
+          return
+        }
+
+        this.#handler.onError(err)
+        return
+      }
+      case 'ENOTFOUND':
+        this.#state.deleteRecord(this.#origin)
+      // eslint-disable-next-line no-fallthrough
+      default:
+        this.#handler.onError(err)
+        break
+    }
+  }
+}
+
+module.exports = interceptorOpts => {
+  if (
+    interceptorOpts?.maxTTL != null &&
+    (typeof interceptorOpts?.maxTTL !== 'number' || interceptorOpts?.maxTTL < 0)
+  ) {
+    throw new InvalidArgumentError('Invalid maxTTL. Must be a positive number')
+  }
+
+  if (
+    interceptorOpts?.maxItems != null &&
+    (typeof interceptorOpts?.maxItems !== 'number' ||
+      interceptorOpts?.maxItems < 1)
+  ) {
+    throw new InvalidArgumentError(
+      'Invalid maxItems. Must be a positive number and greater than zero'
+    )
+  }
+
+  if (
+    interceptorOpts?.affinity != null &&
+    interceptorOpts?.affinity !== 4 &&
+    interceptorOpts?.affinity !== 6
+  ) {
+    throw new InvalidArgumentError('Invalid affinity. Must be either 4 or 6')
+  }
+
+  if (
+    interceptorOpts?.dualStack != null &&
+    typeof interceptorOpts?.dualStack !== 'boolean'
+  ) {
+    throw new InvalidArgumentError('Invalid dualStack. Must be a boolean')
+  }
+
+  if (
+    interceptorOpts?.lookup != null &&
+    typeof interceptorOpts?.lookup !== 'function'
+  ) {
+    throw new InvalidArgumentError('Invalid lookup. Must be a function')
+  }
+
+  if (
+    interceptorOpts?.pick != null &&
+    typeof interceptorOpts?.pick !== 'function'
+  ) {
+    throw new InvalidArgumentError('Invalid pick. Must be a function')
+  }
+
+  const dualStack = interceptorOpts?.dualStack ?? true
+  let affinity
+  if (dualStack) {
+    affinity = interceptorOpts?.affinity ?? null
+  } else {
+    affinity = interceptorOpts?.affinity ?? 4
+  }
+
+  const opts = {
+    maxTTL: interceptorOpts?.maxTTL ?? 10e3, // Expressed in ms
+    lookup: interceptorOpts?.lookup ?? null,
+    pick: interceptorOpts?.pick ?? null,
+    dualStack,
+    affinity,
+    maxItems: interceptorOpts?.maxItems ?? Infinity
+  }
+
+  const instance = new DNSInstance(opts)
+
+  return dispatch => {
+    return function dnsInterceptor (origDispatchOpts, handler) {
+      const origin =
+        origDispatchOpts.origin.constructor === URL
+          ? origDispatchOpts.origin
+          : new URL(origDispatchOpts.origin)
+
+      if (isIP(origin.hostname) !== 0) {
+        return dispatch(origDispatchOpts, handler)
+      }
+
+      instance.runLookup(origin, origDispatchOpts, (err, newOrigin) => {
+        if (err) {
+          return handler.onError(err)
+        }
+
+        let dispatchOpts = null
+        dispatchOpts = {
+          ...origDispatchOpts,
+          servername: origin.hostname, // For SNI on TLS
+          origin: newOrigin,
+          headers: {
+            host: origin.hostname,
+            ...origDispatchOpts.headers
+          }
+        }
+
+        dispatch(
+          dispatchOpts,
+          instance.getHandler({ origin, dispatch, handler }, origDispatchOpts)
+        )
+      })
+
+      return true
+    }
+  }
+}
+
+
+/***/ }),
+
+/***/ 3199:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const util = __nccwpck_require__(94407)
+const { InvalidArgumentError, RequestAbortedError } = __nccwpck_require__(22174)
+const DecoratorHandler = __nccwpck_require__(7004)
+
+class DumpHandler extends DecoratorHandler {
+  #maxSize = 1024 * 1024
+  #abort = null
+  #dumped = false
+  #aborted = false
+  #size = 0
+  #reason = null
+  #handler = null
+
+  constructor ({ maxSize }, handler) {
+    super(handler)
+
+    if (maxSize != null && (!Number.isFinite(maxSize) || maxSize < 1)) {
+      throw new InvalidArgumentError('maxSize must be a number greater than 0')
+    }
+
+    this.#maxSize = maxSize ?? this.#maxSize
+    this.#handler = handler
+  }
+
+  onConnect (abort) {
+    this.#abort = abort
+
+    this.#handler.onConnect(this.#customAbort.bind(this))
+  }
+
+  #customAbort (reason) {
+    this.#aborted = true
+    this.#reason = reason
+  }
+
+  // TODO: will require adjustment after new hooks are out
+  onHeaders (statusCode, rawHeaders, resume, statusMessage) {
+    const headers = util.parseHeaders(rawHeaders)
+    const contentLength = headers['content-length']
+
+    if (contentLength != null && contentLength > this.#maxSize) {
+      throw new RequestAbortedError(
+        `Response size (${contentLength}) larger than maxSize (${
+          this.#maxSize
+        })`
+      )
+    }
+
+    if (this.#aborted) {
+      return true
+    }
+
+    return this.#handler.onHeaders(
+      statusCode,
+      rawHeaders,
+      resume,
+      statusMessage
+    )
+  }
+
+  onError (err) {
+    if (this.#dumped) {
+      return
+    }
+
+    err = this.#reason ?? err
+
+    this.#handler.onError(err)
+  }
+
+  onData (chunk) {
+    this.#size = this.#size + chunk.length
+
+    if (this.#size >= this.#maxSize) {
+      this.#dumped = true
+
+      if (this.#aborted) {
+        this.#handler.onError(this.#reason)
+      } else {
+        this.#handler.onComplete([])
+      }
+    }
+
+    return true
+  }
+
+  onComplete (trailers) {
+    if (this.#dumped) {
+      return
+    }
+
+    if (this.#aborted) {
+      this.#handler.onError(this.reason)
+      return
+    }
+
+    this.#handler.onComplete(trailers)
+  }
+}
+
+function createDumpInterceptor (
+  { maxSize: defaultMaxSize } = {
+    maxSize: 1024 * 1024
+  }
+) {
+  return dispatch => {
+    return function Intercept (opts, handler) {
+      const { dumpMaxSize = defaultMaxSize } =
+        opts
+
+      const dumpHandler = new DumpHandler(
+        { maxSize: dumpMaxSize },
+        handler
+      )
+
+      return dispatch(opts, dumpHandler)
+    }
+  }
+}
+
+module.exports = createDumpInterceptor
+
+
+/***/ }),
+
+/***/ 11115:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const RedirectHandler = __nccwpck_require__(59470)
+
+function createRedirectInterceptor ({ maxRedirections: defaultMaxRedirections }) {
+  return (dispatch) => {
+    return function Intercept (opts, handler) {
+      const { maxRedirections = defaultMaxRedirections } = opts
+
+      if (!maxRedirections) {
+        return dispatch(opts, handler)
+      }
+
+      const redirectHandler = new RedirectHandler(dispatch, maxRedirections, opts, handler)
+      opts = { ...opts, maxRedirections: 0 } // Stop sub dispatcher from also redirecting.
+      return dispatch(opts, redirectHandler)
+    }
+  }
+}
+
+module.exports = createRedirectInterceptor
+
+
+/***/ }),
+
+/***/ 42370:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const RedirectHandler = __nccwpck_require__(59470)
+
+module.exports = opts => {
+  const globalMaxRedirections = opts?.maxRedirections
+  return dispatch => {
+    return function redirectInterceptor (opts, handler) {
+      const { maxRedirections = globalMaxRedirections, ...baseOpts } = opts
+
+      if (!maxRedirections) {
+        return dispatch(opts, handler)
+      }
+
+      const redirectHandler = new RedirectHandler(
+        dispatch,
+        maxRedirections,
+        opts,
+        handler
+      )
+
+      return dispatch(baseOpts, redirectHandler)
+    }
+  }
+}
+
+
+/***/ }),
+
+/***/ 66080:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const RetryHandler = __nccwpck_require__(61465)
+
+module.exports = globalOpts => {
+  return dispatch => {
+    return function retryInterceptor (opts, handler) {
+      return dispatch(
+        opts,
+        new RetryHandler(
+          { ...opts, retryOptions: { ...globalOpts, ...opts.retryOptions } },
+          {
+            handler,
+            dispatch
+          }
+        )
+      )
+    }
+  }
+}
+
+
+/***/ }),
+
+/***/ 59086:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SPECIAL_HEADERS = exports.HEADER_STATE = exports.MINOR = exports.MAJOR = exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS = exports.TOKEN = exports.STRICT_TOKEN = exports.HEX = exports.URL_CHAR = exports.STRICT_URL_CHAR = exports.USERINFO_CHARS = exports.MARK = exports.ALPHANUM = exports.NUM = exports.HEX_MAP = exports.NUM_MAP = exports.ALPHA = exports.FINISH = exports.H_METHOD_MAP = exports.METHOD_MAP = exports.METHODS_RTSP = exports.METHODS_ICE = exports.METHODS_HTTP = exports.METHODS = exports.LENIENT_FLAGS = exports.FLAGS = exports.TYPE = exports.ERROR = void 0;
+const utils_1 = __nccwpck_require__(44118);
+// C headers
+var ERROR;
+(function (ERROR) {
+    ERROR[ERROR["OK"] = 0] = "OK";
+    ERROR[ERROR["INTERNAL"] = 1] = "INTERNAL";
+    ERROR[ERROR["STRICT"] = 2] = "STRICT";
+    ERROR[ERROR["LF_EXPECTED"] = 3] = "LF_EXPECTED";
+    ERROR[ERROR["UNEXPECTED_CONTENT_LENGTH"] = 4] = "UNEXPECTED_CONTENT_LENGTH";
+    ERROR[ERROR["CLOSED_CONNECTION"] = 5] = "CLOSED_CONNECTION";
+    ERROR[ERROR["INVALID_METHOD"] = 6] = "INVALID_METHOD";
+    ERROR[ERROR["INVALID_URL"] = 7] = "INVALID_URL";
+    ERROR[ERROR["INVALID_CONSTANT"] = 8] = "INVALID_CONSTANT";
+    ERROR[ERROR["INVALID_VERSION"] = 9] = "INVALID_VERSION";
+    ERROR[ERROR["INVALID_HEADER_TOKEN"] = 10] = "INVALID_HEADER_TOKEN";
+    ERROR[ERROR["INVALID_CONTENT_LENGTH"] = 11] = "INVALID_CONTENT_LENGTH";
+    ERROR[ERROR["INVALID_CHUNK_SIZE"] = 12] = "INVALID_CHUNK_SIZE";
+    ERROR[ERROR["INVALID_STATUS"] = 13] = "INVALID_STATUS";
+    ERROR[ERROR["INVALID_EOF_STATE"] = 14] = "INVALID_EOF_STATE";
+    ERROR[ERROR["INVALID_TRANSFER_ENCODING"] = 15] = "INVALID_TRANSFER_ENCODING";
+    ERROR[ERROR["CB_MESSAGE_BEGIN"] = 16] = "CB_MESSAGE_BEGIN";
+    ERROR[ERROR["CB_HEADERS_COMPLETE"] = 17] = "CB_HEADERS_COMPLETE";
+    ERROR[ERROR["CB_MESSAGE_COMPLETE"] = 18] = "CB_MESSAGE_COMPLETE";
+    ERROR[ERROR["CB_CHUNK_HEADER"] = 19] = "CB_CHUNK_HEADER";
+    ERROR[ERROR["CB_CHUNK_COMPLETE"] = 20] = "CB_CHUNK_COMPLETE";
+    ERROR[ERROR["PAUSED"] = 21] = "PAUSED";
+    ERROR[ERROR["PAUSED_UPGRADE"] = 22] = "PAUSED_UPGRADE";
+    ERROR[ERROR["PAUSED_H2_UPGRADE"] = 23] = "PAUSED_H2_UPGRADE";
+    ERROR[ERROR["USER"] = 24] = "USER";
+})(ERROR = exports.ERROR || (exports.ERROR = {}));
+var TYPE;
+(function (TYPE) {
+    TYPE[TYPE["BOTH"] = 0] = "BOTH";
+    TYPE[TYPE["REQUEST"] = 1] = "REQUEST";
+    TYPE[TYPE["RESPONSE"] = 2] = "RESPONSE";
+})(TYPE = exports.TYPE || (exports.TYPE = {}));
+var FLAGS;
+(function (FLAGS) {
+    FLAGS[FLAGS["CONNECTION_KEEP_ALIVE"] = 1] = "CONNECTION_KEEP_ALIVE";
+    FLAGS[FLAGS["CONNECTION_CLOSE"] = 2] = "CONNECTION_CLOSE";
+    FLAGS[FLAGS["CONNECTION_UPGRADE"] = 4] = "CONNECTION_UPGRADE";
+    FLAGS[FLAGS["CHUNKED"] = 8] = "CHUNKED";
+    FLAGS[FLAGS["UPGRADE"] = 16] = "UPGRADE";
+    FLAGS[FLAGS["CONTENT_LENGTH"] = 32] = "CONTENT_LENGTH";
+    FLAGS[FLAGS["SKIPBODY"] = 64] = "SKIPBODY";
+    FLAGS[FLAGS["TRAILING"] = 128] = "TRAILING";
+    // 1 << 8 is unused
+    FLAGS[FLAGS["TRANSFER_ENCODING"] = 512] = "TRANSFER_ENCODING";
+})(FLAGS = exports.FLAGS || (exports.FLAGS = {}));
+var LENIENT_FLAGS;
+(function (LENIENT_FLAGS) {
+    LENIENT_FLAGS[LENIENT_FLAGS["HEADERS"] = 1] = "HEADERS";
+    LENIENT_FLAGS[LENIENT_FLAGS["CHUNKED_LENGTH"] = 2] = "CHUNKED_LENGTH";
+    LENIENT_FLAGS[LENIENT_FLAGS["KEEP_ALIVE"] = 4] = "KEEP_ALIVE";
+})(LENIENT_FLAGS = exports.LENIENT_FLAGS || (exports.LENIENT_FLAGS = {}));
+var METHODS;
+(function (METHODS) {
+    METHODS[METHODS["DELETE"] = 0] = "DELETE";
+    METHODS[METHODS["GET"] = 1] = "GET";
+    METHODS[METHODS["HEAD"] = 2] = "HEAD";
+    METHODS[METHODS["POST"] = 3] = "POST";
+    METHODS[METHODS["PUT"] = 4] = "PUT";
+    /* pathological */
+    METHODS[METHODS["CONNECT"] = 5] = "CONNECT";
+    METHODS[METHODS["OPTIONS"] = 6] = "OPTIONS";
+    METHODS[METHODS["TRACE"] = 7] = "TRACE";
+    /* WebDAV */
+    METHODS[METHODS["COPY"] = 8] = "COPY";
+    METHODS[METHODS["LOCK"] = 9] = "LOCK";
+    METHODS[METHODS["MKCOL"] = 10] = "MKCOL";
+    METHODS[METHODS["MOVE"] = 11] = "MOVE";
+    METHODS[METHODS["PROPFIND"] = 12] = "PROPFIND";
+    METHODS[METHODS["PROPPATCH"] = 13] = "PROPPATCH";
+    METHODS[METHODS["SEARCH"] = 14] = "SEARCH";
+    METHODS[METHODS["UNLOCK"] = 15] = "UNLOCK";
+    METHODS[METHODS["BIND"] = 16] = "BIND";
+    METHODS[METHODS["REBIND"] = 17] = "REBIND";
+    METHODS[METHODS["UNBIND"] = 18] = "UNBIND";
+    METHODS[METHODS["ACL"] = 19] = "ACL";
+    /* subversion */
+    METHODS[METHODS["REPORT"] = 20] = "REPORT";
+    METHODS[METHODS["MKACTIVITY"] = 21] = "MKACTIVITY";
+    METHODS[METHODS["CHECKOUT"] = 22] = "CHECKOUT";
+    METHODS[METHODS["MERGE"] = 23] = "MERGE";
+    /* upnp */
+    METHODS[METHODS["M-SEARCH"] = 24] = "M-SEARCH";
+    METHODS[METHODS["NOTIFY"] = 25] = "NOTIFY";
+    METHODS[METHODS["SUBSCRIBE"] = 26] = "SUBSCRIBE";
+    METHODS[METHODS["UNSUBSCRIBE"] = 27] = "UNSUBSCRIBE";
+    /* RFC-5789 */
+    METHODS[METHODS["PATCH"] = 28] = "PATCH";
+    METHODS[METHODS["PURGE"] = 29] = "PURGE";
+    /* CalDAV */
+    METHODS[METHODS["MKCALENDAR"] = 30] = "MKCALENDAR";
+    /* RFC-2068, section 19.6.1.2 */
+    METHODS[METHODS["LINK"] = 31] = "LINK";
+    METHODS[METHODS["UNLINK"] = 32] = "UNLINK";
+    /* icecast */
+    METHODS[METHODS["SOURCE"] = 33] = "SOURCE";
+    /* RFC-7540, section 11.6 */
+    METHODS[METHODS["PRI"] = 34] = "PRI";
+    /* RFC-2326 RTSP */
+    METHODS[METHODS["DESCRIBE"] = 35] = "DESCRIBE";
+    METHODS[METHODS["ANNOUNCE"] = 36] = "ANNOUNCE";
+    METHODS[METHODS["SETUP"] = 37] = "SETUP";
+    METHODS[METHODS["PLAY"] = 38] = "PLAY";
+    METHODS[METHODS["PAUSE"] = 39] = "PAUSE";
+    METHODS[METHODS["TEARDOWN"] = 40] = "TEARDOWN";
+    METHODS[METHODS["GET_PARAMETER"] = 41] = "GET_PARAMETER";
+    METHODS[METHODS["SET_PARAMETER"] = 42] = "SET_PARAMETER";
+    METHODS[METHODS["REDIRECT"] = 43] = "REDIRECT";
+    METHODS[METHODS["RECORD"] = 44] = "RECORD";
+    /* RAOP */
+    METHODS[METHODS["FLUSH"] = 45] = "FLUSH";
+})(METHODS = exports.METHODS || (exports.METHODS = {}));
+exports.METHODS_HTTP = [
+    METHODS.DELETE,
+    METHODS.GET,
+    METHODS.HEAD,
+    METHODS.POST,
+    METHODS.PUT,
+    METHODS.CONNECT,
+    METHODS.OPTIONS,
+    METHODS.TRACE,
+    METHODS.COPY,
+    METHODS.LOCK,
+    METHODS.MKCOL,
+    METHODS.MOVE,
+    METHODS.PROPFIND,
+    METHODS.PROPPATCH,
+    METHODS.SEARCH,
+    METHODS.UNLOCK,
+    METHODS.BIND,
+    METHODS.REBIND,
+    METHODS.UNBIND,
+    METHODS.ACL,
+    METHODS.REPORT,
+    METHODS.MKACTIVITY,
+    METHODS.CHECKOUT,
+    METHODS.MERGE,
+    METHODS['M-SEARCH'],
+    METHODS.NOTIFY,
+    METHODS.SUBSCRIBE,
+    METHODS.UNSUBSCRIBE,
+    METHODS.PATCH,
+    METHODS.PURGE,
+    METHODS.MKCALENDAR,
+    METHODS.LINK,
+    METHODS.UNLINK,
+    METHODS.PRI,
+    // TODO(indutny): should we allow it with HTTP?
+    METHODS.SOURCE,
+];
+exports.METHODS_ICE = [
+    METHODS.SOURCE,
+];
+exports.METHODS_RTSP = [
+    METHODS.OPTIONS,
+    METHODS.DESCRIBE,
+    METHODS.ANNOUNCE,
+    METHODS.SETUP,
+    METHODS.PLAY,
+    METHODS.PAUSE,
+    METHODS.TEARDOWN,
+    METHODS.GET_PARAMETER,
+    METHODS.SET_PARAMETER,
+    METHODS.REDIRECT,
+    METHODS.RECORD,
+    METHODS.FLUSH,
+    // For AirPlay
+    METHODS.GET,
+    METHODS.POST,
+];
+exports.METHOD_MAP = utils_1.enumToMap(METHODS);
+exports.H_METHOD_MAP = {};
+Object.keys(exports.METHOD_MAP).forEach((key) => {
+    if (/^H/.test(key)) {
+        exports.H_METHOD_MAP[key] = exports.METHOD_MAP[key];
+    }
+});
+var FINISH;
+(function (FINISH) {
+    FINISH[FINISH["SAFE"] = 0] = "SAFE";
+    FINISH[FINISH["SAFE_WITH_CB"] = 1] = "SAFE_WITH_CB";
+    FINISH[FINISH["UNSAFE"] = 2] = "UNSAFE";
+})(FINISH = exports.FINISH || (exports.FINISH = {}));
+exports.ALPHA = [];
+for (let i = 'A'.charCodeAt(0); i <= 'Z'.charCodeAt(0); i++) {
+    // Upper case
+    exports.ALPHA.push(String.fromCharCode(i));
+    // Lower case
+    exports.ALPHA.push(String.fromCharCode(i + 0x20));
+}
+exports.NUM_MAP = {
+    0: 0, 1: 1, 2: 2, 3: 3, 4: 4,
+    5: 5, 6: 6, 7: 7, 8: 8, 9: 9,
+};
+exports.HEX_MAP = {
+    0: 0, 1: 1, 2: 2, 3: 3, 4: 4,
+    5: 5, 6: 6, 7: 7, 8: 8, 9: 9,
+    A: 0XA, B: 0XB, C: 0XC, D: 0XD, E: 0XE, F: 0XF,
+    a: 0xa, b: 0xb, c: 0xc, d: 0xd, e: 0xe, f: 0xf,
+};
+exports.NUM = [
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+];
+exports.ALPHANUM = exports.ALPHA.concat(exports.NUM);
+exports.MARK = ['-', '_', '.', '!', '~', '*', '\'', '(', ')'];
+exports.USERINFO_CHARS = exports.ALPHANUM
+    .concat(exports.MARK)
+    .concat(['%', ';', ':', '&', '=', '+', '$', ',']);
+// TODO(indutny): use RFC
+exports.STRICT_URL_CHAR = [
+    '!', '"', '$', '%', '&', '\'',
+    '(', ')', '*', '+', ',', '-', '.', '/',
+    ':', ';', '<', '=', '>',
+    '@', '[', '\\', ']', '^', '_',
+    '`',
+    '{', '|', '}', '~',
+].concat(exports.ALPHANUM);
+exports.URL_CHAR = exports.STRICT_URL_CHAR
+    .concat(['\t', '\f']);
+// All characters with 0x80 bit set to 1
+for (let i = 0x80; i <= 0xff; i++) {
+    exports.URL_CHAR.push(i);
+}
+exports.HEX = exports.NUM.concat(['a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F']);
+/* Tokens as defined by rfc 2616. Also lowercases them.
+ *        token       = 1*<any CHAR except CTLs or separators>
+ *     separators     = "(" | ")" | "<" | ">" | "@"
+ *                    | "," | ";" | ":" | "\" | <">
+ *                    | "/" | "[" | "]" | "?" | "="
+ *                    | "{" | "}" | SP | HT
+ */
+exports.STRICT_TOKEN = [
+    '!', '#', '$', '%', '&', '\'',
+    '*', '+', '-', '.',
+    '^', '_', '`',
+    '|', '~',
+].concat(exports.ALPHANUM);
+exports.TOKEN = exports.STRICT_TOKEN.concat([' ']);
+/*
+ * Verify that a char is a valid visible (printable) US-ASCII
+ * character or %x80-FF
+ */
+exports.HEADER_CHARS = ['\t'];
+for (let i = 32; i <= 255; i++) {
+    if (i !== 127) {
+        exports.HEADER_CHARS.push(i);
+    }
+}
+// ',' = \x44
+exports.CONNECTION_TOKEN_CHARS = exports.HEADER_CHARS.filter((c) => c !== 44);
+exports.MAJOR = exports.NUM_MAP;
+exports.MINOR = exports.MAJOR;
+var HEADER_STATE;
+(function (HEADER_STATE) {
+    HEADER_STATE[HEADER_STATE["GENERAL"] = 0] = "GENERAL";
+    HEADER_STATE[HEADER_STATE["CONNECTION"] = 1] = "CONNECTION";
+    HEADER_STATE[HEADER_STATE["CONTENT_LENGTH"] = 2] = "CONTENT_LENGTH";
+    HEADER_STATE[HEADER_STATE["TRANSFER_ENCODING"] = 3] = "TRANSFER_ENCODING";
+    HEADER_STATE[HEADER_STATE["UPGRADE"] = 4] = "UPGRADE";
+    HEADER_STATE[HEADER_STATE["CONNECTION_KEEP_ALIVE"] = 5] = "CONNECTION_KEEP_ALIVE";
+    HEADER_STATE[HEADER_STATE["CONNECTION_CLOSE"] = 6] = "CONNECTION_CLOSE";
+    HEADER_STATE[HEADER_STATE["CONNECTION_UPGRADE"] = 7] = "CONNECTION_UPGRADE";
+    HEADER_STATE[HEADER_STATE["TRANSFER_ENCODING_CHUNKED"] = 8] = "TRANSFER_ENCODING_CHUNKED";
+})(HEADER_STATE = exports.HEADER_STATE || (exports.HEADER_STATE = {}));
+exports.SPECIAL_HEADERS = {
+    'connection': HEADER_STATE.CONNECTION,
+    'content-length': HEADER_STATE.CONTENT_LENGTH,
+    'proxy-connection': HEADER_STATE.CONNECTION,
+    'transfer-encoding': HEADER_STATE.TRANSFER_ENCODING,
+    'upgrade': HEADER_STATE.UPGRADE,
+};
+//# sourceMappingURL=constants.js.map
+
+/***/ }),
+
+/***/ 91475:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Buffer } = __nccwpck_require__(72254)
+
+module.exports = Buffer.from('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', 'base64')
+
+
+/***/ }),
+
+/***/ 27784:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Buffer } = __nccwpck_require__(72254)
+
+module.exports = Buffer.from('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', 'base64')
+
+
+/***/ }),
+
+/***/ 44118:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.enumToMap = void 0;
+function enumToMap(obj) {
+    const res = {};
+    Object.keys(obj).forEach((key) => {
+        const value = obj[key];
+        if (typeof value === 'number') {
+            res[key] = value;
+        }
+    });
+    return res;
+}
+exports.enumToMap = enumToMap;
+//# sourceMappingURL=utils.js.map
+
+/***/ }),
+
+/***/ 56549:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kClients } = __nccwpck_require__(5392)
+const Agent = __nccwpck_require__(83421)
+const {
+  kAgent,
+  kMockAgentSet,
+  kMockAgentGet,
+  kDispatches,
+  kIsMockActive,
+  kNetConnect,
+  kGetNetConnect,
+  kOptions,
+  kFactory
+} = __nccwpck_require__(67296)
+const MockClient = __nccwpck_require__(32144)
+const MockPool = __nccwpck_require__(92565)
+const { matchValue, buildMockOptions } = __nccwpck_require__(94202)
+const { InvalidArgumentError, UndiciError } = __nccwpck_require__(22174)
+const Dispatcher = __nccwpck_require__(51927)
+const Pluralizer = __nccwpck_require__(77551)
+const PendingInterceptorsFormatter = __nccwpck_require__(70698)
+
+class MockAgent extends Dispatcher {
+  constructor (opts) {
+    super(opts)
+
+    this[kNetConnect] = true
+    this[kIsMockActive] = true
+
+    // Instantiate Agent and encapsulate
+    if ((opts?.agent && typeof opts.agent.dispatch !== 'function')) {
+      throw new InvalidArgumentError('Argument opts.agent must implement Agent')
+    }
+    const agent = opts?.agent ? opts.agent : new Agent(opts)
+    this[kAgent] = agent
+
+    this[kClients] = agent[kClients]
+    this[kOptions] = buildMockOptions(opts)
+  }
+
+  get (origin) {
+    let dispatcher = this[kMockAgentGet](origin)
+
+    if (!dispatcher) {
+      dispatcher = this[kFactory](origin)
+      this[kMockAgentSet](origin, dispatcher)
+    }
+    return dispatcher
+  }
+
+  dispatch (opts, handler) {
+    // Call MockAgent.get to perform additional setup before dispatching as normal
+    this.get(opts.origin)
+    return this[kAgent].dispatch(opts, handler)
+  }
+
+  async close () {
+    await this[kAgent].close()
+    this[kClients].clear()
+  }
+
+  deactivate () {
+    this[kIsMockActive] = false
+  }
+
+  activate () {
+    this[kIsMockActive] = true
+  }
+
+  enableNetConnect (matcher) {
+    if (typeof matcher === 'string' || typeof matcher === 'function' || matcher instanceof RegExp) {
+      if (Array.isArray(this[kNetConnect])) {
+        this[kNetConnect].push(matcher)
+      } else {
+        this[kNetConnect] = [matcher]
+      }
+    } else if (typeof matcher === 'undefined') {
+      this[kNetConnect] = true
+    } else {
+      throw new InvalidArgumentError('Unsupported matcher. Must be one of String|Function|RegExp.')
+    }
+  }
+
+  disableNetConnect () {
+    this[kNetConnect] = false
+  }
+
+  // This is required to bypass issues caused by using global symbols - see:
+  // https://github.com/nodejs/undici/issues/1447
+  get isMockActive () {
+    return this[kIsMockActive]
+  }
+
+  [kMockAgentSet] (origin, dispatcher) {
+    this[kClients].set(origin, dispatcher)
+  }
+
+  [kFactory] (origin) {
+    const mockOptions = Object.assign({ agent: this }, this[kOptions])
+    return this[kOptions] && this[kOptions].connections === 1
+      ? new MockClient(origin, mockOptions)
+      : new MockPool(origin, mockOptions)
+  }
+
+  [kMockAgentGet] (origin) {
+    // First check if we can immediately find it
+    const client = this[kClients].get(origin)
+    if (client) {
+      return client
+    }
+
+    // If the origin is not a string create a dummy parent pool and return to user
+    if (typeof origin !== 'string') {
+      const dispatcher = this[kFactory]('http://localhost:9999')
+      this[kMockAgentSet](origin, dispatcher)
+      return dispatcher
+    }
+
+    // If we match, create a pool and assign the same dispatches
+    for (const [keyMatcher, nonExplicitDispatcher] of Array.from(this[kClients])) {
+      if (nonExplicitDispatcher && typeof keyMatcher !== 'string' && matchValue(keyMatcher, origin)) {
+        const dispatcher = this[kFactory](origin)
+        this[kMockAgentSet](origin, dispatcher)
+        dispatcher[kDispatches] = nonExplicitDispatcher[kDispatches]
+        return dispatcher
+      }
+    }
+  }
+
+  [kGetNetConnect] () {
+    return this[kNetConnect]
+  }
+
+  pendingInterceptors () {
+    const mockAgentClients = this[kClients]
+
+    return Array.from(mockAgentClients.entries())
+      .flatMap(([origin, scope]) => scope[kDispatches].map(dispatch => ({ ...dispatch, origin })))
+      .filter(({ pending }) => pending)
+  }
+
+  assertNoPendingInterceptors ({ pendingInterceptorsFormatter = new PendingInterceptorsFormatter() } = {}) {
+    const pending = this.pendingInterceptors()
+
+    if (pending.length === 0) {
+      return
+    }
+
+    const pluralizer = new Pluralizer('interceptor', 'interceptors').pluralize(pending.length)
+
+    throw new UndiciError(`
+${pluralizer.count} ${pluralizer.noun} ${pluralizer.is} pending:
+
+${pendingInterceptorsFormatter.format(pending)}
+`.trim())
+  }
+}
+
+module.exports = MockAgent
+
+
+/***/ }),
+
+/***/ 32144:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { promisify } = __nccwpck_require__(47261)
+const Client = __nccwpck_require__(6655)
+const { buildMockDispatch } = __nccwpck_require__(94202)
+const {
+  kDispatches,
+  kMockAgent,
+  kClose,
+  kOriginalClose,
+  kOrigin,
+  kOriginalDispatch,
+  kConnected
+} = __nccwpck_require__(67296)
+const { MockInterceptor } = __nccwpck_require__(34800)
+const Symbols = __nccwpck_require__(5392)
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+
+/**
+ * MockClient provides an API that extends the Client to influence the mockDispatches.
+ */
+class MockClient extends Client {
+  constructor (origin, opts) {
+    super(origin, opts)
+
+    if (!opts || !opts.agent || typeof opts.agent.dispatch !== 'function') {
+      throw new InvalidArgumentError('Argument opts.agent must implement Agent')
+    }
+
+    this[kMockAgent] = opts.agent
+    this[kOrigin] = origin
+    this[kDispatches] = []
+    this[kConnected] = 1
+    this[kOriginalDispatch] = this.dispatch
+    this[kOriginalClose] = this.close.bind(this)
+
+    this.dispatch = buildMockDispatch.call(this)
+    this.close = this[kClose]
+  }
+
+  get [Symbols.kConnected] () {
+    return this[kConnected]
+  }
+
+  /**
+   * Sets up the base interceptor for mocking replies from undici.
+   */
+  intercept (opts) {
+    return new MockInterceptor(opts, this[kDispatches])
+  }
+
+  async [kClose] () {
+    await promisify(this[kOriginalClose])()
+    this[kConnected] = 0
+    this[kMockAgent][Symbols.kClients].delete(this[kOrigin])
+  }
+}
+
+module.exports = MockClient
+
+
+/***/ }),
+
+/***/ 54331:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { UndiciError } = __nccwpck_require__(22174)
+
+const kMockNotMatchedError = Symbol.for('undici.error.UND_MOCK_ERR_MOCK_NOT_MATCHED')
+
+/**
+ * The request does not match any registered mock dispatches.
+ */
+class MockNotMatchedError extends UndiciError {
+  constructor (message) {
+    super(message)
+    Error.captureStackTrace(this, MockNotMatchedError)
+    this.name = 'MockNotMatchedError'
+    this.message = message || 'The request does not match any registered mock dispatches'
+    this.code = 'UND_MOCK_ERR_MOCK_NOT_MATCHED'
+  }
+
+  static [Symbol.hasInstance] (instance) {
+    return instance && instance[kMockNotMatchedError] === true
+  }
+
+  [kMockNotMatchedError] = true
+}
+
+module.exports = {
+  MockNotMatchedError
+}
+
+
+/***/ }),
+
+/***/ 34800:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { getResponseData, buildKey, addMockDispatch } = __nccwpck_require__(94202)
+const {
+  kDispatches,
+  kDispatchKey,
+  kDefaultHeaders,
+  kDefaultTrailers,
+  kContentLength,
+  kMockDispatch
+} = __nccwpck_require__(67296)
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+const { buildURL } = __nccwpck_require__(94407)
+
+/**
+ * Defines the scope API for an interceptor reply
+ */
+class MockScope {
+  constructor (mockDispatch) {
+    this[kMockDispatch] = mockDispatch
+  }
+
+  /**
+   * Delay a reply by a set amount in ms.
+   */
+  delay (waitInMs) {
+    if (typeof waitInMs !== 'number' || !Number.isInteger(waitInMs) || waitInMs <= 0) {
+      throw new InvalidArgumentError('waitInMs must be a valid integer > 0')
+    }
+
+    this[kMockDispatch].delay = waitInMs
+    return this
+  }
+
+  /**
+   * For a defined reply, never mark as consumed.
+   */
+  persist () {
+    this[kMockDispatch].persist = true
+    return this
+  }
+
+  /**
+   * Allow one to define a reply for a set amount of matching requests.
+   */
+  times (repeatTimes) {
+    if (typeof repeatTimes !== 'number' || !Number.isInteger(repeatTimes) || repeatTimes <= 0) {
+      throw new InvalidArgumentError('repeatTimes must be a valid integer > 0')
+    }
+
+    this[kMockDispatch].times = repeatTimes
+    return this
+  }
+}
+
+/**
+ * Defines an interceptor for a Mock
+ */
+class MockInterceptor {
+  constructor (opts, mockDispatches) {
+    if (typeof opts !== 'object') {
+      throw new InvalidArgumentError('opts must be an object')
+    }
+    if (typeof opts.path === 'undefined') {
+      throw new InvalidArgumentError('opts.path must be defined')
+    }
+    if (typeof opts.method === 'undefined') {
+      opts.method = 'GET'
+    }
+    // See https://github.com/nodejs/undici/issues/1245
+    // As per RFC 3986, clients are not supposed to send URI
+    // fragments to servers when they retrieve a document,
+    if (typeof opts.path === 'string') {
+      if (opts.query) {
+        opts.path = buildURL(opts.path, opts.query)
+      } else {
+        // Matches https://github.com/nodejs/undici/blob/main/lib/web/fetch/index.js#L1811
+        const parsedURL = new URL(opts.path, 'data://')
+        opts.path = parsedURL.pathname + parsedURL.search
+      }
+    }
+    if (typeof opts.method === 'string') {
+      opts.method = opts.method.toUpperCase()
+    }
+
+    this[kDispatchKey] = buildKey(opts)
+    this[kDispatches] = mockDispatches
+    this[kDefaultHeaders] = {}
+    this[kDefaultTrailers] = {}
+    this[kContentLength] = false
+  }
+
+  createMockScopeDispatchData ({ statusCode, data, responseOptions }) {
+    const responseData = getResponseData(data)
+    const contentLength = this[kContentLength] ? { 'content-length': responseData.length } : {}
+    const headers = { ...this[kDefaultHeaders], ...contentLength, ...responseOptions.headers }
+    const trailers = { ...this[kDefaultTrailers], ...responseOptions.trailers }
+
+    return { statusCode, data, headers, trailers }
+  }
+
+  validateReplyParameters (replyParameters) {
+    if (typeof replyParameters.statusCode === 'undefined') {
+      throw new InvalidArgumentError('statusCode must be defined')
+    }
+    if (typeof replyParameters.responseOptions !== 'object' || replyParameters.responseOptions === null) {
+      throw new InvalidArgumentError('responseOptions must be an object')
+    }
+  }
+
+  /**
+   * Mock an undici request with a defined reply.
+   */
+  reply (replyOptionsCallbackOrStatusCode) {
+    // Values of reply aren't available right now as they
+    // can only be available when the reply callback is invoked.
+    if (typeof replyOptionsCallbackOrStatusCode === 'function') {
+      // We'll first wrap the provided callback in another function,
+      // this function will properly resolve the data from the callback
+      // when invoked.
+      const wrappedDefaultsCallback = (opts) => {
+        // Our reply options callback contains the parameter for statusCode, data and options.
+        const resolvedData = replyOptionsCallbackOrStatusCode(opts)
+
+        // Check if it is in the right format
+        if (typeof resolvedData !== 'object' || resolvedData === null) {
+          throw new InvalidArgumentError('reply options callback must return an object')
+        }
+
+        const replyParameters = { data: '', responseOptions: {}, ...resolvedData }
+        this.validateReplyParameters(replyParameters)
+        // Since the values can be obtained immediately we return them
+        // from this higher order function that will be resolved later.
+        return {
+          ...this.createMockScopeDispatchData(replyParameters)
+        }
+      }
+
+      // Add usual dispatch data, but this time set the data parameter to function that will eventually provide data.
+      const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], wrappedDefaultsCallback)
+      return new MockScope(newMockDispatch)
+    }
+
+    // We can have either one or three parameters, if we get here,
+    // we should have 1-3 parameters. So we spread the arguments of
+    // this function to obtain the parameters, since replyData will always
+    // just be the statusCode.
+    const replyParameters = {
+      statusCode: replyOptionsCallbackOrStatusCode,
+      data: arguments[1] === undefined ? '' : arguments[1],
+      responseOptions: arguments[2] === undefined ? {} : arguments[2]
+    }
+    this.validateReplyParameters(replyParameters)
+
+    // Send in-already provided data like usual
+    const dispatchData = this.createMockScopeDispatchData(replyParameters)
+    const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], dispatchData)
+    return new MockScope(newMockDispatch)
+  }
+
+  /**
+   * Mock an undici request with a defined error.
+   */
+  replyWithError (error) {
+    if (typeof error === 'undefined') {
+      throw new InvalidArgumentError('error must be defined')
+    }
+
+    const newMockDispatch = addMockDispatch(this[kDispatches], this[kDispatchKey], { error })
+    return new MockScope(newMockDispatch)
+  }
+
+  /**
+   * Set default reply headers on the interceptor for subsequent replies
+   */
+  defaultReplyHeaders (headers) {
+    if (typeof headers === 'undefined') {
+      throw new InvalidArgumentError('headers must be defined')
+    }
+
+    this[kDefaultHeaders] = headers
+    return this
+  }
+
+  /**
+   * Set default reply trailers on the interceptor for subsequent replies
+   */
+  defaultReplyTrailers (trailers) {
+    if (typeof trailers === 'undefined') {
+      throw new InvalidArgumentError('trailers must be defined')
+    }
+
+    this[kDefaultTrailers] = trailers
+    return this
+  }
+
+  /**
+   * Set reply content length header for replies on the interceptor
+   */
+  replyContentLength () {
+    this[kContentLength] = true
+    return this
+  }
+}
+
+module.exports.MockInterceptor = MockInterceptor
+module.exports.MockScope = MockScope
+
+
+/***/ }),
+
+/***/ 92565:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { promisify } = __nccwpck_require__(47261)
+const Pool = __nccwpck_require__(11795)
+const { buildMockDispatch } = __nccwpck_require__(94202)
+const {
+  kDispatches,
+  kMockAgent,
+  kClose,
+  kOriginalClose,
+  kOrigin,
+  kOriginalDispatch,
+  kConnected
+} = __nccwpck_require__(67296)
+const { MockInterceptor } = __nccwpck_require__(34800)
+const Symbols = __nccwpck_require__(5392)
+const { InvalidArgumentError } = __nccwpck_require__(22174)
+
+/**
+ * MockPool provides an API that extends the Pool to influence the mockDispatches.
+ */
+class MockPool extends Pool {
+  constructor (origin, opts) {
+    super(origin, opts)
+
+    if (!opts || !opts.agent || typeof opts.agent.dispatch !== 'function') {
+      throw new InvalidArgumentError('Argument opts.agent must implement Agent')
+    }
+
+    this[kMockAgent] = opts.agent
+    this[kOrigin] = origin
+    this[kDispatches] = []
+    this[kConnected] = 1
+    this[kOriginalDispatch] = this.dispatch
+    this[kOriginalClose] = this.close.bind(this)
+
+    this.dispatch = buildMockDispatch.call(this)
+    this.close = this[kClose]
+  }
+
+  get [Symbols.kConnected] () {
+    return this[kConnected]
+  }
+
+  /**
+   * Sets up the base interceptor for mocking replies from undici.
+   */
+  intercept (opts) {
+    return new MockInterceptor(opts, this[kDispatches])
+  }
+
+  async [kClose] () {
+    await promisify(this[kOriginalClose])()
+    this[kConnected] = 0
+    this[kMockAgent][Symbols.kClients].delete(this[kOrigin])
+  }
+}
+
+module.exports = MockPool
+
+
+/***/ }),
+
+/***/ 67296:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = {
+  kAgent: Symbol('agent'),
+  kOptions: Symbol('options'),
+  kFactory: Symbol('factory'),
+  kDispatches: Symbol('dispatches'),
+  kDispatchKey: Symbol('dispatch key'),
+  kDefaultHeaders: Symbol('default headers'),
+  kDefaultTrailers: Symbol('default trailers'),
+  kContentLength: Symbol('content length'),
+  kMockAgent: Symbol('mock agent'),
+  kMockAgentSet: Symbol('mock agent set'),
+  kMockAgentGet: Symbol('mock agent get'),
+  kMockDispatch: Symbol('mock dispatch'),
+  kClose: Symbol('close'),
+  kOriginalClose: Symbol('original agent close'),
+  kOrigin: Symbol('origin'),
+  kIsMockActive: Symbol('is mock active'),
+  kNetConnect: Symbol('net connect'),
+  kGetNetConnect: Symbol('get net connect'),
+  kConnected: Symbol('connected')
+}
+
+
+/***/ }),
+
+/***/ 94202:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { MockNotMatchedError } = __nccwpck_require__(54331)
+const {
+  kDispatches,
+  kMockAgent,
+  kOriginalDispatch,
+  kOrigin,
+  kGetNetConnect
+} = __nccwpck_require__(67296)
+const { buildURL } = __nccwpck_require__(94407)
+const { STATUS_CODES } = __nccwpck_require__(88849)
+const {
+  types: {
+    isPromise
+  }
+} = __nccwpck_require__(47261)
+
+function matchValue (match, value) {
+  if (typeof match === 'string') {
+    return match === value
+  }
+  if (match instanceof RegExp) {
+    return match.test(value)
+  }
+  if (typeof match === 'function') {
+    return match(value) === true
+  }
+  return false
+}
+
+function lowerCaseEntries (headers) {
+  return Object.fromEntries(
+    Object.entries(headers).map(([headerName, headerValue]) => {
+      return [headerName.toLocaleLowerCase(), headerValue]
+    })
+  )
+}
+
+/**
+ * @param {import('../../index').Headers|string[]|Record<string, string>} headers
+ * @param {string} key
+ */
+function getHeaderByName (headers, key) {
+  if (Array.isArray(headers)) {
+    for (let i = 0; i < headers.length; i += 2) {
+      if (headers[i].toLocaleLowerCase() === key.toLocaleLowerCase()) {
+        return headers[i + 1]
+      }
+    }
+
+    return undefined
+  } else if (typeof headers.get === 'function') {
+    return headers.get(key)
+  } else {
+    return lowerCaseEntries(headers)[key.toLocaleLowerCase()]
+  }
+}
+
+/** @param {string[]} headers */
+function buildHeadersFromArray (headers) { // fetch HeadersList
+  const clone = headers.slice()
+  const entries = []
+  for (let index = 0; index < clone.length; index += 2) {
+    entries.push([clone[index], clone[index + 1]])
+  }
+  return Object.fromEntries(entries)
+}
+
+function matchHeaders (mockDispatch, headers) {
+  if (typeof mockDispatch.headers === 'function') {
+    if (Array.isArray(headers)) { // fetch HeadersList
+      headers = buildHeadersFromArray(headers)
+    }
+    return mockDispatch.headers(headers ? lowerCaseEntries(headers) : {})
+  }
+  if (typeof mockDispatch.headers === 'undefined') {
+    return true
+  }
+  if (typeof headers !== 'object' || typeof mockDispatch.headers !== 'object') {
+    return false
+  }
+
+  for (const [matchHeaderName, matchHeaderValue] of Object.entries(mockDispatch.headers)) {
+    const headerValue = getHeaderByName(headers, matchHeaderName)
+
+    if (!matchValue(matchHeaderValue, headerValue)) {
+      return false
+    }
+  }
+  return true
+}
+
+function safeUrl (path) {
+  if (typeof path !== 'string') {
+    return path
+  }
+
+  const pathSegments = path.split('?')
+
+  if (pathSegments.length !== 2) {
+    return path
+  }
+
+  const qp = new URLSearchParams(pathSegments.pop())
+  qp.sort()
+  return [...pathSegments, qp.toString()].join('?')
+}
+
+function matchKey (mockDispatch, { path, method, body, headers }) {
+  const pathMatch = matchValue(mockDispatch.path, path)
+  const methodMatch = matchValue(mockDispatch.method, method)
+  const bodyMatch = typeof mockDispatch.body !== 'undefined' ? matchValue(mockDispatch.body, body) : true
+  const headersMatch = matchHeaders(mockDispatch, headers)
+  return pathMatch && methodMatch && bodyMatch && headersMatch
+}
+
+function getResponseData (data) {
+  if (Buffer.isBuffer(data)) {
+    return data
+  } else if (data instanceof Uint8Array) {
+    return data
+  } else if (data instanceof ArrayBuffer) {
+    return data
+  } else if (typeof data === 'object') {
+    return JSON.stringify(data)
+  } else {
+    return data.toString()
+  }
+}
+
+function getMockDispatch (mockDispatches, key) {
+  const basePath = key.query ? buildURL(key.path, key.query) : key.path
+  const resolvedPath = typeof basePath === 'string' ? safeUrl(basePath) : basePath
+
+  // Match path
+  let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path }) => matchValue(safeUrl(path), resolvedPath))
+  if (matchedMockDispatches.length === 0) {
+    throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`)
+  }
+
+  // Match method
+  matchedMockDispatches = matchedMockDispatches.filter(({ method }) => matchValue(method, key.method))
+  if (matchedMockDispatches.length === 0) {
+    throw new MockNotMatchedError(`Mock dispatch not matched for method '${key.method}' on path '${resolvedPath}'`)
+  }
+
+  // Match body
+  matchedMockDispatches = matchedMockDispatches.filter(({ body }) => typeof body !== 'undefined' ? matchValue(body, key.body) : true)
+  if (matchedMockDispatches.length === 0) {
+    throw new MockNotMatchedError(`Mock dispatch not matched for body '${key.body}' on path '${resolvedPath}'`)
+  }
+
+  // Match headers
+  matchedMockDispatches = matchedMockDispatches.filter((mockDispatch) => matchHeaders(mockDispatch, key.headers))
+  if (matchedMockDispatches.length === 0) {
+    const headers = typeof key.headers === 'object' ? JSON.stringify(key.headers) : key.headers
+    throw new MockNotMatchedError(`Mock dispatch not matched for headers '${headers}' on path '${resolvedPath}'`)
+  }
+
+  return matchedMockDispatches[0]
+}
+
+function addMockDispatch (mockDispatches, key, data) {
+  const baseData = { timesInvoked: 0, times: 1, persist: false, consumed: false }
+  const replyData = typeof data === 'function' ? { callback: data } : { ...data }
+  const newMockDispatch = { ...baseData, ...key, pending: true, data: { error: null, ...replyData } }
+  mockDispatches.push(newMockDispatch)
+  return newMockDispatch
+}
+
+function deleteMockDispatch (mockDispatches, key) {
+  const index = mockDispatches.findIndex(dispatch => {
+    if (!dispatch.consumed) {
+      return false
+    }
+    return matchKey(dispatch, key)
+  })
+  if (index !== -1) {
+    mockDispatches.splice(index, 1)
+  }
+}
+
+function buildKey (opts) {
+  const { path, method, body, headers, query } = opts
+  return {
+    path,
+    method,
+    body,
+    headers,
+    query
+  }
+}
+
+function generateKeyValues (data) {
+  const keys = Object.keys(data)
+  const result = []
+  for (let i = 0; i < keys.length; ++i) {
+    const key = keys[i]
+    const value = data[key]
+    const name = Buffer.from(`${key}`)
+    if (Array.isArray(value)) {
+      for (let j = 0; j < value.length; ++j) {
+        result.push(name, Buffer.from(`${value[j]}`))
+      }
+    } else {
+      result.push(name, Buffer.from(`${value}`))
+    }
+  }
+  return result
+}
+
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Status
+ * @param {number} statusCode
+ */
+function getStatusText (statusCode) {
+  return STATUS_CODES[statusCode] || 'unknown'
+}
+
+async function getResponse (body) {
+  const buffers = []
+  for await (const data of body) {
+    buffers.push(data)
+  }
+  return Buffer.concat(buffers).toString('utf8')
+}
+
+/**
+ * Mock dispatch function used to simulate undici dispatches
+ */
+function mockDispatch (opts, handler) {
+  // Get mock dispatch from built key
+  const key = buildKey(opts)
+  const mockDispatch = getMockDispatch(this[kDispatches], key)
+
+  mockDispatch.timesInvoked++
+
+  // Here's where we resolve a callback if a callback is present for the dispatch data.
+  if (mockDispatch.data.callback) {
+    mockDispatch.data = { ...mockDispatch.data, ...mockDispatch.data.callback(opts) }
+  }
+
+  // Parse mockDispatch data
+  const { data: { statusCode, data, headers, trailers, error }, delay, persist } = mockDispatch
+  const { timesInvoked, times } = mockDispatch
+
+  // If it's used up and not persistent, mark as consumed
+  mockDispatch.consumed = !persist && timesInvoked >= times
+  mockDispatch.pending = timesInvoked < times
+
+  // If specified, trigger dispatch error
+  if (error !== null) {
+    deleteMockDispatch(this[kDispatches], key)
+    handler.onError(error)
+    return true
+  }
+
+  // Handle the request with a delay if necessary
+  if (typeof delay === 'number' && delay > 0) {
+    setTimeout(() => {
+      handleReply(this[kDispatches])
+    }, delay)
+  } else {
+    handleReply(this[kDispatches])
+  }
+
+  function handleReply (mockDispatches, _data = data) {
+    // fetch's HeadersList is a 1D string array
+    const optsHeaders = Array.isArray(opts.headers)
+      ? buildHeadersFromArray(opts.headers)
+      : opts.headers
+    const body = typeof _data === 'function'
+      ? _data({ ...opts, headers: optsHeaders })
+      : _data
+
+    // util.types.isPromise is likely needed for jest.
+    if (isPromise(body)) {
+      // If handleReply is asynchronous, throwing an error
+      // in the callback will reject the promise, rather than
+      // synchronously throw the error, which breaks some tests.
+      // Rather, we wait for the callback to resolve if it is a
+      // promise, and then re-run handleReply with the new body.
+      body.then((newData) => handleReply(mockDispatches, newData))
+      return
+    }
+
+    const responseData = getResponseData(body)
+    const responseHeaders = generateKeyValues(headers)
+    const responseTrailers = generateKeyValues(trailers)
+
+    handler.onConnect?.(err => handler.onError(err), null)
+    handler.onHeaders?.(statusCode, responseHeaders, resume, getStatusText(statusCode))
+    handler.onData?.(Buffer.from(responseData))
+    handler.onComplete?.(responseTrailers)
+    deleteMockDispatch(mockDispatches, key)
+  }
+
+  function resume () {}
+
+  return true
+}
+
+function buildMockDispatch () {
+  const agent = this[kMockAgent]
+  const origin = this[kOrigin]
+  const originalDispatch = this[kOriginalDispatch]
+
+  return function dispatch (opts, handler) {
+    if (agent.isMockActive) {
+      try {
+        mockDispatch.call(this, opts, handler)
+      } catch (error) {
+        if (error instanceof MockNotMatchedError) {
+          const netConnect = agent[kGetNetConnect]()
+          if (netConnect === false) {
+            throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect disabled)`)
+          }
+          if (checkNetConnect(netConnect, origin)) {
+            originalDispatch.call(this, opts, handler)
+          } else {
+            throw new MockNotMatchedError(`${error.message}: subsequent request to origin ${origin} was not allowed (net.connect is not enabled for this origin)`)
+          }
+        } else {
+          throw error
+        }
+      }
+    } else {
+      originalDispatch.call(this, opts, handler)
+    }
+  }
+}
+
+function checkNetConnect (netConnect, origin) {
+  const url = new URL(origin)
+  if (netConnect === true) {
+    return true
+  } else if (Array.isArray(netConnect) && netConnect.some((matcher) => matchValue(matcher, url.host))) {
+    return true
+  }
+  return false
+}
+
+function buildMockOptions (opts) {
+  if (opts) {
+    const { agent, ...mockOptions } = opts
+    return mockOptions
+  }
+}
+
+module.exports = {
+  getResponseData,
+  getMockDispatch,
+  addMockDispatch,
+  deleteMockDispatch,
+  buildKey,
+  generateKeyValues,
+  matchValue,
+  getResponse,
+  getStatusText,
+  mockDispatch,
+  buildMockDispatch,
+  checkNetConnect,
+  buildMockOptions,
+  getHeaderByName,
+  buildHeadersFromArray
+}
+
+
+/***/ }),
+
+/***/ 70698:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Transform } = __nccwpck_require__(84492)
+const { Console } = __nccwpck_require__(40027)
+
+const PERSISTENT = process.versions.icu ? '✅' : 'Y '
+const NOT_PERSISTENT = process.versions.icu ? '❌' : 'N '
+
+/**
+ * Gets the output of `console.table(…)` as a string.
+ */
+module.exports = class PendingInterceptorsFormatter {
+  constructor ({ disableColors } = {}) {
+    this.transform = new Transform({
+      transform (chunk, _enc, cb) {
+        cb(null, chunk)
+      }
+    })
+
+    this.logger = new Console({
+      stdout: this.transform,
+      inspectOptions: {
+        colors: !disableColors && !process.env.CI
+      }
+    })
+  }
+
+  format (pendingInterceptors) {
+    const withPrettyHeaders = pendingInterceptors.map(
+      ({ method, path, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+        Method: method,
+        Origin: origin,
+        Path: path,
+        'Status code': statusCode,
+        Persistent: persist ? PERSISTENT : NOT_PERSISTENT,
+        Invocations: timesInvoked,
+        Remaining: persist ? Infinity : times - timesInvoked
+      }))
+
+    this.logger.table(withPrettyHeaders)
+    return this.transform.read().toString()
+  }
+}
+
+
+/***/ }),
+
+/***/ 77551:
+/***/ ((module) => {
+
+"use strict";
+
+
+const singulars = {
+  pronoun: 'it',
+  is: 'is',
+  was: 'was',
+  this: 'this'
+}
+
+const plurals = {
+  pronoun: 'they',
+  is: 'are',
+  was: 'were',
+  this: 'these'
+}
+
+module.exports = class Pluralizer {
+  constructor (singular, plural) {
+    this.singular = singular
+    this.plural = plural
+  }
+
+  pluralize (count) {
+    const one = count === 1
+    const keys = one ? singulars : plurals
+    const noun = one ? this.singular : this.plural
+    return { ...keys, count, noun }
+  }
+}
+
+
+/***/ }),
+
+/***/ 48413:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * This module offers an optimized timer implementation designed for scenarios
+ * where high precision is not critical.
+ *
+ * The timer achieves faster performance by using a low-resolution approach,
+ * with an accuracy target of within 500ms. This makes it particularly useful
+ * for timers with delays of 1 second or more, where exact timing is less
+ * crucial.
+ *
+ * It's important to note that Node.js timers are inherently imprecise, as
+ * delays can occur due to the event loop being blocked by other operations.
+ * Consequently, timers may trigger later than their scheduled time.
+ */
+
+/**
+ * The fastNow variable contains the internal fast timer clock value.
+ *
+ * @type {number}
+ */
+let fastNow = 0
+
+/**
+ * RESOLUTION_MS represents the target resolution time in milliseconds.
+ *
+ * @type {number}
+ * @default 1000
+ */
+const RESOLUTION_MS = 1e3
+
+/**
+ * TICK_MS defines the desired interval in milliseconds between each tick.
+ * The target value is set to half the resolution time, minus 1 ms, to account
+ * for potential event loop overhead.
+ *
+ * @type {number}
+ * @default 499
+ */
+const TICK_MS = (RESOLUTION_MS >> 1) - 1
+
+/**
+ * fastNowTimeout is a Node.js timer used to manage and process
+ * the FastTimers stored in the `fastTimers` array.
+ *
+ * @type {NodeJS.Timeout}
+ */
+let fastNowTimeout
+
+/**
+ * The kFastTimer symbol is used to identify FastTimer instances.
+ *
+ * @type {Symbol}
+ */
+const kFastTimer = Symbol('kFastTimer')
+
+/**
+ * The fastTimers array contains all active FastTimers.
+ *
+ * @type {FastTimer[]}
+ */
+const fastTimers = []
+
+/**
+ * These constants represent the various states of a FastTimer.
+ */
+
+/**
+ * The `NOT_IN_LIST` constant indicates that the FastTimer is not included
+ * in the `fastTimers` array. Timers with this status will not be processed
+ * during the next tick by the `onTick` function.
+ *
+ * A FastTimer can be re-added to the `fastTimers` array by invoking the
+ * `refresh` method on the FastTimer instance.
+ *
+ * @type {-2}
+ */
+const NOT_IN_LIST = -2
+
+/**
+ * The `TO_BE_CLEARED` constant indicates that the FastTimer is scheduled
+ * for removal from the `fastTimers` array. A FastTimer in this state will
+ * be removed in the next tick by the `onTick` function and will no longer
+ * be processed.
+ *
+ * This status is also set when the `clear` method is called on the FastTimer instance.
+ *
+ * @type {-1}
+ */
+const TO_BE_CLEARED = -1
+
+/**
+ * The `PENDING` constant signifies that the FastTimer is awaiting processing
+ * in the next tick by the `onTick` function. Timers with this status will have
+ * their `_idleStart` value set and their status updated to `ACTIVE` in the next tick.
+ *
+ * @type {0}
+ */
+const PENDING = 0
+
+/**
+ * The `ACTIVE` constant indicates that the FastTimer is active and waiting
+ * for its timer to expire. During the next tick, the `onTick` function will
+ * check if the timer has expired, and if so, it will execute the associated callback.
+ *
+ * @type {1}
+ */
+const ACTIVE = 1
+
+/**
+ * The onTick function processes the fastTimers array.
+ *
+ * @returns {void}
+ */
+function onTick () {
+  /**
+   * Increment the fastNow value by the TICK_MS value, despite the actual time
+   * that has passed since the last tick. This approach ensures independence
+   * from the system clock and delays caused by a blocked event loop.
+   *
+   * @type {number}
+   */
+  fastNow += TICK_MS
+
+  /**
+   * The `idx` variable is used to iterate over the `fastTimers` array.
+   * Expired timers are removed by replacing them with the last element in the array.
+   * Consequently, `idx` is only incremented when the current element is not removed.
+   *
+   * @type {number}
+   */
+  let idx = 0
+
+  /**
+   * The len variable will contain the length of the fastTimers array
+   * and will be decremented when a FastTimer should be removed from the
+   * fastTimers array.
+   *
+   * @type {number}
+   */
+  let len = fastTimers.length
+
+  while (idx < len) {
+    /**
+     * @type {FastTimer}
+     */
+    const timer = fastTimers[idx]
+
+    // If the timer is in the ACTIVE state and the timer has expired, it will
+    // be processed in the next tick.
+    if (timer._state === PENDING) {
+      // Set the _idleStart value to the fastNow value minus the TICK_MS value
+      // to account for the time the timer was in the PENDING state.
+      timer._idleStart = fastNow - TICK_MS
+      timer._state = ACTIVE
+    } else if (
+      timer._state === ACTIVE &&
+      fastNow >= timer._idleStart + timer._idleTimeout
+    ) {
+      timer._state = TO_BE_CLEARED
+      timer._idleStart = -1
+      timer._onTimeout(timer._timerArg)
+    }
+
+    if (timer._state === TO_BE_CLEARED) {
+      timer._state = NOT_IN_LIST
+
+      // Move the last element to the current index and decrement len if it is
+      // not the only element in the array.
+      if (--len !== 0) {
+        fastTimers[idx] = fastTimers[len]
+      }
+    } else {
+      ++idx
+    }
+  }
+
+  // Set the length of the fastTimers array to the new length and thus
+  // removing the excess FastTimers elements from the array.
+  fastTimers.length = len
+
+  // If there are still active FastTimers in the array, refresh the Timer.
+  // If there are no active FastTimers, the timer will be refreshed again
+  // when a new FastTimer is instantiated.
+  if (fastTimers.length !== 0) {
+    refreshTimeout()
+  }
+}
+
+function refreshTimeout () {
+  // If the fastNowTimeout is already set, refresh it.
+  if (fastNowTimeout) {
+    fastNowTimeout.refresh()
+  // fastNowTimeout is not instantiated yet, create a new Timer.
+  } else {
+    clearTimeout(fastNowTimeout)
+    fastNowTimeout = setTimeout(onTick, TICK_MS)
+
+    // If the Timer has an unref method, call it to allow the process to exit if
+    // there are no other active handles.
+    if (fastNowTimeout.unref) {
+      fastNowTimeout.unref()
+    }
+  }
+}
+
+/**
+ * The `FastTimer` class is a data structure designed to store and manage
+ * timer information.
+ */
+class FastTimer {
+  [kFastTimer] = true
+
+  /**
+   * The state of the timer, which can be one of the following:
+   * - NOT_IN_LIST (-2)
+   * - TO_BE_CLEARED (-1)
+   * - PENDING (0)
+   * - ACTIVE (1)
+   *
+   * @type {-2|-1|0|1}
+   * @private
+   */
+  _state = NOT_IN_LIST
+
+  /**
+   * The number of milliseconds to wait before calling the callback.
+   *
+   * @type {number}
+   * @private
+   */
+  _idleTimeout = -1
+
+  /**
+   * The time in milliseconds when the timer was started. This value is used to
+   * calculate when the timer should expire.
+   *
+   * @type {number}
+   * @default -1
+   * @private
+   */
+  _idleStart = -1
+
+  /**
+   * The function to be executed when the timer expires.
+   * @type {Function}
+   * @private
+   */
+  _onTimeout
+
+  /**
+   * The argument to be passed to the callback when the timer expires.
+   *
+   * @type {*}
+   * @private
+   */
+  _timerArg
+
+  /**
+   * @constructor
+   * @param {Function} callback A function to be executed after the timer
+   * expires.
+   * @param {number} delay The time, in milliseconds that the timer should wait
+   * before the specified function or code is executed.
+   * @param {*} arg
+   */
+  constructor (callback, delay, arg) {
+    this._onTimeout = callback
+    this._idleTimeout = delay
+    this._timerArg = arg
+
+    this.refresh()
+  }
+
+  /**
+   * Sets the timer's start time to the current time, and reschedules the timer
+   * to call its callback at the previously specified duration adjusted to the
+   * current time.
+   * Using this on a timer that has already called its callback will reactivate
+   * the timer.
+   *
+   * @returns {void}
+   */
+  refresh () {
+    // In the special case that the timer is not in the list of active timers,
+    // add it back to the array to be processed in the next tick by the onTick
+    // function.
+    if (this._state === NOT_IN_LIST) {
+      fastTimers.push(this)
+    }
+
+    // If the timer is the only active timer, refresh the fastNowTimeout for
+    // better resolution.
+    if (!fastNowTimeout || fastTimers.length === 1) {
+      refreshTimeout()
+    }
+
+    // Setting the state to PENDING will cause the timer to be reset in the
+    // next tick by the onTick function.
+    this._state = PENDING
+  }
+
+  /**
+   * The `clear` method cancels the timer, preventing it from executing.
+   *
+   * @returns {void}
+   * @private
+   */
+  clear () {
+    // Set the state to TO_BE_CLEARED to mark the timer for removal in the next
+    // tick by the onTick function.
+    this._state = TO_BE_CLEARED
+
+    // Reset the _idleStart value to -1 to indicate that the timer is no longer
+    // active.
+    this._idleStart = -1
+  }
+}
+
+/**
+ * This module exports a setTimeout and clearTimeout function that can be
+ * used as a drop-in replacement for the native functions.
+ */
+module.exports = {
+  /**
+   * The setTimeout() method sets a timer which executes a function once the
+   * timer expires.
+   * @param {Function} callback A function to be executed after the timer
+   * expires.
+   * @param {number} delay The time, in milliseconds that the timer should
+   * wait before the specified function or code is executed.
+   * @param {*} [arg] An optional argument to be passed to the callback function
+   * when the timer expires.
+   * @returns {NodeJS.Timeout|FastTimer}
+   */
+  setTimeout (callback, delay, arg) {
+    // If the delay is less than or equal to the RESOLUTION_MS value return a
+    // native Node.js Timer instance.
+    return delay <= RESOLUTION_MS
+      ? setTimeout(callback, delay, arg)
+      : new FastTimer(callback, delay, arg)
+  },
+  /**
+   * The clearTimeout method cancels an instantiated Timer previously created
+   * by calling setTimeout.
+   *
+   * @param {NodeJS.Timeout|FastTimer} timeout
+   */
+  clearTimeout (timeout) {
+    // If the timeout is a FastTimer, call its own clear method.
+    if (timeout[kFastTimer]) {
+      /**
+       * @type {FastTimer}
+       */
+      timeout.clear()
+      // Otherwise it is an instance of a native NodeJS.Timeout, so call the
+      // Node.js native clearTimeout function.
+    } else {
+      clearTimeout(timeout)
+    }
+  },
+  /**
+   * The setFastTimeout() method sets a fastTimer which executes a function once
+   * the timer expires.
+   * @param {Function} callback A function to be executed after the timer
+   * expires.
+   * @param {number} delay The time, in milliseconds that the timer should
+   * wait before the specified function or code is executed.
+   * @param {*} [arg] An optional argument to be passed to the callback function
+   * when the timer expires.
+   * @returns {FastTimer}
+   */
+  setFastTimeout (callback, delay, arg) {
+    return new FastTimer(callback, delay, arg)
+  },
+  /**
+   * The clearTimeout method cancels an instantiated FastTimer previously
+   * created by calling setFastTimeout.
+   *
+   * @param {FastTimer} timeout
+   */
+  clearFastTimeout (timeout) {
+    timeout.clear()
+  },
+  /**
+   * The now method returns the value of the internal fast timer clock.
+   *
+   * @returns {number}
+   */
+  now () {
+    return fastNow
+  },
+  /**
+   * Trigger the onTick function to process the fastTimers array.
+   * Exported for testing purposes only.
+   * Marking as deprecated to discourage any use outside of testing.
+   * @deprecated
+   * @param {number} [delay=0] The delay in milliseconds to add to the now value.
+   */
+  tick (delay = 0) {
+    fastNow += delay - RESOLUTION_MS + 1
+    onTick()
+    onTick()
+  },
+  /**
+   * Reset FastTimers.
+   * Exported for testing purposes only.
+   * Marking as deprecated to discourage any use outside of testing.
+   * @deprecated
+   */
+  reset () {
+    fastNow = 0
+    fastTimers.length = 0
+    clearTimeout(fastNowTimeout)
+    fastNowTimeout = null
+  },
+  /**
+   * Exporting for testing purposes only.
+   * Marking as deprecated to discourage any use outside of testing.
+   * @deprecated
+   */
+  kFastTimer
+}
+
+
+/***/ }),
+
+/***/ 61821:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kConstruct } = __nccwpck_require__(90053)
+const { urlEquals, getFieldValues } = __nccwpck_require__(63166)
+const { kEnumerableProperty, isDisturbed } = __nccwpck_require__(94407)
+const { webidl } = __nccwpck_require__(37829)
+const { Response, cloneResponse, fromInnerResponse } = __nccwpck_require__(33139)
+const { Request, fromInnerRequest } = __nccwpck_require__(13925)
+const { kState } = __nccwpck_require__(78172)
+const { fetching } = __nccwpck_require__(31158)
+const { urlIsHttpHttpsScheme, createDeferredPromise, readAllBytes } = __nccwpck_require__(91976)
+const assert = __nccwpck_require__(98061)
+
+/**
+ * @see https://w3c.github.io/ServiceWorker/#dfn-cache-batch-operation
+ * @typedef {Object} CacheBatchOperation
+ * @property {'delete' | 'put'} type
+ * @property {any} request
+ * @property {any} response
+ * @property {import('../../types/cache').CacheQueryOptions} options
+ */
+
+/**
+ * @see https://w3c.github.io/ServiceWorker/#dfn-request-response-list
+ * @typedef {[any, any][]} requestResponseList
+ */
+
+class Cache {
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-request-response-list
+   * @type {requestResponseList}
+   */
+  #relevantRequestResponseList
+
+  constructor () {
+    if (arguments[0] !== kConstruct) {
+      webidl.illegalConstructor()
+    }
+
+    webidl.util.markAsUncloneable(this)
+    this.#relevantRequestResponseList = arguments[1]
+  }
+
+  async match (request, options = {}) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.match'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    request = webidl.converters.RequestInfo(request, prefix, 'request')
+    options = webidl.converters.CacheQueryOptions(options, prefix, 'options')
+
+    const p = this.#internalMatchAll(request, options, 1)
+
+    if (p.length === 0) {
+      return
+    }
+
+    return p[0]
+  }
+
+  async matchAll (request = undefined, options = {}) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.matchAll'
+    if (request !== undefined) request = webidl.converters.RequestInfo(request, prefix, 'request')
+    options = webidl.converters.CacheQueryOptions(options, prefix, 'options')
+
+    return this.#internalMatchAll(request, options)
+  }
+
+  async add (request) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.add'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    request = webidl.converters.RequestInfo(request, prefix, 'request')
+
+    // 1.
+    const requests = [request]
+
+    // 2.
+    const responseArrayPromise = this.addAll(requests)
+
+    // 3.
+    return await responseArrayPromise
+  }
+
+  async addAll (requests) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.addAll'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    // 1.
+    const responsePromises = []
+
+    // 2.
+    const requestList = []
+
+    // 3.
+    for (let request of requests) {
+      if (request === undefined) {
+        throw webidl.errors.conversionFailed({
+          prefix,
+          argument: 'Argument 1',
+          types: ['undefined is not allowed']
+        })
+      }
+
+      request = webidl.converters.RequestInfo(request)
+
+      if (typeof request === 'string') {
+        continue
+      }
+
+      // 3.1
+      const r = request[kState]
+
+      // 3.2
+      if (!urlIsHttpHttpsScheme(r.url) || r.method !== 'GET') {
+        throw webidl.errors.exception({
+          header: prefix,
+          message: 'Expected http/s scheme when method is not GET.'
+        })
+      }
+    }
+
+    // 4.
+    /** @type {ReturnType<typeof fetching>[]} */
+    const fetchControllers = []
+
+    // 5.
+    for (const request of requests) {
+      // 5.1
+      const r = new Request(request)[kState]
+
+      // 5.2
+      if (!urlIsHttpHttpsScheme(r.url)) {
+        throw webidl.errors.exception({
+          header: prefix,
+          message: 'Expected http/s scheme.'
+        })
+      }
+
+      // 5.4
+      r.initiator = 'fetch'
+      r.destination = 'subresource'
+
+      // 5.5
+      requestList.push(r)
+
+      // 5.6
+      const responsePromise = createDeferredPromise()
+
+      // 5.7
+      fetchControllers.push(fetching({
+        request: r,
+        processResponse (response) {
+          // 1.
+          if (response.type === 'error' || response.status === 206 || response.status < 200 || response.status > 299) {
+            responsePromise.reject(webidl.errors.exception({
+              header: 'Cache.addAll',
+              message: 'Received an invalid status code or the request failed.'
+            }))
+          } else if (response.headersList.contains('vary')) { // 2.
+            // 2.1
+            const fieldValues = getFieldValues(response.headersList.get('vary'))
+
+            // 2.2
+            for (const fieldValue of fieldValues) {
+              // 2.2.1
+              if (fieldValue === '*') {
+                responsePromise.reject(webidl.errors.exception({
+                  header: 'Cache.addAll',
+                  message: 'invalid vary field value'
+                }))
+
+                for (const controller of fetchControllers) {
+                  controller.abort()
+                }
+
+                return
+              }
+            }
+          }
+        },
+        processResponseEndOfBody (response) {
+          // 1.
+          if (response.aborted) {
+            responsePromise.reject(new DOMException('aborted', 'AbortError'))
+            return
+          }
+
+          // 2.
+          responsePromise.resolve(response)
+        }
+      }))
+
+      // 5.8
+      responsePromises.push(responsePromise.promise)
+    }
+
+    // 6.
+    const p = Promise.all(responsePromises)
+
+    // 7.
+    const responses = await p
+
+    // 7.1
+    const operations = []
+
+    // 7.2
+    let index = 0
+
+    // 7.3
+    for (const response of responses) {
+      // 7.3.1
+      /** @type {CacheBatchOperation} */
+      const operation = {
+        type: 'put', // 7.3.2
+        request: requestList[index], // 7.3.3
+        response // 7.3.4
+      }
+
+      operations.push(operation) // 7.3.5
+
+      index++ // 7.3.6
+    }
+
+    // 7.5
+    const cacheJobPromise = createDeferredPromise()
+
+    // 7.6.1
+    let errorData = null
+
+    // 7.6.2
+    try {
+      this.#batchCacheOperations(operations)
+    } catch (e) {
+      errorData = e
+    }
+
+    // 7.6.3
+    queueMicrotask(() => {
+      // 7.6.3.1
+      if (errorData === null) {
+        cacheJobPromise.resolve(undefined)
+      } else {
+        // 7.6.3.2
+        cacheJobPromise.reject(errorData)
+      }
+    })
+
+    // 7.7
+    return cacheJobPromise.promise
+  }
+
+  async put (request, response) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.put'
+    webidl.argumentLengthCheck(arguments, 2, prefix)
+
+    request = webidl.converters.RequestInfo(request, prefix, 'request')
+    response = webidl.converters.Response(response, prefix, 'response')
+
+    // 1.
+    let innerRequest = null
+
+    // 2.
+    if (request instanceof Request) {
+      innerRequest = request[kState]
+    } else { // 3.
+      innerRequest = new Request(request)[kState]
+    }
+
+    // 4.
+    if (!urlIsHttpHttpsScheme(innerRequest.url) || innerRequest.method !== 'GET') {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: 'Expected an http/s scheme when method is not GET'
+      })
+    }
+
+    // 5.
+    const innerResponse = response[kState]
+
+    // 6.
+    if (innerResponse.status === 206) {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: 'Got 206 status'
+      })
+    }
+
+    // 7.
+    if (innerResponse.headersList.contains('vary')) {
+      // 7.1.
+      const fieldValues = getFieldValues(innerResponse.headersList.get('vary'))
+
+      // 7.2.
+      for (const fieldValue of fieldValues) {
+        // 7.2.1
+        if (fieldValue === '*') {
+          throw webidl.errors.exception({
+            header: prefix,
+            message: 'Got * vary field value'
+          })
+        }
+      }
+    }
+
+    // 8.
+    if (innerResponse.body && (isDisturbed(innerResponse.body.stream) || innerResponse.body.stream.locked)) {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: 'Response body is locked or disturbed'
+      })
+    }
+
+    // 9.
+    const clonedResponse = cloneResponse(innerResponse)
+
+    // 10.
+    const bodyReadPromise = createDeferredPromise()
+
+    // 11.
+    if (innerResponse.body != null) {
+      // 11.1
+      const stream = innerResponse.body.stream
+
+      // 11.2
+      const reader = stream.getReader()
+
+      // 11.3
+      readAllBytes(reader).then(bodyReadPromise.resolve, bodyReadPromise.reject)
+    } else {
+      bodyReadPromise.resolve(undefined)
+    }
+
+    // 12.
+    /** @type {CacheBatchOperation[]} */
+    const operations = []
+
+    // 13.
+    /** @type {CacheBatchOperation} */
+    const operation = {
+      type: 'put', // 14.
+      request: innerRequest, // 15.
+      response: clonedResponse // 16.
+    }
+
+    // 17.
+    operations.push(operation)
+
+    // 19.
+    const bytes = await bodyReadPromise.promise
+
+    if (clonedResponse.body != null) {
+      clonedResponse.body.source = bytes
+    }
+
+    // 19.1
+    const cacheJobPromise = createDeferredPromise()
+
+    // 19.2.1
+    let errorData = null
+
+    // 19.2.2
+    try {
+      this.#batchCacheOperations(operations)
+    } catch (e) {
+      errorData = e
+    }
+
+    // 19.2.3
+    queueMicrotask(() => {
+      // 19.2.3.1
+      if (errorData === null) {
+        cacheJobPromise.resolve()
+      } else { // 19.2.3.2
+        cacheJobPromise.reject(errorData)
+      }
+    })
+
+    return cacheJobPromise.promise
+  }
+
+  async delete (request, options = {}) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.delete'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    request = webidl.converters.RequestInfo(request, prefix, 'request')
+    options = webidl.converters.CacheQueryOptions(options, prefix, 'options')
+
+    /**
+     * @type {Request}
+     */
+    let r = null
+
+    if (request instanceof Request) {
+      r = request[kState]
+
+      if (r.method !== 'GET' && !options.ignoreMethod) {
+        return false
+      }
+    } else {
+      assert(typeof request === 'string')
+
+      r = new Request(request)[kState]
+    }
+
+    /** @type {CacheBatchOperation[]} */
+    const operations = []
+
+    /** @type {CacheBatchOperation} */
+    const operation = {
+      type: 'delete',
+      request: r,
+      options
+    }
+
+    operations.push(operation)
+
+    const cacheJobPromise = createDeferredPromise()
+
+    let errorData = null
+    let requestResponses
+
+    try {
+      requestResponses = this.#batchCacheOperations(operations)
+    } catch (e) {
+      errorData = e
+    }
+
+    queueMicrotask(() => {
+      if (errorData === null) {
+        cacheJobPromise.resolve(!!requestResponses?.length)
+      } else {
+        cacheJobPromise.reject(errorData)
+      }
+    })
+
+    return cacheJobPromise.promise
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#dom-cache-keys
+   * @param {any} request
+   * @param {import('../../types/cache').CacheQueryOptions} options
+   * @returns {Promise<readonly Request[]>}
+   */
+  async keys (request = undefined, options = {}) {
+    webidl.brandCheck(this, Cache)
+
+    const prefix = 'Cache.keys'
+
+    if (request !== undefined) request = webidl.converters.RequestInfo(request, prefix, 'request')
+    options = webidl.converters.CacheQueryOptions(options, prefix, 'options')
+
+    // 1.
+    let r = null
+
+    // 2.
+    if (request !== undefined) {
+      // 2.1
+      if (request instanceof Request) {
+        // 2.1.1
+        r = request[kState]
+
+        // 2.1.2
+        if (r.method !== 'GET' && !options.ignoreMethod) {
+          return []
+        }
+      } else if (typeof request === 'string') { // 2.2
+        r = new Request(request)[kState]
+      }
+    }
+
+    // 4.
+    const promise = createDeferredPromise()
+
+    // 5.
+    // 5.1
+    const requests = []
+
+    // 5.2
+    if (request === undefined) {
+      // 5.2.1
+      for (const requestResponse of this.#relevantRequestResponseList) {
+        // 5.2.1.1
+        requests.push(requestResponse[0])
+      }
+    } else { // 5.3
+      // 5.3.1
+      const requestResponses = this.#queryCache(r, options)
+
+      // 5.3.2
+      for (const requestResponse of requestResponses) {
+        // 5.3.2.1
+        requests.push(requestResponse[0])
+      }
+    }
+
+    // 5.4
+    queueMicrotask(() => {
+      // 5.4.1
+      const requestList = []
+
+      // 5.4.2
+      for (const request of requests) {
+        const requestObject = fromInnerRequest(
+          request,
+          new AbortController().signal,
+          'immutable'
+        )
+        // 5.4.2.1
+        requestList.push(requestObject)
+      }
+
+      // 5.4.3
+      promise.resolve(Object.freeze(requestList))
+    })
+
+    return promise.promise
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#batch-cache-operations-algorithm
+   * @param {CacheBatchOperation[]} operations
+   * @returns {requestResponseList}
+   */
+  #batchCacheOperations (operations) {
+    // 1.
+    const cache = this.#relevantRequestResponseList
+
+    // 2.
+    const backupCache = [...cache]
+
+    // 3.
+    const addedItems = []
+
+    // 4.1
+    const resultList = []
+
+    try {
+      // 4.2
+      for (const operation of operations) {
+        // 4.2.1
+        if (operation.type !== 'delete' && operation.type !== 'put') {
+          throw webidl.errors.exception({
+            header: 'Cache.#batchCacheOperations',
+            message: 'operation type does not match "delete" or "put"'
+          })
+        }
+
+        // 4.2.2
+        if (operation.type === 'delete' && operation.response != null) {
+          throw webidl.errors.exception({
+            header: 'Cache.#batchCacheOperations',
+            message: 'delete operation should not have an associated response'
+          })
+        }
+
+        // 4.2.3
+        if (this.#queryCache(operation.request, operation.options, addedItems).length) {
+          throw new DOMException('???', 'InvalidStateError')
+        }
+
+        // 4.2.4
+        let requestResponses
+
+        // 4.2.5
+        if (operation.type === 'delete') {
+          // 4.2.5.1
+          requestResponses = this.#queryCache(operation.request, operation.options)
+
+          // TODO: the spec is wrong, this is needed to pass WPTs
+          if (requestResponses.length === 0) {
+            return []
+          }
+
+          // 4.2.5.2
+          for (const requestResponse of requestResponses) {
+            const idx = cache.indexOf(requestResponse)
+            assert(idx !== -1)
+
+            // 4.2.5.2.1
+            cache.splice(idx, 1)
+          }
+        } else if (operation.type === 'put') { // 4.2.6
+          // 4.2.6.1
+          if (operation.response == null) {
+            throw webidl.errors.exception({
+              header: 'Cache.#batchCacheOperations',
+              message: 'put operation should have an associated response'
+            })
+          }
+
+          // 4.2.6.2
+          const r = operation.request
+
+          // 4.2.6.3
+          if (!urlIsHttpHttpsScheme(r.url)) {
+            throw webidl.errors.exception({
+              header: 'Cache.#batchCacheOperations',
+              message: 'expected http or https scheme'
+            })
+          }
+
+          // 4.2.6.4
+          if (r.method !== 'GET') {
+            throw webidl.errors.exception({
+              header: 'Cache.#batchCacheOperations',
+              message: 'not get method'
+            })
+          }
+
+          // 4.2.6.5
+          if (operation.options != null) {
+            throw webidl.errors.exception({
+              header: 'Cache.#batchCacheOperations',
+              message: 'options must not be defined'
+            })
+          }
+
+          // 4.2.6.6
+          requestResponses = this.#queryCache(operation.request)
+
+          // 4.2.6.7
+          for (const requestResponse of requestResponses) {
+            const idx = cache.indexOf(requestResponse)
+            assert(idx !== -1)
+
+            // 4.2.6.7.1
+            cache.splice(idx, 1)
+          }
+
+          // 4.2.6.8
+          cache.push([operation.request, operation.response])
+
+          // 4.2.6.10
+          addedItems.push([operation.request, operation.response])
+        }
+
+        // 4.2.7
+        resultList.push([operation.request, operation.response])
+      }
+
+      // 4.3
+      return resultList
+    } catch (e) { // 5.
+      // 5.1
+      this.#relevantRequestResponseList.length = 0
+
+      // 5.2
+      this.#relevantRequestResponseList = backupCache
+
+      // 5.3
+      throw e
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#query-cache
+   * @param {any} requestQuery
+   * @param {import('../../types/cache').CacheQueryOptions} options
+   * @param {requestResponseList} targetStorage
+   * @returns {requestResponseList}
+   */
+  #queryCache (requestQuery, options, targetStorage) {
+    /** @type {requestResponseList} */
+    const resultList = []
+
+    const storage = targetStorage ?? this.#relevantRequestResponseList
+
+    for (const requestResponse of storage) {
+      const [cachedRequest, cachedResponse] = requestResponse
+      if (this.#requestMatchesCachedItem(requestQuery, cachedRequest, cachedResponse, options)) {
+        resultList.push(requestResponse)
+      }
+    }
+
+    return resultList
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#request-matches-cached-item-algorithm
+   * @param {any} requestQuery
+   * @param {any} request
+   * @param {any | null} response
+   * @param {import('../../types/cache').CacheQueryOptions | undefined} options
+   * @returns {boolean}
+   */
+  #requestMatchesCachedItem (requestQuery, request, response = null, options) {
+    // if (options?.ignoreMethod === false && request.method === 'GET') {
+    //   return false
+    // }
+
+    const queryURL = new URL(requestQuery.url)
+
+    const cachedURL = new URL(request.url)
+
+    if (options?.ignoreSearch) {
+      cachedURL.search = ''
+
+      queryURL.search = ''
+    }
+
+    if (!urlEquals(queryURL, cachedURL, true)) {
+      return false
+    }
+
+    if (
+      response == null ||
+      options?.ignoreVary ||
+      !response.headersList.contains('vary')
+    ) {
+      return true
+    }
+
+    const fieldValues = getFieldValues(response.headersList.get('vary'))
+
+    for (const fieldValue of fieldValues) {
+      if (fieldValue === '*') {
+        return false
+      }
+
+      const requestValue = request.headersList.get(fieldValue)
+      const queryValue = requestQuery.headersList.get(fieldValue)
+
+      // If one has the header and the other doesn't, or one has
+      // a different value than the other, return false
+      if (requestValue !== queryValue) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  #internalMatchAll (request, options, maxResponses = Infinity) {
+    // 1.
+    let r = null
+
+    // 2.
+    if (request !== undefined) {
+      if (request instanceof Request) {
+        // 2.1.1
+        r = request[kState]
+
+        // 2.1.2
+        if (r.method !== 'GET' && !options.ignoreMethod) {
+          return []
+        }
+      } else if (typeof request === 'string') {
+        // 2.2.1
+        r = new Request(request)[kState]
+      }
+    }
+
+    // 5.
+    // 5.1
+    const responses = []
+
+    // 5.2
+    if (request === undefined) {
+      // 5.2.1
+      for (const requestResponse of this.#relevantRequestResponseList) {
+        responses.push(requestResponse[1])
+      }
+    } else { // 5.3
+      // 5.3.1
+      const requestResponses = this.#queryCache(r, options)
+
+      // 5.3.2
+      for (const requestResponse of requestResponses) {
+        responses.push(requestResponse[1])
+      }
+    }
+
+    // 5.4
+    // We don't implement CORs so we don't need to loop over the responses, yay!
+
+    // 5.5.1
+    const responseList = []
+
+    // 5.5.2
+    for (const response of responses) {
+      // 5.5.2.1
+      const responseObject = fromInnerResponse(response, 'immutable')
+
+      responseList.push(responseObject.clone())
+
+      if (responseList.length >= maxResponses) {
+        break
+      }
+    }
+
+    // 6.
+    return Object.freeze(responseList)
+  }
+}
+
+Object.defineProperties(Cache.prototype, {
+  [Symbol.toStringTag]: {
+    value: 'Cache',
+    configurable: true
+  },
+  match: kEnumerableProperty,
+  matchAll: kEnumerableProperty,
+  add: kEnumerableProperty,
+  addAll: kEnumerableProperty,
+  put: kEnumerableProperty,
+  delete: kEnumerableProperty,
+  keys: kEnumerableProperty
+})
+
+const cacheQueryOptionConverters = [
+  {
+    key: 'ignoreSearch',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'ignoreMethod',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'ignoreVary',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  }
+]
+
+webidl.converters.CacheQueryOptions = webidl.dictionaryConverter(cacheQueryOptionConverters)
+
+webidl.converters.MultiCacheQueryOptions = webidl.dictionaryConverter([
+  ...cacheQueryOptionConverters,
+  {
+    key: 'cacheName',
+    converter: webidl.converters.DOMString
+  }
+])
+
+webidl.converters.Response = webidl.interfaceConverter(Response)
+
+webidl.converters['sequence<RequestInfo>'] = webidl.sequenceConverter(
+  webidl.converters.RequestInfo
+)
+
+module.exports = {
+  Cache
+}
+
+
+/***/ }),
+
+/***/ 12130:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kConstruct } = __nccwpck_require__(90053)
+const { Cache } = __nccwpck_require__(61821)
+const { webidl } = __nccwpck_require__(37829)
+const { kEnumerableProperty } = __nccwpck_require__(94407)
+
+class CacheStorage {
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#dfn-relevant-name-to-cache-map
+   * @type {Map<string, import('./cache').requestResponseList}
+   */
+  #caches = new Map()
+
+  constructor () {
+    if (arguments[0] !== kConstruct) {
+      webidl.illegalConstructor()
+    }
+
+    webidl.util.markAsUncloneable(this)
+  }
+
+  async match (request, options = {}) {
+    webidl.brandCheck(this, CacheStorage)
+    webidl.argumentLengthCheck(arguments, 1, 'CacheStorage.match')
+
+    request = webidl.converters.RequestInfo(request)
+    options = webidl.converters.MultiCacheQueryOptions(options)
+
+    // 1.
+    if (options.cacheName != null) {
+      // 1.1.1.1
+      if (this.#caches.has(options.cacheName)) {
+        // 1.1.1.1.1
+        const cacheList = this.#caches.get(options.cacheName)
+        const cache = new Cache(kConstruct, cacheList)
+
+        return await cache.match(request, options)
+      }
+    } else { // 2.
+      // 2.2
+      for (const cacheList of this.#caches.values()) {
+        const cache = new Cache(kConstruct, cacheList)
+
+        // 2.2.1.2
+        const response = await cache.match(request, options)
+
+        if (response !== undefined) {
+          return response
+        }
+      }
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#cache-storage-has
+   * @param {string} cacheName
+   * @returns {Promise<boolean>}
+   */
+  async has (cacheName) {
+    webidl.brandCheck(this, CacheStorage)
+
+    const prefix = 'CacheStorage.has'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    cacheName = webidl.converters.DOMString(cacheName, prefix, 'cacheName')
+
+    // 2.1.1
+    // 2.2
+    return this.#caches.has(cacheName)
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#dom-cachestorage-open
+   * @param {string} cacheName
+   * @returns {Promise<Cache>}
+   */
+  async open (cacheName) {
+    webidl.brandCheck(this, CacheStorage)
+
+    const prefix = 'CacheStorage.open'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    cacheName = webidl.converters.DOMString(cacheName, prefix, 'cacheName')
+
+    // 2.1
+    if (this.#caches.has(cacheName)) {
+      // await caches.open('v1') !== await caches.open('v1')
+
+      // 2.1.1
+      const cache = this.#caches.get(cacheName)
+
+      // 2.1.1.1
+      return new Cache(kConstruct, cache)
+    }
+
+    // 2.2
+    const cache = []
+
+    // 2.3
+    this.#caches.set(cacheName, cache)
+
+    // 2.4
+    return new Cache(kConstruct, cache)
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#cache-storage-delete
+   * @param {string} cacheName
+   * @returns {Promise<boolean>}
+   */
+  async delete (cacheName) {
+    webidl.brandCheck(this, CacheStorage)
+
+    const prefix = 'CacheStorage.delete'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    cacheName = webidl.converters.DOMString(cacheName, prefix, 'cacheName')
+
+    return this.#caches.delete(cacheName)
+  }
+
+  /**
+   * @see https://w3c.github.io/ServiceWorker/#cache-storage-keys
+   * @returns {Promise<string[]>}
+   */
+  async keys () {
+    webidl.brandCheck(this, CacheStorage)
+
+    // 2.1
+    const keys = this.#caches.keys()
+
+    // 2.2
+    return [...keys]
+  }
+}
+
+Object.defineProperties(CacheStorage.prototype, {
+  [Symbol.toStringTag]: {
+    value: 'CacheStorage',
+    configurable: true
+  },
+  match: kEnumerableProperty,
+  has: kEnumerableProperty,
+  open: kEnumerableProperty,
+  delete: kEnumerableProperty,
+  keys: kEnumerableProperty
+})
+
+module.exports = {
+  CacheStorage
+}
+
+
+/***/ }),
+
+/***/ 90053:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+module.exports = {
+  kConstruct: (__nccwpck_require__(5392).kConstruct)
+}
+
+
+/***/ }),
+
+/***/ 63166:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+const { URLSerializer } = __nccwpck_require__(86954)
+const { isValidHeaderName } = __nccwpck_require__(91976)
+
+/**
+ * @see https://url.spec.whatwg.org/#concept-url-equals
+ * @param {URL} A
+ * @param {URL} B
+ * @param {boolean | undefined} excludeFragment
+ * @returns {boolean}
+ */
+function urlEquals (A, B, excludeFragment = false) {
+  const serializedA = URLSerializer(A, excludeFragment)
+
+  const serializedB = URLSerializer(B, excludeFragment)
+
+  return serializedA === serializedB
+}
+
+/**
+ * @see https://github.com/chromium/chromium/blob/694d20d134cb553d8d89e5500b9148012b1ba299/content/browser/cache_storage/cache_storage_cache.cc#L260-L262
+ * @param {string} header
+ */
+function getFieldValues (header) {
+  assert(header !== null)
+
+  const values = []
+
+  for (let value of header.split(',')) {
+    value = value.trim()
+
+    if (isValidHeaderName(value)) {
+      values.push(value)
+    }
+  }
+
+  return values
+}
+
+module.exports = {
+  urlEquals,
+  getFieldValues
+}
+
+
+/***/ }),
+
+/***/ 67246:
+/***/ ((module) => {
+
+"use strict";
+
+
+// https://wicg.github.io/cookie-store/#cookie-maximum-attribute-value-size
+const maxAttributeValueSize = 1024
+
+// https://wicg.github.io/cookie-store/#cookie-maximum-name-value-pair-size
+const maxNameValuePairSize = 4096
+
+module.exports = {
+  maxAttributeValueSize,
+  maxNameValuePairSize
+}
+
+
+/***/ }),
+
+/***/ 57705:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { parseSetCookie } = __nccwpck_require__(45318)
+const { stringify } = __nccwpck_require__(72660)
+const { webidl } = __nccwpck_require__(37829)
+const { Headers } = __nccwpck_require__(24997)
+
+/**
+ * @typedef {Object} Cookie
+ * @property {string} name
+ * @property {string} value
+ * @property {Date|number|undefined} expires
+ * @property {number|undefined} maxAge
+ * @property {string|undefined} domain
+ * @property {string|undefined} path
+ * @property {boolean|undefined} secure
+ * @property {boolean|undefined} httpOnly
+ * @property {'Strict'|'Lax'|'None'} sameSite
+ * @property {string[]} unparsed
+ */
+
+/**
+ * @param {Headers} headers
+ * @returns {Record<string, string>}
+ */
+function getCookies (headers) {
+  webidl.argumentLengthCheck(arguments, 1, 'getCookies')
+
+  webidl.brandCheck(headers, Headers, { strict: false })
+
+  const cookie = headers.get('cookie')
+  const out = {}
+
+  if (!cookie) {
+    return out
+  }
+
+  for (const piece of cookie.split(';')) {
+    const [name, ...value] = piece.split('=')
+
+    out[name.trim()] = value.join('=')
+  }
+
+  return out
+}
+
+/**
+ * @param {Headers} headers
+ * @param {string} name
+ * @param {{ path?: string, domain?: string }|undefined} attributes
+ * @returns {void}
+ */
+function deleteCookie (headers, name, attributes) {
+  webidl.brandCheck(headers, Headers, { strict: false })
+
+  const prefix = 'deleteCookie'
+  webidl.argumentLengthCheck(arguments, 2, prefix)
+
+  name = webidl.converters.DOMString(name, prefix, 'name')
+  attributes = webidl.converters.DeleteCookieAttributes(attributes)
+
+  // Matches behavior of
+  // https://github.com/denoland/deno_std/blob/63827b16330b82489a04614027c33b7904e08be5/http/cookie.ts#L278
+  setCookie(headers, {
+    name,
+    value: '',
+    expires: new Date(0),
+    ...attributes
+  })
+}
+
+/**
+ * @param {Headers} headers
+ * @returns {Cookie[]}
+ */
+function getSetCookies (headers) {
+  webidl.argumentLengthCheck(arguments, 1, 'getSetCookies')
+
+  webidl.brandCheck(headers, Headers, { strict: false })
+
+  const cookies = headers.getSetCookie()
+
+  if (!cookies) {
+    return []
+  }
+
+  return cookies.map((pair) => parseSetCookie(pair))
+}
+
+/**
+ * @param {Headers} headers
+ * @param {Cookie} cookie
+ * @returns {void}
+ */
+function setCookie (headers, cookie) {
+  webidl.argumentLengthCheck(arguments, 2, 'setCookie')
+
+  webidl.brandCheck(headers, Headers, { strict: false })
+
+  cookie = webidl.converters.Cookie(cookie)
+
+  const str = stringify(cookie)
+
+  if (str) {
+    headers.append('Set-Cookie', str)
+  }
+}
+
+webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([
+  {
+    converter: webidl.nullableConverter(webidl.converters.DOMString),
+    key: 'path',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.nullableConverter(webidl.converters.DOMString),
+    key: 'domain',
+    defaultValue: () => null
+  }
+])
+
+webidl.converters.Cookie = webidl.dictionaryConverter([
+  {
+    converter: webidl.converters.DOMString,
+    key: 'name'
+  },
+  {
+    converter: webidl.converters.DOMString,
+    key: 'value'
+  },
+  {
+    converter: webidl.nullableConverter((value) => {
+      if (typeof value === 'number') {
+        return webidl.converters['unsigned long long'](value)
+      }
+
+      return new Date(value)
+    }),
+    key: 'expires',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.nullableConverter(webidl.converters['long long']),
+    key: 'maxAge',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.nullableConverter(webidl.converters.DOMString),
+    key: 'domain',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.nullableConverter(webidl.converters.DOMString),
+    key: 'path',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.nullableConverter(webidl.converters.boolean),
+    key: 'secure',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.nullableConverter(webidl.converters.boolean),
+    key: 'httpOnly',
+    defaultValue: () => null
+  },
+  {
+    converter: webidl.converters.USVString,
+    key: 'sameSite',
+    allowedValues: ['Strict', 'Lax', 'None']
+  },
+  {
+    converter: webidl.sequenceConverter(webidl.converters.DOMString),
+    key: 'unparsed',
+    defaultValue: () => new Array(0)
+  }
+])
+
+module.exports = {
+  getCookies,
+  deleteCookie,
+  getSetCookies,
+  setCookie
+}
+
+
+/***/ }),
+
+/***/ 45318:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { maxNameValuePairSize, maxAttributeValueSize } = __nccwpck_require__(67246)
+const { isCTLExcludingHtab } = __nccwpck_require__(72660)
+const { collectASequenceOfCodePointsFast } = __nccwpck_require__(86954)
+const assert = __nccwpck_require__(98061)
+
+/**
+ * @description Parses the field-value attributes of a set-cookie header string.
+ * @see https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4
+ * @param {string} header
+ * @returns if the header is invalid, null will be returned
+ */
+function parseSetCookie (header) {
+  // 1. If the set-cookie-string contains a %x00-08 / %x0A-1F / %x7F
+  //    character (CTL characters excluding HTAB): Abort these steps and
+  //    ignore the set-cookie-string entirely.
+  if (isCTLExcludingHtab(header)) {
+    return null
+  }
+
+  let nameValuePair = ''
+  let unparsedAttributes = ''
+  let name = ''
+  let value = ''
+
+  // 2. If the set-cookie-string contains a %x3B (";") character:
+  if (header.includes(';')) {
+    // 1. The name-value-pair string consists of the characters up to,
+    //    but not including, the first %x3B (";"), and the unparsed-
+    //    attributes consist of the remainder of the set-cookie-string
+    //    (including the %x3B (";") in question).
+    const position = { position: 0 }
+
+    nameValuePair = collectASequenceOfCodePointsFast(';', header, position)
+    unparsedAttributes = header.slice(position.position)
+  } else {
+    // Otherwise:
+
+    // 1. The name-value-pair string consists of all the characters
+    //    contained in the set-cookie-string, and the unparsed-
+    //    attributes is the empty string.
+    nameValuePair = header
+  }
+
+  // 3. If the name-value-pair string lacks a %x3D ("=") character, then
+  //    the name string is empty, and the value string is the value of
+  //    name-value-pair.
+  if (!nameValuePair.includes('=')) {
+    value = nameValuePair
+  } else {
+    //    Otherwise, the name string consists of the characters up to, but
+    //    not including, the first %x3D ("=") character, and the (possibly
+    //    empty) value string consists of the characters after the first
+    //    %x3D ("=") character.
+    const position = { position: 0 }
+    name = collectASequenceOfCodePointsFast(
+      '=',
+      nameValuePair,
+      position
+    )
+    value = nameValuePair.slice(position.position + 1)
+  }
+
+  // 4. Remove any leading or trailing WSP characters from the name
+  //    string and the value string.
+  name = name.trim()
+  value = value.trim()
+
+  // 5. If the sum of the lengths of the name string and the value string
+  //    is more than 4096 octets, abort these steps and ignore the set-
+  //    cookie-string entirely.
+  if (name.length + value.length > maxNameValuePairSize) {
+    return null
+  }
+
+  // 6. The cookie-name is the name string, and the cookie-value is the
+  //    value string.
+  return {
+    name, value, ...parseUnparsedAttributes(unparsedAttributes)
+  }
+}
+
+/**
+ * Parses the remaining attributes of a set-cookie header
+ * @see https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4
+ * @param {string} unparsedAttributes
+ * @param {[Object.<string, unknown>]={}} cookieAttributeList
+ */
+function parseUnparsedAttributes (unparsedAttributes, cookieAttributeList = {}) {
+  // 1. If the unparsed-attributes string is empty, skip the rest of
+  //    these steps.
+  if (unparsedAttributes.length === 0) {
+    return cookieAttributeList
+  }
+
+  // 2. Discard the first character of the unparsed-attributes (which
+  //    will be a %x3B (";") character).
+  assert(unparsedAttributes[0] === ';')
+  unparsedAttributes = unparsedAttributes.slice(1)
+
+  let cookieAv = ''
+
+  // 3. If the remaining unparsed-attributes contains a %x3B (";")
+  //    character:
+  if (unparsedAttributes.includes(';')) {
+    // 1. Consume the characters of the unparsed-attributes up to, but
+    //    not including, the first %x3B (";") character.
+    cookieAv = collectASequenceOfCodePointsFast(
+      ';',
+      unparsedAttributes,
+      { position: 0 }
+    )
+    unparsedAttributes = unparsedAttributes.slice(cookieAv.length)
+  } else {
+    // Otherwise:
+
+    // 1. Consume the remainder of the unparsed-attributes.
+    cookieAv = unparsedAttributes
+    unparsedAttributes = ''
+  }
+
+  // Let the cookie-av string be the characters consumed in this step.
+
+  let attributeName = ''
+  let attributeValue = ''
+
+  // 4. If the cookie-av string contains a %x3D ("=") character:
+  if (cookieAv.includes('=')) {
+    // 1. The (possibly empty) attribute-name string consists of the
+    //    characters up to, but not including, the first %x3D ("=")
+    //    character, and the (possibly empty) attribute-value string
+    //    consists of the characters after the first %x3D ("=")
+    //    character.
+    const position = { position: 0 }
+
+    attributeName = collectASequenceOfCodePointsFast(
+      '=',
+      cookieAv,
+      position
+    )
+    attributeValue = cookieAv.slice(position.position + 1)
+  } else {
+    // Otherwise:
+
+    // 1. The attribute-name string consists of the entire cookie-av
+    //    string, and the attribute-value string is empty.
+    attributeName = cookieAv
+  }
+
+  // 5. Remove any leading or trailing WSP characters from the attribute-
+  //    name string and the attribute-value string.
+  attributeName = attributeName.trim()
+  attributeValue = attributeValue.trim()
+
+  // 6. If the attribute-value is longer than 1024 octets, ignore the
+  //    cookie-av string and return to Step 1 of this algorithm.
+  if (attributeValue.length > maxAttributeValueSize) {
+    return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList)
+  }
+
+  // 7. Process the attribute-name and attribute-value according to the
+  //    requirements in the following subsections.  (Notice that
+  //    attributes with unrecognized attribute-names are ignored.)
+  const attributeNameLowercase = attributeName.toLowerCase()
+
+  // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.1
+  // If the attribute-name case-insensitively matches the string
+  // "Expires", the user agent MUST process the cookie-av as follows.
+  if (attributeNameLowercase === 'expires') {
+    // 1. Let the expiry-time be the result of parsing the attribute-value
+    //    as cookie-date (see Section 5.1.1).
+    const expiryTime = new Date(attributeValue)
+
+    // 2. If the attribute-value failed to parse as a cookie date, ignore
+    //    the cookie-av.
+
+    cookieAttributeList.expires = expiryTime
+  } else if (attributeNameLowercase === 'max-age') {
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.2
+    // If the attribute-name case-insensitively matches the string "Max-
+    // Age", the user agent MUST process the cookie-av as follows.
+
+    // 1. If the first character of the attribute-value is not a DIGIT or a
+    //    "-" character, ignore the cookie-av.
+    const charCode = attributeValue.charCodeAt(0)
+
+    if ((charCode < 48 || charCode > 57) && attributeValue[0] !== '-') {
+      return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList)
+    }
+
+    // 2. If the remainder of attribute-value contains a non-DIGIT
+    //    character, ignore the cookie-av.
+    if (!/^\d+$/.test(attributeValue)) {
+      return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList)
+    }
+
+    // 3. Let delta-seconds be the attribute-value converted to an integer.
+    const deltaSeconds = Number(attributeValue)
+
+    // 4. Let cookie-age-limit be the maximum age of the cookie (which
+    //    SHOULD be 400 days or less, see Section 4.1.2.2).
+
+    // 5. Set delta-seconds to the smaller of its present value and cookie-
+    //    age-limit.
+    // deltaSeconds = Math.min(deltaSeconds * 1000, maxExpiresMs)
+
+    // 6. If delta-seconds is less than or equal to zero (0), let expiry-
+    //    time be the earliest representable date and time.  Otherwise, let
+    //    the expiry-time be the current date and time plus delta-seconds
+    //    seconds.
+    // const expiryTime = deltaSeconds <= 0 ? Date.now() : Date.now() + deltaSeconds
+
+    // 7. Append an attribute to the cookie-attribute-list with an
+    //    attribute-name of Max-Age and an attribute-value of expiry-time.
+    cookieAttributeList.maxAge = deltaSeconds
+  } else if (attributeNameLowercase === 'domain') {
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.3
+    // If the attribute-name case-insensitively matches the string "Domain",
+    // the user agent MUST process the cookie-av as follows.
+
+    // 1. Let cookie-domain be the attribute-value.
+    let cookieDomain = attributeValue
+
+    // 2. If cookie-domain starts with %x2E ("."), let cookie-domain be
+    //    cookie-domain without its leading %x2E (".").
+    if (cookieDomain[0] === '.') {
+      cookieDomain = cookieDomain.slice(1)
+    }
+
+    // 3. Convert the cookie-domain to lower case.
+    cookieDomain = cookieDomain.toLowerCase()
+
+    // 4. Append an attribute to the cookie-attribute-list with an
+    //    attribute-name of Domain and an attribute-value of cookie-domain.
+    cookieAttributeList.domain = cookieDomain
+  } else if (attributeNameLowercase === 'path') {
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.4
+    // If the attribute-name case-insensitively matches the string "Path",
+    // the user agent MUST process the cookie-av as follows.
+
+    // 1. If the attribute-value is empty or if the first character of the
+    //    attribute-value is not %x2F ("/"):
+    let cookiePath = ''
+    if (attributeValue.length === 0 || attributeValue[0] !== '/') {
+      // 1. Let cookie-path be the default-path.
+      cookiePath = '/'
+    } else {
+      // Otherwise:
+
+      // 1. Let cookie-path be the attribute-value.
+      cookiePath = attributeValue
+    }
+
+    // 2. Append an attribute to the cookie-attribute-list with an
+    //    attribute-name of Path and an attribute-value of cookie-path.
+    cookieAttributeList.path = cookiePath
+  } else if (attributeNameLowercase === 'secure') {
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.5
+    // If the attribute-name case-insensitively matches the string "Secure",
+    // the user agent MUST append an attribute to the cookie-attribute-list
+    // with an attribute-name of Secure and an empty attribute-value.
+
+    cookieAttributeList.secure = true
+  } else if (attributeNameLowercase === 'httponly') {
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.6
+    // If the attribute-name case-insensitively matches the string
+    // "HttpOnly", the user agent MUST append an attribute to the cookie-
+    // attribute-list with an attribute-name of HttpOnly and an empty
+    // attribute-value.
+
+    cookieAttributeList.httpOnly = true
+  } else if (attributeNameLowercase === 'samesite') {
+    // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-rfc6265bis#section-5.4.7
+    // If the attribute-name case-insensitively matches the string
+    // "SameSite", the user agent MUST process the cookie-av as follows:
+
+    // 1. Let enforcement be "Default".
+    let enforcement = 'Default'
+
+    const attributeValueLowercase = attributeValue.toLowerCase()
+    // 2. If cookie-av's attribute-value is a case-insensitive match for
+    //    "None", set enforcement to "None".
+    if (attributeValueLowercase.includes('none')) {
+      enforcement = 'None'
+    }
+
+    // 3. If cookie-av's attribute-value is a case-insensitive match for
+    //    "Strict", set enforcement to "Strict".
+    if (attributeValueLowercase.includes('strict')) {
+      enforcement = 'Strict'
+    }
+
+    // 4. If cookie-av's attribute-value is a case-insensitive match for
+    //    "Lax", set enforcement to "Lax".
+    if (attributeValueLowercase.includes('lax')) {
+      enforcement = 'Lax'
+    }
+
+    // 5. Append an attribute to the cookie-attribute-list with an
+    //    attribute-name of "SameSite" and an attribute-value of
+    //    enforcement.
+    cookieAttributeList.sameSite = enforcement
+  } else {
+    cookieAttributeList.unparsed ??= []
+
+    cookieAttributeList.unparsed.push(`${attributeName}=${attributeValue}`)
+  }
+
+  // 8. Return to Step 1 of this algorithm.
+  return parseUnparsedAttributes(unparsedAttributes, cookieAttributeList)
+}
+
+module.exports = {
+  parseSetCookie,
+  parseUnparsedAttributes
+}
+
+
+/***/ }),
+
+/***/ 72660:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isCTLExcludingHtab (value) {
+  for (let i = 0; i < value.length; ++i) {
+    const code = value.charCodeAt(i)
+
+    if (
+      (code >= 0x00 && code <= 0x08) ||
+      (code >= 0x0A && code <= 0x1F) ||
+      code === 0x7F
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+/**
+ CHAR           = <any US-ASCII character (octets 0 - 127)>
+ token          = 1*<any CHAR except CTLs or separators>
+ separators     = "(" | ")" | "<" | ">" | "@"
+                | "," | ";" | ":" | "\" | <">
+                | "/" | "[" | "]" | "?" | "="
+                | "{" | "}" | SP | HT
+ * @param {string} name
+ */
+function validateCookieName (name) {
+  for (let i = 0; i < name.length; ++i) {
+    const code = name.charCodeAt(i)
+
+    if (
+      code < 0x21 || // exclude CTLs (0-31), SP and HT
+      code > 0x7E || // exclude non-ascii and DEL
+      code === 0x22 || // "
+      code === 0x28 || // (
+      code === 0x29 || // )
+      code === 0x3C || // <
+      code === 0x3E || // >
+      code === 0x40 || // @
+      code === 0x2C || // ,
+      code === 0x3B || // ;
+      code === 0x3A || // :
+      code === 0x5C || // \
+      code === 0x2F || // /
+      code === 0x5B || // [
+      code === 0x5D || // ]
+      code === 0x3F || // ?
+      code === 0x3D || // =
+      code === 0x7B || // {
+      code === 0x7D // }
+    ) {
+      throw new Error('Invalid cookie name')
+    }
+  }
+}
+
+/**
+ cookie-value      = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE )
+ cookie-octet      = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
+                       ; US-ASCII characters excluding CTLs,
+                       ; whitespace DQUOTE, comma, semicolon,
+                       ; and backslash
+ * @param {string} value
+ */
+function validateCookieValue (value) {
+  let len = value.length
+  let i = 0
+
+  // if the value is wrapped in DQUOTE
+  if (value[0] === '"') {
+    if (len === 1 || value[len - 1] !== '"') {
+      throw new Error('Invalid cookie value')
+    }
+    --len
+    ++i
+  }
+
+  while (i < len) {
+    const code = value.charCodeAt(i++)
+
+    if (
+      code < 0x21 || // exclude CTLs (0-31)
+      code > 0x7E || // non-ascii and DEL (127)
+      code === 0x22 || // "
+      code === 0x2C || // ,
+      code === 0x3B || // ;
+      code === 0x5C // \
+    ) {
+      throw new Error('Invalid cookie value')
+    }
+  }
+}
+
+/**
+ * path-value        = <any CHAR except CTLs or ";">
+ * @param {string} path
+ */
+function validateCookiePath (path) {
+  for (let i = 0; i < path.length; ++i) {
+    const code = path.charCodeAt(i)
+
+    if (
+      code < 0x20 || // exclude CTLs (0-31)
+      code === 0x7F || // DEL
+      code === 0x3B // ;
+    ) {
+      throw new Error('Invalid cookie path')
+    }
+  }
+}
+
+/**
+ * I have no idea why these values aren't allowed to be honest,
+ * but Deno tests these. - Khafra
+ * @param {string} domain
+ */
+function validateCookieDomain (domain) {
+  if (
+    domain.startsWith('-') ||
+    domain.endsWith('.') ||
+    domain.endsWith('-')
+  ) {
+    throw new Error('Invalid cookie domain')
+  }
+}
+
+const IMFDays = [
+  'Sun', 'Mon', 'Tue', 'Wed',
+  'Thu', 'Fri', 'Sat'
+]
+
+const IMFMonths = [
+  'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun',
+  'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'
+]
+
+const IMFPaddedNumbers = Array(61).fill(0).map((_, i) => i.toString().padStart(2, '0'))
+
+/**
+ * @see https://www.rfc-editor.org/rfc/rfc7231#section-7.1.1.1
+ * @param {number|Date} date
+  IMF-fixdate  = day-name "," SP date1 SP time-of-day SP GMT
+  ; fixed length/zone/capitalization subset of the format
+  ; see Section 3.3 of [RFC5322]
+
+  day-name     = %x4D.6F.6E ; "Mon", case-sensitive
+              / %x54.75.65 ; "Tue", case-sensitive
+              / %x57.65.64 ; "Wed", case-sensitive
+              / %x54.68.75 ; "Thu", case-sensitive
+              / %x46.72.69 ; "Fri", case-sensitive
+              / %x53.61.74 ; "Sat", case-sensitive
+              / %x53.75.6E ; "Sun", case-sensitive
+  date1        = day SP month SP year
+                  ; e.g., 02 Jun 1982
+
+  day          = 2DIGIT
+  month        = %x4A.61.6E ; "Jan", case-sensitive
+              / %x46.65.62 ; "Feb", case-sensitive
+              / %x4D.61.72 ; "Mar", case-sensitive
+              / %x41.70.72 ; "Apr", case-sensitive
+              / %x4D.61.79 ; "May", case-sensitive
+              / %x4A.75.6E ; "Jun", case-sensitive
+              / %x4A.75.6C ; "Jul", case-sensitive
+              / %x41.75.67 ; "Aug", case-sensitive
+              / %x53.65.70 ; "Sep", case-sensitive
+              / %x4F.63.74 ; "Oct", case-sensitive
+              / %x4E.6F.76 ; "Nov", case-sensitive
+              / %x44.65.63 ; "Dec", case-sensitive
+  year         = 4DIGIT
+
+  GMT          = %x47.4D.54 ; "GMT", case-sensitive
+
+  time-of-day  = hour ":" minute ":" second
+              ; 00:00:00 - 23:59:60 (leap second)
+
+  hour         = 2DIGIT
+  minute       = 2DIGIT
+  second       = 2DIGIT
+ */
+function toIMFDate (date) {
+  if (typeof date === 'number') {
+    date = new Date(date)
+  }
+
+  return `${IMFDays[date.getUTCDay()]}, ${IMFPaddedNumbers[date.getUTCDate()]} ${IMFMonths[date.getUTCMonth()]} ${date.getUTCFullYear()} ${IMFPaddedNumbers[date.getUTCHours()]}:${IMFPaddedNumbers[date.getUTCMinutes()]}:${IMFPaddedNumbers[date.getUTCSeconds()]} GMT`
+}
+
+/**
+ max-age-av        = "Max-Age=" non-zero-digit *DIGIT
+                       ; In practice, both expires-av and max-age-av
+                       ; are limited to dates representable by the
+                       ; user agent.
+ * @param {number} maxAge
+ */
+function validateCookieMaxAge (maxAge) {
+  if (maxAge < 0) {
+    throw new Error('Invalid cookie max-age')
+  }
+}
+
+/**
+ * @see https://www.rfc-editor.org/rfc/rfc6265#section-4.1.1
+ * @param {import('./index').Cookie} cookie
+ */
+function stringify (cookie) {
+  if (cookie.name.length === 0) {
+    return null
+  }
+
+  validateCookieName(cookie.name)
+  validateCookieValue(cookie.value)
+
+  const out = [`${cookie.name}=${cookie.value}`]
+
+  // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-cookie-prefixes-00#section-3.1
+  // https://datatracker.ietf.org/doc/html/draft-ietf-httpbis-cookie-prefixes-00#section-3.2
+  if (cookie.name.startsWith('__Secure-')) {
+    cookie.secure = true
+  }
+
+  if (cookie.name.startsWith('__Host-')) {
+    cookie.secure = true
+    cookie.domain = null
+    cookie.path = '/'
+  }
+
+  if (cookie.secure) {
+    out.push('Secure')
+  }
+
+  if (cookie.httpOnly) {
+    out.push('HttpOnly')
+  }
+
+  if (typeof cookie.maxAge === 'number') {
+    validateCookieMaxAge(cookie.maxAge)
+    out.push(`Max-Age=${cookie.maxAge}`)
+  }
+
+  if (cookie.domain) {
+    validateCookieDomain(cookie.domain)
+    out.push(`Domain=${cookie.domain}`)
+  }
+
+  if (cookie.path) {
+    validateCookiePath(cookie.path)
+    out.push(`Path=${cookie.path}`)
+  }
+
+  if (cookie.expires && cookie.expires.toString() !== 'Invalid Date') {
+    out.push(`Expires=${toIMFDate(cookie.expires)}`)
+  }
+
+  if (cookie.sameSite) {
+    out.push(`SameSite=${cookie.sameSite}`)
+  }
+
+  for (const part of cookie.unparsed) {
+    if (!part.includes('=')) {
+      throw new Error('Invalid unparsed')
+    }
+
+    const [key, ...value] = part.split('=')
+
+    out.push(`${key.trim()}=${value.join('=')}`)
+  }
+
+  return out.join('; ')
+}
+
+module.exports = {
+  isCTLExcludingHtab,
+  validateCookieName,
+  validateCookiePath,
+  validateCookieValue,
+  toIMFDate,
+  stringify
+}
+
+
+/***/ }),
+
+/***/ 47882:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+const { Transform } = __nccwpck_require__(84492)
+const { isASCIINumber, isValidLastEventId } = __nccwpck_require__(7793)
+
+/**
+ * @type {number[]} BOM
+ */
+const BOM = [0xEF, 0xBB, 0xBF]
+/**
+ * @type {10} LF
+ */
+const LF = 0x0A
+/**
+ * @type {13} CR
+ */
+const CR = 0x0D
+/**
+ * @type {58} COLON
+ */
+const COLON = 0x3A
+/**
+ * @type {32} SPACE
+ */
+const SPACE = 0x20
+
+/**
+ * @typedef {object} EventSourceStreamEvent
+ * @type {object}
+ * @property {string} [event] The event type.
+ * @property {string} [data] The data of the message.
+ * @property {string} [id] A unique ID for the event.
+ * @property {string} [retry] The reconnection time, in milliseconds.
+ */
+
+/**
+ * @typedef eventSourceSettings
+ * @type {object}
+ * @property {string} lastEventId The last event ID received from the server.
+ * @property {string} origin The origin of the event source.
+ * @property {number} reconnectionTime The reconnection time, in milliseconds.
+ */
+
+class EventSourceStream extends Transform {
+  /**
+   * @type {eventSourceSettings}
+   */
+  state = null
+
+  /**
+   * Leading byte-order-mark check.
+   * @type {boolean}
+   */
+  checkBOM = true
+
+  /**
+   * @type {boolean}
+   */
+  crlfCheck = false
+
+  /**
+   * @type {boolean}
+   */
+  eventEndCheck = false
+
+  /**
+   * @type {Buffer}
+   */
+  buffer = null
+
+  pos = 0
+
+  event = {
+    data: undefined,
+    event: undefined,
+    id: undefined,
+    retry: undefined
+  }
+
+  /**
+   * @param {object} options
+   * @param {eventSourceSettings} options.eventSourceSettings
+   * @param {Function} [options.push]
+   */
+  constructor (options = {}) {
+    // Enable object mode as EventSourceStream emits objects of shape
+    // EventSourceStreamEvent
+    options.readableObjectMode = true
+
+    super(options)
+
+    this.state = options.eventSourceSettings || {}
+    if (options.push) {
+      this.push = options.push
+    }
+  }
+
+  /**
+   * @param {Buffer} chunk
+   * @param {string} _encoding
+   * @param {Function} callback
+   * @returns {void}
+   */
+  _transform (chunk, _encoding, callback) {
+    if (chunk.length === 0) {
+      callback()
+      return
+    }
+
+    // Cache the chunk in the buffer, as the data might not be complete while
+    // processing it
+    // TODO: Investigate if there is a more performant way to handle
+    // incoming chunks
+    // see: https://github.com/nodejs/undici/issues/2630
+    if (this.buffer) {
+      this.buffer = Buffer.concat([this.buffer, chunk])
+    } else {
+      this.buffer = chunk
+    }
+
+    // Strip leading byte-order-mark if we opened the stream and started
+    // the processing of the incoming data
+    if (this.checkBOM) {
+      switch (this.buffer.length) {
+        case 1:
+          // Check if the first byte is the same as the first byte of the BOM
+          if (this.buffer[0] === BOM[0]) {
+            // If it is, we need to wait for more data
+            callback()
+            return
+          }
+          // Set the checkBOM flag to false as we don't need to check for the
+          // BOM anymore
+          this.checkBOM = false
+
+          // The buffer only contains one byte so we need to wait for more data
+          callback()
+          return
+        case 2:
+          // Check if the first two bytes are the same as the first two bytes
+          // of the BOM
+          if (
+            this.buffer[0] === BOM[0] &&
+            this.buffer[1] === BOM[1]
+          ) {
+            // If it is, we need to wait for more data, because the third byte
+            // is needed to determine if it is the BOM or not
+            callback()
+            return
+          }
+
+          // Set the checkBOM flag to false as we don't need to check for the
+          // BOM anymore
+          this.checkBOM = false
+          break
+        case 3:
+          // Check if the first three bytes are the same as the first three
+          // bytes of the BOM
+          if (
+            this.buffer[0] === BOM[0] &&
+            this.buffer[1] === BOM[1] &&
+            this.buffer[2] === BOM[2]
+          ) {
+            // If it is, we can drop the buffered data, as it is only the BOM
+            this.buffer = Buffer.alloc(0)
+            // Set the checkBOM flag to false as we don't need to check for the
+            // BOM anymore
+            this.checkBOM = false
+
+            // Await more data
+            callback()
+            return
+          }
+          // If it is not the BOM, we can start processing the data
+          this.checkBOM = false
+          break
+        default:
+          // The buffer is longer than 3 bytes, so we can drop the BOM if it is
+          // present
+          if (
+            this.buffer[0] === BOM[0] &&
+            this.buffer[1] === BOM[1] &&
+            this.buffer[2] === BOM[2]
+          ) {
+            // Remove the BOM from the buffer
+            this.buffer = this.buffer.subarray(3)
+          }
+
+          // Set the checkBOM flag to false as we don't need to check for the
+          this.checkBOM = false
+          break
+      }
+    }
+
+    while (this.pos < this.buffer.length) {
+      // If the previous line ended with an end-of-line, we need to check
+      // if the next character is also an end-of-line.
+      if (this.eventEndCheck) {
+        // If the the current character is an end-of-line, then the event
+        // is finished and we can process it
+
+        // If the previous line ended with a carriage return, we need to
+        // check if the current character is a line feed and remove it
+        // from the buffer.
+        if (this.crlfCheck) {
+          // If the current character is a line feed, we can remove it
+          // from the buffer and reset the crlfCheck flag
+          if (this.buffer[this.pos] === LF) {
+            this.buffer = this.buffer.subarray(this.pos + 1)
+            this.pos = 0
+            this.crlfCheck = false
+
+            // It is possible that the line feed is not the end of the
+            // event. We need to check if the next character is an
+            // end-of-line character to determine if the event is
+            // finished. We simply continue the loop to check the next
+            // character.
+
+            // As we removed the line feed from the buffer and set the
+            // crlfCheck flag to false, we basically don't make any
+            // distinction between a line feed and a carriage return.
+            continue
+          }
+          this.crlfCheck = false
+        }
+
+        if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
+          // If the current character is a carriage return, we need to
+          // set the crlfCheck flag to true, as we need to check if the
+          // next character is a line feed so we can remove it from the
+          // buffer
+          if (this.buffer[this.pos] === CR) {
+            this.crlfCheck = true
+          }
+
+          this.buffer = this.buffer.subarray(this.pos + 1)
+          this.pos = 0
+          if (
+            this.event.data !== undefined || this.event.event || this.event.id || this.event.retry) {
+            this.processEvent(this.event)
+          }
+          this.clearEvent()
+          continue
+        }
+        // If the current character is not an end-of-line, then the event
+        // is not finished and we have to reset the eventEndCheck flag
+        this.eventEndCheck = false
+        continue
+      }
+
+      // If the current character is an end-of-line, we can process the
+      // line
+      if (this.buffer[this.pos] === LF || this.buffer[this.pos] === CR) {
+        // If the current character is a carriage return, we need to
+        // set the crlfCheck flag to true, as we need to check if the
+        // next character is a line feed
+        if (this.buffer[this.pos] === CR) {
+          this.crlfCheck = true
+        }
+
+        // In any case, we can process the line as we reached an
+        // end-of-line character
+        this.parseLine(this.buffer.subarray(0, this.pos), this.event)
+
+        // Remove the processed line from the buffer
+        this.buffer = this.buffer.subarray(this.pos + 1)
+        // Reset the position as we removed the processed line from the buffer
+        this.pos = 0
+        // A line was processed and this could be the end of the event. We need
+        // to check if the next line is empty to determine if the event is
+        // finished.
+        this.eventEndCheck = true
+        continue
+      }
+
+      this.pos++
+    }
+
+    callback()
+  }
+
+  /**
+   * @param {Buffer} line
+   * @param {EventStreamEvent} event
+   */
+  parseLine (line, event) {
+    // If the line is empty (a blank line)
+    // Dispatch the event, as defined below.
+    // This will be handled in the _transform method
+    if (line.length === 0) {
+      return
+    }
+
+    // If the line starts with a U+003A COLON character (:)
+    // Ignore the line.
+    const colonPosition = line.indexOf(COLON)
+    if (colonPosition === 0) {
+      return
+    }
+
+    let field = ''
+    let value = ''
+
+    // If the line contains a U+003A COLON character (:)
+    if (colonPosition !== -1) {
+      // Collect the characters on the line before the first U+003A COLON
+      // character (:), and let field be that string.
+      // TODO: Investigate if there is a more performant way to extract the
+      // field
+      // see: https://github.com/nodejs/undici/issues/2630
+      field = line.subarray(0, colonPosition).toString('utf8')
+
+      // Collect the characters on the line after the first U+003A COLON
+      // character (:), and let value be that string.
+      // If value starts with a U+0020 SPACE character, remove it from value.
+      let valueStart = colonPosition + 1
+      if (line[valueStart] === SPACE) {
+        ++valueStart
+      }
+      // TODO: Investigate if there is a more performant way to extract the
+      // value
+      // see: https://github.com/nodejs/undici/issues/2630
+      value = line.subarray(valueStart).toString('utf8')
+
+      // Otherwise, the string is not empty but does not contain a U+003A COLON
+      // character (:)
+    } else {
+      // Process the field using the steps described below, using the whole
+      // line as the field name, and the empty string as the field value.
+      field = line.toString('utf8')
+      value = ''
+    }
+
+    // Modify the event with the field name and value. The value is also
+    // decoded as UTF-8
+    switch (field) {
+      case 'data':
+        if (event[field] === undefined) {
+          event[field] = value
+        } else {
+          event[field] += `\n${value}`
+        }
+        break
+      case 'retry':
+        if (isASCIINumber(value)) {
+          event[field] = value
+        }
+        break
+      case 'id':
+        if (isValidLastEventId(value)) {
+          event[field] = value
+        }
+        break
+      case 'event':
+        if (value.length > 0) {
+          event[field] = value
+        }
+        break
+    }
+  }
+
+  /**
+   * @param {EventSourceStreamEvent} event
+   */
+  processEvent (event) {
+    if (event.retry && isASCIINumber(event.retry)) {
+      this.state.reconnectionTime = parseInt(event.retry, 10)
+    }
+
+    if (event.id && isValidLastEventId(event.id)) {
+      this.state.lastEventId = event.id
+    }
+
+    // only dispatch event, when data is provided
+    if (event.data !== undefined) {
+      this.push({
+        type: event.event || 'message',
+        options: {
+          data: event.data,
+          lastEventId: this.state.lastEventId,
+          origin: this.state.origin
+        }
+      })
+    }
+  }
+
+  clearEvent () {
+    this.event = {
+      data: undefined,
+      event: undefined,
+      id: undefined,
+      retry: undefined
+    }
+  }
+}
+
+module.exports = {
+  EventSourceStream
+}
+
+
+/***/ }),
+
+/***/ 62205:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { pipeline } = __nccwpck_require__(84492)
+const { fetching } = __nccwpck_require__(31158)
+const { makeRequest } = __nccwpck_require__(13925)
+const { webidl } = __nccwpck_require__(37829)
+const { EventSourceStream } = __nccwpck_require__(47882)
+const { parseMIMEType } = __nccwpck_require__(86954)
+const { createFastMessageEvent } = __nccwpck_require__(15135)
+const { isNetworkError } = __nccwpck_require__(33139)
+const { delay } = __nccwpck_require__(7793)
+const { kEnumerableProperty } = __nccwpck_require__(94407)
+const { environmentSettingsObject } = __nccwpck_require__(91976)
+
+let experimentalWarned = false
+
+/**
+ * A reconnection time, in milliseconds. This must initially be an implementation-defined value,
+ * probably in the region of a few seconds.
+ *
+ * In Comparison:
+ * - Chrome uses 3000ms.
+ * - Deno uses 5000ms.
+ *
+ * @type {3000}
+ */
+const defaultReconnectionTime = 3000
+
+/**
+ * The readyState attribute represents the state of the connection.
+ * @enum
+ * @readonly
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#dom-eventsource-readystate-dev
+ */
+
+/**
+ * The connection has not yet been established, or it was closed and the user
+ * agent is reconnecting.
+ * @type {0}
+ */
+const CONNECTING = 0
+
+/**
+ * The user agent has an open connection and is dispatching events as it
+ * receives them.
+ * @type {1}
+ */
+const OPEN = 1
+
+/**
+ * The connection is not open, and the user agent is not trying to reconnect.
+ * @type {2}
+ */
+const CLOSED = 2
+
+/**
+ * Requests for the element will have their mode set to "cors" and their credentials mode set to "same-origin".
+ * @type {'anonymous'}
+ */
+const ANONYMOUS = 'anonymous'
+
+/**
+ * Requests for the element will have their mode set to "cors" and their credentials mode set to "include".
+ * @type {'use-credentials'}
+ */
+const USE_CREDENTIALS = 'use-credentials'
+
+/**
+ * The EventSource interface is used to receive server-sent events. It
+ * connects to a server over HTTP and receives events in text/event-stream
+ * format without closing the connection.
+ * @extends {EventTarget}
+ * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#server-sent-events
+ * @api public
+ */
+class EventSource extends EventTarget {
+  #events = {
+    open: null,
+    error: null,
+    message: null
+  }
+
+  #url = null
+  #withCredentials = false
+
+  #readyState = CONNECTING
+
+  #request = null
+  #controller = null
+
+  #dispatcher
+
+  /**
+   * @type {import('./eventsource-stream').eventSourceSettings}
+   */
+  #state
+
+  /**
+   * Creates a new EventSource object.
+   * @param {string} url
+   * @param {EventSourceInit} [eventSourceInitDict]
+   * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#the-eventsource-interface
+   */
+  constructor (url, eventSourceInitDict = {}) {
+    // 1. Let ev be a new EventSource object.
+    super()
+
+    webidl.util.markAsUncloneable(this)
+
+    const prefix = 'EventSource constructor'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    if (!experimentalWarned) {
+      experimentalWarned = true
+      process.emitWarning('EventSource is experimental, expect them to change at any time.', {
+        code: 'UNDICI-ES'
+      })
+    }
+
+    url = webidl.converters.USVString(url, prefix, 'url')
+    eventSourceInitDict = webidl.converters.EventSourceInitDict(eventSourceInitDict, prefix, 'eventSourceInitDict')
+
+    this.#dispatcher = eventSourceInitDict.dispatcher
+    this.#state = {
+      lastEventId: '',
+      reconnectionTime: defaultReconnectionTime
+    }
+
+    // 2. Let settings be ev's relevant settings object.
+    // https://html.spec.whatwg.org/multipage/webappapis.html#environment-settings-object
+    const settings = environmentSettingsObject
+
+    let urlRecord
+
+    try {
+      // 3. Let urlRecord be the result of encoding-parsing a URL given url, relative to settings.
+      urlRecord = new URL(url, settings.settingsObject.baseUrl)
+      this.#state.origin = urlRecord.origin
+    } catch (e) {
+      // 4. If urlRecord is failure, then throw a "SyntaxError" DOMException.
+      throw new DOMException(e, 'SyntaxError')
+    }
+
+    // 5. Set ev's url to urlRecord.
+    this.#url = urlRecord.href
+
+    // 6. Let corsAttributeState be Anonymous.
+    let corsAttributeState = ANONYMOUS
+
+    // 7. If the value of eventSourceInitDict's withCredentials member is true,
+    // then set corsAttributeState to Use Credentials and set ev's
+    // withCredentials attribute to true.
+    if (eventSourceInitDict.withCredentials) {
+      corsAttributeState = USE_CREDENTIALS
+      this.#withCredentials = true
+    }
+
+    // 8. Let request be the result of creating a potential-CORS request given
+    // urlRecord, the empty string, and corsAttributeState.
+    const initRequest = {
+      redirect: 'follow',
+      keepalive: true,
+      // @see https://html.spec.whatwg.org/multipage/urls-and-fetching.html#cors-settings-attributes
+      mode: 'cors',
+      credentials: corsAttributeState === 'anonymous'
+        ? 'same-origin'
+        : 'omit',
+      referrer: 'no-referrer'
+    }
+
+    // 9. Set request's client to settings.
+    initRequest.client = environmentSettingsObject.settingsObject
+
+    // 10. User agents may set (`Accept`, `text/event-stream`) in request's header list.
+    initRequest.headersList = [['accept', { name: 'accept', value: 'text/event-stream' }]]
+
+    // 11. Set request's cache mode to "no-store".
+    initRequest.cache = 'no-store'
+
+    // 12. Set request's initiator type to "other".
+    initRequest.initiator = 'other'
+
+    initRequest.urlList = [new URL(this.#url)]
+
+    // 13. Set ev's request to request.
+    this.#request = makeRequest(initRequest)
+
+    this.#connect()
+  }
+
+  /**
+   * Returns the state of this EventSource object's connection. It can have the
+   * values described below.
+   * @returns {0|1|2}
+   * @readonly
+   */
+  get readyState () {
+    return this.#readyState
+  }
+
+  /**
+   * Returns the URL providing the event stream.
+   * @readonly
+   * @returns {string}
+   */
+  get url () {
+    return this.#url
+  }
+
+  /**
+   * Returns a boolean indicating whether the EventSource object was
+   * instantiated with CORS credentials set (true), or not (false, the default).
+   */
+  get withCredentials () {
+    return this.#withCredentials
+  }
+
+  #connect () {
+    if (this.#readyState === CLOSED) return
+
+    this.#readyState = CONNECTING
+
+    const fetchParams = {
+      request: this.#request,
+      dispatcher: this.#dispatcher
+    }
+
+    // 14. Let processEventSourceEndOfBody given response res be the following step: if res is not a network error, then reestablish the connection.
+    const processEventSourceEndOfBody = (response) => {
+      if (isNetworkError(response)) {
+        this.dispatchEvent(new Event('error'))
+        this.close()
+      }
+
+      this.#reconnect()
+    }
+
+    // 15. Fetch request, with processResponseEndOfBody set to processEventSourceEndOfBody...
+    fetchParams.processResponseEndOfBody = processEventSourceEndOfBody
+
+    // and processResponse set to the following steps given response res:
+    fetchParams.processResponse = (response) => {
+      // 1. If res is an aborted network error, then fail the connection.
+
+      if (isNetworkError(response)) {
+        // 1. When a user agent is to fail the connection, the user agent
+        // must queue a task which, if the readyState attribute is set to a
+        // value other than CLOSED, sets the readyState attribute to CLOSED
+        // and fires an event named error at the EventSource object. Once the
+        // user agent has failed the connection, it does not attempt to
+        // reconnect.
+        if (response.aborted) {
+          this.close()
+          this.dispatchEvent(new Event('error'))
+          return
+          // 2. Otherwise, if res is a network error, then reestablish the
+          // connection, unless the user agent knows that to be futile, in
+          // which case the user agent may fail the connection.
+        } else {
+          this.#reconnect()
+          return
+        }
+      }
+
+      // 3. Otherwise, if res's status is not 200, or if res's `Content-Type`
+      // is not `text/event-stream`, then fail the connection.
+      const contentType = response.headersList.get('content-type', true)
+      const mimeType = contentType !== null ? parseMIMEType(contentType) : 'failure'
+      const contentTypeValid = mimeType !== 'failure' && mimeType.essence === 'text/event-stream'
+      if (
+        response.status !== 200 ||
+        contentTypeValid === false
+      ) {
+        this.close()
+        this.dispatchEvent(new Event('error'))
+        return
+      }
+
+      // 4. Otherwise, announce the connection and interpret res's body
+      // line by line.
+
+      // When a user agent is to announce the connection, the user agent
+      // must queue a task which, if the readyState attribute is set to a
+      // value other than CLOSED, sets the readyState attribute to OPEN
+      // and fires an event named open at the EventSource object.
+      // @see https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model
+      this.#readyState = OPEN
+      this.dispatchEvent(new Event('open'))
+
+      // If redirected to a different origin, set the origin to the new origin.
+      this.#state.origin = response.urlList[response.urlList.length - 1].origin
+
+      const eventSourceStream = new EventSourceStream({
+        eventSourceSettings: this.#state,
+        push: (event) => {
+          this.dispatchEvent(createFastMessageEvent(
+            event.type,
+            event.options
+          ))
+        }
+      })
+
+      pipeline(response.body.stream,
+        eventSourceStream,
+        (error) => {
+          if (
+            error?.aborted === false
+          ) {
+            this.close()
+            this.dispatchEvent(new Event('error'))
+          }
+        })
+    }
+
+    this.#controller = fetching(fetchParams)
+  }
+
+  /**
+   * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#sse-processing-model
+   * @returns {Promise<void>}
+   */
+  async #reconnect () {
+    // When a user agent is to reestablish the connection, the user agent must
+    // run the following steps. These steps are run in parallel, not as part of
+    // a task. (The tasks that it queues, of course, are run like normal tasks
+    // and not themselves in parallel.)
+
+    // 1. Queue a task to run the following steps:
+
+    //   1. If the readyState attribute is set to CLOSED, abort the task.
+    if (this.#readyState === CLOSED) return
+
+    //   2. Set the readyState attribute to CONNECTING.
+    this.#readyState = CONNECTING
+
+    //   3. Fire an event named error at the EventSource object.
+    this.dispatchEvent(new Event('error'))
+
+    // 2. Wait a delay equal to the reconnection time of the event source.
+    await delay(this.#state.reconnectionTime)
+
+    // 5. Queue a task to run the following steps:
+
+    //   1. If the EventSource object's readyState attribute is not set to
+    //      CONNECTING, then return.
+    if (this.#readyState !== CONNECTING) return
+
+    //   2. Let request be the EventSource object's request.
+    //   3. If the EventSource object's last event ID string is not the empty
+    //      string, then:
+    //      1. Let lastEventIDValue be the EventSource object's last event ID
+    //         string, encoded as UTF-8.
+    //      2. Set (`Last-Event-ID`, lastEventIDValue) in request's header
+    //         list.
+    if (this.#state.lastEventId.length) {
+      this.#request.headersList.set('last-event-id', this.#state.lastEventId, true)
+    }
+
+    //   4. Fetch request and process the response obtained in this fashion, if any, as described earlier in this section.
+    this.#connect()
+  }
+
+  /**
+   * Closes the connection, if any, and sets the readyState attribute to
+   * CLOSED.
+   */
+  close () {
+    webidl.brandCheck(this, EventSource)
+
+    if (this.#readyState === CLOSED) return
+    this.#readyState = CLOSED
+    this.#controller.abort()
+    this.#request = null
+  }
+
+  get onopen () {
+    return this.#events.open
+  }
+
+  set onopen (fn) {
+    if (this.#events.open) {
+      this.removeEventListener('open', this.#events.open)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.open = fn
+      this.addEventListener('open', fn)
+    } else {
+      this.#events.open = null
+    }
+  }
+
+  get onmessage () {
+    return this.#events.message
+  }
+
+  set onmessage (fn) {
+    if (this.#events.message) {
+      this.removeEventListener('message', this.#events.message)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.message = fn
+      this.addEventListener('message', fn)
+    } else {
+      this.#events.message = null
+    }
+  }
+
+  get onerror () {
+    return this.#events.error
+  }
+
+  set onerror (fn) {
+    if (this.#events.error) {
+      this.removeEventListener('error', this.#events.error)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.error = fn
+      this.addEventListener('error', fn)
+    } else {
+      this.#events.error = null
+    }
+  }
+}
+
+const constantsPropertyDescriptors = {
+  CONNECTING: {
+    __proto__: null,
+    configurable: false,
+    enumerable: true,
+    value: CONNECTING,
+    writable: false
+  },
+  OPEN: {
+    __proto__: null,
+    configurable: false,
+    enumerable: true,
+    value: OPEN,
+    writable: false
+  },
+  CLOSED: {
+    __proto__: null,
+    configurable: false,
+    enumerable: true,
+    value: CLOSED,
+    writable: false
+  }
+}
+
+Object.defineProperties(EventSource, constantsPropertyDescriptors)
+Object.defineProperties(EventSource.prototype, constantsPropertyDescriptors)
+
+Object.defineProperties(EventSource.prototype, {
+  close: kEnumerableProperty,
+  onerror: kEnumerableProperty,
+  onmessage: kEnumerableProperty,
+  onopen: kEnumerableProperty,
+  readyState: kEnumerableProperty,
+  url: kEnumerableProperty,
+  withCredentials: kEnumerableProperty
+})
+
+webidl.converters.EventSourceInitDict = webidl.dictionaryConverter([
+  {
+    key: 'withCredentials',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'dispatcher', // undici only
+    converter: webidl.converters.any
+  }
+])
+
+module.exports = {
+  EventSource,
+  defaultReconnectionTime
+}
+
+
+/***/ }),
+
+/***/ 7793:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * Checks if the given value is a valid LastEventId.
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isValidLastEventId (value) {
+  // LastEventId should not contain U+0000 NULL
+  return value.indexOf('\u0000') === -1
+}
+
+/**
+ * Checks if the given value is a base 10 digit.
+ * @param {string} value
+ * @returns {boolean}
+ */
+function isASCIINumber (value) {
+  if (value.length === 0) return false
+  for (let i = 0; i < value.length; i++) {
+    if (value.charCodeAt(i) < 0x30 || value.charCodeAt(i) > 0x39) return false
+  }
+  return true
+}
+
+// https://github.com/nodejs/undici/issues/2664
+function delay (ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms).unref()
+  })
+}
+
+module.exports = {
+  isValidLastEventId,
+  isASCIINumber,
+  delay
+}
+
+
+/***/ }),
+
+/***/ 23291:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const util = __nccwpck_require__(94407)
+const {
+  ReadableStreamFrom,
+  isBlobLike,
+  isReadableStreamLike,
+  readableStreamClose,
+  createDeferredPromise,
+  fullyReadBody,
+  extractMimeType,
+  utf8DecodeBytes
+} = __nccwpck_require__(91976)
+const { FormData } = __nccwpck_require__(4923)
+const { kState } = __nccwpck_require__(78172)
+const { webidl } = __nccwpck_require__(37829)
+const { Blob } = __nccwpck_require__(72254)
+const assert = __nccwpck_require__(98061)
+const { isErrored, isDisturbed } = __nccwpck_require__(84492)
+const { isArrayBuffer } = __nccwpck_require__(93746)
+const { serializeAMimeType } = __nccwpck_require__(86954)
+const { multipartFormDataParser } = __nccwpck_require__(43227)
+let random
+
+try {
+  const crypto = __nccwpck_require__(6005)
+  random = (max) => crypto.randomInt(0, max)
+} catch {
+  random = (max) => Math.floor(Math.random(max))
+}
+
+const textEncoder = new TextEncoder()
+function noop () {}
+
+const hasFinalizationRegistry = globalThis.FinalizationRegistry && process.version.indexOf('v18') !== 0
+let streamRegistry
+
+if (hasFinalizationRegistry) {
+  streamRegistry = new FinalizationRegistry((weakRef) => {
+    const stream = weakRef.deref()
+    if (stream && !stream.locked && !isDisturbed(stream) && !isErrored(stream)) {
+      stream.cancel('Response object has been garbage collected').catch(noop)
+    }
+  })
+}
+
+// https://fetch.spec.whatwg.org/#concept-bodyinit-extract
+function extractBody (object, keepalive = false) {
+  // 1. Let stream be null.
+  let stream = null
+
+  // 2. If object is a ReadableStream object, then set stream to object.
+  if (object instanceof ReadableStream) {
+    stream = object
+  } else if (isBlobLike(object)) {
+    // 3. Otherwise, if object is a Blob object, set stream to the
+    //    result of running object’s get stream.
+    stream = object.stream()
+  } else {
+    // 4. Otherwise, set stream to a new ReadableStream object, and set
+    //    up stream with byte reading support.
+    stream = new ReadableStream({
+      async pull (controller) {
+        const buffer = typeof source === 'string' ? textEncoder.encode(source) : source
+
+        if (buffer.byteLength) {
+          controller.enqueue(buffer)
+        }
+
+        queueMicrotask(() => readableStreamClose(controller))
+      },
+      start () {},
+      type: 'bytes'
+    })
+  }
+
+  // 5. Assert: stream is a ReadableStream object.
+  assert(isReadableStreamLike(stream))
+
+  // 6. Let action be null.
+  let action = null
+
+  // 7. Let source be null.
+  let source = null
+
+  // 8. Let length be null.
+  let length = null
+
+  // 9. Let type be null.
+  let type = null
+
+  // 10. Switch on object:
+  if (typeof object === 'string') {
+    // Set source to the UTF-8 encoding of object.
+    // Note: setting source to a Uint8Array here breaks some mocking assumptions.
+    source = object
+
+    // Set type to `text/plain;charset=UTF-8`.
+    type = 'text/plain;charset=UTF-8'
+  } else if (object instanceof URLSearchParams) {
+    // URLSearchParams
+
+    // spec says to run application/x-www-form-urlencoded on body.list
+    // this is implemented in Node.js as apart of an URLSearchParams instance toString method
+    // See: https://github.com/nodejs/node/blob/e46c680bf2b211bbd52cf959ca17ee98c7f657f5/lib/internal/url.js#L490
+    // and https://github.com/nodejs/node/blob/e46c680bf2b211bbd52cf959ca17ee98c7f657f5/lib/internal/url.js#L1100
+
+    // Set source to the result of running the application/x-www-form-urlencoded serializer with object’s list.
+    source = object.toString()
+
+    // Set type to `application/x-www-form-urlencoded;charset=UTF-8`.
+    type = 'application/x-www-form-urlencoded;charset=UTF-8'
+  } else if (isArrayBuffer(object)) {
+    // BufferSource/ArrayBuffer
+
+    // Set source to a copy of the bytes held by object.
+    source = new Uint8Array(object.slice())
+  } else if (ArrayBuffer.isView(object)) {
+    // BufferSource/ArrayBufferView
+
+    // Set source to a copy of the bytes held by object.
+    source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength))
+  } else if (util.isFormDataLike(object)) {
+    const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, '0')}`
+    const prefix = `--${boundary}\r\nContent-Disposition: form-data`
+
+    /*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+    const escape = (str) =>
+      str.replace(/\n/g, '%0A').replace(/\r/g, '%0D').replace(/"/g, '%22')
+    const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, '\r\n')
+
+    // Set action to this step: run the multipart/form-data
+    // encoding algorithm, with object’s entry list and UTF-8.
+    // - This ensures that the body is immutable and can't be changed afterwords
+    // - That the content-length is calculated in advance.
+    // - And that all parts are pre-encoded and ready to be sent.
+
+    const blobParts = []
+    const rn = new Uint8Array([13, 10]) // '\r\n'
+    length = 0
+    let hasUnknownSizeValue = false
+
+    for (const [name, value] of object) {
+      if (typeof value === 'string') {
+        const chunk = textEncoder.encode(prefix +
+          `; name="${escape(normalizeLinefeeds(name))}"` +
+          `\r\n\r\n${normalizeLinefeeds(value)}\r\n`)
+        blobParts.push(chunk)
+        length += chunk.byteLength
+      } else {
+        const chunk = textEncoder.encode(`${prefix}; name="${escape(normalizeLinefeeds(name))}"` +
+          (value.name ? `; filename="${escape(value.name)}"` : '') + '\r\n' +
+          `Content-Type: ${
+            value.type || 'application/octet-stream'
+          }\r\n\r\n`)
+        blobParts.push(chunk, value, rn)
+        if (typeof value.size === 'number') {
+          length += chunk.byteLength + value.size + rn.byteLength
+        } else {
+          hasUnknownSizeValue = true
+        }
+      }
+    }
+
+    // CRLF is appended to the body to function with legacy servers and match other implementations.
+    // https://github.com/curl/curl/blob/3434c6b46e682452973972e8313613dfa58cd690/lib/mime.c#L1029-L1030
+    // https://github.com/form-data/form-data/issues/63
+    const chunk = textEncoder.encode(`--${boundary}--\r\n`)
+    blobParts.push(chunk)
+    length += chunk.byteLength
+    if (hasUnknownSizeValue) {
+      length = null
+    }
+
+    // Set source to object.
+    source = object
+
+    action = async function * () {
+      for (const part of blobParts) {
+        if (part.stream) {
+          yield * part.stream()
+        } else {
+          yield part
+        }
+      }
+    }
+
+    // Set type to `multipart/form-data; boundary=`,
+    // followed by the multipart/form-data boundary string generated
+    // by the multipart/form-data encoding algorithm.
+    type = `multipart/form-data; boundary=${boundary}`
+  } else if (isBlobLike(object)) {
+    // Blob
+
+    // Set source to object.
+    source = object
+
+    // Set length to object’s size.
+    length = object.size
+
+    // If object’s type attribute is not the empty byte sequence, set
+    // type to its value.
+    if (object.type) {
+      type = object.type
+    }
+  } else if (typeof object[Symbol.asyncIterator] === 'function') {
+    // If keepalive is true, then throw a TypeError.
+    if (keepalive) {
+      throw new TypeError('keepalive')
+    }
+
+    // If object is disturbed or locked, then throw a TypeError.
+    if (util.isDisturbed(object) || object.locked) {
+      throw new TypeError(
+        'Response body object should not be disturbed or locked'
+      )
+    }
+
+    stream =
+      object instanceof ReadableStream ? object : ReadableStreamFrom(object)
+  }
+
+  // 11. If source is a byte sequence, then set action to a
+  // step that returns source and length to source’s length.
+  if (typeof source === 'string' || util.isBuffer(source)) {
+    length = Buffer.byteLength(source)
+  }
+
+  // 12. If action is non-null, then run these steps in in parallel:
+  if (action != null) {
+    // Run action.
+    let iterator
+    stream = new ReadableStream({
+      async start () {
+        iterator = action(object)[Symbol.asyncIterator]()
+      },
+      async pull (controller) {
+        const { value, done } = await iterator.next()
+        if (done) {
+          // When running action is done, close stream.
+          queueMicrotask(() => {
+            controller.close()
+            controller.byobRequest?.respond(0)
+          })
+        } else {
+          // Whenever one or more bytes are available and stream is not errored,
+          // enqueue a Uint8Array wrapping an ArrayBuffer containing the available
+          // bytes into stream.
+          if (!isErrored(stream)) {
+            const buffer = new Uint8Array(value)
+            if (buffer.byteLength) {
+              controller.enqueue(buffer)
+            }
+          }
+        }
+        return controller.desiredSize > 0
+      },
+      async cancel (reason) {
+        await iterator.return()
+      },
+      type: 'bytes'
+    })
+  }
+
+  // 13. Let body be a body whose stream is stream, source is source,
+  // and length is length.
+  const body = { stream, source, length }
+
+  // 14. Return (body, type).
+  return [body, type]
+}
+
+// https://fetch.spec.whatwg.org/#bodyinit-safely-extract
+function safelyExtractBody (object, keepalive = false) {
+  // To safely extract a body and a `Content-Type` value from
+  // a byte sequence or BodyInit object object, run these steps:
+
+  // 1. If object is a ReadableStream object, then:
+  if (object instanceof ReadableStream) {
+    // Assert: object is neither disturbed nor locked.
+    // istanbul ignore next
+    assert(!util.isDisturbed(object), 'The body has already been consumed.')
+    // istanbul ignore next
+    assert(!object.locked, 'The stream is locked.')
+  }
+
+  // 2. Return the results of extracting object.
+  return extractBody(object, keepalive)
+}
+
+function cloneBody (instance, body) {
+  // To clone a body body, run these steps:
+
+  // https://fetch.spec.whatwg.org/#concept-body-clone
+
+  // 1. Let « out1, out2 » be the result of teeing body’s stream.
+  const [out1, out2] = body.stream.tee()
+
+  // 2. Set body’s stream to out1.
+  body.stream = out1
+
+  // 3. Return a body whose stream is out2 and other members are copied from body.
+  return {
+    stream: out2,
+    length: body.length,
+    source: body.source
+  }
+}
+
+function throwIfAborted (state) {
+  if (state.aborted) {
+    throw new DOMException('The operation was aborted.', 'AbortError')
+  }
+}
+
+function bodyMixinMethods (instance) {
+  const methods = {
+    blob () {
+      // The blob() method steps are to return the result of
+      // running consume body with this and the following step
+      // given a byte sequence bytes: return a Blob whose
+      // contents are bytes and whose type attribute is this’s
+      // MIME type.
+      return consumeBody(this, (bytes) => {
+        let mimeType = bodyMimeType(this)
+
+        if (mimeType === null) {
+          mimeType = ''
+        } else if (mimeType) {
+          mimeType = serializeAMimeType(mimeType)
+        }
+
+        // Return a Blob whose contents are bytes and type attribute
+        // is mimeType.
+        return new Blob([bytes], { type: mimeType })
+      }, instance)
+    },
+
+    arrayBuffer () {
+      // The arrayBuffer() method steps are to return the result
+      // of running consume body with this and the following step
+      // given a byte sequence bytes: return a new ArrayBuffer
+      // whose contents are bytes.
+      return consumeBody(this, (bytes) => {
+        return new Uint8Array(bytes).buffer
+      }, instance)
+    },
+
+    text () {
+      // The text() method steps are to return the result of running
+      // consume body with this and UTF-8 decode.
+      return consumeBody(this, utf8DecodeBytes, instance)
+    },
+
+    json () {
+      // The json() method steps are to return the result of running
+      // consume body with this and parse JSON from bytes.
+      return consumeBody(this, parseJSONFromBytes, instance)
+    },
+
+    formData () {
+      // The formData() method steps are to return the result of running
+      // consume body with this and the following step given a byte sequence bytes:
+      return consumeBody(this, (value) => {
+        // 1. Let mimeType be the result of get the MIME type with this.
+        const mimeType = bodyMimeType(this)
+
+        // 2. If mimeType is non-null, then switch on mimeType’s essence and run
+        //    the corresponding steps:
+        if (mimeType !== null) {
+          switch (mimeType.essence) {
+            case 'multipart/form-data': {
+              // 1. ... [long step]
+              const parsed = multipartFormDataParser(value, mimeType)
+
+              // 2. If that fails for some reason, then throw a TypeError.
+              if (parsed === 'failure') {
+                throw new TypeError('Failed to parse body as FormData.')
+              }
+
+              // 3. Return a new FormData object, appending each entry,
+              //    resulting from the parsing operation, to its entry list.
+              const fd = new FormData()
+              fd[kState] = parsed
+
+              return fd
+            }
+            case 'application/x-www-form-urlencoded': {
+              // 1. Let entries be the result of parsing bytes.
+              const entries = new URLSearchParams(value.toString())
+
+              // 2. If entries is failure, then throw a TypeError.
+
+              // 3. Return a new FormData object whose entry list is entries.
+              const fd = new FormData()
+
+              for (const [name, value] of entries) {
+                fd.append(name, value)
+              }
+
+              return fd
+            }
+          }
+        }
+
+        // 3. Throw a TypeError.
+        throw new TypeError(
+          'Content-Type was not one of "multipart/form-data" or "application/x-www-form-urlencoded".'
+        )
+      }, instance)
+    },
+
+    bytes () {
+      // The bytes() method steps are to return the result of running consume body
+      // with this and the following step given a byte sequence bytes: return the
+      // result of creating a Uint8Array from bytes in this’s relevant realm.
+      return consumeBody(this, (bytes) => {
+        return new Uint8Array(bytes)
+      }, instance)
+    }
+  }
+
+  return methods
+}
+
+function mixinBody (prototype) {
+  Object.assign(prototype.prototype, bodyMixinMethods(prototype))
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-body-consume-body
+ * @param {Response|Request} object
+ * @param {(value: unknown) => unknown} convertBytesToJSValue
+ * @param {Response|Request} instance
+ */
+async function consumeBody (object, convertBytesToJSValue, instance) {
+  webidl.brandCheck(object, instance)
+
+  // 1. If object is unusable, then return a promise rejected
+  //    with a TypeError.
+  if (bodyUnusable(object)) {
+    throw new TypeError('Body is unusable: Body has already been read')
+  }
+
+  throwIfAborted(object[kState])
+
+  // 2. Let promise be a new promise.
+  const promise = createDeferredPromise()
+
+  // 3. Let errorSteps given error be to reject promise with error.
+  const errorSteps = (error) => promise.reject(error)
+
+  // 4. Let successSteps given a byte sequence data be to resolve
+  //    promise with the result of running convertBytesToJSValue
+  //    with data. If that threw an exception, then run errorSteps
+  //    with that exception.
+  const successSteps = (data) => {
+    try {
+      promise.resolve(convertBytesToJSValue(data))
+    } catch (e) {
+      errorSteps(e)
+    }
+  }
+
+  // 5. If object’s body is null, then run successSteps with an
+  //    empty byte sequence.
+  if (object[kState].body == null) {
+    successSteps(Buffer.allocUnsafe(0))
+    return promise.promise
+  }
+
+  // 6. Otherwise, fully read object’s body given successSteps,
+  //    errorSteps, and object’s relevant global object.
+  await fullyReadBody(object[kState].body, successSteps, errorSteps)
+
+  // 7. Return promise.
+  return promise.promise
+}
+
+// https://fetch.spec.whatwg.org/#body-unusable
+function bodyUnusable (object) {
+  const body = object[kState].body
+
+  // An object including the Body interface mixin is
+  // said to be unusable if its body is non-null and
+  // its body’s stream is disturbed or locked.
+  return body != null && (body.stream.locked || util.isDisturbed(body.stream))
+}
+
+/**
+ * @see https://infra.spec.whatwg.org/#parse-json-bytes-to-a-javascript-value
+ * @param {Uint8Array} bytes
+ */
+function parseJSONFromBytes (bytes) {
+  return JSON.parse(utf8DecodeBytes(bytes))
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-body-mime-type
+ * @param {import('./response').Response|import('./request').Request} requestOrResponse
+ */
+function bodyMimeType (requestOrResponse) {
+  // 1. Let headers be null.
+  // 2. If requestOrResponse is a Request object, then set headers to requestOrResponse’s request’s header list.
+  // 3. Otherwise, set headers to requestOrResponse’s response’s header list.
+  /** @type {import('./headers').HeadersList} */
+  const headers = requestOrResponse[kState].headersList
+
+  // 4. Let mimeType be the result of extracting a MIME type from headers.
+  const mimeType = extractMimeType(headers)
+
+  // 5. If mimeType is failure, then return null.
+  if (mimeType === 'failure') {
+    return null
+  }
+
+  // 6. Return mimeType.
+  return mimeType
+}
+
+module.exports = {
+  extractBody,
+  safelyExtractBody,
+  cloneBody,
+  mixinBody,
+  streamRegistry,
+  hasFinalizationRegistry,
+  bodyUnusable
+}
+
+
+/***/ }),
+
+/***/ 87979:
+/***/ ((module) => {
+
+"use strict";
+
+
+const corsSafeListedMethods = /** @type {const} */ (['GET', 'HEAD', 'POST'])
+const corsSafeListedMethodsSet = new Set(corsSafeListedMethods)
+
+const nullBodyStatus = /** @type {const} */ ([101, 204, 205, 304])
+
+const redirectStatus = /** @type {const} */ ([301, 302, 303, 307, 308])
+const redirectStatusSet = new Set(redirectStatus)
+
+/**
+ * @see https://fetch.spec.whatwg.org/#block-bad-port
+ */
+const badPorts = /** @type {const} */ ([
+  '1', '7', '9', '11', '13', '15', '17', '19', '20', '21', '22', '23', '25', '37', '42', '43', '53', '69', '77', '79',
+  '87', '95', '101', '102', '103', '104', '109', '110', '111', '113', '115', '117', '119', '123', '135', '137',
+  '139', '143', '161', '179', '389', '427', '465', '512', '513', '514', '515', '526', '530', '531', '532',
+  '540', '548', '554', '556', '563', '587', '601', '636', '989', '990', '993', '995', '1719', '1720', '1723',
+  '2049', '3659', '4045', '4190', '5060', '5061', '6000', '6566', '6665', '6666', '6667', '6668', '6669', '6679',
+  '6697', '10080'
+])
+const badPortsSet = new Set(badPorts)
+
+/**
+ * @see https://w3c.github.io/webappsec-referrer-policy/#referrer-policies
+ */
+const referrerPolicy = /** @type {const} */ ([
+  '',
+  'no-referrer',
+  'no-referrer-when-downgrade',
+  'same-origin',
+  'origin',
+  'strict-origin',
+  'origin-when-cross-origin',
+  'strict-origin-when-cross-origin',
+  'unsafe-url'
+])
+const referrerPolicySet = new Set(referrerPolicy)
+
+const requestRedirect = /** @type {const} */ (['follow', 'manual', 'error'])
+
+const safeMethods = /** @type {const} */ (['GET', 'HEAD', 'OPTIONS', 'TRACE'])
+const safeMethodsSet = new Set(safeMethods)
+
+const requestMode = /** @type {const} */ (['navigate', 'same-origin', 'no-cors', 'cors'])
+
+const requestCredentials = /** @type {const} */ (['omit', 'same-origin', 'include'])
+
+const requestCache = /** @type {const} */ ([
+  'default',
+  'no-store',
+  'reload',
+  'no-cache',
+  'force-cache',
+  'only-if-cached'
+])
+
+/**
+ * @see https://fetch.spec.whatwg.org/#request-body-header-name
+ */
+const requestBodyHeader = /** @type {const} */ ([
+  'content-encoding',
+  'content-language',
+  'content-location',
+  'content-type',
+  // See https://github.com/nodejs/undici/issues/2021
+  // 'Content-Length' is a forbidden header name, which is typically
+  // removed in the Headers implementation. However, undici doesn't
+  // filter out headers, so we add it here.
+  'content-length'
+])
+
+/**
+ * @see https://fetch.spec.whatwg.org/#enumdef-requestduplex
+ */
+const requestDuplex = /** @type {const} */ ([
+  'half'
+])
+
+/**
+ * @see http://fetch.spec.whatwg.org/#forbidden-method
+ */
+const forbiddenMethods = /** @type {const} */ (['CONNECT', 'TRACE', 'TRACK'])
+const forbiddenMethodsSet = new Set(forbiddenMethods)
+
+const subresource = /** @type {const} */ ([
+  'audio',
+  'audioworklet',
+  'font',
+  'image',
+  'manifest',
+  'paintworklet',
+  'script',
+  'style',
+  'track',
+  'video',
+  'xslt',
+  ''
+])
+const subresourceSet = new Set(subresource)
+
+module.exports = {
+  subresource,
+  forbiddenMethods,
+  requestBodyHeader,
+  referrerPolicy,
+  requestRedirect,
+  requestMode,
+  requestCredentials,
+  requestCache,
+  redirectStatus,
+  corsSafeListedMethods,
+  nullBodyStatus,
+  safeMethods,
+  badPorts,
+  requestDuplex,
+  subresourceSet,
+  badPortsSet,
+  redirectStatusSet,
+  corsSafeListedMethodsSet,
+  safeMethodsSet,
+  forbiddenMethodsSet,
+  referrerPolicySet
+}
+
+
+/***/ }),
+
+/***/ 86954:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const assert = __nccwpck_require__(98061)
+
+const encoder = new TextEncoder()
+
+/**
+ * @see https://mimesniff.spec.whatwg.org/#http-token-code-point
+ */
+const HTTP_TOKEN_CODEPOINTS = /^[!#$%&'*+\-.^_|~A-Za-z0-9]+$/
+const HTTP_WHITESPACE_REGEX = /[\u000A\u000D\u0009\u0020]/ // eslint-disable-line
+const ASCII_WHITESPACE_REPLACE_REGEX = /[\u0009\u000A\u000C\u000D\u0020]/g // eslint-disable-line
+/**
+ * @see https://mimesniff.spec.whatwg.org/#http-quoted-string-token-code-point
+ */
+const HTTP_QUOTED_STRING_TOKENS = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/ // eslint-disable-line
+
+// https://fetch.spec.whatwg.org/#data-url-processor
+/** @param {URL} dataURL */
+function dataURLProcessor (dataURL) {
+  // 1. Assert: dataURL’s scheme is "data".
+  assert(dataURL.protocol === 'data:')
+
+  // 2. Let input be the result of running the URL
+  // serializer on dataURL with exclude fragment
+  // set to true.
+  let input = URLSerializer(dataURL, true)
+
+  // 3. Remove the leading "data:" string from input.
+  input = input.slice(5)
+
+  // 4. Let position point at the start of input.
+  const position = { position: 0 }
+
+  // 5. Let mimeType be the result of collecting a
+  // sequence of code points that are not equal
+  // to U+002C (,), given position.
+  let mimeType = collectASequenceOfCodePointsFast(
+    ',',
+    input,
+    position
+  )
+
+  // 6. Strip leading and trailing ASCII whitespace
+  // from mimeType.
+  // Undici implementation note: we need to store the
+  // length because if the mimetype has spaces removed,
+  // the wrong amount will be sliced from the input in
+  // step #9
+  const mimeTypeLength = mimeType.length
+  mimeType = removeASCIIWhitespace(mimeType, true, true)
+
+  // 7. If position is past the end of input, then
+  // return failure
+  if (position.position >= input.length) {
+    return 'failure'
+  }
+
+  // 8. Advance position by 1.
+  position.position++
+
+  // 9. Let encodedBody be the remainder of input.
+  const encodedBody = input.slice(mimeTypeLength + 1)
+
+  // 10. Let body be the percent-decoding of encodedBody.
+  let body = stringPercentDecode(encodedBody)
+
+  // 11. If mimeType ends with U+003B (;), followed by
+  // zero or more U+0020 SPACE, followed by an ASCII
+  // case-insensitive match for "base64", then:
+  if (/;(\u0020){0,}base64$/i.test(mimeType)) {
+    // 1. Let stringBody be the isomorphic decode of body.
+    const stringBody = isomorphicDecode(body)
+
+    // 2. Set body to the forgiving-base64 decode of
+    // stringBody.
+    body = forgivingBase64(stringBody)
+
+    // 3. If body is failure, then return failure.
+    if (body === 'failure') {
+      return 'failure'
+    }
+
+    // 4. Remove the last 6 code points from mimeType.
+    mimeType = mimeType.slice(0, -6)
+
+    // 5. Remove trailing U+0020 SPACE code points from mimeType,
+    // if any.
+    mimeType = mimeType.replace(/(\u0020)+$/, '')
+
+    // 6. Remove the last U+003B (;) code point from mimeType.
+    mimeType = mimeType.slice(0, -1)
+  }
+
+  // 12. If mimeType starts with U+003B (;), then prepend
+  // "text/plain" to mimeType.
+  if (mimeType.startsWith(';')) {
+    mimeType = 'text/plain' + mimeType
+  }
+
+  // 13. Let mimeTypeRecord be the result of parsing
+  // mimeType.
+  let mimeTypeRecord = parseMIMEType(mimeType)
+
+  // 14. If mimeTypeRecord is failure, then set
+  // mimeTypeRecord to text/plain;charset=US-ASCII.
+  if (mimeTypeRecord === 'failure') {
+    mimeTypeRecord = parseMIMEType('text/plain;charset=US-ASCII')
+  }
+
+  // 15. Return a new data: URL struct whose MIME
+  // type is mimeTypeRecord and body is body.
+  // https://fetch.spec.whatwg.org/#data-url-struct
+  return { mimeType: mimeTypeRecord, body }
+}
+
+// https://url.spec.whatwg.org/#concept-url-serializer
+/**
+ * @param {URL} url
+ * @param {boolean} excludeFragment
+ */
+function URLSerializer (url, excludeFragment = false) {
+  if (!excludeFragment) {
+    return url.href
+  }
+
+  const href = url.href
+  const hashLength = url.hash.length
+
+  const serialized = hashLength === 0 ? href : href.substring(0, href.length - hashLength)
+
+  if (!hashLength && href.endsWith('#')) {
+    return serialized.slice(0, -1)
+  }
+
+  return serialized
+}
+
+// https://infra.spec.whatwg.org/#collect-a-sequence-of-code-points
+/**
+ * @param {(char: string) => boolean} condition
+ * @param {string} input
+ * @param {{ position: number }} position
+ */
+function collectASequenceOfCodePoints (condition, input, position) {
+  // 1. Let result be the empty string.
+  let result = ''
+
+  // 2. While position doesn’t point past the end of input and the
+  // code point at position within input meets the condition condition:
+  while (position.position < input.length && condition(input[position.position])) {
+    // 1. Append that code point to the end of result.
+    result += input[position.position]
+
+    // 2. Advance position by 1.
+    position.position++
+  }
+
+  // 3. Return result.
+  return result
+}
+
+/**
+ * A faster collectASequenceOfCodePoints that only works when comparing a single character.
+ * @param {string} char
+ * @param {string} input
+ * @param {{ position: number }} position
+ */
+function collectASequenceOfCodePointsFast (char, input, position) {
+  const idx = input.indexOf(char, position.position)
+  const start = position.position
+
+  if (idx === -1) {
+    position.position = input.length
+    return input.slice(start)
+  }
+
+  position.position = idx
+  return input.slice(start, position.position)
+}
+
+// https://url.spec.whatwg.org/#string-percent-decode
+/** @param {string} input */
+function stringPercentDecode (input) {
+  // 1. Let bytes be the UTF-8 encoding of input.
+  const bytes = encoder.encode(input)
+
+  // 2. Return the percent-decoding of bytes.
+  return percentDecode(bytes)
+}
+
+/**
+ * @param {number} byte
+ */
+function isHexCharByte (byte) {
+  // 0-9 A-F a-f
+  return (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x46) || (byte >= 0x61 && byte <= 0x66)
+}
+
+/**
+ * @param {number} byte
+ */
+function hexByteToNumber (byte) {
+  return (
+    // 0-9
+    byte >= 0x30 && byte <= 0x39
+      ? (byte - 48)
+    // Convert to uppercase
+    // ((byte & 0xDF) - 65) + 10
+      : ((byte & 0xDF) - 55)
+  )
+}
+
+// https://url.spec.whatwg.org/#percent-decode
+/** @param {Uint8Array} input */
+function percentDecode (input) {
+  const length = input.length
+  // 1. Let output be an empty byte sequence.
+  /** @type {Uint8Array} */
+  const output = new Uint8Array(length)
+  let j = 0
+  // 2. For each byte byte in input:
+  for (let i = 0; i < length; ++i) {
+    const byte = input[i]
+
+    // 1. If byte is not 0x25 (%), then append byte to output.
+    if (byte !== 0x25) {
+      output[j++] = byte
+
+    // 2. Otherwise, if byte is 0x25 (%) and the next two bytes
+    // after byte in input are not in the ranges
+    // 0x30 (0) to 0x39 (9), 0x41 (A) to 0x46 (F),
+    // and 0x61 (a) to 0x66 (f), all inclusive, append byte
+    // to output.
+    } else if (
+      byte === 0x25 &&
+      !(isHexCharByte(input[i + 1]) && isHexCharByte(input[i + 2]))
+    ) {
+      output[j++] = 0x25
+
+    // 3. Otherwise:
+    } else {
+      // 1. Let bytePoint be the two bytes after byte in input,
+      // decoded, and then interpreted as hexadecimal number.
+      // 2. Append a byte whose value is bytePoint to output.
+      output[j++] = (hexByteToNumber(input[i + 1]) << 4) | hexByteToNumber(input[i + 2])
+
+      // 3. Skip the next two bytes in input.
+      i += 2
+    }
+  }
+
+  // 3. Return output.
+  return length === j ? output : output.subarray(0, j)
+}
+
+// https://mimesniff.spec.whatwg.org/#parse-a-mime-type
+/** @param {string} input */
+function parseMIMEType (input) {
+  // 1. Remove any leading and trailing HTTP whitespace
+  // from input.
+  input = removeHTTPWhitespace(input, true, true)
+
+  // 2. Let position be a position variable for input,
+  // initially pointing at the start of input.
+  const position = { position: 0 }
+
+  // 3. Let type be the result of collecting a sequence
+  // of code points that are not U+002F (/) from
+  // input, given position.
+  const type = collectASequenceOfCodePointsFast(
+    '/',
+    input,
+    position
+  )
+
+  // 4. If type is the empty string or does not solely
+  // contain HTTP token code points, then return failure.
+  // https://mimesniff.spec.whatwg.org/#http-token-code-point
+  if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
+    return 'failure'
+  }
+
+  // 5. If position is past the end of input, then return
+  // failure
+  if (position.position > input.length) {
+    return 'failure'
+  }
+
+  // 6. Advance position by 1. (This skips past U+002F (/).)
+  position.position++
+
+  // 7. Let subtype be the result of collecting a sequence of
+  // code points that are not U+003B (;) from input, given
+  // position.
+  let subtype = collectASequenceOfCodePointsFast(
+    ';',
+    input,
+    position
+  )
+
+  // 8. Remove any trailing HTTP whitespace from subtype.
+  subtype = removeHTTPWhitespace(subtype, false, true)
+
+  // 9. If subtype is the empty string or does not solely
+  // contain HTTP token code points, then return failure.
+  if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
+    return 'failure'
+  }
+
+  const typeLowercase = type.toLowerCase()
+  const subtypeLowercase = subtype.toLowerCase()
+
+  // 10. Let mimeType be a new MIME type record whose type
+  // is type, in ASCII lowercase, and subtype is subtype,
+  // in ASCII lowercase.
+  // https://mimesniff.spec.whatwg.org/#mime-type
+  const mimeType = {
+    type: typeLowercase,
+    subtype: subtypeLowercase,
+    /** @type {Map<string, string>} */
+    parameters: new Map(),
+    // https://mimesniff.spec.whatwg.org/#mime-type-essence
+    essence: `${typeLowercase}/${subtypeLowercase}`
+  }
+
+  // 11. While position is not past the end of input:
+  while (position.position < input.length) {
+    // 1. Advance position by 1. (This skips past U+003B (;).)
+    position.position++
+
+    // 2. Collect a sequence of code points that are HTTP
+    // whitespace from input given position.
+    collectASequenceOfCodePoints(
+      // https://fetch.spec.whatwg.org/#http-whitespace
+      char => HTTP_WHITESPACE_REGEX.test(char),
+      input,
+      position
+    )
+
+    // 3. Let parameterName be the result of collecting a
+    // sequence of code points that are not U+003B (;)
+    // or U+003D (=) from input, given position.
+    let parameterName = collectASequenceOfCodePoints(
+      (char) => char !== ';' && char !== '=',
+      input,
+      position
+    )
+
+    // 4. Set parameterName to parameterName, in ASCII
+    // lowercase.
+    parameterName = parameterName.toLowerCase()
+
+    // 5. If position is not past the end of input, then:
+    if (position.position < input.length) {
+      // 1. If the code point at position within input is
+      // U+003B (;), then continue.
+      if (input[position.position] === ';') {
+        continue
+      }
+
+      // 2. Advance position by 1. (This skips past U+003D (=).)
+      position.position++
+    }
+
+    // 6. If position is past the end of input, then break.
+    if (position.position > input.length) {
+      break
+    }
+
+    // 7. Let parameterValue be null.
+    let parameterValue = null
+
+    // 8. If the code point at position within input is
+    // U+0022 ("), then:
+    if (input[position.position] === '"') {
+      // 1. Set parameterValue to the result of collecting
+      // an HTTP quoted string from input, given position
+      // and the extract-value flag.
+      parameterValue = collectAnHTTPQuotedString(input, position, true)
+
+      // 2. Collect a sequence of code points that are not
+      // U+003B (;) from input, given position.
+      collectASequenceOfCodePointsFast(
+        ';',
+        input,
+        position
+      )
+
+    // 9. Otherwise:
+    } else {
+      // 1. Set parameterValue to the result of collecting
+      // a sequence of code points that are not U+003B (;)
+      // from input, given position.
+      parameterValue = collectASequenceOfCodePointsFast(
+        ';',
+        input,
+        position
+      )
+
+      // 2. Remove any trailing HTTP whitespace from parameterValue.
+      parameterValue = removeHTTPWhitespace(parameterValue, false, true)
+
+      // 3. If parameterValue is the empty string, then continue.
+      if (parameterValue.length === 0) {
+        continue
+      }
+    }
+
+    // 10. If all of the following are true
+    // - parameterName is not the empty string
+    // - parameterName solely contains HTTP token code points
+    // - parameterValue solely contains HTTP quoted-string token code points
+    // - mimeType’s parameters[parameterName] does not exist
+    // then set mimeType’s parameters[parameterName] to parameterValue.
+    if (
+      parameterName.length !== 0 &&
+      HTTP_TOKEN_CODEPOINTS.test(parameterName) &&
+      (parameterValue.length === 0 || HTTP_QUOTED_STRING_TOKENS.test(parameterValue)) &&
+      !mimeType.parameters.has(parameterName)
+    ) {
+      mimeType.parameters.set(parameterName, parameterValue)
+    }
+  }
+
+  // 12. Return mimeType.
+  return mimeType
+}
+
+// https://infra.spec.whatwg.org/#forgiving-base64-decode
+/** @param {string} data */
+function forgivingBase64 (data) {
+  // 1. Remove all ASCII whitespace from data.
+  data = data.replace(ASCII_WHITESPACE_REPLACE_REGEX, '')  // eslint-disable-line
+
+  let dataLength = data.length
+  // 2. If data’s code point length divides by 4 leaving
+  // no remainder, then:
+  if (dataLength % 4 === 0) {
+    // 1. If data ends with one or two U+003D (=) code points,
+    // then remove them from data.
+    if (data.charCodeAt(dataLength - 1) === 0x003D) {
+      --dataLength
+      if (data.charCodeAt(dataLength - 1) === 0x003D) {
+        --dataLength
+      }
+    }
+  }
+
+  // 3. If data’s code point length divides by 4 leaving
+  // a remainder of 1, then return failure.
+  if (dataLength % 4 === 1) {
+    return 'failure'
+  }
+
+  // 4. If data contains a code point that is not one of
+  //  U+002B (+)
+  //  U+002F (/)
+  //  ASCII alphanumeric
+  // then return failure.
+  if (/[^+/0-9A-Za-z]/.test(data.length === dataLength ? data : data.substring(0, dataLength))) {
+    return 'failure'
+  }
+
+  const buffer = Buffer.from(data, 'base64')
+  return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength)
+}
+
+// https://fetch.spec.whatwg.org/#collect-an-http-quoted-string
+// tests: https://fetch.spec.whatwg.org/#example-http-quoted-string
+/**
+ * @param {string} input
+ * @param {{ position: number }} position
+ * @param {boolean?} extractValue
+ */
+function collectAnHTTPQuotedString (input, position, extractValue) {
+  // 1. Let positionStart be position.
+  const positionStart = position.position
+
+  // 2. Let value be the empty string.
+  let value = ''
+
+  // 3. Assert: the code point at position within input
+  // is U+0022 (").
+  assert(input[position.position] === '"')
+
+  // 4. Advance position by 1.
+  position.position++
+
+  // 5. While true:
+  while (true) {
+    // 1. Append the result of collecting a sequence of code points
+    // that are not U+0022 (") or U+005C (\) from input, given
+    // position, to value.
+    value += collectASequenceOfCodePoints(
+      (char) => char !== '"' && char !== '\\',
+      input,
+      position
+    )
+
+    // 2. If position is past the end of input, then break.
+    if (position.position >= input.length) {
+      break
+    }
+
+    // 3. Let quoteOrBackslash be the code point at position within
+    // input.
+    const quoteOrBackslash = input[position.position]
+
+    // 4. Advance position by 1.
+    position.position++
+
+    // 5. If quoteOrBackslash is U+005C (\), then:
+    if (quoteOrBackslash === '\\') {
+      // 1. If position is past the end of input, then append
+      // U+005C (\) to value and break.
+      if (position.position >= input.length) {
+        value += '\\'
+        break
+      }
+
+      // 2. Append the code point at position within input to value.
+      value += input[position.position]
+
+      // 3. Advance position by 1.
+      position.position++
+
+    // 6. Otherwise:
+    } else {
+      // 1. Assert: quoteOrBackslash is U+0022 (").
+      assert(quoteOrBackslash === '"')
+
+      // 2. Break.
+      break
+    }
+  }
+
+  // 6. If the extract-value flag is set, then return value.
+  if (extractValue) {
+    return value
+  }
+
+  // 7. Return the code points from positionStart to position,
+  // inclusive, within input.
+  return input.slice(positionStart, position.position)
+}
+
+/**
+ * @see https://mimesniff.spec.whatwg.org/#serialize-a-mime-type
+ */
+function serializeAMimeType (mimeType) {
+  assert(mimeType !== 'failure')
+  const { parameters, essence } = mimeType
+
+  // 1. Let serialization be the concatenation of mimeType’s
+  //    type, U+002F (/), and mimeType’s subtype.
+  let serialization = essence
+
+  // 2. For each name → value of mimeType’s parameters:
+  for (let [name, value] of parameters.entries()) {
+    // 1. Append U+003B (;) to serialization.
+    serialization += ';'
+
+    // 2. Append name to serialization.
+    serialization += name
+
+    // 3. Append U+003D (=) to serialization.
+    serialization += '='
+
+    // 4. If value does not solely contain HTTP token code
+    //    points or value is the empty string, then:
+    if (!HTTP_TOKEN_CODEPOINTS.test(value)) {
+      // 1. Precede each occurrence of U+0022 (") or
+      //    U+005C (\) in value with U+005C (\).
+      value = value.replace(/(\\|")/g, '\\$1')
+
+      // 2. Prepend U+0022 (") to value.
+      value = '"' + value
+
+      // 3. Append U+0022 (") to value.
+      value += '"'
+    }
+
+    // 5. Append value to serialization.
+    serialization += value
+  }
+
+  // 3. Return serialization.
+  return serialization
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#http-whitespace
+ * @param {number} char
+ */
+function isHTTPWhiteSpace (char) {
+  // "\r\n\t "
+  return char === 0x00d || char === 0x00a || char === 0x009 || char === 0x020
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#http-whitespace
+ * @param {string} str
+ * @param {boolean} [leading=true]
+ * @param {boolean} [trailing=true]
+ */
+function removeHTTPWhitespace (str, leading = true, trailing = true) {
+  return removeChars(str, leading, trailing, isHTTPWhiteSpace)
+}
+
+/**
+ * @see https://infra.spec.whatwg.org/#ascii-whitespace
+ * @param {number} char
+ */
+function isASCIIWhitespace (char) {
+  // "\r\n\t\f "
+  return char === 0x00d || char === 0x00a || char === 0x009 || char === 0x00c || char === 0x020
+}
+
+/**
+ * @see https://infra.spec.whatwg.org/#strip-leading-and-trailing-ascii-whitespace
+ * @param {string} str
+ * @param {boolean} [leading=true]
+ * @param {boolean} [trailing=true]
+ */
+function removeASCIIWhitespace (str, leading = true, trailing = true) {
+  return removeChars(str, leading, trailing, isASCIIWhitespace)
+}
+
+/**
+ * @param {string} str
+ * @param {boolean} leading
+ * @param {boolean} trailing
+ * @param {(charCode: number) => boolean} predicate
+ * @returns
+ */
+function removeChars (str, leading, trailing, predicate) {
+  let lead = 0
+  let trail = str.length - 1
+
+  if (leading) {
+    while (lead < str.length && predicate(str.charCodeAt(lead))) lead++
+  }
+
+  if (trailing) {
+    while (trail > 0 && predicate(str.charCodeAt(trail))) trail--
+  }
+
+  return lead === 0 && trail === str.length - 1 ? str : str.slice(lead, trail + 1)
+}
+
+/**
+ * @see https://infra.spec.whatwg.org/#isomorphic-decode
+ * @param {Uint8Array} input
+ * @returns {string}
+ */
+function isomorphicDecode (input) {
+  // 1. To isomorphic decode a byte sequence input, return a string whose code point
+  //    length is equal to input’s length and whose code points have the same values
+  //    as the values of input’s bytes, in the same order.
+  const length = input.length
+  if ((2 << 15) - 1 > length) {
+    return String.fromCharCode.apply(null, input)
+  }
+  let result = ''; let i = 0
+  let addition = (2 << 15) - 1
+  while (i < length) {
+    if (i + addition > length) {
+      addition = length - i
+    }
+    result += String.fromCharCode.apply(null, input.subarray(i, i += addition))
+  }
+  return result
+}
+
+/**
+ * @see https://mimesniff.spec.whatwg.org/#minimize-a-supported-mime-type
+ * @param {Exclude<ReturnType<typeof parseMIMEType>, 'failure'>} mimeType
+ */
+function minimizeSupportedMimeType (mimeType) {
+  switch (mimeType.essence) {
+    case 'application/ecmascript':
+    case 'application/javascript':
+    case 'application/x-ecmascript':
+    case 'application/x-javascript':
+    case 'text/ecmascript':
+    case 'text/javascript':
+    case 'text/javascript1.0':
+    case 'text/javascript1.1':
+    case 'text/javascript1.2':
+    case 'text/javascript1.3':
+    case 'text/javascript1.4':
+    case 'text/javascript1.5':
+    case 'text/jscript':
+    case 'text/livescript':
+    case 'text/x-ecmascript':
+    case 'text/x-javascript':
+      // 1. If mimeType is a JavaScript MIME type, then return "text/javascript".
+      return 'text/javascript'
+    case 'application/json':
+    case 'text/json':
+      // 2. If mimeType is a JSON MIME type, then return "application/json".
+      return 'application/json'
+    case 'image/svg+xml':
+      // 3. If mimeType’s essence is "image/svg+xml", then return "image/svg+xml".
+      return 'image/svg+xml'
+    case 'text/xml':
+    case 'application/xml':
+      // 4. If mimeType is an XML MIME type, then return "application/xml".
+      return 'application/xml'
+  }
+
+  // 2. If mimeType is a JSON MIME type, then return "application/json".
+  if (mimeType.subtype.endsWith('+json')) {
+    return 'application/json'
+  }
+
+  // 4. If mimeType is an XML MIME type, then return "application/xml".
+  if (mimeType.subtype.endsWith('+xml')) {
+    return 'application/xml'
+  }
+
+  // 5. If mimeType is supported by the user agent, then return mimeType’s essence.
+  // Technically, node doesn't support any mimetypes.
+
+  // 6. Return the empty string.
+  return ''
+}
+
+module.exports = {
+  dataURLProcessor,
+  URLSerializer,
+  collectASequenceOfCodePoints,
+  collectASequenceOfCodePointsFast,
+  stringPercentDecode,
+  parseMIMEType,
+  collectAnHTTPQuotedString,
+  serializeAMimeType,
+  removeChars,
+  removeHTTPWhitespace,
+  minimizeSupportedMimeType,
+  HTTP_TOKEN_CODEPOINTS,
+  isomorphicDecode
+}
+
+
+/***/ }),
+
+/***/ 77962:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kConnected, kSize } = __nccwpck_require__(5392)
+
+class CompatWeakRef {
+  constructor (value) {
+    this.value = value
+  }
+
+  deref () {
+    return this.value[kConnected] === 0 && this.value[kSize] === 0
+      ? undefined
+      : this.value
+  }
+}
+
+class CompatFinalizer {
+  constructor (finalizer) {
+    this.finalizer = finalizer
+  }
+
+  register (dispatcher, key) {
+    if (dispatcher.on) {
+      dispatcher.on('disconnect', () => {
+        if (dispatcher[kConnected] === 0 && dispatcher[kSize] === 0) {
+          this.finalizer(key)
+        }
+      })
+    }
+  }
+
+  unregister (key) {}
+}
+
+module.exports = function () {
+  // FIXME: remove workaround when the Node bug is backported to v18
+  // https://github.com/nodejs/node/issues/49344#issuecomment-1741776308
+  if (process.env.NODE_V8_COVERAGE && process.version.startsWith('v18')) {
+    process._rawDebug('Using compatibility WeakRef and FinalizationRegistry')
+    return {
+      WeakRef: CompatWeakRef,
+      FinalizationRegistry: CompatFinalizer
+    }
+  }
+  return { WeakRef, FinalizationRegistry }
+}
+
+
+/***/ }),
+
+/***/ 52586:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Blob, File } = __nccwpck_require__(72254)
+const { kState } = __nccwpck_require__(78172)
+const { webidl } = __nccwpck_require__(37829)
+
+// TODO(@KhafraDev): remove
+class FileLike {
+  constructor (blobLike, fileName, options = {}) {
+    // TODO: argument idl type check
+
+    // The File constructor is invoked with two or three parameters, depending
+    // on whether the optional dictionary parameter is used. When the File()
+    // constructor is invoked, user agents must run the following steps:
+
+    // 1. Let bytes be the result of processing blob parts given fileBits and
+    // options.
+
+    // 2. Let n be the fileName argument to the constructor.
+    const n = fileName
+
+    // 3. Process FilePropertyBag dictionary argument by running the following
+    // substeps:
+
+    //    1. If the type member is provided and is not the empty string, let t
+    //    be set to the type dictionary member. If t contains any characters
+    //    outside the range U+0020 to U+007E, then set t to the empty string
+    //    and return from these substeps.
+    //    TODO
+    const t = options.type
+
+    //    2. Convert every character in t to ASCII lowercase.
+    //    TODO
+
+    //    3. If the lastModified member is provided, let d be set to the
+    //    lastModified dictionary member. If it is not provided, set d to the
+    //    current date and time represented as the number of milliseconds since
+    //    the Unix Epoch (which is the equivalent of Date.now() [ECMA-262]).
+    const d = options.lastModified ?? Date.now()
+
+    // 4. Return a new File object F such that:
+    // F refers to the bytes byte sequence.
+    // F.size is set to the number of total bytes in bytes.
+    // F.name is set to n.
+    // F.type is set to t.
+    // F.lastModified is set to d.
+
+    this[kState] = {
+      blobLike,
+      name: n,
+      type: t,
+      lastModified: d
+    }
+  }
+
+  stream (...args) {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].blobLike.stream(...args)
+  }
+
+  arrayBuffer (...args) {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].blobLike.arrayBuffer(...args)
+  }
+
+  slice (...args) {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].blobLike.slice(...args)
+  }
+
+  text (...args) {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].blobLike.text(...args)
+  }
+
+  get size () {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].blobLike.size
+  }
+
+  get type () {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].blobLike.type
+  }
+
+  get name () {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].name
+  }
+
+  get lastModified () {
+    webidl.brandCheck(this, FileLike)
+
+    return this[kState].lastModified
+  }
+
+  get [Symbol.toStringTag] () {
+    return 'File'
+  }
+}
+
+webidl.converters.Blob = webidl.interfaceConverter(Blob)
+
+// If this function is moved to ./util.js, some tools (such as
+// rollup) will warn about circular dependencies. See:
+// https://github.com/nodejs/undici/issues/1629
+function isFileLike (object) {
+  return (
+    (object instanceof File) ||
+    (
+      object &&
+      (typeof object.stream === 'function' ||
+      typeof object.arrayBuffer === 'function') &&
+      object[Symbol.toStringTag] === 'File'
+    )
+  )
+}
+
+module.exports = { FileLike, isFileLike }
+
+
+/***/ }),
+
+/***/ 43227:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { isUSVString, bufferToLowerCasedHeaderName } = __nccwpck_require__(94407)
+const { utf8DecodeBytes } = __nccwpck_require__(91976)
+const { HTTP_TOKEN_CODEPOINTS, isomorphicDecode } = __nccwpck_require__(86954)
+const { isFileLike } = __nccwpck_require__(52586)
+const { makeEntry } = __nccwpck_require__(4923)
+const assert = __nccwpck_require__(98061)
+const { File: NodeFile } = __nccwpck_require__(72254)
+
+const File = globalThis.File ?? NodeFile
+
+const formDataNameBuffer = Buffer.from('form-data; name="')
+const filenameBuffer = Buffer.from('; filename')
+const dd = Buffer.from('--')
+const ddcrlf = Buffer.from('--\r\n')
+
+/**
+ * @param {string} chars
+ */
+function isAsciiString (chars) {
+  for (let i = 0; i < chars.length; ++i) {
+    if ((chars.charCodeAt(i) & ~0x7F) !== 0) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * @see https://andreubotella.github.io/multipart-form-data/#multipart-form-data-boundary
+ * @param {string} boundary
+ */
+function validateBoundary (boundary) {
+  const length = boundary.length
+
+  // - its length is greater or equal to 27 and lesser or equal to 70, and
+  if (length < 27 || length > 70) {
+    return false
+  }
+
+  // - it is composed by bytes in the ranges 0x30 to 0x39, 0x41 to 0x5A, or
+  //   0x61 to 0x7A, inclusive (ASCII alphanumeric), or which are 0x27 ('),
+  //   0x2D (-) or 0x5F (_).
+  for (let i = 0; i < length; ++i) {
+    const cp = boundary.charCodeAt(i)
+
+    if (!(
+      (cp >= 0x30 && cp <= 0x39) ||
+      (cp >= 0x41 && cp <= 0x5a) ||
+      (cp >= 0x61 && cp <= 0x7a) ||
+      cp === 0x27 ||
+      cp === 0x2d ||
+      cp === 0x5f
+    )) {
+      return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * @see https://andreubotella.github.io/multipart-form-data/#multipart-form-data-parser
+ * @param {Buffer} input
+ * @param {ReturnType<import('./data-url')['parseMIMEType']>} mimeType
+ */
+function multipartFormDataParser (input, mimeType) {
+  // 1. Assert: mimeType’s essence is "multipart/form-data".
+  assert(mimeType !== 'failure' && mimeType.essence === 'multipart/form-data')
+
+  const boundaryString = mimeType.parameters.get('boundary')
+
+  // 2. If mimeType’s parameters["boundary"] does not exist, return failure.
+  //    Otherwise, let boundary be the result of UTF-8 decoding mimeType’s
+  //    parameters["boundary"].
+  if (boundaryString === undefined) {
+    return 'failure'
+  }
+
+  const boundary = Buffer.from(`--${boundaryString}`, 'utf8')
+
+  // 3. Let entry list be an empty entry list.
+  const entryList = []
+
+  // 4. Let position be a pointer to a byte in input, initially pointing at
+  //    the first byte.
+  const position = { position: 0 }
+
+  // Note: undici addition, allows leading and trailing CRLFs.
+  while (input[position.position] === 0x0d && input[position.position + 1] === 0x0a) {
+    position.position += 2
+  }
+
+  let trailing = input.length
+
+  while (input[trailing - 1] === 0x0a && input[trailing - 2] === 0x0d) {
+    trailing -= 2
+  }
+
+  if (trailing !== input.length) {
+    input = input.subarray(0, trailing)
+  }
+
+  // 5. While true:
+  while (true) {
+    // 5.1. If position points to a sequence of bytes starting with 0x2D 0x2D
+    //      (`--`) followed by boundary, advance position by 2 + the length of
+    //      boundary. Otherwise, return failure.
+    // Note: boundary is padded with 2 dashes already, no need to add 2.
+    if (input.subarray(position.position, position.position + boundary.length).equals(boundary)) {
+      position.position += boundary.length
+    } else {
+      return 'failure'
+    }
+
+    // 5.2. If position points to the sequence of bytes 0x2D 0x2D 0x0D 0x0A
+    //      (`--` followed by CR LF) followed by the end of input, return entry list.
+    // Note: a body does NOT need to end with CRLF. It can end with --.
+    if (
+      (position.position === input.length - 2 && bufferStartsWith(input, dd, position)) ||
+      (position.position === input.length - 4 && bufferStartsWith(input, ddcrlf, position))
+    ) {
+      return entryList
+    }
+
+    // 5.3. If position does not point to a sequence of bytes starting with 0x0D
+    //      0x0A (CR LF), return failure.
+    if (input[position.position] !== 0x0d || input[position.position + 1] !== 0x0a) {
+      return 'failure'
+    }
+
+    // 5.4. Advance position by 2. (This skips past the newline.)
+    position.position += 2
+
+    // 5.5. Let name, filename and contentType be the result of parsing
+    //      multipart/form-data headers on input and position, if the result
+    //      is not failure. Otherwise, return failure.
+    const result = parseMultipartFormDataHeaders(input, position)
+
+    if (result === 'failure') {
+      return 'failure'
+    }
+
+    let { name, filename, contentType, encoding } = result
+
+    // 5.6. Advance position by 2. (This skips past the empty line that marks
+    //      the end of the headers.)
+    position.position += 2
+
+    // 5.7. Let body be the empty byte sequence.
+    let body
+
+    // 5.8. Body loop: While position is not past the end of input:
+    // TODO: the steps here are completely wrong
+    {
+      const boundaryIndex = input.indexOf(boundary.subarray(2), position.position)
+
+      if (boundaryIndex === -1) {
+        return 'failure'
+      }
+
+      body = input.subarray(position.position, boundaryIndex - 4)
+
+      position.position += body.length
+
+      // Note: position must be advanced by the body's length before being
+      // decoded, otherwise the parsing will fail.
+      if (encoding === 'base64') {
+        body = Buffer.from(body.toString(), 'base64')
+      }
+    }
+
+    // 5.9. If position does not point to a sequence of bytes starting with
+    //      0x0D 0x0A (CR LF), return failure. Otherwise, advance position by 2.
+    if (input[position.position] !== 0x0d || input[position.position + 1] !== 0x0a) {
+      return 'failure'
+    } else {
+      position.position += 2
+    }
+
+    // 5.10. If filename is not null:
+    let value
+
+    if (filename !== null) {
+      // 5.10.1. If contentType is null, set contentType to "text/plain".
+      contentType ??= 'text/plain'
+
+      // 5.10.2. If contentType is not an ASCII string, set contentType to the empty string.
+
+      // Note: `buffer.isAscii` can be used at zero-cost, but converting a string to a buffer is a high overhead.
+      // Content-Type is a relatively small string, so it is faster to use `String#charCodeAt`.
+      if (!isAsciiString(contentType)) {
+        contentType = ''
+      }
+
+      // 5.10.3. Let value be a new File object with name filename, type contentType, and body body.
+      value = new File([body], filename, { type: contentType })
+    } else {
+      // 5.11. Otherwise:
+
+      // 5.11.1. Let value be the UTF-8 decoding without BOM of body.
+      value = utf8DecodeBytes(Buffer.from(body))
+    }
+
+    // 5.12. Assert: name is a scalar value string and value is either a scalar value string or a File object.
+    assert(isUSVString(name))
+    assert((typeof value === 'string' && isUSVString(value)) || isFileLike(value))
+
+    // 5.13. Create an entry with name and value, and append it to entry list.
+    entryList.push(makeEntry(name, value, filename))
+  }
+}
+
+/**
+ * @see https://andreubotella.github.io/multipart-form-data/#parse-multipart-form-data-headers
+ * @param {Buffer} input
+ * @param {{ position: number }} position
+ */
+function parseMultipartFormDataHeaders (input, position) {
+  // 1. Let name, filename and contentType be null.
+  let name = null
+  let filename = null
+  let contentType = null
+  let encoding = null
+
+  // 2. While true:
+  while (true) {
+    // 2.1. If position points to a sequence of bytes starting with 0x0D 0x0A (CR LF):
+    if (input[position.position] === 0x0d && input[position.position + 1] === 0x0a) {
+      // 2.1.1. If name is null, return failure.
+      if (name === null) {
+        return 'failure'
+      }
+
+      // 2.1.2. Return name, filename and contentType.
+      return { name, filename, contentType, encoding }
+    }
+
+    // 2.2. Let header name be the result of collecting a sequence of bytes that are
+    //      not 0x0A (LF), 0x0D (CR) or 0x3A (:), given position.
+    let headerName = collectASequenceOfBytes(
+      (char) => char !== 0x0a && char !== 0x0d && char !== 0x3a,
+      input,
+      position
+    )
+
+    // 2.3. Remove any HTTP tab or space bytes from the start or end of header name.
+    headerName = removeChars(headerName, true, true, (char) => char === 0x9 || char === 0x20)
+
+    // 2.4. If header name does not match the field-name token production, return failure.
+    if (!HTTP_TOKEN_CODEPOINTS.test(headerName.toString())) {
+      return 'failure'
+    }
+
+    // 2.5. If the byte at position is not 0x3A (:), return failure.
+    if (input[position.position] !== 0x3a) {
+      return 'failure'
+    }
+
+    // 2.6. Advance position by 1.
+    position.position++
+
+    // 2.7. Collect a sequence of bytes that are HTTP tab or space bytes given position.
+    //      (Do nothing with those bytes.)
+    collectASequenceOfBytes(
+      (char) => char === 0x20 || char === 0x09,
+      input,
+      position
+    )
+
+    // 2.8. Byte-lowercase header name and switch on the result:
+    switch (bufferToLowerCasedHeaderName(headerName)) {
+      case 'content-disposition': {
+        // 1. Set name and filename to null.
+        name = filename = null
+
+        // 2. If position does not point to a sequence of bytes starting with
+        //    `form-data; name="`, return failure.
+        if (!bufferStartsWith(input, formDataNameBuffer, position)) {
+          return 'failure'
+        }
+
+        // 3. Advance position so it points at the byte after the next 0x22 (")
+        //    byte (the one in the sequence of bytes matched above).
+        position.position += 17
+
+        // 4. Set name to the result of parsing a multipart/form-data name given
+        //    input and position, if the result is not failure. Otherwise, return
+        //    failure.
+        name = parseMultipartFormDataName(input, position)
+
+        if (name === null) {
+          return 'failure'
+        }
+
+        // 5. If position points to a sequence of bytes starting with `; filename="`:
+        if (bufferStartsWith(input, filenameBuffer, position)) {
+          // Note: undici also handles filename*
+          let check = position.position + filenameBuffer.length
+
+          if (input[check] === 0x2a) {
+            position.position += 1
+            check += 1
+          }
+
+          if (input[check] !== 0x3d || input[check + 1] !== 0x22) { // ="
+            return 'failure'
+          }
+
+          // 1. Advance position so it points at the byte after the next 0x22 (") byte
+          //    (the one in the sequence of bytes matched above).
+          position.position += 12
+
+          // 2. Set filename to the result of parsing a multipart/form-data name given
+          //    input and position, if the result is not failure. Otherwise, return failure.
+          filename = parseMultipartFormDataName(input, position)
+
+          if (filename === null) {
+            return 'failure'
+          }
+        }
+
+        break
+      }
+      case 'content-type': {
+        // 1. Let header value be the result of collecting a sequence of bytes that are
+        //    not 0x0A (LF) or 0x0D (CR), given position.
+        let headerValue = collectASequenceOfBytes(
+          (char) => char !== 0x0a && char !== 0x0d,
+          input,
+          position
+        )
+
+        // 2. Remove any HTTP tab or space bytes from the end of header value.
+        headerValue = removeChars(headerValue, false, true, (char) => char === 0x9 || char === 0x20)
+
+        // 3. Set contentType to the isomorphic decoding of header value.
+        contentType = isomorphicDecode(headerValue)
+
+        break
+      }
+      case 'content-transfer-encoding': {
+        let headerValue = collectASequenceOfBytes(
+          (char) => char !== 0x0a && char !== 0x0d,
+          input,
+          position
+        )
+
+        headerValue = removeChars(headerValue, false, true, (char) => char === 0x9 || char === 0x20)
+
+        encoding = isomorphicDecode(headerValue)
+
+        break
+      }
+      default: {
+        // Collect a sequence of bytes that are not 0x0A (LF) or 0x0D (CR), given position.
+        // (Do nothing with those bytes.)
+        collectASequenceOfBytes(
+          (char) => char !== 0x0a && char !== 0x0d,
+          input,
+          position
+        )
+      }
+    }
+
+    // 2.9. If position does not point to a sequence of bytes starting with 0x0D 0x0A
+    //      (CR LF), return failure. Otherwise, advance position by 2 (past the newline).
+    if (input[position.position] !== 0x0d && input[position.position + 1] !== 0x0a) {
+      return 'failure'
+    } else {
+      position.position += 2
+    }
+  }
+}
+
+/**
+ * @see https://andreubotella.github.io/multipart-form-data/#parse-a-multipart-form-data-name
+ * @param {Buffer} input
+ * @param {{ position: number }} position
+ */
+function parseMultipartFormDataName (input, position) {
+  // 1. Assert: The byte at (position - 1) is 0x22 (").
+  assert(input[position.position - 1] === 0x22)
+
+  // 2. Let name be the result of collecting a sequence of bytes that are not 0x0A (LF), 0x0D (CR) or 0x22 ("), given position.
+  /** @type {string | Buffer} */
+  let name = collectASequenceOfBytes(
+    (char) => char !== 0x0a && char !== 0x0d && char !== 0x22,
+    input,
+    position
+  )
+
+  // 3. If the byte at position is not 0x22 ("), return failure. Otherwise, advance position by 1.
+  if (input[position.position] !== 0x22) {
+    return null // name could be 'failure'
+  } else {
+    position.position++
+  }
+
+  // 4. Replace any occurrence of the following subsequences in name with the given byte:
+  // - `%0A`: 0x0A (LF)
+  // - `%0D`: 0x0D (CR)
+  // - `%22`: 0x22 (")
+  name = new TextDecoder().decode(name)
+    .replace(/%0A/ig, '\n')
+    .replace(/%0D/ig, '\r')
+    .replace(/%22/g, '"')
+
+  // 5. Return the UTF-8 decoding without BOM of name.
+  return name
+}
+
+/**
+ * @param {(char: number) => boolean} condition
+ * @param {Buffer} input
+ * @param {{ position: number }} position
+ */
+function collectASequenceOfBytes (condition, input, position) {
+  let start = position.position
+
+  while (start < input.length && condition(input[start])) {
+    ++start
+  }
+
+  return input.subarray(position.position, (position.position = start))
+}
+
+/**
+ * @param {Buffer} buf
+ * @param {boolean} leading
+ * @param {boolean} trailing
+ * @param {(charCode: number) => boolean} predicate
+ * @returns {Buffer}
+ */
+function removeChars (buf, leading, trailing, predicate) {
+  let lead = 0
+  let trail = buf.length - 1
+
+  if (leading) {
+    while (lead < buf.length && predicate(buf[lead])) lead++
+  }
+
+  if (trailing) {
+    while (trail > 0 && predicate(buf[trail])) trail--
+  }
+
+  return lead === 0 && trail === buf.length - 1 ? buf : buf.subarray(lead, trail + 1)
+}
+
+/**
+ * Checks if {@param buffer} starts with {@param start}
+ * @param {Buffer} buffer
+ * @param {Buffer} start
+ * @param {{ position: number }} position
+ */
+function bufferStartsWith (buffer, start, position) {
+  if (buffer.length < start.length) {
+    return false
+  }
+
+  for (let i = 0; i < start.length; i++) {
+    if (start[i] !== buffer[position.position + i]) {
+      return false
+    }
+  }
+
+  return true
+}
+
+module.exports = {
+  multipartFormDataParser,
+  validateBoundary
+}
+
+
+/***/ }),
+
+/***/ 4923:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { isBlobLike, iteratorMixin } = __nccwpck_require__(91976)
+const { kState } = __nccwpck_require__(78172)
+const { kEnumerableProperty } = __nccwpck_require__(94407)
+const { FileLike, isFileLike } = __nccwpck_require__(52586)
+const { webidl } = __nccwpck_require__(37829)
+const { File: NativeFile } = __nccwpck_require__(72254)
+const nodeUtil = __nccwpck_require__(47261)
+
+/** @type {globalThis['File']} */
+const File = globalThis.File ?? NativeFile
+
+// https://xhr.spec.whatwg.org/#formdata
+class FormData {
+  constructor (form) {
+    webidl.util.markAsUncloneable(this)
+
+    if (form !== undefined) {
+      throw webidl.errors.conversionFailed({
+        prefix: 'FormData constructor',
+        argument: 'Argument 1',
+        types: ['undefined']
+      })
+    }
+
+    this[kState] = []
+  }
+
+  append (name, value, filename = undefined) {
+    webidl.brandCheck(this, FormData)
+
+    const prefix = 'FormData.append'
+    webidl.argumentLengthCheck(arguments, 2, prefix)
+
+    if (arguments.length === 3 && !isBlobLike(value)) {
+      throw new TypeError(
+        "Failed to execute 'append' on 'FormData': parameter 2 is not of type 'Blob'"
+      )
+    }
+
+    // 1. Let value be value if given; otherwise blobValue.
+
+    name = webidl.converters.USVString(name, prefix, 'name')
+    value = isBlobLike(value)
+      ? webidl.converters.Blob(value, prefix, 'value', { strict: false })
+      : webidl.converters.USVString(value, prefix, 'value')
+    filename = arguments.length === 3
+      ? webidl.converters.USVString(filename, prefix, 'filename')
+      : undefined
+
+    // 2. Let entry be the result of creating an entry with
+    // name, value, and filename if given.
+    const entry = makeEntry(name, value, filename)
+
+    // 3. Append entry to this’s entry list.
+    this[kState].push(entry)
+  }
+
+  delete (name) {
+    webidl.brandCheck(this, FormData)
+
+    const prefix = 'FormData.delete'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    name = webidl.converters.USVString(name, prefix, 'name')
+
+    // The delete(name) method steps are to remove all entries whose name
+    // is name from this’s entry list.
+    this[kState] = this[kState].filter(entry => entry.name !== name)
+  }
+
+  get (name) {
+    webidl.brandCheck(this, FormData)
+
+    const prefix = 'FormData.get'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    name = webidl.converters.USVString(name, prefix, 'name')
+
+    // 1. If there is no entry whose name is name in this’s entry list,
+    // then return null.
+    const idx = this[kState].findIndex((entry) => entry.name === name)
+    if (idx === -1) {
+      return null
+    }
+
+    // 2. Return the value of the first entry whose name is name from
+    // this’s entry list.
+    return this[kState][idx].value
+  }
+
+  getAll (name) {
+    webidl.brandCheck(this, FormData)
+
+    const prefix = 'FormData.getAll'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    name = webidl.converters.USVString(name, prefix, 'name')
+
+    // 1. If there is no entry whose name is name in this’s entry list,
+    // then return the empty list.
+    // 2. Return the values of all entries whose name is name, in order,
+    // from this’s entry list.
+    return this[kState]
+      .filter((entry) => entry.name === name)
+      .map((entry) => entry.value)
+  }
+
+  has (name) {
+    webidl.brandCheck(this, FormData)
+
+    const prefix = 'FormData.has'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    name = webidl.converters.USVString(name, prefix, 'name')
+
+    // The has(name) method steps are to return true if there is an entry
+    // whose name is name in this’s entry list; otherwise false.
+    return this[kState].findIndex((entry) => entry.name === name) !== -1
+  }
+
+  set (name, value, filename = undefined) {
+    webidl.brandCheck(this, FormData)
+
+    const prefix = 'FormData.set'
+    webidl.argumentLengthCheck(arguments, 2, prefix)
+
+    if (arguments.length === 3 && !isBlobLike(value)) {
+      throw new TypeError(
+        "Failed to execute 'set' on 'FormData': parameter 2 is not of type 'Blob'"
+      )
+    }
+
+    // The set(name, value) and set(name, blobValue, filename) method steps
+    // are:
+
+    // 1. Let value be value if given; otherwise blobValue.
+
+    name = webidl.converters.USVString(name, prefix, 'name')
+    value = isBlobLike(value)
+      ? webidl.converters.Blob(value, prefix, 'name', { strict: false })
+      : webidl.converters.USVString(value, prefix, 'name')
+    filename = arguments.length === 3
+      ? webidl.converters.USVString(filename, prefix, 'name')
+      : undefined
+
+    // 2. Let entry be the result of creating an entry with name, value, and
+    // filename if given.
+    const entry = makeEntry(name, value, filename)
+
+    // 3. If there are entries in this’s entry list whose name is name, then
+    // replace the first such entry with entry and remove the others.
+    const idx = this[kState].findIndex((entry) => entry.name === name)
+    if (idx !== -1) {
+      this[kState] = [
+        ...this[kState].slice(0, idx),
+        entry,
+        ...this[kState].slice(idx + 1).filter((entry) => entry.name !== name)
+      ]
+    } else {
+      // 4. Otherwise, append entry to this’s entry list.
+      this[kState].push(entry)
+    }
+  }
+
+  [nodeUtil.inspect.custom] (depth, options) {
+    const state = this[kState].reduce((a, b) => {
+      if (a[b.name]) {
+        if (Array.isArray(a[b.name])) {
+          a[b.name].push(b.value)
+        } else {
+          a[b.name] = [a[b.name], b.value]
+        }
+      } else {
+        a[b.name] = b.value
+      }
+
+      return a
+    }, { __proto__: null })
+
+    options.depth ??= depth
+    options.colors ??= true
+
+    const output = nodeUtil.formatWithOptions(options, state)
+
+    // remove [Object null prototype]
+    return `FormData ${output.slice(output.indexOf(']') + 2)}`
+  }
+}
+
+iteratorMixin('FormData', FormData, kState, 'name', 'value')
+
+Object.defineProperties(FormData.prototype, {
+  append: kEnumerableProperty,
+  delete: kEnumerableProperty,
+  get: kEnumerableProperty,
+  getAll: kEnumerableProperty,
+  has: kEnumerableProperty,
+  set: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'FormData',
+    configurable: true
+  }
+})
+
+/**
+ * @see https://html.spec.whatwg.org/multipage/form-control-infrastructure.html#create-an-entry
+ * @param {string} name
+ * @param {string|Blob} value
+ * @param {?string} filename
+ * @returns
+ */
+function makeEntry (name, value, filename) {
+  // 1. Set name to the result of converting name into a scalar value string.
+  // Note: This operation was done by the webidl converter USVString.
+
+  // 2. If value is a string, then set value to the result of converting
+  //    value into a scalar value string.
+  if (typeof value === 'string') {
+    // Note: This operation was done by the webidl converter USVString.
+  } else {
+    // 3. Otherwise:
+
+    // 1. If value is not a File object, then set value to a new File object,
+    //    representing the same bytes, whose name attribute value is "blob"
+    if (!isFileLike(value)) {
+      value = value instanceof Blob
+        ? new File([value], 'blob', { type: value.type })
+        : new FileLike(value, 'blob', { type: value.type })
+    }
+
+    // 2. If filename is given, then set value to a new File object,
+    //    representing the same bytes, whose name attribute is filename.
+    if (filename !== undefined) {
+      /** @type {FilePropertyBag} */
+      const options = {
+        type: value.type,
+        lastModified: value.lastModified
+      }
+
+      value = value instanceof NativeFile
+        ? new File([value], filename, options)
+        : new FileLike(value, filename, options)
+    }
+  }
+
+  // 4. Return an entry whose name is name and whose value is value.
+  return { name, value }
+}
+
+module.exports = { FormData, makeEntry }
+
+
+/***/ }),
+
+/***/ 71332:
+/***/ ((module) => {
+
+"use strict";
+
+
+// In case of breaking changes, increase the version
+// number to avoid conflicts.
+const globalOrigin = Symbol.for('undici.globalOrigin.1')
+
+function getGlobalOrigin () {
+  return globalThis[globalOrigin]
+}
+
+function setGlobalOrigin (newOrigin) {
+  if (newOrigin === undefined) {
+    Object.defineProperty(globalThis, globalOrigin, {
+      value: undefined,
+      writable: true,
+      enumerable: false,
+      configurable: false
+    })
+
+    return
+  }
+
+  const parsedURL = new URL(newOrigin)
+
+  if (parsedURL.protocol !== 'http:' && parsedURL.protocol !== 'https:') {
+    throw new TypeError(`Only http & https urls are allowed, received ${parsedURL.protocol}`)
+  }
+
+  Object.defineProperty(globalThis, globalOrigin, {
+    value: parsedURL,
+    writable: true,
+    enumerable: false,
+    configurable: false
+  })
+}
+
+module.exports = {
+  getGlobalOrigin,
+  setGlobalOrigin
+}
+
+
+/***/ }),
+
+/***/ 24997:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// https://github.com/Ethan-Arrowood/undici-fetch
+
+
+
+const { kConstruct } = __nccwpck_require__(5392)
+const { kEnumerableProperty } = __nccwpck_require__(94407)
+const {
+  iteratorMixin,
+  isValidHeaderName,
+  isValidHeaderValue
+} = __nccwpck_require__(91976)
+const { webidl } = __nccwpck_require__(37829)
+const assert = __nccwpck_require__(98061)
+const util = __nccwpck_require__(47261)
+
+const kHeadersMap = Symbol('headers map')
+const kHeadersSortedMap = Symbol('headers map sorted')
+
+/**
+ * @param {number} code
+ */
+function isHTTPWhiteSpaceCharCode (code) {
+  return code === 0x00a || code === 0x00d || code === 0x009 || code === 0x020
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-header-value-normalize
+ * @param {string} potentialValue
+ */
+function headerValueNormalize (potentialValue) {
+  //  To normalize a byte sequence potentialValue, remove
+  //  any leading and trailing HTTP whitespace bytes from
+  //  potentialValue.
+  let i = 0; let j = potentialValue.length
+
+  while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(j - 1))) --j
+  while (j > i && isHTTPWhiteSpaceCharCode(potentialValue.charCodeAt(i))) ++i
+
+  return i === 0 && j === potentialValue.length ? potentialValue : potentialValue.substring(i, j)
+}
+
+function fill (headers, object) {
+  // To fill a Headers object headers with a given object object, run these steps:
+
+  // 1. If object is a sequence, then for each header in object:
+  // Note: webidl conversion to array has already been done.
+  if (Array.isArray(object)) {
+    for (let i = 0; i < object.length; ++i) {
+      const header = object[i]
+      // 1. If header does not contain exactly two items, then throw a TypeError.
+      if (header.length !== 2) {
+        throw webidl.errors.exception({
+          header: 'Headers constructor',
+          message: `expected name/value pair to be length 2, found ${header.length}.`
+        })
+      }
+
+      // 2. Append (header’s first item, header’s second item) to headers.
+      appendHeader(headers, header[0], header[1])
+    }
+  } else if (typeof object === 'object' && object !== null) {
+    // Note: null should throw
+
+    // 2. Otherwise, object is a record, then for each key → value in object,
+    //    append (key, value) to headers
+    const keys = Object.keys(object)
+    for (let i = 0; i < keys.length; ++i) {
+      appendHeader(headers, keys[i], object[keys[i]])
+    }
+  } else {
+    throw webidl.errors.conversionFailed({
+      prefix: 'Headers constructor',
+      argument: 'Argument 1',
+      types: ['sequence<sequence<ByteString>>', 'record<ByteString, ByteString>']
+    })
+  }
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-headers-append
+ */
+function appendHeader (headers, name, value) {
+  // 1. Normalize value.
+  value = headerValueNormalize(value)
+
+  // 2. If name is not a header name or value is not a
+  //    header value, then throw a TypeError.
+  if (!isValidHeaderName(name)) {
+    throw webidl.errors.invalidArgument({
+      prefix: 'Headers.append',
+      value: name,
+      type: 'header name'
+    })
+  } else if (!isValidHeaderValue(value)) {
+    throw webidl.errors.invalidArgument({
+      prefix: 'Headers.append',
+      value,
+      type: 'header value'
+    })
+  }
+
+  // 3. If headers’s guard is "immutable", then throw a TypeError.
+  // 4. Otherwise, if headers’s guard is "request" and name is a
+  //    forbidden header name, return.
+  // 5. Otherwise, if headers’s guard is "request-no-cors":
+  //    TODO
+  // Note: undici does not implement forbidden header names
+  if (getHeadersGuard(headers) === 'immutable') {
+    throw new TypeError('immutable')
+  }
+
+  // 6. Otherwise, if headers’s guard is "response" and name is a
+  //    forbidden response-header name, return.
+
+  // 7. Append (name, value) to headers’s header list.
+  return getHeadersList(headers).append(name, value, false)
+
+  // 8. If headers’s guard is "request-no-cors", then remove
+  //    privileged no-CORS request headers from headers
+}
+
+function compareHeaderName (a, b) {
+  return a[0] < b[0] ? -1 : 1
+}
+
+class HeadersList {
+  /** @type {[string, string][]|null} */
+  cookies = null
+
+  constructor (init) {
+    if (init instanceof HeadersList) {
+      this[kHeadersMap] = new Map(init[kHeadersMap])
+      this[kHeadersSortedMap] = init[kHeadersSortedMap]
+      this.cookies = init.cookies === null ? null : [...init.cookies]
+    } else {
+      this[kHeadersMap] = new Map(init)
+      this[kHeadersSortedMap] = null
+    }
+  }
+
+  /**
+   * @see https://fetch.spec.whatwg.org/#header-list-contains
+   * @param {string} name
+   * @param {boolean} isLowerCase
+   */
+  contains (name, isLowerCase) {
+    // A header list list contains a header name name if list
+    // contains a header whose name is a byte-case-insensitive
+    // match for name.
+
+    return this[kHeadersMap].has(isLowerCase ? name : name.toLowerCase())
+  }
+
+  clear () {
+    this[kHeadersMap].clear()
+    this[kHeadersSortedMap] = null
+    this.cookies = null
+  }
+
+  /**
+   * @see https://fetch.spec.whatwg.org/#concept-header-list-append
+   * @param {string} name
+   * @param {string} value
+   * @param {boolean} isLowerCase
+   */
+  append (name, value, isLowerCase) {
+    this[kHeadersSortedMap] = null
+
+    // 1. If list contains name, then set name to the first such
+    //    header’s name.
+    const lowercaseName = isLowerCase ? name : name.toLowerCase()
+    const exists = this[kHeadersMap].get(lowercaseName)
+
+    // 2. Append (name, value) to list.
+    if (exists) {
+      const delimiter = lowercaseName === 'cookie' ? '; ' : ', '
+      this[kHeadersMap].set(lowercaseName, {
+        name: exists.name,
+        value: `${exists.value}${delimiter}${value}`
+      })
+    } else {
+      this[kHeadersMap].set(lowercaseName, { name, value })
+    }
+
+    if (lowercaseName === 'set-cookie') {
+      (this.cookies ??= []).push(value)
+    }
+  }
+
+  /**
+   * @see https://fetch.spec.whatwg.org/#concept-header-list-set
+   * @param {string} name
+   * @param {string} value
+   * @param {boolean} isLowerCase
+   */
+  set (name, value, isLowerCase) {
+    this[kHeadersSortedMap] = null
+    const lowercaseName = isLowerCase ? name : name.toLowerCase()
+
+    if (lowercaseName === 'set-cookie') {
+      this.cookies = [value]
+    }
+
+    // 1. If list contains name, then set the value of
+    //    the first such header to value and remove the
+    //    others.
+    // 2. Otherwise, append header (name, value) to list.
+    this[kHeadersMap].set(lowercaseName, { name, value })
+  }
+
+  /**
+   * @see https://fetch.spec.whatwg.org/#concept-header-list-delete
+   * @param {string} name
+   * @param {boolean} isLowerCase
+   */
+  delete (name, isLowerCase) {
+    this[kHeadersSortedMap] = null
+    if (!isLowerCase) name = name.toLowerCase()
+
+    if (name === 'set-cookie') {
+      this.cookies = null
+    }
+
+    this[kHeadersMap].delete(name)
+  }
+
+  /**
+   * @see https://fetch.spec.whatwg.org/#concept-header-list-get
+   * @param {string} name
+   * @param {boolean} isLowerCase
+   * @returns {string | null}
+   */
+  get (name, isLowerCase) {
+    // 1. If list does not contain name, then return null.
+    // 2. Return the values of all headers in list whose name
+    //    is a byte-case-insensitive match for name,
+    //    separated from each other by 0x2C 0x20, in order.
+    return this[kHeadersMap].get(isLowerCase ? name : name.toLowerCase())?.value ?? null
+  }
+
+  * [Symbol.iterator] () {
+    // use the lowercased name
+    for (const { 0: name, 1: { value } } of this[kHeadersMap]) {
+      yield [name, value]
+    }
+  }
+
+  get entries () {
+    const headers = {}
+
+    if (this[kHeadersMap].size !== 0) {
+      for (const { name, value } of this[kHeadersMap].values()) {
+        headers[name] = value
+      }
+    }
+
+    return headers
+  }
+
+  rawValues () {
+    return this[kHeadersMap].values()
+  }
+
+  get entriesList () {
+    const headers = []
+
+    if (this[kHeadersMap].size !== 0) {
+      for (const { 0: lowerName, 1: { name, value } } of this[kHeadersMap]) {
+        if (lowerName === 'set-cookie') {
+          for (const cookie of this.cookies) {
+            headers.push([name, cookie])
+          }
+        } else {
+          headers.push([name, value])
+        }
+      }
+    }
+
+    return headers
+  }
+
+  // https://fetch.spec.whatwg.org/#convert-header-names-to-a-sorted-lowercase-set
+  toSortedArray () {
+    const size = this[kHeadersMap].size
+    const array = new Array(size)
+    // In most cases, you will use the fast-path.
+    // fast-path: Use binary insertion sort for small arrays.
+    if (size <= 32) {
+      if (size === 0) {
+        // If empty, it is an empty array. To avoid the first index assignment.
+        return array
+      }
+      // Improve performance by unrolling loop and avoiding double-loop.
+      // Double-loop-less version of the binary insertion sort.
+      const iterator = this[kHeadersMap][Symbol.iterator]()
+      const firstValue = iterator.next().value
+      // set [name, value] to first index.
+      array[0] = [firstValue[0], firstValue[1].value]
+      // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
+      // 3.2.2. Assert: value is non-null.
+      assert(firstValue[1].value !== null)
+      for (
+        let i = 1, j = 0, right = 0, left = 0, pivot = 0, x, value;
+        i < size;
+        ++i
+      ) {
+        // get next value
+        value = iterator.next().value
+        // set [name, value] to current index.
+        x = array[i] = [value[0], value[1].value]
+        // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
+        // 3.2.2. Assert: value is non-null.
+        assert(x[1] !== null)
+        left = 0
+        right = i
+        // binary search
+        while (left < right) {
+          // middle index
+          pivot = left + ((right - left) >> 1)
+          // compare header name
+          if (array[pivot][0] <= x[0]) {
+            left = pivot + 1
+          } else {
+            right = pivot
+          }
+        }
+        if (i !== pivot) {
+          j = i
+          while (j > left) {
+            array[j] = array[--j]
+          }
+          array[left] = x
+        }
+      }
+      /* c8 ignore next 4 */
+      if (!iterator.next().done) {
+        // This is for debugging and will never be called.
+        throw new TypeError('Unreachable')
+      }
+      return array
+    } else {
+      // This case would be a rare occurrence.
+      // slow-path: fallback
+      let i = 0
+      for (const { 0: name, 1: { value } } of this[kHeadersMap]) {
+        array[i++] = [name, value]
+        // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
+        // 3.2.2. Assert: value is non-null.
+        assert(value !== null)
+      }
+      return array.sort(compareHeaderName)
+    }
+  }
+}
+
+// https://fetch.spec.whatwg.org/#headers-class
+class Headers {
+  #guard
+  #headersList
+
+  constructor (init = undefined) {
+    webidl.util.markAsUncloneable(this)
+
+    if (init === kConstruct) {
+      return
+    }
+
+    this.#headersList = new HeadersList()
+
+    // The new Headers(init) constructor steps are:
+
+    // 1. Set this’s guard to "none".
+    this.#guard = 'none'
+
+    // 2. If init is given, then fill this with init.
+    if (init !== undefined) {
+      init = webidl.converters.HeadersInit(init, 'Headers contructor', 'init')
+      fill(this, init)
+    }
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-append
+  append (name, value) {
+    webidl.brandCheck(this, Headers)
+
+    webidl.argumentLengthCheck(arguments, 2, 'Headers.append')
+
+    const prefix = 'Headers.append'
+    name = webidl.converters.ByteString(name, prefix, 'name')
+    value = webidl.converters.ByteString(value, prefix, 'value')
+
+    return appendHeader(this, name, value)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-delete
+  delete (name) {
+    webidl.brandCheck(this, Headers)
+
+    webidl.argumentLengthCheck(arguments, 1, 'Headers.delete')
+
+    const prefix = 'Headers.delete'
+    name = webidl.converters.ByteString(name, prefix, 'name')
+
+    // 1. If name is not a header name, then throw a TypeError.
+    if (!isValidHeaderName(name)) {
+      throw webidl.errors.invalidArgument({
+        prefix: 'Headers.delete',
+        value: name,
+        type: 'header name'
+      })
+    }
+
+    // 2. If this’s guard is "immutable", then throw a TypeError.
+    // 3. Otherwise, if this’s guard is "request" and name is a
+    //    forbidden header name, return.
+    // 4. Otherwise, if this’s guard is "request-no-cors", name
+    //    is not a no-CORS-safelisted request-header name, and
+    //    name is not a privileged no-CORS request-header name,
+    //    return.
+    // 5. Otherwise, if this’s guard is "response" and name is
+    //    a forbidden response-header name, return.
+    // Note: undici does not implement forbidden header names
+    if (this.#guard === 'immutable') {
+      throw new TypeError('immutable')
+    }
+
+    // 6. If this’s header list does not contain name, then
+    //    return.
+    if (!this.#headersList.contains(name, false)) {
+      return
+    }
+
+    // 7. Delete name from this’s header list.
+    // 8. If this’s guard is "request-no-cors", then remove
+    //    privileged no-CORS request headers from this.
+    this.#headersList.delete(name, false)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-get
+  get (name) {
+    webidl.brandCheck(this, Headers)
+
+    webidl.argumentLengthCheck(arguments, 1, 'Headers.get')
+
+    const prefix = 'Headers.get'
+    name = webidl.converters.ByteString(name, prefix, 'name')
+
+    // 1. If name is not a header name, then throw a TypeError.
+    if (!isValidHeaderName(name)) {
+      throw webidl.errors.invalidArgument({
+        prefix,
+        value: name,
+        type: 'header name'
+      })
+    }
+
+    // 2. Return the result of getting name from this’s header
+    //    list.
+    return this.#headersList.get(name, false)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-has
+  has (name) {
+    webidl.brandCheck(this, Headers)
+
+    webidl.argumentLengthCheck(arguments, 1, 'Headers.has')
+
+    const prefix = 'Headers.has'
+    name = webidl.converters.ByteString(name, prefix, 'name')
+
+    // 1. If name is not a header name, then throw a TypeError.
+    if (!isValidHeaderName(name)) {
+      throw webidl.errors.invalidArgument({
+        prefix,
+        value: name,
+        type: 'header name'
+      })
+    }
+
+    // 2. Return true if this’s header list contains name;
+    //    otherwise false.
+    return this.#headersList.contains(name, false)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-set
+  set (name, value) {
+    webidl.brandCheck(this, Headers)
+
+    webidl.argumentLengthCheck(arguments, 2, 'Headers.set')
+
+    const prefix = 'Headers.set'
+    name = webidl.converters.ByteString(name, prefix, 'name')
+    value = webidl.converters.ByteString(value, prefix, 'value')
+
+    // 1. Normalize value.
+    value = headerValueNormalize(value)
+
+    // 2. If name is not a header name or value is not a
+    //    header value, then throw a TypeError.
+    if (!isValidHeaderName(name)) {
+      throw webidl.errors.invalidArgument({
+        prefix,
+        value: name,
+        type: 'header name'
+      })
+    } else if (!isValidHeaderValue(value)) {
+      throw webidl.errors.invalidArgument({
+        prefix,
+        value,
+        type: 'header value'
+      })
+    }
+
+    // 3. If this’s guard is "immutable", then throw a TypeError.
+    // 4. Otherwise, if this’s guard is "request" and name is a
+    //    forbidden header name, return.
+    // 5. Otherwise, if this’s guard is "request-no-cors" and
+    //    name/value is not a no-CORS-safelisted request-header,
+    //    return.
+    // 6. Otherwise, if this’s guard is "response" and name is a
+    //    forbidden response-header name, return.
+    // Note: undici does not implement forbidden header names
+    if (this.#guard === 'immutable') {
+      throw new TypeError('immutable')
+    }
+
+    // 7. Set (name, value) in this’s header list.
+    // 8. If this’s guard is "request-no-cors", then remove
+    //    privileged no-CORS request headers from this
+    this.#headersList.set(name, value, false)
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-headers-getsetcookie
+  getSetCookie () {
+    webidl.brandCheck(this, Headers)
+
+    // 1. If this’s header list does not contain `Set-Cookie`, then return « ».
+    // 2. Return the values of all headers in this’s header list whose name is
+    //    a byte-case-insensitive match for `Set-Cookie`, in order.
+
+    const list = this.#headersList.cookies
+
+    if (list) {
+      return [...list]
+    }
+
+    return []
+  }
+
+  // https://fetch.spec.whatwg.org/#concept-header-list-sort-and-combine
+  get [kHeadersSortedMap] () {
+    if (this.#headersList[kHeadersSortedMap]) {
+      return this.#headersList[kHeadersSortedMap]
+    }
+
+    // 1. Let headers be an empty list of headers with the key being the name
+    //    and value the value.
+    const headers = []
+
+    // 2. Let names be the result of convert header names to a sorted-lowercase
+    //    set with all the names of the headers in list.
+    const names = this.#headersList.toSortedArray()
+
+    const cookies = this.#headersList.cookies
+
+    // fast-path
+    if (cookies === null || cookies.length === 1) {
+      // Note: The non-null assertion of value has already been done by `HeadersList#toSortedArray`
+      return (this.#headersList[kHeadersSortedMap] = names)
+    }
+
+    // 3. For each name of names:
+    for (let i = 0; i < names.length; ++i) {
+      const { 0: name, 1: value } = names[i]
+      // 1. If name is `set-cookie`, then:
+      if (name === 'set-cookie') {
+        // 1. Let values be a list of all values of headers in list whose name
+        //    is a byte-case-insensitive match for name, in order.
+
+        // 2. For each value of values:
+        // 1. Append (name, value) to headers.
+        for (let j = 0; j < cookies.length; ++j) {
+          headers.push([name, cookies[j]])
+        }
+      } else {
+        // 2. Otherwise:
+
+        // 1. Let value be the result of getting name from list.
+
+        // 2. Assert: value is non-null.
+        // Note: This operation was done by `HeadersList#toSortedArray`.
+
+        // 3. Append (name, value) to headers.
+        headers.push([name, value])
+      }
+    }
+
+    // 4. Return headers.
+    return (this.#headersList[kHeadersSortedMap] = headers)
+  }
+
+  [util.inspect.custom] (depth, options) {
+    options.depth ??= depth
+
+    return `Headers ${util.formatWithOptions(options, this.#headersList.entries)}`
+  }
+
+  static getHeadersGuard (o) {
+    return o.#guard
+  }
+
+  static setHeadersGuard (o, guard) {
+    o.#guard = guard
+  }
+
+  static getHeadersList (o) {
+    return o.#headersList
+  }
+
+  static setHeadersList (o, list) {
+    o.#headersList = list
+  }
+}
+
+const { getHeadersGuard, setHeadersGuard, getHeadersList, setHeadersList } = Headers
+Reflect.deleteProperty(Headers, 'getHeadersGuard')
+Reflect.deleteProperty(Headers, 'setHeadersGuard')
+Reflect.deleteProperty(Headers, 'getHeadersList')
+Reflect.deleteProperty(Headers, 'setHeadersList')
+
+iteratorMixin('Headers', Headers, kHeadersSortedMap, 0, 1)
+
+Object.defineProperties(Headers.prototype, {
+  append: kEnumerableProperty,
+  delete: kEnumerableProperty,
+  get: kEnumerableProperty,
+  has: kEnumerableProperty,
+  set: kEnumerableProperty,
+  getSetCookie: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'Headers',
+    configurable: true
+  },
+  [util.inspect.custom]: {
+    enumerable: false
+  }
+})
+
+webidl.converters.HeadersInit = function (V, prefix, argument) {
+  if (webidl.util.Type(V) === 'Object') {
+    const iterator = Reflect.get(V, Symbol.iterator)
+
+    // A work-around to ensure we send the properly-cased Headers when V is a Headers object.
+    // Read https://github.com/nodejs/undici/pull/3159#issuecomment-2075537226 before touching, please.
+    if (!util.types.isProxy(V) && iterator === Headers.prototype.entries) { // Headers object
+      try {
+        return getHeadersList(V).entriesList
+      } catch {
+        // fall-through
+      }
+    }
+
+    if (typeof iterator === 'function') {
+      return webidl.converters['sequence<sequence<ByteString>>'](V, prefix, argument, iterator.bind(V))
+    }
+
+    return webidl.converters['record<ByteString, ByteString>'](V, prefix, argument)
+  }
+
+  throw webidl.errors.conversionFailed({
+    prefix: 'Headers constructor',
+    argument: 'Argument 1',
+    types: ['sequence<sequence<ByteString>>', 'record<ByteString, ByteString>']
+  })
+}
+
+module.exports = {
+  fill,
+  // for test.
+  compareHeaderName,
+  Headers,
+  HeadersList,
+  getHeadersGuard,
+  setHeadersGuard,
+  setHeadersList,
+  getHeadersList
+}
+
+
+/***/ }),
+
+/***/ 31158:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// https://github.com/Ethan-Arrowood/undici-fetch
+
+
+
+const {
+  makeNetworkError,
+  makeAppropriateNetworkError,
+  filterResponse,
+  makeResponse,
+  fromInnerResponse
+} = __nccwpck_require__(33139)
+const { HeadersList } = __nccwpck_require__(24997)
+const { Request, cloneRequest } = __nccwpck_require__(13925)
+const zlib = __nccwpck_require__(65628)
+const {
+  bytesMatch,
+  makePolicyContainer,
+  clonePolicyContainer,
+  requestBadPort,
+  TAOCheck,
+  appendRequestOriginHeader,
+  responseLocationURL,
+  requestCurrentURL,
+  setRequestReferrerPolicyOnRedirect,
+  tryUpgradeRequestToAPotentiallyTrustworthyURL,
+  createOpaqueTimingInfo,
+  appendFetchMetadata,
+  corsCheck,
+  crossOriginResourcePolicyCheck,
+  determineRequestsReferrer,
+  coarsenedSharedCurrentTime,
+  createDeferredPromise,
+  isBlobLike,
+  sameOrigin,
+  isCancelled,
+  isAborted,
+  isErrorLike,
+  fullyReadBody,
+  readableStreamClose,
+  isomorphicEncode,
+  urlIsLocal,
+  urlIsHttpHttpsScheme,
+  urlHasHttpsScheme,
+  clampAndCoarsenConnectionTimingInfo,
+  simpleRangeHeaderValue,
+  buildContentRange,
+  createInflate,
+  extractMimeType
+} = __nccwpck_require__(91976)
+const { kState, kDispatcher } = __nccwpck_require__(78172)
+const assert = __nccwpck_require__(98061)
+const { safelyExtractBody, extractBody } = __nccwpck_require__(23291)
+const {
+  redirectStatusSet,
+  nullBodyStatus,
+  safeMethodsSet,
+  requestBodyHeader,
+  subresourceSet
+} = __nccwpck_require__(87979)
+const EE = __nccwpck_require__(15673)
+const { Readable, pipeline, finished } = __nccwpck_require__(84492)
+const { addAbortListener, isErrored, isReadable, bufferToLowerCasedHeaderName } = __nccwpck_require__(94407)
+const { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = __nccwpck_require__(86954)
+const { getGlobalDispatcher } = __nccwpck_require__(72354)
+const { webidl } = __nccwpck_require__(37829)
+const { STATUS_CODES } = __nccwpck_require__(88849)
+const GET_OR_HEAD = ['GET', 'HEAD']
+
+const defaultUserAgent = typeof __UNDICI_IS_NODE__ !== 'undefined' || typeof esbuildDetection !== 'undefined'
+  ? 'node'
+  : 'undici'
+
+/** @type {import('buffer').resolveObjectURL} */
+let resolveObjectURL
+
+class Fetch extends EE {
+  constructor (dispatcher) {
+    super()
+
+    this.dispatcher = dispatcher
+    this.connection = null
+    this.dump = false
+    this.state = 'ongoing'
+  }
+
+  terminate (reason) {
+    if (this.state !== 'ongoing') {
+      return
+    }
+
+    this.state = 'terminated'
+    this.connection?.destroy(reason)
+    this.emit('terminated', reason)
+  }
+
+  // https://fetch.spec.whatwg.org/#fetch-controller-abort
+  abort (error) {
+    if (this.state !== 'ongoing') {
+      return
+    }
+
+    // 1. Set controller’s state to "aborted".
+    this.state = 'aborted'
+
+    // 2. Let fallbackError be an "AbortError" DOMException.
+    // 3. Set error to fallbackError if it is not given.
+    if (!error) {
+      error = new DOMException('The operation was aborted.', 'AbortError')
+    }
+
+    // 4. Let serializedError be StructuredSerialize(error).
+    //    If that threw an exception, catch it, and let
+    //    serializedError be StructuredSerialize(fallbackError).
+
+    // 5. Set controller’s serialized abort reason to serializedError.
+    this.serializedAbortReason = error
+
+    this.connection?.destroy(error)
+    this.emit('terminated', error)
+  }
+}
+
+function handleFetchDone (response) {
+  finalizeAndReportTiming(response, 'fetch')
+}
+
+// https://fetch.spec.whatwg.org/#fetch-method
+function fetch (input, init = undefined) {
+  webidl.argumentLengthCheck(arguments, 1, 'globalThis.fetch')
+
+  // 1. Let p be a new promise.
+  let p = createDeferredPromise()
+
+  // 2. Let requestObject be the result of invoking the initial value of
+  // Request as constructor with input and init as arguments. If this throws
+  // an exception, reject p with it and return p.
+  let requestObject
+
+  try {
+    requestObject = new Request(input, init)
+  } catch (e) {
+    p.reject(e)
+    return p.promise
+  }
+
+  // 3. Let request be requestObject’s request.
+  const request = requestObject[kState]
+
+  // 4. If requestObject’s signal’s aborted flag is set, then:
+  if (requestObject.signal.aborted) {
+    // 1. Abort the fetch() call with p, request, null, and
+    //    requestObject’s signal’s abort reason.
+    abortFetch(p, request, null, requestObject.signal.reason)
+
+    // 2. Return p.
+    return p.promise
+  }
+
+  // 5. Let globalObject be request’s client’s global object.
+  const globalObject = request.client.globalObject
+
+  // 6. If globalObject is a ServiceWorkerGlobalScope object, then set
+  // request’s service-workers mode to "none".
+  if (globalObject?.constructor?.name === 'ServiceWorkerGlobalScope') {
+    request.serviceWorkers = 'none'
+  }
+
+  // 7. Let responseObject be null.
+  let responseObject = null
+
+  // 8. Let relevantRealm be this’s relevant Realm.
+
+  // 9. Let locallyAborted be false.
+  let locallyAborted = false
+
+  // 10. Let controller be null.
+  let controller = null
+
+  // 11. Add the following abort steps to requestObject’s signal:
+  addAbortListener(
+    requestObject.signal,
+    () => {
+      // 1. Set locallyAborted to true.
+      locallyAborted = true
+
+      // 2. Assert: controller is non-null.
+      assert(controller != null)
+
+      // 3. Abort controller with requestObject’s signal’s abort reason.
+      controller.abort(requestObject.signal.reason)
+
+      const realResponse = responseObject?.deref()
+
+      // 4. Abort the fetch() call with p, request, responseObject,
+      //    and requestObject’s signal’s abort reason.
+      abortFetch(p, request, realResponse, requestObject.signal.reason)
+    }
+  )
+
+  // 12. Let handleFetchDone given response response be to finalize and
+  // report timing with response, globalObject, and "fetch".
+  // see function handleFetchDone
+
+  // 13. Set controller to the result of calling fetch given request,
+  // with processResponseEndOfBody set to handleFetchDone, and processResponse
+  // given response being these substeps:
+
+  const processResponse = (response) => {
+    // 1. If locallyAborted is true, terminate these substeps.
+    if (locallyAborted) {
+      return
+    }
+
+    // 2. If response’s aborted flag is set, then:
+    if (response.aborted) {
+      // 1. Let deserializedError be the result of deserialize a serialized
+      //    abort reason given controller’s serialized abort reason and
+      //    relevantRealm.
+
+      // 2. Abort the fetch() call with p, request, responseObject, and
+      //    deserializedError.
+
+      abortFetch(p, request, responseObject, controller.serializedAbortReason)
+      return
+    }
+
+    // 3. If response is a network error, then reject p with a TypeError
+    // and terminate these substeps.
+    if (response.type === 'error') {
+      p.reject(new TypeError('fetch failed', { cause: response.error }))
+      return
+    }
+
+    // 4. Set responseObject to the result of creating a Response object,
+    // given response, "immutable", and relevantRealm.
+    responseObject = new WeakRef(fromInnerResponse(response, 'immutable'))
+
+    // 5. Resolve p with responseObject.
+    p.resolve(responseObject.deref())
+    p = null
+  }
+
+  controller = fetching({
+    request,
+    processResponseEndOfBody: handleFetchDone,
+    processResponse,
+    dispatcher: requestObject[kDispatcher] // undici
+  })
+
+  // 14. Return p.
+  return p.promise
+}
+
+// https://fetch.spec.whatwg.org/#finalize-and-report-timing
+function finalizeAndReportTiming (response, initiatorType = 'other') {
+  // 1. If response is an aborted network error, then return.
+  if (response.type === 'error' && response.aborted) {
+    return
+  }
+
+  // 2. If response’s URL list is null or empty, then return.
+  if (!response.urlList?.length) {
+    return
+  }
+
+  // 3. Let originalURL be response’s URL list[0].
+  const originalURL = response.urlList[0]
+
+  // 4. Let timingInfo be response’s timing info.
+  let timingInfo = response.timingInfo
+
+  // 5. Let cacheState be response’s cache state.
+  let cacheState = response.cacheState
+
+  // 6. If originalURL’s scheme is not an HTTP(S) scheme, then return.
+  if (!urlIsHttpHttpsScheme(originalURL)) {
+    return
+  }
+
+  // 7. If timingInfo is null, then return.
+  if (timingInfo === null) {
+    return
+  }
+
+  // 8. If response’s timing allow passed flag is not set, then:
+  if (!response.timingAllowPassed) {
+    //  1. Set timingInfo to a the result of creating an opaque timing info for timingInfo.
+    timingInfo = createOpaqueTimingInfo({
+      startTime: timingInfo.startTime
+    })
+
+    //  2. Set cacheState to the empty string.
+    cacheState = ''
+  }
+
+  // 9. Set timingInfo’s end time to the coarsened shared current time
+  // given global’s relevant settings object’s cross-origin isolated
+  // capability.
+  // TODO: given global’s relevant settings object’s cross-origin isolated
+  // capability?
+  timingInfo.endTime = coarsenedSharedCurrentTime()
+
+  // 10. Set response’s timing info to timingInfo.
+  response.timingInfo = timingInfo
+
+  // 11. Mark resource timing for timingInfo, originalURL, initiatorType,
+  // global, and cacheState.
+  markResourceTiming(
+    timingInfo,
+    originalURL.href,
+    initiatorType,
+    globalThis,
+    cacheState
+  )
+}
+
+// https://w3c.github.io/resource-timing/#dfn-mark-resource-timing
+const markResourceTiming = performance.markResourceTiming
+
+// https://fetch.spec.whatwg.org/#abort-fetch
+function abortFetch (p, request, responseObject, error) {
+  // 1. Reject promise with error.
+  if (p) {
+    // We might have already resolved the promise at this stage
+    p.reject(error)
+  }
+
+  // 2. If request’s body is not null and is readable, then cancel request’s
+  // body with error.
+  if (request.body != null && isReadable(request.body?.stream)) {
+    request.body.stream.cancel(error).catch((err) => {
+      if (err.code === 'ERR_INVALID_STATE') {
+        // Node bug?
+        return
+      }
+      throw err
+    })
+  }
+
+  // 3. If responseObject is null, then return.
+  if (responseObject == null) {
+    return
+  }
+
+  // 4. Let response be responseObject’s response.
+  const response = responseObject[kState]
+
+  // 5. If response’s body is not null and is readable, then error response’s
+  // body with error.
+  if (response.body != null && isReadable(response.body?.stream)) {
+    response.body.stream.cancel(error).catch((err) => {
+      if (err.code === 'ERR_INVALID_STATE') {
+        // Node bug?
+        return
+      }
+      throw err
+    })
+  }
+}
+
+// https://fetch.spec.whatwg.org/#fetching
+function fetching ({
+  request,
+  processRequestBodyChunkLength,
+  processRequestEndOfBody,
+  processResponse,
+  processResponseEndOfBody,
+  processResponseConsumeBody,
+  useParallelQueue = false,
+  dispatcher = getGlobalDispatcher() // undici
+}) {
+  // Ensure that the dispatcher is set accordingly
+  assert(dispatcher)
+
+  // 1. Let taskDestination be null.
+  let taskDestination = null
+
+  // 2. Let crossOriginIsolatedCapability be false.
+  let crossOriginIsolatedCapability = false
+
+  // 3. If request’s client is non-null, then:
+  if (request.client != null) {
+    // 1. Set taskDestination to request’s client’s global object.
+    taskDestination = request.client.globalObject
+
+    // 2. Set crossOriginIsolatedCapability to request’s client’s cross-origin
+    // isolated capability.
+    crossOriginIsolatedCapability =
+      request.client.crossOriginIsolatedCapability
+  }
+
+  // 4. If useParallelQueue is true, then set taskDestination to the result of
+  // starting a new parallel queue.
+  // TODO
+
+  // 5. Let timingInfo be a new fetch timing info whose start time and
+  // post-redirect start time are the coarsened shared current time given
+  // crossOriginIsolatedCapability.
+  const currentTime = coarsenedSharedCurrentTime(crossOriginIsolatedCapability)
+  const timingInfo = createOpaqueTimingInfo({
+    startTime: currentTime
+  })
+
+  // 6. Let fetchParams be a new fetch params whose
+  // request is request,
+  // timing info is timingInfo,
+  // process request body chunk length is processRequestBodyChunkLength,
+  // process request end-of-body is processRequestEndOfBody,
+  // process response is processResponse,
+  // process response consume body is processResponseConsumeBody,
+  // process response end-of-body is processResponseEndOfBody,
+  // task destination is taskDestination,
+  // and cross-origin isolated capability is crossOriginIsolatedCapability.
+  const fetchParams = {
+    controller: new Fetch(dispatcher),
+    request,
+    timingInfo,
+    processRequestBodyChunkLength,
+    processRequestEndOfBody,
+    processResponse,
+    processResponseConsumeBody,
+    processResponseEndOfBody,
+    taskDestination,
+    crossOriginIsolatedCapability
+  }
+
+  // 7. If request’s body is a byte sequence, then set request’s body to
+  //    request’s body as a body.
+  // NOTE: Since fetching is only called from fetch, body should already be
+  // extracted.
+  assert(!request.body || request.body.stream)
+
+  // 8. If request’s window is "client", then set request’s window to request’s
+  // client, if request’s client’s global object is a Window object; otherwise
+  // "no-window".
+  if (request.window === 'client') {
+    // TODO: What if request.client is null?
+    request.window =
+      request.client?.globalObject?.constructor?.name === 'Window'
+        ? request.client
+        : 'no-window'
+  }
+
+  // 9. If request’s origin is "client", then set request’s origin to request’s
+  // client’s origin.
+  if (request.origin === 'client') {
+    request.origin = request.client.origin
+  }
+
+  // 10. If all of the following conditions are true:
+  // TODO
+
+  // 11. If request’s policy container is "client", then:
+  if (request.policyContainer === 'client') {
+    // 1. If request’s client is non-null, then set request’s policy
+    // container to a clone of request’s client’s policy container. [HTML]
+    if (request.client != null) {
+      request.policyContainer = clonePolicyContainer(
+        request.client.policyContainer
+      )
+    } else {
+      // 2. Otherwise, set request’s policy container to a new policy
+      // container.
+      request.policyContainer = makePolicyContainer()
+    }
+  }
+
+  // 12. If request’s header list does not contain `Accept`, then:
+  if (!request.headersList.contains('accept', true)) {
+    // 1. Let value be `*/*`.
+    const value = '*/*'
+
+    // 2. A user agent should set value to the first matching statement, if
+    // any, switching on request’s destination:
+    // "document"
+    // "frame"
+    // "iframe"
+    // `text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8`
+    // "image"
+    // `image/png,image/svg+xml,image/*;q=0.8,*/*;q=0.5`
+    // "style"
+    // `text/css,*/*;q=0.1`
+    // TODO
+
+    // 3. Append `Accept`/value to request’s header list.
+    request.headersList.append('accept', value, true)
+  }
+
+  // 13. If request’s header list does not contain `Accept-Language`, then
+  // user agents should append `Accept-Language`/an appropriate value to
+  // request’s header list.
+  if (!request.headersList.contains('accept-language', true)) {
+    request.headersList.append('accept-language', '*', true)
+  }
+
+  // 14. If request’s priority is null, then use request’s initiator and
+  // destination appropriately in setting request’s priority to a
+  // user-agent-defined object.
+  if (request.priority === null) {
+    // TODO
+  }
+
+  // 15. If request is a subresource request, then:
+  if (subresourceSet.has(request.destination)) {
+    // TODO
+  }
+
+  // 16. Run main fetch given fetchParams.
+  mainFetch(fetchParams)
+    .catch(err => {
+      fetchParams.controller.terminate(err)
+    })
+
+  // 17. Return fetchParam's controller
+  return fetchParams.controller
+}
+
+// https://fetch.spec.whatwg.org/#concept-main-fetch
+async function mainFetch (fetchParams, recursive = false) {
+  // 1. Let request be fetchParams’s request.
+  const request = fetchParams.request
+
+  // 2. Let response be null.
+  let response = null
+
+  // 3. If request’s local-URLs-only flag is set and request’s current URL is
+  // not local, then set response to a network error.
+  if (request.localURLsOnly && !urlIsLocal(requestCurrentURL(request))) {
+    response = makeNetworkError('local URLs only')
+  }
+
+  // 4. Run report Content Security Policy violations for request.
+  // TODO
+
+  // 5. Upgrade request to a potentially trustworthy URL, if appropriate.
+  tryUpgradeRequestToAPotentiallyTrustworthyURL(request)
+
+  // 6. If should request be blocked due to a bad port, should fetching request
+  // be blocked as mixed content, or should request be blocked by Content
+  // Security Policy returns blocked, then set response to a network error.
+  if (requestBadPort(request) === 'blocked') {
+    response = makeNetworkError('bad port')
+  }
+  // TODO: should fetching request be blocked as mixed content?
+  // TODO: should request be blocked by Content Security Policy?
+
+  // 7. If request’s referrer policy is the empty string, then set request’s
+  // referrer policy to request’s policy container’s referrer policy.
+  if (request.referrerPolicy === '') {
+    request.referrerPolicy = request.policyContainer.referrerPolicy
+  }
+
+  // 8. If request’s referrer is not "no-referrer", then set request’s
+  // referrer to the result of invoking determine request’s referrer.
+  if (request.referrer !== 'no-referrer') {
+    request.referrer = determineRequestsReferrer(request)
+  }
+
+  // 9. Set request’s current URL’s scheme to "https" if all of the following
+  // conditions are true:
+  // - request’s current URL’s scheme is "http"
+  // - request’s current URL’s host is a domain
+  // - Matching request’s current URL’s host per Known HSTS Host Domain Name
+  //   Matching results in either a superdomain match with an asserted
+  //   includeSubDomains directive or a congruent match (with or without an
+  //   asserted includeSubDomains directive). [HSTS]
+  // TODO
+
+  // 10. If recursive is false, then run the remaining steps in parallel.
+  // TODO
+
+  // 11. If response is null, then set response to the result of running
+  // the steps corresponding to the first matching statement:
+  if (response === null) {
+    response = await (async () => {
+      const currentURL = requestCurrentURL(request)
+
+      if (
+        // - request’s current URL’s origin is same origin with request’s origin,
+        //   and request’s response tainting is "basic"
+        (sameOrigin(currentURL, request.url) && request.responseTainting === 'basic') ||
+        // request’s current URL’s scheme is "data"
+        (currentURL.protocol === 'data:') ||
+        // - request’s mode is "navigate" or "websocket"
+        (request.mode === 'navigate' || request.mode === 'websocket')
+      ) {
+        // 1. Set request’s response tainting to "basic".
+        request.responseTainting = 'basic'
+
+        // 2. Return the result of running scheme fetch given fetchParams.
+        return await schemeFetch(fetchParams)
+      }
+
+      // request’s mode is "same-origin"
+      if (request.mode === 'same-origin') {
+        // 1. Return a network error.
+        return makeNetworkError('request mode cannot be "same-origin"')
+      }
+
+      // request’s mode is "no-cors"
+      if (request.mode === 'no-cors') {
+        // 1. If request’s redirect mode is not "follow", then return a network
+        // error.
+        if (request.redirect !== 'follow') {
+          return makeNetworkError(
+            'redirect mode cannot be "follow" for "no-cors" request'
+          )
+        }
+
+        // 2. Set request’s response tainting to "opaque".
+        request.responseTainting = 'opaque'
+
+        // 3. Return the result of running scheme fetch given fetchParams.
+        return await schemeFetch(fetchParams)
+      }
+
+      // request’s current URL’s scheme is not an HTTP(S) scheme
+      if (!urlIsHttpHttpsScheme(requestCurrentURL(request))) {
+        // Return a network error.
+        return makeNetworkError('URL scheme must be a HTTP(S) scheme')
+      }
+
+      // - request’s use-CORS-preflight flag is set
+      // - request’s unsafe-request flag is set and either request’s method is
+      //   not a CORS-safelisted method or CORS-unsafe request-header names with
+      //   request’s header list is not empty
+      //    1. Set request’s response tainting to "cors".
+      //    2. Let corsWithPreflightResponse be the result of running HTTP fetch
+      //    given fetchParams and true.
+      //    3. If corsWithPreflightResponse is a network error, then clear cache
+      //    entries using request.
+      //    4. Return corsWithPreflightResponse.
+      // TODO
+
+      // Otherwise
+      //    1. Set request’s response tainting to "cors".
+      request.responseTainting = 'cors'
+
+      //    2. Return the result of running HTTP fetch given fetchParams.
+      return await httpFetch(fetchParams)
+    })()
+  }
+
+  // 12. If recursive is true, then return response.
+  if (recursive) {
+    return response
+  }
+
+  // 13. If response is not a network error and response is not a filtered
+  // response, then:
+  if (response.status !== 0 && !response.internalResponse) {
+    // If request’s response tainting is "cors", then:
+    if (request.responseTainting === 'cors') {
+      // 1. Let headerNames be the result of extracting header list values
+      // given `Access-Control-Expose-Headers` and response’s header list.
+      // TODO
+      // 2. If request’s credentials mode is not "include" and headerNames
+      // contains `*`, then set response’s CORS-exposed header-name list to
+      // all unique header names in response’s header list.
+      // TODO
+      // 3. Otherwise, if headerNames is not null or failure, then set
+      // response’s CORS-exposed header-name list to headerNames.
+      // TODO
+    }
+
+    // Set response to the following filtered response with response as its
+    // internal response, depending on request’s response tainting:
+    if (request.responseTainting === 'basic') {
+      response = filterResponse(response, 'basic')
+    } else if (request.responseTainting === 'cors') {
+      response = filterResponse(response, 'cors')
+    } else if (request.responseTainting === 'opaque') {
+      response = filterResponse(response, 'opaque')
+    } else {
+      assert(false)
+    }
+  }
+
+  // 14. Let internalResponse be response, if response is a network error,
+  // and response’s internal response otherwise.
+  let internalResponse =
+    response.status === 0 ? response : response.internalResponse
+
+  // 15. If internalResponse’s URL list is empty, then set it to a clone of
+  // request’s URL list.
+  if (internalResponse.urlList.length === 0) {
+    internalResponse.urlList.push(...request.urlList)
+  }
+
+  // 16. If request’s timing allow failed flag is unset, then set
+  // internalResponse’s timing allow passed flag.
+  if (!request.timingAllowFailed) {
+    response.timingAllowPassed = true
+  }
+
+  // 17. If response is not a network error and any of the following returns
+  // blocked
+  // - should internalResponse to request be blocked as mixed content
+  // - should internalResponse to request be blocked by Content Security Policy
+  // - should internalResponse to request be blocked due to its MIME type
+  // - should internalResponse to request be blocked due to nosniff
+  // TODO
+
+  // 18. If response’s type is "opaque", internalResponse’s status is 206,
+  // internalResponse’s range-requested flag is set, and request’s header
+  // list does not contain `Range`, then set response and internalResponse
+  // to a network error.
+  if (
+    response.type === 'opaque' &&
+    internalResponse.status === 206 &&
+    internalResponse.rangeRequested &&
+    !request.headers.contains('range', true)
+  ) {
+    response = internalResponse = makeNetworkError()
+  }
+
+  // 19. If response is not a network error and either request’s method is
+  // `HEAD` or `CONNECT`, or internalResponse’s status is a null body status,
+  // set internalResponse’s body to null and disregard any enqueuing toward
+  // it (if any).
+  if (
+    response.status !== 0 &&
+    (request.method === 'HEAD' ||
+      request.method === 'CONNECT' ||
+      nullBodyStatus.includes(internalResponse.status))
+  ) {
+    internalResponse.body = null
+    fetchParams.controller.dump = true
+  }
+
+  // 20. If request’s integrity metadata is not the empty string, then:
+  if (request.integrity) {
+    // 1. Let processBodyError be this step: run fetch finale given fetchParams
+    // and a network error.
+    const processBodyError = (reason) =>
+      fetchFinale(fetchParams, makeNetworkError(reason))
+
+    // 2. If request’s response tainting is "opaque", or response’s body is null,
+    // then run processBodyError and abort these steps.
+    if (request.responseTainting === 'opaque' || response.body == null) {
+      processBodyError(response.error)
+      return
+    }
+
+    // 3. Let processBody given bytes be these steps:
+    const processBody = (bytes) => {
+      // 1. If bytes do not match request’s integrity metadata,
+      // then run processBodyError and abort these steps. [SRI]
+      if (!bytesMatch(bytes, request.integrity)) {
+        processBodyError('integrity mismatch')
+        return
+      }
+
+      // 2. Set response’s body to bytes as a body.
+      response.body = safelyExtractBody(bytes)[0]
+
+      // 3. Run fetch finale given fetchParams and response.
+      fetchFinale(fetchParams, response)
+    }
+
+    // 4. Fully read response’s body given processBody and processBodyError.
+    await fullyReadBody(response.body, processBody, processBodyError)
+  } else {
+    // 21. Otherwise, run fetch finale given fetchParams and response.
+    fetchFinale(fetchParams, response)
+  }
+}
+
+// https://fetch.spec.whatwg.org/#concept-scheme-fetch
+// given a fetch params fetchParams
+function schemeFetch (fetchParams) {
+  // Note: since the connection is destroyed on redirect, which sets fetchParams to a
+  // cancelled state, we do not want this condition to trigger *unless* there have been
+  // no redirects. See https://github.com/nodejs/undici/issues/1776
+  // 1. If fetchParams is canceled, then return the appropriate network error for fetchParams.
+  if (isCancelled(fetchParams) && fetchParams.request.redirectCount === 0) {
+    return Promise.resolve(makeAppropriateNetworkError(fetchParams))
+  }
+
+  // 2. Let request be fetchParams’s request.
+  const { request } = fetchParams
+
+  const { protocol: scheme } = requestCurrentURL(request)
+
+  // 3. Switch on request’s current URL’s scheme and run the associated steps:
+  switch (scheme) {
+    case 'about:': {
+      // If request’s current URL’s path is the string "blank", then return a new response
+      // whose status message is `OK`, header list is « (`Content-Type`, `text/html;charset=utf-8`) »,
+      // and body is the empty byte sequence as a body.
+
+      // Otherwise, return a network error.
+      return Promise.resolve(makeNetworkError('about scheme is not supported'))
+    }
+    case 'blob:': {
+      if (!resolveObjectURL) {
+        resolveObjectURL = (__nccwpck_require__(72254).resolveObjectURL)
+      }
+
+      // 1. Let blobURLEntry be request’s current URL’s blob URL entry.
+      const blobURLEntry = requestCurrentURL(request)
+
+      // https://github.com/web-platform-tests/wpt/blob/7b0ebaccc62b566a1965396e5be7bb2bc06f841f/FileAPI/url/resources/fetch-tests.js#L52-L56
+      // Buffer.resolveObjectURL does not ignore URL queries.
+      if (blobURLEntry.search.length !== 0) {
+        return Promise.resolve(makeNetworkError('NetworkError when attempting to fetch resource.'))
+      }
+
+      const blob = resolveObjectURL(blobURLEntry.toString())
+
+      // 2. If request’s method is not `GET`, blobURLEntry is null, or blobURLEntry’s
+      //    object is not a Blob object, then return a network error.
+      if (request.method !== 'GET' || !isBlobLike(blob)) {
+        return Promise.resolve(makeNetworkError('invalid method'))
+      }
+
+      // 3. Let blob be blobURLEntry’s object.
+      // Note: done above
+
+      // 4. Let response be a new response.
+      const response = makeResponse()
+
+      // 5. Let fullLength be blob’s size.
+      const fullLength = blob.size
+
+      // 6. Let serializedFullLength be fullLength, serialized and isomorphic encoded.
+      const serializedFullLength = isomorphicEncode(`${fullLength}`)
+
+      // 7. Let type be blob’s type.
+      const type = blob.type
+
+      // 8. If request’s header list does not contain `Range`:
+      // 9. Otherwise:
+      if (!request.headersList.contains('range', true)) {
+        // 1. Let bodyWithType be the result of safely extracting blob.
+        // Note: in the FileAPI a blob "object" is a Blob *or* a MediaSource.
+        // In node, this can only ever be a Blob. Therefore we can safely
+        // use extractBody directly.
+        const bodyWithType = extractBody(blob)
+
+        // 2. Set response’s status message to `OK`.
+        response.statusText = 'OK'
+
+        // 3. Set response’s body to bodyWithType’s body.
+        response.body = bodyWithType[0]
+
+        // 4. Set response’s header list to « (`Content-Length`, serializedFullLength), (`Content-Type`, type) ».
+        response.headersList.set('content-length', serializedFullLength, true)
+        response.headersList.set('content-type', type, true)
+      } else {
+        // 1. Set response’s range-requested flag.
+        response.rangeRequested = true
+
+        // 2. Let rangeHeader be the result of getting `Range` from request’s header list.
+        const rangeHeader = request.headersList.get('range', true)
+
+        // 3. Let rangeValue be the result of parsing a single range header value given rangeHeader and true.
+        const rangeValue = simpleRangeHeaderValue(rangeHeader, true)
+
+        // 4. If rangeValue is failure, then return a network error.
+        if (rangeValue === 'failure') {
+          return Promise.resolve(makeNetworkError('failed to fetch the data URL'))
+        }
+
+        // 5. Let (rangeStart, rangeEnd) be rangeValue.
+        let { rangeStartValue: rangeStart, rangeEndValue: rangeEnd } = rangeValue
+
+        // 6. If rangeStart is null:
+        // 7. Otherwise:
+        if (rangeStart === null) {
+          // 1. Set rangeStart to fullLength − rangeEnd.
+          rangeStart = fullLength - rangeEnd
+
+          // 2. Set rangeEnd to rangeStart + rangeEnd − 1.
+          rangeEnd = rangeStart + rangeEnd - 1
+        } else {
+          // 1. If rangeStart is greater than or equal to fullLength, then return a network error.
+          if (rangeStart >= fullLength) {
+            return Promise.resolve(makeNetworkError('Range start is greater than the blob\'s size.'))
+          }
+
+          // 2. If rangeEnd is null or rangeEnd is greater than or equal to fullLength, then set
+          //    rangeEnd to fullLength − 1.
+          if (rangeEnd === null || rangeEnd >= fullLength) {
+            rangeEnd = fullLength - 1
+          }
+        }
+
+        // 8. Let slicedBlob be the result of invoking slice blob given blob, rangeStart,
+        //    rangeEnd + 1, and type.
+        const slicedBlob = blob.slice(rangeStart, rangeEnd, type)
+
+        // 9. Let slicedBodyWithType be the result of safely extracting slicedBlob.
+        // Note: same reason as mentioned above as to why we use extractBody
+        const slicedBodyWithType = extractBody(slicedBlob)
+
+        // 10. Set response’s body to slicedBodyWithType’s body.
+        response.body = slicedBodyWithType[0]
+
+        // 11. Let serializedSlicedLength be slicedBlob’s size, serialized and isomorphic encoded.
+        const serializedSlicedLength = isomorphicEncode(`${slicedBlob.size}`)
+
+        // 12. Let contentRange be the result of invoking build a content range given rangeStart,
+        //     rangeEnd, and fullLength.
+        const contentRange = buildContentRange(rangeStart, rangeEnd, fullLength)
+
+        // 13. Set response’s status to 206.
+        response.status = 206
+
+        // 14. Set response’s status message to `Partial Content`.
+        response.statusText = 'Partial Content'
+
+        // 15. Set response’s header list to « (`Content-Length`, serializedSlicedLength),
+        //     (`Content-Type`, type), (`Content-Range`, contentRange) ».
+        response.headersList.set('content-length', serializedSlicedLength, true)
+        response.headersList.set('content-type', type, true)
+        response.headersList.set('content-range', contentRange, true)
+      }
+
+      // 10. Return response.
+      return Promise.resolve(response)
+    }
+    case 'data:': {
+      // 1. Let dataURLStruct be the result of running the
+      //    data: URL processor on request’s current URL.
+      const currentURL = requestCurrentURL(request)
+      const dataURLStruct = dataURLProcessor(currentURL)
+
+      // 2. If dataURLStruct is failure, then return a
+      //    network error.
+      if (dataURLStruct === 'failure') {
+        return Promise.resolve(makeNetworkError('failed to fetch the data URL'))
+      }
+
+      // 3. Let mimeType be dataURLStruct’s MIME type, serialized.
+      const mimeType = serializeAMimeType(dataURLStruct.mimeType)
+
+      // 4. Return a response whose status message is `OK`,
+      //    header list is « (`Content-Type`, mimeType) »,
+      //    and body is dataURLStruct’s body as a body.
+      return Promise.resolve(makeResponse({
+        statusText: 'OK',
+        headersList: [
+          ['content-type', { name: 'Content-Type', value: mimeType }]
+        ],
+        body: safelyExtractBody(dataURLStruct.body)[0]
+      }))
+    }
+    case 'file:': {
+      // For now, unfortunate as it is, file URLs are left as an exercise for the reader.
+      // When in doubt, return a network error.
+      return Promise.resolve(makeNetworkError('not implemented... yet...'))
+    }
+    case 'http:':
+    case 'https:': {
+      // Return the result of running HTTP fetch given fetchParams.
+
+      return httpFetch(fetchParams)
+        .catch((err) => makeNetworkError(err))
+    }
+    default: {
+      return Promise.resolve(makeNetworkError('unknown scheme'))
+    }
+  }
+}
+
+// https://fetch.spec.whatwg.org/#finalize-response
+function finalizeResponse (fetchParams, response) {
+  // 1. Set fetchParams’s request’s done flag.
+  fetchParams.request.done = true
+
+  // 2, If fetchParams’s process response done is not null, then queue a fetch
+  // task to run fetchParams’s process response done given response, with
+  // fetchParams’s task destination.
+  if (fetchParams.processResponseDone != null) {
+    queueMicrotask(() => fetchParams.processResponseDone(response))
+  }
+}
+
+// https://fetch.spec.whatwg.org/#fetch-finale
+function fetchFinale (fetchParams, response) {
+  // 1. Let timingInfo be fetchParams’s timing info.
+  let timingInfo = fetchParams.timingInfo
+
+  // 2. If response is not a network error and fetchParams’s request’s client is a secure context,
+  //    then set timingInfo’s server-timing headers to the result of getting, decoding, and splitting
+  //    `Server-Timing` from response’s internal response’s header list.
+  // TODO
+
+  // 3. Let processResponseEndOfBody be the following steps:
+  const processResponseEndOfBody = () => {
+    // 1. Let unsafeEndTime be the unsafe shared current time.
+    const unsafeEndTime = Date.now() // ?
+
+    // 2. If fetchParams’s request’s destination is "document", then set fetchParams’s controller’s
+    //    full timing info to fetchParams’s timing info.
+    if (fetchParams.request.destination === 'document') {
+      fetchParams.controller.fullTimingInfo = timingInfo
+    }
+
+    // 3. Set fetchParams’s controller’s report timing steps to the following steps given a global object global:
+    fetchParams.controller.reportTimingSteps = () => {
+      // 1. If fetchParams’s request’s URL’s scheme is not an HTTP(S) scheme, then return.
+      if (fetchParams.request.url.protocol !== 'https:') {
+        return
+      }
+
+      // 2. Set timingInfo’s end time to the relative high resolution time given unsafeEndTime and global.
+      timingInfo.endTime = unsafeEndTime
+
+      // 3. Let cacheState be response’s cache state.
+      let cacheState = response.cacheState
+
+      // 4. Let bodyInfo be response’s body info.
+      const bodyInfo = response.bodyInfo
+
+      // 5. If response’s timing allow passed flag is not set, then set timingInfo to the result of creating an
+      //    opaque timing info for timingInfo and set cacheState to the empty string.
+      if (!response.timingAllowPassed) {
+        timingInfo = createOpaqueTimingInfo(timingInfo)
+
+        cacheState = ''
+      }
+
+      // 6. Let responseStatus be 0.
+      let responseStatus = 0
+
+      // 7. If fetchParams’s request’s mode is not "navigate" or response’s has-cross-origin-redirects is false:
+      if (fetchParams.request.mode !== 'navigator' || !response.hasCrossOriginRedirects) {
+        // 1. Set responseStatus to response’s status.
+        responseStatus = response.status
+
+        // 2. Let mimeType be the result of extracting a MIME type from response’s header list.
+        const mimeType = extractMimeType(response.headersList)
+
+        // 3. If mimeType is not failure, then set bodyInfo’s content type to the result of minimizing a supported MIME type given mimeType.
+        if (mimeType !== 'failure') {
+          bodyInfo.contentType = minimizeSupportedMimeType(mimeType)
+        }
+      }
+
+      // 8. If fetchParams’s request’s initiator type is non-null, then mark resource timing given timingInfo,
+      //    fetchParams’s request’s URL, fetchParams’s request’s initiator type, global, cacheState, bodyInfo,
+      //    and responseStatus.
+      if (fetchParams.request.initiatorType != null) {
+        // TODO: update markresourcetiming
+        markResourceTiming(timingInfo, fetchParams.request.url.href, fetchParams.request.initiatorType, globalThis, cacheState, bodyInfo, responseStatus)
+      }
+    }
+
+    // 4. Let processResponseEndOfBodyTask be the following steps:
+    const processResponseEndOfBodyTask = () => {
+      // 1. Set fetchParams’s request’s done flag.
+      fetchParams.request.done = true
+
+      // 2. If fetchParams’s process response end-of-body is non-null, then run fetchParams’s process
+      //    response end-of-body given response.
+      if (fetchParams.processResponseEndOfBody != null) {
+        queueMicrotask(() => fetchParams.processResponseEndOfBody(response))
+      }
+
+      // 3. If fetchParams’s request’s initiator type is non-null and fetchParams’s request’s client’s
+      //    global object is fetchParams’s task destination, then run fetchParams’s controller’s report
+      //    timing steps given fetchParams’s request’s client’s global object.
+      if (fetchParams.request.initiatorType != null) {
+        fetchParams.controller.reportTimingSteps()
+      }
+    }
+
+    // 5. Queue a fetch task to run processResponseEndOfBodyTask with fetchParams’s task destination
+    queueMicrotask(() => processResponseEndOfBodyTask())
+  }
+
+  // 4. If fetchParams’s process response is non-null, then queue a fetch task to run fetchParams’s
+  //    process response given response, with fetchParams’s task destination.
+  if (fetchParams.processResponse != null) {
+    queueMicrotask(() => {
+      fetchParams.processResponse(response)
+      fetchParams.processResponse = null
+    })
+  }
+
+  // 5. Let internalResponse be response, if response is a network error; otherwise response’s internal response.
+  const internalResponse = response.type === 'error' ? response : (response.internalResponse ?? response)
+
+  // 6. If internalResponse’s body is null, then run processResponseEndOfBody.
+  // 7. Otherwise:
+  if (internalResponse.body == null) {
+    processResponseEndOfBody()
+  } else {
+    // mcollina: all the following steps of the specs are skipped.
+    // The internal transform stream is not needed.
+    // See https://github.com/nodejs/undici/pull/3093#issuecomment-2050198541
+
+    // 1. Let transformStream be a new TransformStream.
+    // 2. Let identityTransformAlgorithm be an algorithm which, given chunk, enqueues chunk in transformStream.
+    // 3. Set up transformStream with transformAlgorithm set to identityTransformAlgorithm and flushAlgorithm
+    //    set to processResponseEndOfBody.
+    // 4. Set internalResponse’s body’s stream to the result of internalResponse’s body’s stream piped through transformStream.
+
+    finished(internalResponse.body.stream, () => {
+      processResponseEndOfBody()
+    })
+  }
+}
+
+// https://fetch.spec.whatwg.org/#http-fetch
+async function httpFetch (fetchParams) {
+  // 1. Let request be fetchParams’s request.
+  const request = fetchParams.request
+
+  // 2. Let response be null.
+  let response = null
+
+  // 3. Let actualResponse be null.
+  let actualResponse = null
+
+  // 4. Let timingInfo be fetchParams’s timing info.
+  const timingInfo = fetchParams.timingInfo
+
+  // 5. If request’s service-workers mode is "all", then:
+  if (request.serviceWorkers === 'all') {
+    // TODO
+  }
+
+  // 6. If response is null, then:
+  if (response === null) {
+    // 1. If makeCORSPreflight is true and one of these conditions is true:
+    // TODO
+
+    // 2. If request’s redirect mode is "follow", then set request’s
+    // service-workers mode to "none".
+    if (request.redirect === 'follow') {
+      request.serviceWorkers = 'none'
+    }
+
+    // 3. Set response and actualResponse to the result of running
+    // HTTP-network-or-cache fetch given fetchParams.
+    actualResponse = response = await httpNetworkOrCacheFetch(fetchParams)
+
+    // 4. If request’s response tainting is "cors" and a CORS check
+    // for request and response returns failure, then return a network error.
+    if (
+      request.responseTainting === 'cors' &&
+      corsCheck(request, response) === 'failure'
+    ) {
+      return makeNetworkError('cors failure')
+    }
+
+    // 5. If the TAO check for request and response returns failure, then set
+    // request’s timing allow failed flag.
+    if (TAOCheck(request, response) === 'failure') {
+      request.timingAllowFailed = true
+    }
+  }
+
+  // 7. If either request’s response tainting or response’s type
+  // is "opaque", and the cross-origin resource policy check with
+  // request’s origin, request’s client, request’s destination,
+  // and actualResponse returns blocked, then return a network error.
+  if (
+    (request.responseTainting === 'opaque' || response.type === 'opaque') &&
+    crossOriginResourcePolicyCheck(
+      request.origin,
+      request.client,
+      request.destination,
+      actualResponse
+    ) === 'blocked'
+  ) {
+    return makeNetworkError('blocked')
+  }
+
+  // 8. If actualResponse’s status is a redirect status, then:
+  if (redirectStatusSet.has(actualResponse.status)) {
+    // 1. If actualResponse’s status is not 303, request’s body is not null,
+    // and the connection uses HTTP/2, then user agents may, and are even
+    // encouraged to, transmit an RST_STREAM frame.
+    // See, https://github.com/whatwg/fetch/issues/1288
+    if (request.redirect !== 'manual') {
+      fetchParams.controller.connection.destroy(undefined, false)
+    }
+
+    // 2. Switch on request’s redirect mode:
+    if (request.redirect === 'error') {
+      // Set response to a network error.
+      response = makeNetworkError('unexpected redirect')
+    } else if (request.redirect === 'manual') {
+      // Set response to an opaque-redirect filtered response whose internal
+      // response is actualResponse.
+      // NOTE(spec): On the web this would return an `opaqueredirect` response,
+      // but that doesn't make sense server side.
+      // See https://github.com/nodejs/undici/issues/1193.
+      response = actualResponse
+    } else if (request.redirect === 'follow') {
+      // Set response to the result of running HTTP-redirect fetch given
+      // fetchParams and response.
+      response = await httpRedirectFetch(fetchParams, response)
+    } else {
+      assert(false)
+    }
+  }
+
+  // 9. Set response’s timing info to timingInfo.
+  response.timingInfo = timingInfo
+
+  // 10. Return response.
+  return response
+}
+
+// https://fetch.spec.whatwg.org/#http-redirect-fetch
+function httpRedirectFetch (fetchParams, response) {
+  // 1. Let request be fetchParams’s request.
+  const request = fetchParams.request
+
+  // 2. Let actualResponse be response, if response is not a filtered response,
+  // and response’s internal response otherwise.
+  const actualResponse = response.internalResponse
+    ? response.internalResponse
+    : response
+
+  // 3. Let locationURL be actualResponse’s location URL given request’s current
+  // URL’s fragment.
+  let locationURL
+
+  try {
+    locationURL = responseLocationURL(
+      actualResponse,
+      requestCurrentURL(request).hash
+    )
+
+    // 4. If locationURL is null, then return response.
+    if (locationURL == null) {
+      return response
+    }
+  } catch (err) {
+    // 5. If locationURL is failure, then return a network error.
+    return Promise.resolve(makeNetworkError(err))
+  }
+
+  // 6. If locationURL’s scheme is not an HTTP(S) scheme, then return a network
+  // error.
+  if (!urlIsHttpHttpsScheme(locationURL)) {
+    return Promise.resolve(makeNetworkError('URL scheme must be a HTTP(S) scheme'))
+  }
+
+  // 7. If request’s redirect count is 20, then return a network error.
+  if (request.redirectCount === 20) {
+    return Promise.resolve(makeNetworkError('redirect count exceeded'))
+  }
+
+  // 8. Increase request’s redirect count by 1.
+  request.redirectCount += 1
+
+  // 9. If request’s mode is "cors", locationURL includes credentials, and
+  // request’s origin is not same origin with locationURL’s origin, then return
+  //  a network error.
+  if (
+    request.mode === 'cors' &&
+    (locationURL.username || locationURL.password) &&
+    !sameOrigin(request, locationURL)
+  ) {
+    return Promise.resolve(makeNetworkError('cross origin not allowed for request mode "cors"'))
+  }
+
+  // 10. If request’s response tainting is "cors" and locationURL includes
+  // credentials, then return a network error.
+  if (
+    request.responseTainting === 'cors' &&
+    (locationURL.username || locationURL.password)
+  ) {
+    return Promise.resolve(makeNetworkError(
+      'URL cannot contain credentials for request mode "cors"'
+    ))
+  }
+
+  // 11. If actualResponse’s status is not 303, request’s body is non-null,
+  // and request’s body’s source is null, then return a network error.
+  if (
+    actualResponse.status !== 303 &&
+    request.body != null &&
+    request.body.source == null
+  ) {
+    return Promise.resolve(makeNetworkError())
+  }
+
+  // 12. If one of the following is true
+  // - actualResponse’s status is 301 or 302 and request’s method is `POST`
+  // - actualResponse’s status is 303 and request’s method is not `GET` or `HEAD`
+  if (
+    ([301, 302].includes(actualResponse.status) && request.method === 'POST') ||
+    (actualResponse.status === 303 &&
+      !GET_OR_HEAD.includes(request.method))
+  ) {
+    // then:
+    // 1. Set request’s method to `GET` and request’s body to null.
+    request.method = 'GET'
+    request.body = null
+
+    // 2. For each headerName of request-body-header name, delete headerName from
+    // request’s header list.
+    for (const headerName of requestBodyHeader) {
+      request.headersList.delete(headerName)
+    }
+  }
+
+  // 13. If request’s current URL’s origin is not same origin with locationURL’s
+  //     origin, then for each headerName of CORS non-wildcard request-header name,
+  //     delete headerName from request’s header list.
+  if (!sameOrigin(requestCurrentURL(request), locationURL)) {
+    // https://fetch.spec.whatwg.org/#cors-non-wildcard-request-header-name
+    request.headersList.delete('authorization', true)
+
+    // https://fetch.spec.whatwg.org/#authentication-entries
+    request.headersList.delete('proxy-authorization', true)
+
+    // "Cookie" and "Host" are forbidden request-headers, which undici doesn't implement.
+    request.headersList.delete('cookie', true)
+    request.headersList.delete('host', true)
+  }
+
+  // 14. If request’s body is non-null, then set request’s body to the first return
+  // value of safely extracting request’s body’s source.
+  if (request.body != null) {
+    assert(request.body.source != null)
+    request.body = safelyExtractBody(request.body.source)[0]
+  }
+
+  // 15. Let timingInfo be fetchParams’s timing info.
+  const timingInfo = fetchParams.timingInfo
+
+  // 16. Set timingInfo’s redirect end time and post-redirect start time to the
+  // coarsened shared current time given fetchParams’s cross-origin isolated
+  // capability.
+  timingInfo.redirectEndTime = timingInfo.postRedirectStartTime =
+    coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability)
+
+  // 17. If timingInfo’s redirect start time is 0, then set timingInfo’s
+  //  redirect start time to timingInfo’s start time.
+  if (timingInfo.redirectStartTime === 0) {
+    timingInfo.redirectStartTime = timingInfo.startTime
+  }
+
+  // 18. Append locationURL to request’s URL list.
+  request.urlList.push(locationURL)
+
+  // 19. Invoke set request’s referrer policy on redirect on request and
+  // actualResponse.
+  setRequestReferrerPolicyOnRedirect(request, actualResponse)
+
+  // 20. Return the result of running main fetch given fetchParams and true.
+  return mainFetch(fetchParams, true)
+}
+
+// https://fetch.spec.whatwg.org/#http-network-or-cache-fetch
+async function httpNetworkOrCacheFetch (
+  fetchParams,
+  isAuthenticationFetch = false,
+  isNewConnectionFetch = false
+) {
+  // 1. Let request be fetchParams’s request.
+  const request = fetchParams.request
+
+  // 2. Let httpFetchParams be null.
+  let httpFetchParams = null
+
+  // 3. Let httpRequest be null.
+  let httpRequest = null
+
+  // 4. Let response be null.
+  let response = null
+
+  // 5. Let storedResponse be null.
+  // TODO: cache
+
+  // 6. Let httpCache be null.
+  const httpCache = null
+
+  // 7. Let the revalidatingFlag be unset.
+  const revalidatingFlag = false
+
+  // 8. Run these steps, but abort when the ongoing fetch is terminated:
+
+  //    1. If request’s window is "no-window" and request’s redirect mode is
+  //    "error", then set httpFetchParams to fetchParams and httpRequest to
+  //    request.
+  if (request.window === 'no-window' && request.redirect === 'error') {
+    httpFetchParams = fetchParams
+    httpRequest = request
+  } else {
+    // Otherwise:
+
+    // 1. Set httpRequest to a clone of request.
+    httpRequest = cloneRequest(request)
+
+    // 2. Set httpFetchParams to a copy of fetchParams.
+    httpFetchParams = { ...fetchParams }
+
+    // 3. Set httpFetchParams’s request to httpRequest.
+    httpFetchParams.request = httpRequest
+  }
+
+  //    3. Let includeCredentials be true if one of
+  const includeCredentials =
+    request.credentials === 'include' ||
+    (request.credentials === 'same-origin' &&
+      request.responseTainting === 'basic')
+
+  //    4. Let contentLength be httpRequest’s body’s length, if httpRequest’s
+  //    body is non-null; otherwise null.
+  const contentLength = httpRequest.body ? httpRequest.body.length : null
+
+  //    5. Let contentLengthHeaderValue be null.
+  let contentLengthHeaderValue = null
+
+  //    6. If httpRequest’s body is null and httpRequest’s method is `POST` or
+  //    `PUT`, then set contentLengthHeaderValue to `0`.
+  if (
+    httpRequest.body == null &&
+    ['POST', 'PUT'].includes(httpRequest.method)
+  ) {
+    contentLengthHeaderValue = '0'
+  }
+
+  //    7. If contentLength is non-null, then set contentLengthHeaderValue to
+  //    contentLength, serialized and isomorphic encoded.
+  if (contentLength != null) {
+    contentLengthHeaderValue = isomorphicEncode(`${contentLength}`)
+  }
+
+  //    8. If contentLengthHeaderValue is non-null, then append
+  //    `Content-Length`/contentLengthHeaderValue to httpRequest’s header
+  //    list.
+  if (contentLengthHeaderValue != null) {
+    httpRequest.headersList.append('content-length', contentLengthHeaderValue, true)
+  }
+
+  //    9. If contentLengthHeaderValue is non-null, then append (`Content-Length`,
+  //    contentLengthHeaderValue) to httpRequest’s header list.
+
+  //    10. If contentLength is non-null and httpRequest’s keepalive is true,
+  //    then:
+  if (contentLength != null && httpRequest.keepalive) {
+    // NOTE: keepalive is a noop outside of browser context.
+  }
+
+  //    11. If httpRequest’s referrer is a URL, then append
+  //    `Referer`/httpRequest’s referrer, serialized and isomorphic encoded,
+  //     to httpRequest’s header list.
+  if (httpRequest.referrer instanceof URL) {
+    httpRequest.headersList.append('referer', isomorphicEncode(httpRequest.referrer.href), true)
+  }
+
+  //    12. Append a request `Origin` header for httpRequest.
+  appendRequestOriginHeader(httpRequest)
+
+  //    13. Append the Fetch metadata headers for httpRequest. [FETCH-METADATA]
+  appendFetchMetadata(httpRequest)
+
+  //    14. If httpRequest’s header list does not contain `User-Agent`, then
+  //    user agents should append `User-Agent`/default `User-Agent` value to
+  //    httpRequest’s header list.
+  if (!httpRequest.headersList.contains('user-agent', true)) {
+    httpRequest.headersList.append('user-agent', defaultUserAgent)
+  }
+
+  //    15. If httpRequest’s cache mode is "default" and httpRequest’s header
+  //    list contains `If-Modified-Since`, `If-None-Match`,
+  //    `If-Unmodified-Since`, `If-Match`, or `If-Range`, then set
+  //    httpRequest’s cache mode to "no-store".
+  if (
+    httpRequest.cache === 'default' &&
+    (httpRequest.headersList.contains('if-modified-since', true) ||
+      httpRequest.headersList.contains('if-none-match', true) ||
+      httpRequest.headersList.contains('if-unmodified-since', true) ||
+      httpRequest.headersList.contains('if-match', true) ||
+      httpRequest.headersList.contains('if-range', true))
+  ) {
+    httpRequest.cache = 'no-store'
+  }
+
+  //    16. If httpRequest’s cache mode is "no-cache", httpRequest’s prevent
+  //    no-cache cache-control header modification flag is unset, and
+  //    httpRequest’s header list does not contain `Cache-Control`, then append
+  //    `Cache-Control`/`max-age=0` to httpRequest’s header list.
+  if (
+    httpRequest.cache === 'no-cache' &&
+    !httpRequest.preventNoCacheCacheControlHeaderModification &&
+    !httpRequest.headersList.contains('cache-control', true)
+  ) {
+    httpRequest.headersList.append('cache-control', 'max-age=0', true)
+  }
+
+  //    17. If httpRequest’s cache mode is "no-store" or "reload", then:
+  if (httpRequest.cache === 'no-store' || httpRequest.cache === 'reload') {
+    // 1. If httpRequest’s header list does not contain `Pragma`, then append
+    // `Pragma`/`no-cache` to httpRequest’s header list.
+    if (!httpRequest.headersList.contains('pragma', true)) {
+      httpRequest.headersList.append('pragma', 'no-cache', true)
+    }
+
+    // 2. If httpRequest’s header list does not contain `Cache-Control`,
+    // then append `Cache-Control`/`no-cache` to httpRequest’s header list.
+    if (!httpRequest.headersList.contains('cache-control', true)) {
+      httpRequest.headersList.append('cache-control', 'no-cache', true)
+    }
+  }
+
+  //    18. If httpRequest’s header list contains `Range`, then append
+  //    `Accept-Encoding`/`identity` to httpRequest’s header list.
+  if (httpRequest.headersList.contains('range', true)) {
+    httpRequest.headersList.append('accept-encoding', 'identity', true)
+  }
+
+  //    19. Modify httpRequest’s header list per HTTP. Do not append a given
+  //    header if httpRequest’s header list contains that header’s name.
+  //    TODO: https://github.com/whatwg/fetch/issues/1285#issuecomment-896560129
+  if (!httpRequest.headersList.contains('accept-encoding', true)) {
+    if (urlHasHttpsScheme(requestCurrentURL(httpRequest))) {
+      httpRequest.headersList.append('accept-encoding', 'br, gzip, deflate', true)
+    } else {
+      httpRequest.headersList.append('accept-encoding', 'gzip, deflate', true)
+    }
+  }
+
+  httpRequest.headersList.delete('host', true)
+
+  //    20. If includeCredentials is true, then:
+  if (includeCredentials) {
+    // 1. If the user agent is not configured to block cookies for httpRequest
+    // (see section 7 of [COOKIES]), then:
+    // TODO: credentials
+    // 2. If httpRequest’s header list does not contain `Authorization`, then:
+    // TODO: credentials
+  }
+
+  //    21. If there’s a proxy-authentication entry, use it as appropriate.
+  //    TODO: proxy-authentication
+
+  //    22. Set httpCache to the result of determining the HTTP cache
+  //    partition, given httpRequest.
+  //    TODO: cache
+
+  //    23. If httpCache is null, then set httpRequest’s cache mode to
+  //    "no-store".
+  if (httpCache == null) {
+    httpRequest.cache = 'no-store'
+  }
+
+  //    24. If httpRequest’s cache mode is neither "no-store" nor "reload",
+  //    then:
+  if (httpRequest.cache !== 'no-store' && httpRequest.cache !== 'reload') {
+    // TODO: cache
+  }
+
+  // 9. If aborted, then return the appropriate network error for fetchParams.
+  // TODO
+
+  // 10. If response is null, then:
+  if (response == null) {
+    // 1. If httpRequest’s cache mode is "only-if-cached", then return a
+    // network error.
+    if (httpRequest.cache === 'only-if-cached') {
+      return makeNetworkError('only if cached')
+    }
+
+    // 2. Let forwardResponse be the result of running HTTP-network fetch
+    // given httpFetchParams, includeCredentials, and isNewConnectionFetch.
+    const forwardResponse = await httpNetworkFetch(
+      httpFetchParams,
+      includeCredentials,
+      isNewConnectionFetch
+    )
+
+    // 3. If httpRequest’s method is unsafe and forwardResponse’s status is
+    // in the range 200 to 399, inclusive, invalidate appropriate stored
+    // responses in httpCache, as per the "Invalidation" chapter of HTTP
+    // Caching, and set storedResponse to null. [HTTP-CACHING]
+    if (
+      !safeMethodsSet.has(httpRequest.method) &&
+      forwardResponse.status >= 200 &&
+      forwardResponse.status <= 399
+    ) {
+      // TODO: cache
+    }
+
+    // 4. If the revalidatingFlag is set and forwardResponse’s status is 304,
+    // then:
+    if (revalidatingFlag && forwardResponse.status === 304) {
+      // TODO: cache
+    }
+
+    // 5. If response is null, then:
+    if (response == null) {
+      // 1. Set response to forwardResponse.
+      response = forwardResponse
+
+      // 2. Store httpRequest and forwardResponse in httpCache, as per the
+      // "Storing Responses in Caches" chapter of HTTP Caching. [HTTP-CACHING]
+      // TODO: cache
+    }
+  }
+
+  // 11. Set response’s URL list to a clone of httpRequest’s URL list.
+  response.urlList = [...httpRequest.urlList]
+
+  // 12. If httpRequest’s header list contains `Range`, then set response’s
+  // range-requested flag.
+  if (httpRequest.headersList.contains('range', true)) {
+    response.rangeRequested = true
+  }
+
+  // 13. Set response’s request-includes-credentials to includeCredentials.
+  response.requestIncludesCredentials = includeCredentials
+
+  // 14. If response’s status is 401, httpRequest’s response tainting is not
+  // "cors", includeCredentials is true, and request’s window is an environment
+  // settings object, then:
+  // TODO
+
+  // 15. If response’s status is 407, then:
+  if (response.status === 407) {
+    // 1. If request’s window is "no-window", then return a network error.
+    if (request.window === 'no-window') {
+      return makeNetworkError()
+    }
+
+    // 2. ???
+
+    // 3. If fetchParams is canceled, then return the appropriate network error for fetchParams.
+    if (isCancelled(fetchParams)) {
+      return makeAppropriateNetworkError(fetchParams)
+    }
+
+    // 4. Prompt the end user as appropriate in request’s window and store
+    // the result as a proxy-authentication entry. [HTTP-AUTH]
+    // TODO: Invoke some kind of callback?
+
+    // 5. Set response to the result of running HTTP-network-or-cache fetch given
+    // fetchParams.
+    // TODO
+    return makeNetworkError('proxy authentication required')
+  }
+
+  // 16. If all of the following are true
+  if (
+    // response’s status is 421
+    response.status === 421 &&
+    // isNewConnectionFetch is false
+    !isNewConnectionFetch &&
+    // request’s body is null, or request’s body is non-null and request’s body’s source is non-null
+    (request.body == null || request.body.source != null)
+  ) {
+    // then:
+
+    // 1. If fetchParams is canceled, then return the appropriate network error for fetchParams.
+    if (isCancelled(fetchParams)) {
+      return makeAppropriateNetworkError(fetchParams)
+    }
+
+    // 2. Set response to the result of running HTTP-network-or-cache
+    // fetch given fetchParams, isAuthenticationFetch, and true.
+
+    // TODO (spec): The spec doesn't specify this but we need to cancel
+    // the active response before we can start a new one.
+    // https://github.com/whatwg/fetch/issues/1293
+    fetchParams.controller.connection.destroy()
+
+    response = await httpNetworkOrCacheFetch(
+      fetchParams,
+      isAuthenticationFetch,
+      true
+    )
+  }
+
+  // 17. If isAuthenticationFetch is true, then create an authentication entry
+  if (isAuthenticationFetch) {
+    // TODO
+  }
+
+  // 18. Return response.
+  return response
+}
+
+// https://fetch.spec.whatwg.org/#http-network-fetch
+async function httpNetworkFetch (
+  fetchParams,
+  includeCredentials = false,
+  forceNewConnection = false
+) {
+  assert(!fetchParams.controller.connection || fetchParams.controller.connection.destroyed)
+
+  fetchParams.controller.connection = {
+    abort: null,
+    destroyed: false,
+    destroy (err, abort = true) {
+      if (!this.destroyed) {
+        this.destroyed = true
+        if (abort) {
+          this.abort?.(err ?? new DOMException('The operation was aborted.', 'AbortError'))
+        }
+      }
+    }
+  }
+
+  // 1. Let request be fetchParams’s request.
+  const request = fetchParams.request
+
+  // 2. Let response be null.
+  let response = null
+
+  // 3. Let timingInfo be fetchParams’s timing info.
+  const timingInfo = fetchParams.timingInfo
+
+  // 4. Let httpCache be the result of determining the HTTP cache partition,
+  // given request.
+  // TODO: cache
+  const httpCache = null
+
+  // 5. If httpCache is null, then set request’s cache mode to "no-store".
+  if (httpCache == null) {
+    request.cache = 'no-store'
+  }
+
+  // 6. Let networkPartitionKey be the result of determining the network
+  // partition key given request.
+  // TODO
+
+  // 7. Let newConnection be "yes" if forceNewConnection is true; otherwise
+  // "no".
+  const newConnection = forceNewConnection ? 'yes' : 'no' // eslint-disable-line no-unused-vars
+
+  // 8. Switch on request’s mode:
+  if (request.mode === 'websocket') {
+    // Let connection be the result of obtaining a WebSocket connection,
+    // given request’s current URL.
+    // TODO
+  } else {
+    // Let connection be the result of obtaining a connection, given
+    // networkPartitionKey, request’s current URL’s origin,
+    // includeCredentials, and forceNewConnection.
+    // TODO
+  }
+
+  // 9. Run these steps, but abort when the ongoing fetch is terminated:
+
+  //    1. If connection is failure, then return a network error.
+
+  //    2. Set timingInfo’s final connection timing info to the result of
+  //    calling clamp and coarsen connection timing info with connection’s
+  //    timing info, timingInfo’s post-redirect start time, and fetchParams’s
+  //    cross-origin isolated capability.
+
+  //    3. If connection is not an HTTP/2 connection, request’s body is non-null,
+  //    and request’s body’s source is null, then append (`Transfer-Encoding`,
+  //    `chunked`) to request’s header list.
+
+  //    4. Set timingInfo’s final network-request start time to the coarsened
+  //    shared current time given fetchParams’s cross-origin isolated
+  //    capability.
+
+  //    5. Set response to the result of making an HTTP request over connection
+  //    using request with the following caveats:
+
+  //        - Follow the relevant requirements from HTTP. [HTTP] [HTTP-SEMANTICS]
+  //        [HTTP-COND] [HTTP-CACHING] [HTTP-AUTH]
+
+  //        - If request’s body is non-null, and request’s body’s source is null,
+  //        then the user agent may have a buffer of up to 64 kibibytes and store
+  //        a part of request’s body in that buffer. If the user agent reads from
+  //        request’s body beyond that buffer’s size and the user agent needs to
+  //        resend request, then instead return a network error.
+
+  //        - Set timingInfo’s final network-response start time to the coarsened
+  //        shared current time given fetchParams’s cross-origin isolated capability,
+  //        immediately after the user agent’s HTTP parser receives the first byte
+  //        of the response (e.g., frame header bytes for HTTP/2 or response status
+  //        line for HTTP/1.x).
+
+  //        - Wait until all the headers are transmitted.
+
+  //        - Any responses whose status is in the range 100 to 199, inclusive,
+  //        and is not 101, are to be ignored, except for the purposes of setting
+  //        timingInfo’s final network-response start time above.
+
+  //    - If request’s header list contains `Transfer-Encoding`/`chunked` and
+  //    response is transferred via HTTP/1.0 or older, then return a network
+  //    error.
+
+  //    - If the HTTP request results in a TLS client certificate dialog, then:
+
+  //        1. If request’s window is an environment settings object, make the
+  //        dialog available in request’s window.
+
+  //        2. Otherwise, return a network error.
+
+  // To transmit request’s body body, run these steps:
+  let requestBody = null
+  // 1. If body is null and fetchParams’s process request end-of-body is
+  // non-null, then queue a fetch task given fetchParams’s process request
+  // end-of-body and fetchParams’s task destination.
+  if (request.body == null && fetchParams.processRequestEndOfBody) {
+    queueMicrotask(() => fetchParams.processRequestEndOfBody())
+  } else if (request.body != null) {
+    // 2. Otherwise, if body is non-null:
+
+    //    1. Let processBodyChunk given bytes be these steps:
+    const processBodyChunk = async function * (bytes) {
+      // 1. If the ongoing fetch is terminated, then abort these steps.
+      if (isCancelled(fetchParams)) {
+        return
+      }
+
+      // 2. Run this step in parallel: transmit bytes.
+      yield bytes
+
+      // 3. If fetchParams’s process request body is non-null, then run
+      // fetchParams’s process request body given bytes’s length.
+      fetchParams.processRequestBodyChunkLength?.(bytes.byteLength)
+    }
+
+    // 2. Let processEndOfBody be these steps:
+    const processEndOfBody = () => {
+      // 1. If fetchParams is canceled, then abort these steps.
+      if (isCancelled(fetchParams)) {
+        return
+      }
+
+      // 2. If fetchParams’s process request end-of-body is non-null,
+      // then run fetchParams’s process request end-of-body.
+      if (fetchParams.processRequestEndOfBody) {
+        fetchParams.processRequestEndOfBody()
+      }
+    }
+
+    // 3. Let processBodyError given e be these steps:
+    const processBodyError = (e) => {
+      // 1. If fetchParams is canceled, then abort these steps.
+      if (isCancelled(fetchParams)) {
+        return
+      }
+
+      // 2. If e is an "AbortError" DOMException, then abort fetchParams’s controller.
+      if (e.name === 'AbortError') {
+        fetchParams.controller.abort()
+      } else {
+        fetchParams.controller.terminate(e)
+      }
+    }
+
+    // 4. Incrementally read request’s body given processBodyChunk, processEndOfBody,
+    // processBodyError, and fetchParams’s task destination.
+    requestBody = (async function * () {
+      try {
+        for await (const bytes of request.body.stream) {
+          yield * processBodyChunk(bytes)
+        }
+        processEndOfBody()
+      } catch (err) {
+        processBodyError(err)
+      }
+    })()
+  }
+
+  try {
+    // socket is only provided for websockets
+    const { body, status, statusText, headersList, socket } = await dispatch({ body: requestBody })
+
+    if (socket) {
+      response = makeResponse({ status, statusText, headersList, socket })
+    } else {
+      const iterator = body[Symbol.asyncIterator]()
+      fetchParams.controller.next = () => iterator.next()
+
+      response = makeResponse({ status, statusText, headersList })
+    }
+  } catch (err) {
+    // 10. If aborted, then:
+    if (err.name === 'AbortError') {
+      // 1. If connection uses HTTP/2, then transmit an RST_STREAM frame.
+      fetchParams.controller.connection.destroy()
+
+      // 2. Return the appropriate network error for fetchParams.
+      return makeAppropriateNetworkError(fetchParams, err)
+    }
+
+    return makeNetworkError(err)
+  }
+
+  // 11. Let pullAlgorithm be an action that resumes the ongoing fetch
+  // if it is suspended.
+  const pullAlgorithm = async () => {
+    await fetchParams.controller.resume()
+  }
+
+  // 12. Let cancelAlgorithm be an algorithm that aborts fetchParams’s
+  // controller with reason, given reason.
+  const cancelAlgorithm = (reason) => {
+    // If the aborted fetch was already terminated, then we do not
+    // need to do anything.
+    if (!isCancelled(fetchParams)) {
+      fetchParams.controller.abort(reason)
+    }
+  }
+
+  // 13. Let highWaterMark be a non-negative, non-NaN number, chosen by
+  // the user agent.
+  // TODO
+
+  // 14. Let sizeAlgorithm be an algorithm that accepts a chunk object
+  // and returns a non-negative, non-NaN, non-infinite number, chosen by the user agent.
+  // TODO
+
+  // 15. Let stream be a new ReadableStream.
+  // 16. Set up stream with byte reading support with pullAlgorithm set to pullAlgorithm,
+  //     cancelAlgorithm set to cancelAlgorithm.
+  const stream = new ReadableStream(
+    {
+      async start (controller) {
+        fetchParams.controller.controller = controller
+      },
+      async pull (controller) {
+        await pullAlgorithm(controller)
+      },
+      async cancel (reason) {
+        await cancelAlgorithm(reason)
+      },
+      type: 'bytes'
+    }
+  )
+
+  // 17. Run these steps, but abort when the ongoing fetch is terminated:
+
+  //    1. Set response’s body to a new body whose stream is stream.
+  response.body = { stream, source: null, length: null }
+
+  //    2. If response is not a network error and request’s cache mode is
+  //    not "no-store", then update response in httpCache for request.
+  //    TODO
+
+  //    3. If includeCredentials is true and the user agent is not configured
+  //    to block cookies for request (see section 7 of [COOKIES]), then run the
+  //    "set-cookie-string" parsing algorithm (see section 5.2 of [COOKIES]) on
+  //    the value of each header whose name is a byte-case-insensitive match for
+  //    `Set-Cookie` in response’s header list, if any, and request’s current URL.
+  //    TODO
+
+  // 18. If aborted, then:
+  // TODO
+
+  // 19. Run these steps in parallel:
+
+  //    1. Run these steps, but abort when fetchParams is canceled:
+  fetchParams.controller.onAborted = onAborted
+  fetchParams.controller.on('terminated', onAborted)
+  fetchParams.controller.resume = async () => {
+    // 1. While true
+    while (true) {
+      // 1-3. See onData...
+
+      // 4. Set bytes to the result of handling content codings given
+      // codings and bytes.
+      let bytes
+      let isFailure
+      try {
+        const { done, value } = await fetchParams.controller.next()
+
+        if (isAborted(fetchParams)) {
+          break
+        }
+
+        bytes = done ? undefined : value
+      } catch (err) {
+        if (fetchParams.controller.ended && !timingInfo.encodedBodySize) {
+          // zlib doesn't like empty streams.
+          bytes = undefined
+        } else {
+          bytes = err
+
+          // err may be propagated from the result of calling readablestream.cancel,
+          // which might not be an error. https://github.com/nodejs/undici/issues/2009
+          isFailure = true
+        }
+      }
+
+      if (bytes === undefined) {
+        // 2. Otherwise, if the bytes transmission for response’s message
+        // body is done normally and stream is readable, then close
+        // stream, finalize response for fetchParams and response, and
+        // abort these in-parallel steps.
+        readableStreamClose(fetchParams.controller.controller)
+
+        finalizeResponse(fetchParams, response)
+
+        return
+      }
+
+      // 5. Increase timingInfo’s decoded body size by bytes’s length.
+      timingInfo.decodedBodySize += bytes?.byteLength ?? 0
+
+      // 6. If bytes is failure, then terminate fetchParams’s controller.
+      if (isFailure) {
+        fetchParams.controller.terminate(bytes)
+        return
+      }
+
+      // 7. Enqueue a Uint8Array wrapping an ArrayBuffer containing bytes
+      // into stream.
+      const buffer = new Uint8Array(bytes)
+      if (buffer.byteLength) {
+        fetchParams.controller.controller.enqueue(buffer)
+      }
+
+      // 8. If stream is errored, then terminate the ongoing fetch.
+      if (isErrored(stream)) {
+        fetchParams.controller.terminate()
+        return
+      }
+
+      // 9. If stream doesn’t need more data ask the user agent to suspend
+      // the ongoing fetch.
+      if (fetchParams.controller.controller.desiredSize <= 0) {
+        return
+      }
+    }
+  }
+
+  //    2. If aborted, then:
+  function onAborted (reason) {
+    // 2. If fetchParams is aborted, then:
+    if (isAborted(fetchParams)) {
+      // 1. Set response’s aborted flag.
+      response.aborted = true
+
+      // 2. If stream is readable, then error stream with the result of
+      //    deserialize a serialized abort reason given fetchParams’s
+      //    controller’s serialized abort reason and an
+      //    implementation-defined realm.
+      if (isReadable(stream)) {
+        fetchParams.controller.controller.error(
+          fetchParams.controller.serializedAbortReason
+        )
+      }
+    } else {
+      // 3. Otherwise, if stream is readable, error stream with a TypeError.
+      if (isReadable(stream)) {
+        fetchParams.controller.controller.error(new TypeError('terminated', {
+          cause: isErrorLike(reason) ? reason : undefined
+        }))
+      }
+    }
+
+    // 4. If connection uses HTTP/2, then transmit an RST_STREAM frame.
+    // 5. Otherwise, the user agent should close connection unless it would be bad for performance to do so.
+    fetchParams.controller.connection.destroy()
+  }
+
+  // 20. Return response.
+  return response
+
+  function dispatch ({ body }) {
+    const url = requestCurrentURL(request)
+    /** @type {import('../..').Agent} */
+    const agent = fetchParams.controller.dispatcher
+
+    return new Promise((resolve, reject) => agent.dispatch(
+      {
+        path: url.pathname + url.search,
+        origin: url.origin,
+        method: request.method,
+        body: agent.isMockActive ? request.body && (request.body.source || request.body.stream) : body,
+        headers: request.headersList.entries,
+        maxRedirections: 0,
+        upgrade: request.mode === 'websocket' ? 'websocket' : undefined
+      },
+      {
+        body: null,
+        abort: null,
+
+        onConnect (abort) {
+          // TODO (fix): Do we need connection here?
+          const { connection } = fetchParams.controller
+
+          // Set timingInfo’s final connection timing info to the result of calling clamp and coarsen
+          // connection timing info with connection’s timing info, timingInfo’s post-redirect start
+          // time, and fetchParams’s cross-origin isolated capability.
+          // TODO: implement connection timing
+          timingInfo.finalConnectionTimingInfo = clampAndCoarsenConnectionTimingInfo(undefined, timingInfo.postRedirectStartTime, fetchParams.crossOriginIsolatedCapability)
+
+          if (connection.destroyed) {
+            abort(new DOMException('The operation was aborted.', 'AbortError'))
+          } else {
+            fetchParams.controller.on('terminated', abort)
+            this.abort = connection.abort = abort
+          }
+
+          // Set timingInfo’s final network-request start time to the coarsened shared current time given
+          // fetchParams’s cross-origin isolated capability.
+          timingInfo.finalNetworkRequestStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability)
+        },
+
+        onResponseStarted () {
+          // Set timingInfo’s final network-response start time to the coarsened shared current
+          // time given fetchParams’s cross-origin isolated capability, immediately after the
+          // user agent’s HTTP parser receives the first byte of the response (e.g., frame header
+          // bytes for HTTP/2 or response status line for HTTP/1.x).
+          timingInfo.finalNetworkResponseStartTime = coarsenedSharedCurrentTime(fetchParams.crossOriginIsolatedCapability)
+        },
+
+        onHeaders (status, rawHeaders, resume, statusText) {
+          if (status < 200) {
+            return
+          }
+
+          let location = ''
+
+          const headersList = new HeadersList()
+
+          for (let i = 0; i < rawHeaders.length; i += 2) {
+            headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString('latin1'), true)
+          }
+          location = headersList.get('location', true)
+
+          this.body = new Readable({ read: resume })
+
+          const decoders = []
+
+          const willFollow = location && request.redirect === 'follow' &&
+            redirectStatusSet.has(status)
+
+          // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding
+          if (request.method !== 'HEAD' && request.method !== 'CONNECT' && !nullBodyStatus.includes(status) && !willFollow) {
+            // https://www.rfc-editor.org/rfc/rfc7231#section-3.1.2.1
+            const contentEncoding = headersList.get('content-encoding', true)
+            // "All content-coding values are case-insensitive..."
+            /** @type {string[]} */
+            const codings = contentEncoding ? contentEncoding.toLowerCase().split(',') : []
+
+            // Limit the number of content-encodings to prevent resource exhaustion.
+            // CVE fix similar to urllib3 (GHSA-gm62-xv2j-4w53) and curl (CVE-2022-32206).
+            const maxContentEncodings = 5
+            if (codings.length > maxContentEncodings) {
+              reject(new Error(`too many content-encodings in response: ${codings.length}, maximum allowed is ${maxContentEncodings}`))
+              return true
+            }
+
+            for (let i = codings.length - 1; i >= 0; --i) {
+              const coding = codings[i].trim()
+              // https://www.rfc-editor.org/rfc/rfc9112.html#section-7.2
+              if (coding === 'x-gzip' || coding === 'gzip') {
+                decoders.push(zlib.createGunzip({
+                  // Be less strict when decoding compressed responses, since sometimes
+                  // servers send slightly invalid responses that are still accepted
+                  // by common browsers.
+                  // Always using Z_SYNC_FLUSH is what cURL does.
+                  flush: zlib.constants.Z_SYNC_FLUSH,
+                  finishFlush: zlib.constants.Z_SYNC_FLUSH
+                }))
+              } else if (coding === 'deflate') {
+                decoders.push(createInflate({
+                  flush: zlib.constants.Z_SYNC_FLUSH,
+                  finishFlush: zlib.constants.Z_SYNC_FLUSH
+                }))
+              } else if (coding === 'br') {
+                decoders.push(zlib.createBrotliDecompress({
+                  flush: zlib.constants.BROTLI_OPERATION_FLUSH,
+                  finishFlush: zlib.constants.BROTLI_OPERATION_FLUSH
+                }))
+              } else {
+                decoders.length = 0
+                break
+              }
+            }
+          }
+
+          const onError = this.onError.bind(this)
+
+          resolve({
+            status,
+            statusText,
+            headersList,
+            body: decoders.length
+              ? pipeline(this.body, ...decoders, (err) => {
+                if (err) {
+                  this.onError(err)
+                }
+              }).on('error', onError)
+              : this.body.on('error', onError)
+          })
+
+          return true
+        },
+
+        onData (chunk) {
+          if (fetchParams.controller.dump) {
+            return
+          }
+
+          // 1. If one or more bytes have been transmitted from response’s
+          // message body, then:
+
+          //  1. Let bytes be the transmitted bytes.
+          const bytes = chunk
+
+          //  2. Let codings be the result of extracting header list values
+          //  given `Content-Encoding` and response’s header list.
+          //  See pullAlgorithm.
+
+          //  3. Increase timingInfo’s encoded body size by bytes’s length.
+          timingInfo.encodedBodySize += bytes.byteLength
+
+          //  4. See pullAlgorithm...
+
+          return this.body.push(bytes)
+        },
+
+        onComplete () {
+          if (this.abort) {
+            fetchParams.controller.off('terminated', this.abort)
+          }
+
+          if (fetchParams.controller.onAborted) {
+            fetchParams.controller.off('terminated', fetchParams.controller.onAborted)
+          }
+
+          fetchParams.controller.ended = true
+
+          this.body.push(null)
+        },
+
+        onError (error) {
+          if (this.abort) {
+            fetchParams.controller.off('terminated', this.abort)
+          }
+
+          this.body?.destroy(error)
+
+          fetchParams.controller.terminate(error)
+
+          reject(error)
+        },
+
+        onUpgrade (status, rawHeaders, socket) {
+          if (status !== 101) {
+            return
+          }
+
+          const headersList = new HeadersList()
+
+          for (let i = 0; i < rawHeaders.length; i += 2) {
+            headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString('latin1'), true)
+          }
+
+          resolve({
+            status,
+            statusText: STATUS_CODES[status],
+            headersList,
+            socket
+          })
+
+          return true
+        }
+      }
+    ))
+  }
+}
+
+module.exports = {
+  fetch,
+  Fetch,
+  fetching,
+  finalizeAndReportTiming
+}
+
+
+/***/ }),
+
+/***/ 13925:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+/* globals AbortController */
+
+
+
+const { extractBody, mixinBody, cloneBody, bodyUnusable } = __nccwpck_require__(23291)
+const { Headers, fill: fillHeaders, HeadersList, setHeadersGuard, getHeadersGuard, setHeadersList, getHeadersList } = __nccwpck_require__(24997)
+const { FinalizationRegistry } = __nccwpck_require__(77962)()
+const util = __nccwpck_require__(94407)
+const nodeUtil = __nccwpck_require__(47261)
+const {
+  isValidHTTPToken,
+  sameOrigin,
+  environmentSettingsObject
+} = __nccwpck_require__(91976)
+const {
+  forbiddenMethodsSet,
+  corsSafeListedMethodsSet,
+  referrerPolicy,
+  requestRedirect,
+  requestMode,
+  requestCredentials,
+  requestCache,
+  requestDuplex
+} = __nccwpck_require__(87979)
+const { kEnumerableProperty, normalizedMethodRecordsBase, normalizedMethodRecords } = util
+const { kHeaders, kSignal, kState, kDispatcher } = __nccwpck_require__(78172)
+const { webidl } = __nccwpck_require__(37829)
+const { URLSerializer } = __nccwpck_require__(86954)
+const { kConstruct } = __nccwpck_require__(5392)
+const assert = __nccwpck_require__(98061)
+const { getMaxListeners, setMaxListeners, getEventListeners, defaultMaxListeners } = __nccwpck_require__(15673)
+
+const kAbortController = Symbol('abortController')
+
+const requestFinalizer = new FinalizationRegistry(({ signal, abort }) => {
+  signal.removeEventListener('abort', abort)
+})
+
+const dependentControllerMap = new WeakMap()
+
+function buildAbort (acRef) {
+  return abort
+
+  function abort () {
+    const ac = acRef.deref()
+    if (ac !== undefined) {
+      // Currently, there is a problem with FinalizationRegistry.
+      // https://github.com/nodejs/node/issues/49344
+      // https://github.com/nodejs/node/issues/47748
+      // In the case of abort, the first step is to unregister from it.
+      // If the controller can refer to it, it is still registered.
+      // It will be removed in the future.
+      requestFinalizer.unregister(abort)
+
+      // Unsubscribe a listener.
+      // FinalizationRegistry will no longer be called, so this must be done.
+      this.removeEventListener('abort', abort)
+
+      ac.abort(this.reason)
+
+      const controllerList = dependentControllerMap.get(ac.signal)
+
+      if (controllerList !== undefined) {
+        if (controllerList.size !== 0) {
+          for (const ref of controllerList) {
+            const ctrl = ref.deref()
+            if (ctrl !== undefined) {
+              ctrl.abort(this.reason)
+            }
+          }
+          controllerList.clear()
+        }
+        dependentControllerMap.delete(ac.signal)
+      }
+    }
+  }
+}
+
+let patchMethodWarning = false
+
+// https://fetch.spec.whatwg.org/#request-class
+class Request {
+  // https://fetch.spec.whatwg.org/#dom-request
+  constructor (input, init = {}) {
+    webidl.util.markAsUncloneable(this)
+    if (input === kConstruct) {
+      return
+    }
+
+    const prefix = 'Request constructor'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    input = webidl.converters.RequestInfo(input, prefix, 'input')
+    init = webidl.converters.RequestInit(init, prefix, 'init')
+
+    // 1. Let request be null.
+    let request = null
+
+    // 2. Let fallbackMode be null.
+    let fallbackMode = null
+
+    // 3. Let baseURL be this’s relevant settings object’s API base URL.
+    const baseUrl = environmentSettingsObject.settingsObject.baseUrl
+
+    // 4. Let signal be null.
+    let signal = null
+
+    // 5. If input is a string, then:
+    if (typeof input === 'string') {
+      this[kDispatcher] = init.dispatcher
+
+      // 1. Let parsedURL be the result of parsing input with baseURL.
+      // 2. If parsedURL is failure, then throw a TypeError.
+      let parsedURL
+      try {
+        parsedURL = new URL(input, baseUrl)
+      } catch (err) {
+        throw new TypeError('Failed to parse URL from ' + input, { cause: err })
+      }
+
+      // 3. If parsedURL includes credentials, then throw a TypeError.
+      if (parsedURL.username || parsedURL.password) {
+        throw new TypeError(
+          'Request cannot be constructed from a URL that includes credentials: ' +
+            input
+        )
+      }
+
+      // 4. Set request to a new request whose URL is parsedURL.
+      request = makeRequest({ urlList: [parsedURL] })
+
+      // 5. Set fallbackMode to "cors".
+      fallbackMode = 'cors'
+    } else {
+      this[kDispatcher] = init.dispatcher || input[kDispatcher]
+
+      // 6. Otherwise:
+
+      // 7. Assert: input is a Request object.
+      assert(input instanceof Request)
+
+      // 8. Set request to input’s request.
+      request = input[kState]
+
+      // 9. Set signal to input’s signal.
+      signal = input[kSignal]
+    }
+
+    // 7. Let origin be this’s relevant settings object’s origin.
+    const origin = environmentSettingsObject.settingsObject.origin
+
+    // 8. Let window be "client".
+    let window = 'client'
+
+    // 9. If request’s window is an environment settings object and its origin
+    // is same origin with origin, then set window to request’s window.
+    if (
+      request.window?.constructor?.name === 'EnvironmentSettingsObject' &&
+      sameOrigin(request.window, origin)
+    ) {
+      window = request.window
+    }
+
+    // 10. If init["window"] exists and is non-null, then throw a TypeError.
+    if (init.window != null) {
+      throw new TypeError(`'window' option '${window}' must be null`)
+    }
+
+    // 11. If init["window"] exists, then set window to "no-window".
+    if ('window' in init) {
+      window = 'no-window'
+    }
+
+    // 12. Set request to a new request with the following properties:
+    request = makeRequest({
+      // URL request’s URL.
+      // undici implementation note: this is set as the first item in request's urlList in makeRequest
+      // method request’s method.
+      method: request.method,
+      // header list A copy of request’s header list.
+      // undici implementation note: headersList is cloned in makeRequest
+      headersList: request.headersList,
+      // unsafe-request flag Set.
+      unsafeRequest: request.unsafeRequest,
+      // client This’s relevant settings object.
+      client: environmentSettingsObject.settingsObject,
+      // window window.
+      window,
+      // priority request’s priority.
+      priority: request.priority,
+      // origin request’s origin. The propagation of the origin is only significant for navigation requests
+      // being handled by a service worker. In this scenario a request can have an origin that is different
+      // from the current client.
+      origin: request.origin,
+      // referrer request’s referrer.
+      referrer: request.referrer,
+      // referrer policy request’s referrer policy.
+      referrerPolicy: request.referrerPolicy,
+      // mode request’s mode.
+      mode: request.mode,
+      // credentials mode request’s credentials mode.
+      credentials: request.credentials,
+      // cache mode request’s cache mode.
+      cache: request.cache,
+      // redirect mode request’s redirect mode.
+      redirect: request.redirect,
+      // integrity metadata request’s integrity metadata.
+      integrity: request.integrity,
+      // keepalive request’s keepalive.
+      keepalive: request.keepalive,
+      // reload-navigation flag request’s reload-navigation flag.
+      reloadNavigation: request.reloadNavigation,
+      // history-navigation flag request’s history-navigation flag.
+      historyNavigation: request.historyNavigation,
+      // URL list A clone of request’s URL list.
+      urlList: [...request.urlList]
+    })
+
+    const initHasKey = Object.keys(init).length !== 0
+
+    // 13. If init is not empty, then:
+    if (initHasKey) {
+      // 1. If request’s mode is "navigate", then set it to "same-origin".
+      if (request.mode === 'navigate') {
+        request.mode = 'same-origin'
+      }
+
+      // 2. Unset request’s reload-navigation flag.
+      request.reloadNavigation = false
+
+      // 3. Unset request’s history-navigation flag.
+      request.historyNavigation = false
+
+      // 4. Set request’s origin to "client".
+      request.origin = 'client'
+
+      // 5. Set request’s referrer to "client"
+      request.referrer = 'client'
+
+      // 6. Set request’s referrer policy to the empty string.
+      request.referrerPolicy = ''
+
+      // 7. Set request’s URL to request’s current URL.
+      request.url = request.urlList[request.urlList.length - 1]
+
+      // 8. Set request’s URL list to « request’s URL ».
+      request.urlList = [request.url]
+    }
+
+    // 14. If init["referrer"] exists, then:
+    if (init.referrer !== undefined) {
+      // 1. Let referrer be init["referrer"].
+      const referrer = init.referrer
+
+      // 2. If referrer is the empty string, then set request’s referrer to "no-referrer".
+      if (referrer === '') {
+        request.referrer = 'no-referrer'
+      } else {
+        // 1. Let parsedReferrer be the result of parsing referrer with
+        // baseURL.
+        // 2. If parsedReferrer is failure, then throw a TypeError.
+        let parsedReferrer
+        try {
+          parsedReferrer = new URL(referrer, baseUrl)
+        } catch (err) {
+          throw new TypeError(`Referrer "${referrer}" is not a valid URL.`, { cause: err })
+        }
+
+        // 3. If one of the following is true
+        // - parsedReferrer’s scheme is "about" and path is the string "client"
+        // - parsedReferrer’s origin is not same origin with origin
+        // then set request’s referrer to "client".
+        if (
+          (parsedReferrer.protocol === 'about:' && parsedReferrer.hostname === 'client') ||
+          (origin && !sameOrigin(parsedReferrer, environmentSettingsObject.settingsObject.baseUrl))
+        ) {
+          request.referrer = 'client'
+        } else {
+          // 4. Otherwise, set request’s referrer to parsedReferrer.
+          request.referrer = parsedReferrer
+        }
+      }
+    }
+
+    // 15. If init["referrerPolicy"] exists, then set request’s referrer policy
+    // to it.
+    if (init.referrerPolicy !== undefined) {
+      request.referrerPolicy = init.referrerPolicy
+    }
+
+    // 16. Let mode be init["mode"] if it exists, and fallbackMode otherwise.
+    let mode
+    if (init.mode !== undefined) {
+      mode = init.mode
+    } else {
+      mode = fallbackMode
+    }
+
+    // 17. If mode is "navigate", then throw a TypeError.
+    if (mode === 'navigate') {
+      throw webidl.errors.exception({
+        header: 'Request constructor',
+        message: 'invalid request mode navigate.'
+      })
+    }
+
+    // 18. If mode is non-null, set request’s mode to mode.
+    if (mode != null) {
+      request.mode = mode
+    }
+
+    // 19. If init["credentials"] exists, then set request’s credentials mode
+    // to it.
+    if (init.credentials !== undefined) {
+      request.credentials = init.credentials
+    }
+
+    // 18. If init["cache"] exists, then set request’s cache mode to it.
+    if (init.cache !== undefined) {
+      request.cache = init.cache
+    }
+
+    // 21. If request’s cache mode is "only-if-cached" and request’s mode is
+    // not "same-origin", then throw a TypeError.
+    if (request.cache === 'only-if-cached' && request.mode !== 'same-origin') {
+      throw new TypeError(
+        "'only-if-cached' can be set only with 'same-origin' mode"
+      )
+    }
+
+    // 22. If init["redirect"] exists, then set request’s redirect mode to it.
+    if (init.redirect !== undefined) {
+      request.redirect = init.redirect
+    }
+
+    // 23. If init["integrity"] exists, then set request’s integrity metadata to it.
+    if (init.integrity != null) {
+      request.integrity = String(init.integrity)
+    }
+
+    // 24. If init["keepalive"] exists, then set request’s keepalive to it.
+    if (init.keepalive !== undefined) {
+      request.keepalive = Boolean(init.keepalive)
+    }
+
+    // 25. If init["method"] exists, then:
+    if (init.method !== undefined) {
+      // 1. Let method be init["method"].
+      let method = init.method
+
+      const mayBeNormalized = normalizedMethodRecords[method]
+
+      if (mayBeNormalized !== undefined) {
+        // Note: Bypass validation DELETE, GET, HEAD, OPTIONS, POST, PUT, PATCH and these lowercase ones
+        request.method = mayBeNormalized
+      } else {
+        // 2. If method is not a method or method is a forbidden method, then
+        // throw a TypeError.
+        if (!isValidHTTPToken(method)) {
+          throw new TypeError(`'${method}' is not a valid HTTP method.`)
+        }
+
+        const upperCase = method.toUpperCase()
+
+        if (forbiddenMethodsSet.has(upperCase)) {
+          throw new TypeError(`'${method}' HTTP method is unsupported.`)
+        }
+
+        // 3. Normalize method.
+        // https://fetch.spec.whatwg.org/#concept-method-normalize
+        // Note: must be in uppercase
+        method = normalizedMethodRecordsBase[upperCase] ?? method
+
+        // 4. Set request’s method to method.
+        request.method = method
+      }
+
+      if (!patchMethodWarning && request.method === 'patch') {
+        process.emitWarning('Using `patch` is highly likely to result in a `405 Method Not Allowed`. `PATCH` is much more likely to succeed.', {
+          code: 'UNDICI-FETCH-patch'
+        })
+
+        patchMethodWarning = true
+      }
+    }
+
+    // 26. If init["signal"] exists, then set signal to it.
+    if (init.signal !== undefined) {
+      signal = init.signal
+    }
+
+    // 27. Set this’s request to request.
+    this[kState] = request
+
+    // 28. Set this’s signal to a new AbortSignal object with this’s relevant
+    // Realm.
+    // TODO: could this be simplified with AbortSignal.any
+    // (https://dom.spec.whatwg.org/#dom-abortsignal-any)
+    const ac = new AbortController()
+    this[kSignal] = ac.signal
+
+    // 29. If signal is not null, then make this’s signal follow signal.
+    if (signal != null) {
+      if (
+        !signal ||
+        typeof signal.aborted !== 'boolean' ||
+        typeof signal.addEventListener !== 'function'
+      ) {
+        throw new TypeError(
+          "Failed to construct 'Request': member signal is not of type AbortSignal."
+        )
+      }
+
+      if (signal.aborted) {
+        ac.abort(signal.reason)
+      } else {
+        // Keep a strong ref to ac while request object
+        // is alive. This is needed to prevent AbortController
+        // from being prematurely garbage collected.
+        // See, https://github.com/nodejs/undici/issues/1926.
+        this[kAbortController] = ac
+
+        const acRef = new WeakRef(ac)
+        const abort = buildAbort(acRef)
+
+        // Third-party AbortControllers may not work with these.
+        // See, https://github.com/nodejs/undici/pull/1910#issuecomment-1464495619.
+        try {
+          // If the max amount of listeners is equal to the default, increase it
+          // This is only available in node >= v19.9.0
+          if (typeof getMaxListeners === 'function' && getMaxListeners(signal) === defaultMaxListeners) {
+            setMaxListeners(1500, signal)
+          } else if (getEventListeners(signal, 'abort').length >= defaultMaxListeners) {
+            setMaxListeners(1500, signal)
+          }
+        } catch {}
+
+        util.addAbortListener(signal, abort)
+        // The third argument must be a registry key to be unregistered.
+        // Without it, you cannot unregister.
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
+        // abort is used as the unregister key. (because it is unique)
+        requestFinalizer.register(ac, { signal, abort }, abort)
+      }
+    }
+
+    // 30. Set this’s headers to a new Headers object with this’s relevant
+    // Realm, whose header list is request’s header list and guard is
+    // "request".
+    this[kHeaders] = new Headers(kConstruct)
+    setHeadersList(this[kHeaders], request.headersList)
+    setHeadersGuard(this[kHeaders], 'request')
+
+    // 31. If this’s request’s mode is "no-cors", then:
+    if (mode === 'no-cors') {
+      // 1. If this’s request’s method is not a CORS-safelisted method,
+      // then throw a TypeError.
+      if (!corsSafeListedMethodsSet.has(request.method)) {
+        throw new TypeError(
+          `'${request.method} is unsupported in no-cors mode.`
+        )
+      }
+
+      // 2. Set this’s headers’s guard to "request-no-cors".
+      setHeadersGuard(this[kHeaders], 'request-no-cors')
+    }
+
+    // 32. If init is not empty, then:
+    if (initHasKey) {
+      /** @type {HeadersList} */
+      const headersList = getHeadersList(this[kHeaders])
+      // 1. Let headers be a copy of this’s headers and its associated header
+      // list.
+      // 2. If init["headers"] exists, then set headers to init["headers"].
+      const headers = init.headers !== undefined ? init.headers : new HeadersList(headersList)
+
+      // 3. Empty this’s headers’s header list.
+      headersList.clear()
+
+      // 4. If headers is a Headers object, then for each header in its header
+      // list, append header’s name/header’s value to this’s headers.
+      if (headers instanceof HeadersList) {
+        for (const { name, value } of headers.rawValues()) {
+          headersList.append(name, value, false)
+        }
+        // Note: Copy the `set-cookie` meta-data.
+        headersList.cookies = headers.cookies
+      } else {
+        // 5. Otherwise, fill this’s headers with headers.
+        fillHeaders(this[kHeaders], headers)
+      }
+    }
+
+    // 33. Let inputBody be input’s request’s body if input is a Request
+    // object; otherwise null.
+    const inputBody = input instanceof Request ? input[kState].body : null
+
+    // 34. If either init["body"] exists and is non-null or inputBody is
+    // non-null, and request’s method is `GET` or `HEAD`, then throw a
+    // TypeError.
+    if (
+      (init.body != null || inputBody != null) &&
+      (request.method === 'GET' || request.method === 'HEAD')
+    ) {
+      throw new TypeError('Request with GET/HEAD method cannot have body.')
+    }
+
+    // 35. Let initBody be null.
+    let initBody = null
+
+    // 36. If init["body"] exists and is non-null, then:
+    if (init.body != null) {
+      // 1. Let Content-Type be null.
+      // 2. Set initBody and Content-Type to the result of extracting
+      // init["body"], with keepalive set to request’s keepalive.
+      const [extractedBody, contentType] = extractBody(
+        init.body,
+        request.keepalive
+      )
+      initBody = extractedBody
+
+      // 3, If Content-Type is non-null and this’s headers’s header list does
+      // not contain `Content-Type`, then append `Content-Type`/Content-Type to
+      // this’s headers.
+      if (contentType && !getHeadersList(this[kHeaders]).contains('content-type', true)) {
+        this[kHeaders].append('content-type', contentType)
+      }
+    }
+
+    // 37. Let inputOrInitBody be initBody if it is non-null; otherwise
+    // inputBody.
+    const inputOrInitBody = initBody ?? inputBody
+
+    // 38. If inputOrInitBody is non-null and inputOrInitBody’s source is
+    // null, then:
+    if (inputOrInitBody != null && inputOrInitBody.source == null) {
+      // 1. If initBody is non-null and init["duplex"] does not exist,
+      //    then throw a TypeError.
+      if (initBody != null && init.duplex == null) {
+        throw new TypeError('RequestInit: duplex option is required when sending a body.')
+      }
+
+      // 2. If this’s request’s mode is neither "same-origin" nor "cors",
+      // then throw a TypeError.
+      if (request.mode !== 'same-origin' && request.mode !== 'cors') {
+        throw new TypeError(
+          'If request is made from ReadableStream, mode should be "same-origin" or "cors"'
+        )
+      }
+
+      // 3. Set this’s request’s use-CORS-preflight flag.
+      request.useCORSPreflightFlag = true
+    }
+
+    // 39. Let finalBody be inputOrInitBody.
+    let finalBody = inputOrInitBody
+
+    // 40. If initBody is null and inputBody is non-null, then:
+    if (initBody == null && inputBody != null) {
+      // 1. If input is unusable, then throw a TypeError.
+      if (bodyUnusable(input)) {
+        throw new TypeError(
+          'Cannot construct a Request with a Request object that has already been used.'
+        )
+      }
+
+      // 2. Set finalBody to the result of creating a proxy for inputBody.
+      // https://streams.spec.whatwg.org/#readablestream-create-a-proxy
+      const identityTransform = new TransformStream()
+      inputBody.stream.pipeThrough(identityTransform)
+      finalBody = {
+        source: inputBody.source,
+        length: inputBody.length,
+        stream: identityTransform.readable
+      }
+    }
+
+    // 41. Set this’s request’s body to finalBody.
+    this[kState].body = finalBody
+  }
+
+  // Returns request’s HTTP method, which is "GET" by default.
+  get method () {
+    webidl.brandCheck(this, Request)
+
+    // The method getter steps are to return this’s request’s method.
+    return this[kState].method
+  }
+
+  // Returns the URL of request as a string.
+  get url () {
+    webidl.brandCheck(this, Request)
+
+    // The url getter steps are to return this’s request’s URL, serialized.
+    return URLSerializer(this[kState].url)
+  }
+
+  // Returns a Headers object consisting of the headers associated with request.
+  // Note that headers added in the network layer by the user agent will not
+  // be accounted for in this object, e.g., the "Host" header.
+  get headers () {
+    webidl.brandCheck(this, Request)
+
+    // The headers getter steps are to return this’s headers.
+    return this[kHeaders]
+  }
+
+  // Returns the kind of resource requested by request, e.g., "document"
+  // or "script".
+  get destination () {
+    webidl.brandCheck(this, Request)
+
+    // The destination getter are to return this’s request’s destination.
+    return this[kState].destination
+  }
+
+  // Returns the referrer of request. Its value can be a same-origin URL if
+  // explicitly set in init, the empty string to indicate no referrer, and
+  // "about:client" when defaulting to the global’s default. This is used
+  // during fetching to determine the value of the `Referer` header of the
+  // request being made.
+  get referrer () {
+    webidl.brandCheck(this, Request)
+
+    // 1. If this’s request’s referrer is "no-referrer", then return the
+    // empty string.
+    if (this[kState].referrer === 'no-referrer') {
+      return ''
+    }
+
+    // 2. If this’s request’s referrer is "client", then return
+    // "about:client".
+    if (this[kState].referrer === 'client') {
+      return 'about:client'
+    }
+
+    // Return this’s request’s referrer, serialized.
+    return this[kState].referrer.toString()
+  }
+
+  // Returns the referrer policy associated with request.
+  // This is used during fetching to compute the value of the request’s
+  // referrer.
+  get referrerPolicy () {
+    webidl.brandCheck(this, Request)
+
+    // The referrerPolicy getter steps are to return this’s request’s referrer policy.
+    return this[kState].referrerPolicy
+  }
+
+  // Returns the mode associated with request, which is a string indicating
+  // whether the request will use CORS, or will be restricted to same-origin
+  // URLs.
+  get mode () {
+    webidl.brandCheck(this, Request)
+
+    // The mode getter steps are to return this’s request’s mode.
+    return this[kState].mode
+  }
+
+  // Returns the credentials mode associated with request,
+  // which is a string indicating whether credentials will be sent with the
+  // request always, never, or only when sent to a same-origin URL.
+  get credentials () {
+    // The credentials getter steps are to return this’s request’s credentials mode.
+    return this[kState].credentials
+  }
+
+  // Returns the cache mode associated with request,
+  // which is a string indicating how the request will
+  // interact with the browser’s cache when fetching.
+  get cache () {
+    webidl.brandCheck(this, Request)
+
+    // The cache getter steps are to return this’s request’s cache mode.
+    return this[kState].cache
+  }
+
+  // Returns the redirect mode associated with request,
+  // which is a string indicating how redirects for the
+  // request will be handled during fetching. A request
+  // will follow redirects by default.
+  get redirect () {
+    webidl.brandCheck(this, Request)
+
+    // The redirect getter steps are to return this’s request’s redirect mode.
+    return this[kState].redirect
+  }
+
+  // Returns request’s subresource integrity metadata, which is a
+  // cryptographic hash of the resource being fetched. Its value
+  // consists of multiple hashes separated by whitespace. [SRI]
+  get integrity () {
+    webidl.brandCheck(this, Request)
+
+    // The integrity getter steps are to return this’s request’s integrity
+    // metadata.
+    return this[kState].integrity
+  }
+
+  // Returns a boolean indicating whether or not request can outlive the
+  // global in which it was created.
+  get keepalive () {
+    webidl.brandCheck(this, Request)
+
+    // The keepalive getter steps are to return this’s request’s keepalive.
+    return this[kState].keepalive
+  }
+
+  // Returns a boolean indicating whether or not request is for a reload
+  // navigation.
+  get isReloadNavigation () {
+    webidl.brandCheck(this, Request)
+
+    // The isReloadNavigation getter steps are to return true if this’s
+    // request’s reload-navigation flag is set; otherwise false.
+    return this[kState].reloadNavigation
+  }
+
+  // Returns a boolean indicating whether or not request is for a history
+  // navigation (a.k.a. back-forward navigation).
+  get isHistoryNavigation () {
+    webidl.brandCheck(this, Request)
+
+    // The isHistoryNavigation getter steps are to return true if this’s request’s
+    // history-navigation flag is set; otherwise false.
+    return this[kState].historyNavigation
+  }
+
+  // Returns the signal associated with request, which is an AbortSignal
+  // object indicating whether or not request has been aborted, and its
+  // abort event handler.
+  get signal () {
+    webidl.brandCheck(this, Request)
+
+    // The signal getter steps are to return this’s signal.
+    return this[kSignal]
+  }
+
+  get body () {
+    webidl.brandCheck(this, Request)
+
+    return this[kState].body ? this[kState].body.stream : null
+  }
+
+  get bodyUsed () {
+    webidl.brandCheck(this, Request)
+
+    return !!this[kState].body && util.isDisturbed(this[kState].body.stream)
+  }
+
+  get duplex () {
+    webidl.brandCheck(this, Request)
+
+    return 'half'
+  }
+
+  // Returns a clone of request.
+  clone () {
+    webidl.brandCheck(this, Request)
+
+    // 1. If this is unusable, then throw a TypeError.
+    if (bodyUnusable(this)) {
+      throw new TypeError('unusable')
+    }
+
+    // 2. Let clonedRequest be the result of cloning this’s request.
+    const clonedRequest = cloneRequest(this[kState])
+
+    // 3. Let clonedRequestObject be the result of creating a Request object,
+    // given clonedRequest, this’s headers’s guard, and this’s relevant Realm.
+    // 4. Make clonedRequestObject’s signal follow this’s signal.
+    const ac = new AbortController()
+    if (this.signal.aborted) {
+      ac.abort(this.signal.reason)
+    } else {
+      let list = dependentControllerMap.get(this.signal)
+      if (list === undefined) {
+        list = new Set()
+        dependentControllerMap.set(this.signal, list)
+      }
+      const acRef = new WeakRef(ac)
+      list.add(acRef)
+      util.addAbortListener(
+        ac.signal,
+        buildAbort(acRef)
+      )
+    }
+
+    // 4. Return clonedRequestObject.
+    return fromInnerRequest(clonedRequest, ac.signal, getHeadersGuard(this[kHeaders]))
+  }
+
+  [nodeUtil.inspect.custom] (depth, options) {
+    if (options.depth === null) {
+      options.depth = 2
+    }
+
+    options.colors ??= true
+
+    const properties = {
+      method: this.method,
+      url: this.url,
+      headers: this.headers,
+      destination: this.destination,
+      referrer: this.referrer,
+      referrerPolicy: this.referrerPolicy,
+      mode: this.mode,
+      credentials: this.credentials,
+      cache: this.cache,
+      redirect: this.redirect,
+      integrity: this.integrity,
+      keepalive: this.keepalive,
+      isReloadNavigation: this.isReloadNavigation,
+      isHistoryNavigation: this.isHistoryNavigation,
+      signal: this.signal
+    }
+
+    return `Request ${nodeUtil.formatWithOptions(options, properties)}`
+  }
+}
+
+mixinBody(Request)
+
+// https://fetch.spec.whatwg.org/#requests
+function makeRequest (init) {
+  return {
+    method: init.method ?? 'GET',
+    localURLsOnly: init.localURLsOnly ?? false,
+    unsafeRequest: init.unsafeRequest ?? false,
+    body: init.body ?? null,
+    client: init.client ?? null,
+    reservedClient: init.reservedClient ?? null,
+    replacesClientId: init.replacesClientId ?? '',
+    window: init.window ?? 'client',
+    keepalive: init.keepalive ?? false,
+    serviceWorkers: init.serviceWorkers ?? 'all',
+    initiator: init.initiator ?? '',
+    destination: init.destination ?? '',
+    priority: init.priority ?? null,
+    origin: init.origin ?? 'client',
+    policyContainer: init.policyContainer ?? 'client',
+    referrer: init.referrer ?? 'client',
+    referrerPolicy: init.referrerPolicy ?? '',
+    mode: init.mode ?? 'no-cors',
+    useCORSPreflightFlag: init.useCORSPreflightFlag ?? false,
+    credentials: init.credentials ?? 'same-origin',
+    useCredentials: init.useCredentials ?? false,
+    cache: init.cache ?? 'default',
+    redirect: init.redirect ?? 'follow',
+    integrity: init.integrity ?? '',
+    cryptoGraphicsNonceMetadata: init.cryptoGraphicsNonceMetadata ?? '',
+    parserMetadata: init.parserMetadata ?? '',
+    reloadNavigation: init.reloadNavigation ?? false,
+    historyNavigation: init.historyNavigation ?? false,
+    userActivation: init.userActivation ?? false,
+    taintedOrigin: init.taintedOrigin ?? false,
+    redirectCount: init.redirectCount ?? 0,
+    responseTainting: init.responseTainting ?? 'basic',
+    preventNoCacheCacheControlHeaderModification: init.preventNoCacheCacheControlHeaderModification ?? false,
+    done: init.done ?? false,
+    timingAllowFailed: init.timingAllowFailed ?? false,
+    urlList: init.urlList,
+    url: init.urlList[0],
+    headersList: init.headersList
+      ? new HeadersList(init.headersList)
+      : new HeadersList()
+  }
+}
+
+// https://fetch.spec.whatwg.org/#concept-request-clone
+function cloneRequest (request) {
+  // To clone a request request, run these steps:
+
+  // 1. Let newRequest be a copy of request, except for its body.
+  const newRequest = makeRequest({ ...request, body: null })
+
+  // 2. If request’s body is non-null, set newRequest’s body to the
+  // result of cloning request’s body.
+  if (request.body != null) {
+    newRequest.body = cloneBody(newRequest, request.body)
+  }
+
+  // 3. Return newRequest.
+  return newRequest
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#request-create
+ * @param {any} innerRequest
+ * @param {AbortSignal} signal
+ * @param {'request' | 'immutable' | 'request-no-cors' | 'response' | 'none'} guard
+ * @returns {Request}
+ */
+function fromInnerRequest (innerRequest, signal, guard) {
+  const request = new Request(kConstruct)
+  request[kState] = innerRequest
+  request[kSignal] = signal
+  request[kHeaders] = new Headers(kConstruct)
+  setHeadersList(request[kHeaders], innerRequest.headersList)
+  setHeadersGuard(request[kHeaders], guard)
+  return request
+}
+
+Object.defineProperties(Request.prototype, {
+  method: kEnumerableProperty,
+  url: kEnumerableProperty,
+  headers: kEnumerableProperty,
+  redirect: kEnumerableProperty,
+  clone: kEnumerableProperty,
+  signal: kEnumerableProperty,
+  duplex: kEnumerableProperty,
+  destination: kEnumerableProperty,
+  body: kEnumerableProperty,
+  bodyUsed: kEnumerableProperty,
+  isHistoryNavigation: kEnumerableProperty,
+  isReloadNavigation: kEnumerableProperty,
+  keepalive: kEnumerableProperty,
+  integrity: kEnumerableProperty,
+  cache: kEnumerableProperty,
+  credentials: kEnumerableProperty,
+  attribute: kEnumerableProperty,
+  referrerPolicy: kEnumerableProperty,
+  referrer: kEnumerableProperty,
+  mode: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'Request',
+    configurable: true
+  }
+})
+
+webidl.converters.Request = webidl.interfaceConverter(
+  Request
+)
+
+// https://fetch.spec.whatwg.org/#requestinfo
+webidl.converters.RequestInfo = function (V, prefix, argument) {
+  if (typeof V === 'string') {
+    return webidl.converters.USVString(V, prefix, argument)
+  }
+
+  if (V instanceof Request) {
+    return webidl.converters.Request(V, prefix, argument)
+  }
+
+  return webidl.converters.USVString(V, prefix, argument)
+}
+
+webidl.converters.AbortSignal = webidl.interfaceConverter(
+  AbortSignal
+)
+
+// https://fetch.spec.whatwg.org/#requestinit
+webidl.converters.RequestInit = webidl.dictionaryConverter([
+  {
+    key: 'method',
+    converter: webidl.converters.ByteString
+  },
+  {
+    key: 'headers',
+    converter: webidl.converters.HeadersInit
+  },
+  {
+    key: 'body',
+    converter: webidl.nullableConverter(
+      webidl.converters.BodyInit
+    )
+  },
+  {
+    key: 'referrer',
+    converter: webidl.converters.USVString
+  },
+  {
+    key: 'referrerPolicy',
+    converter: webidl.converters.DOMString,
+    // https://w3c.github.io/webappsec-referrer-policy/#referrer-policy
+    allowedValues: referrerPolicy
+  },
+  {
+    key: 'mode',
+    converter: webidl.converters.DOMString,
+    // https://fetch.spec.whatwg.org/#concept-request-mode
+    allowedValues: requestMode
+  },
+  {
+    key: 'credentials',
+    converter: webidl.converters.DOMString,
+    // https://fetch.spec.whatwg.org/#requestcredentials
+    allowedValues: requestCredentials
+  },
+  {
+    key: 'cache',
+    converter: webidl.converters.DOMString,
+    // https://fetch.spec.whatwg.org/#requestcache
+    allowedValues: requestCache
+  },
+  {
+    key: 'redirect',
+    converter: webidl.converters.DOMString,
+    // https://fetch.spec.whatwg.org/#requestredirect
+    allowedValues: requestRedirect
+  },
+  {
+    key: 'integrity',
+    converter: webidl.converters.DOMString
+  },
+  {
+    key: 'keepalive',
+    converter: webidl.converters.boolean
+  },
+  {
+    key: 'signal',
+    converter: webidl.nullableConverter(
+      (signal) => webidl.converters.AbortSignal(
+        signal,
+        'RequestInit',
+        'signal',
+        { strict: false }
+      )
+    )
+  },
+  {
+    key: 'window',
+    converter: webidl.converters.any
+  },
+  {
+    key: 'duplex',
+    converter: webidl.converters.DOMString,
+    allowedValues: requestDuplex
+  },
+  {
+    key: 'dispatcher', // undici specific option
+    converter: webidl.converters.any
+  }
+])
+
+module.exports = { Request, makeRequest, fromInnerRequest, cloneRequest }
+
+
+/***/ }),
+
+/***/ 33139:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Headers, HeadersList, fill, getHeadersGuard, setHeadersGuard, setHeadersList } = __nccwpck_require__(24997)
+const { extractBody, cloneBody, mixinBody, hasFinalizationRegistry, streamRegistry, bodyUnusable } = __nccwpck_require__(23291)
+const util = __nccwpck_require__(94407)
+const nodeUtil = __nccwpck_require__(47261)
+const { kEnumerableProperty } = util
+const {
+  isValidReasonPhrase,
+  isCancelled,
+  isAborted,
+  isBlobLike,
+  serializeJavascriptValueToJSONString,
+  isErrorLike,
+  isomorphicEncode,
+  environmentSettingsObject: relevantRealm
+} = __nccwpck_require__(91976)
+const {
+  redirectStatusSet,
+  nullBodyStatus
+} = __nccwpck_require__(87979)
+const { kState, kHeaders } = __nccwpck_require__(78172)
+const { webidl } = __nccwpck_require__(37829)
+const { FormData } = __nccwpck_require__(4923)
+const { URLSerializer } = __nccwpck_require__(86954)
+const { kConstruct } = __nccwpck_require__(5392)
+const assert = __nccwpck_require__(98061)
+const { types } = __nccwpck_require__(47261)
+
+const textEncoder = new TextEncoder('utf-8')
+
+// https://fetch.spec.whatwg.org/#response-class
+class Response {
+  // Creates network error Response.
+  static error () {
+    // The static error() method steps are to return the result of creating a
+    // Response object, given a new network error, "immutable", and this’s
+    // relevant Realm.
+    const responseObject = fromInnerResponse(makeNetworkError(), 'immutable')
+
+    return responseObject
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-response-json
+  static json (data, init = {}) {
+    webidl.argumentLengthCheck(arguments, 1, 'Response.json')
+
+    if (init !== null) {
+      init = webidl.converters.ResponseInit(init)
+    }
+
+    // 1. Let bytes the result of running serialize a JavaScript value to JSON bytes on data.
+    const bytes = textEncoder.encode(
+      serializeJavascriptValueToJSONString(data)
+    )
+
+    // 2. Let body be the result of extracting bytes.
+    const body = extractBody(bytes)
+
+    // 3. Let responseObject be the result of creating a Response object, given a new response,
+    //    "response", and this’s relevant Realm.
+    const responseObject = fromInnerResponse(makeResponse({}), 'response')
+
+    // 4. Perform initialize a response given responseObject, init, and (body, "application/json").
+    initializeResponse(responseObject, init, { body: body[0], type: 'application/json' })
+
+    // 5. Return responseObject.
+    return responseObject
+  }
+
+  // Creates a redirect Response that redirects to url with status status.
+  static redirect (url, status = 302) {
+    webidl.argumentLengthCheck(arguments, 1, 'Response.redirect')
+
+    url = webidl.converters.USVString(url)
+    status = webidl.converters['unsigned short'](status)
+
+    // 1. Let parsedURL be the result of parsing url with current settings
+    // object’s API base URL.
+    // 2. If parsedURL is failure, then throw a TypeError.
+    // TODO: base-URL?
+    let parsedURL
+    try {
+      parsedURL = new URL(url, relevantRealm.settingsObject.baseUrl)
+    } catch (err) {
+      throw new TypeError(`Failed to parse URL from ${url}`, { cause: err })
+    }
+
+    // 3. If status is not a redirect status, then throw a RangeError.
+    if (!redirectStatusSet.has(status)) {
+      throw new RangeError(`Invalid status code ${status}`)
+    }
+
+    // 4. Let responseObject be the result of creating a Response object,
+    // given a new response, "immutable", and this’s relevant Realm.
+    const responseObject = fromInnerResponse(makeResponse({}), 'immutable')
+
+    // 5. Set responseObject’s response’s status to status.
+    responseObject[kState].status = status
+
+    // 6. Let value be parsedURL, serialized and isomorphic encoded.
+    const value = isomorphicEncode(URLSerializer(parsedURL))
+
+    // 7. Append `Location`/value to responseObject’s response’s header list.
+    responseObject[kState].headersList.append('location', value, true)
+
+    // 8. Return responseObject.
+    return responseObject
+  }
+
+  // https://fetch.spec.whatwg.org/#dom-response
+  constructor (body = null, init = {}) {
+    webidl.util.markAsUncloneable(this)
+    if (body === kConstruct) {
+      return
+    }
+
+    if (body !== null) {
+      body = webidl.converters.BodyInit(body)
+    }
+
+    init = webidl.converters.ResponseInit(init)
+
+    // 1. Set this’s response to a new response.
+    this[kState] = makeResponse({})
+
+    // 2. Set this’s headers to a new Headers object with this’s relevant
+    // Realm, whose header list is this’s response’s header list and guard
+    // is "response".
+    this[kHeaders] = new Headers(kConstruct)
+    setHeadersGuard(this[kHeaders], 'response')
+    setHeadersList(this[kHeaders], this[kState].headersList)
+
+    // 3. Let bodyWithType be null.
+    let bodyWithType = null
+
+    // 4. If body is non-null, then set bodyWithType to the result of extracting body.
+    if (body != null) {
+      const [extractedBody, type] = extractBody(body)
+      bodyWithType = { body: extractedBody, type }
+    }
+
+    // 5. Perform initialize a response given this, init, and bodyWithType.
+    initializeResponse(this, init, bodyWithType)
+  }
+
+  // Returns response’s type, e.g., "cors".
+  get type () {
+    webidl.brandCheck(this, Response)
+
+    // The type getter steps are to return this’s response’s type.
+    return this[kState].type
+  }
+
+  // Returns response’s URL, if it has one; otherwise the empty string.
+  get url () {
+    webidl.brandCheck(this, Response)
+
+    const urlList = this[kState].urlList
+
+    // The url getter steps are to return the empty string if this’s
+    // response’s URL is null; otherwise this’s response’s URL,
+    // serialized with exclude fragment set to true.
+    const url = urlList[urlList.length - 1] ?? null
+
+    if (url === null) {
+      return ''
+    }
+
+    return URLSerializer(url, true)
+  }
+
+  // Returns whether response was obtained through a redirect.
+  get redirected () {
+    webidl.brandCheck(this, Response)
+
+    // The redirected getter steps are to return true if this’s response’s URL
+    // list has more than one item; otherwise false.
+    return this[kState].urlList.length > 1
+  }
+
+  // Returns response’s status.
+  get status () {
+    webidl.brandCheck(this, Response)
+
+    // The status getter steps are to return this’s response’s status.
+    return this[kState].status
+  }
+
+  // Returns whether response’s status is an ok status.
+  get ok () {
+    webidl.brandCheck(this, Response)
+
+    // The ok getter steps are to return true if this’s response’s status is an
+    // ok status; otherwise false.
+    return this[kState].status >= 200 && this[kState].status <= 299
+  }
+
+  // Returns response’s status message.
+  get statusText () {
+    webidl.brandCheck(this, Response)
+
+    // The statusText getter steps are to return this’s response’s status
+    // message.
+    return this[kState].statusText
+  }
+
+  // Returns response’s headers as Headers.
+  get headers () {
+    webidl.brandCheck(this, Response)
+
+    // The headers getter steps are to return this’s headers.
+    return this[kHeaders]
+  }
+
+  get body () {
+    webidl.brandCheck(this, Response)
+
+    return this[kState].body ? this[kState].body.stream : null
+  }
+
+  get bodyUsed () {
+    webidl.brandCheck(this, Response)
+
+    return !!this[kState].body && util.isDisturbed(this[kState].body.stream)
+  }
+
+  // Returns a clone of response.
+  clone () {
+    webidl.brandCheck(this, Response)
+
+    // 1. If this is unusable, then throw a TypeError.
+    if (bodyUnusable(this)) {
+      throw webidl.errors.exception({
+        header: 'Response.clone',
+        message: 'Body has already been consumed.'
+      })
+    }
+
+    // 2. Let clonedResponse be the result of cloning this’s response.
+    const clonedResponse = cloneResponse(this[kState])
+
+    // Note: To re-register because of a new stream.
+    if (hasFinalizationRegistry && this[kState].body?.stream) {
+      streamRegistry.register(this, new WeakRef(this[kState].body.stream))
+    }
+
+    // 3. Return the result of creating a Response object, given
+    // clonedResponse, this’s headers’s guard, and this’s relevant Realm.
+    return fromInnerResponse(clonedResponse, getHeadersGuard(this[kHeaders]))
+  }
+
+  [nodeUtil.inspect.custom] (depth, options) {
+    if (options.depth === null) {
+      options.depth = 2
+    }
+
+    options.colors ??= true
+
+    const properties = {
+      status: this.status,
+      statusText: this.statusText,
+      headers: this.headers,
+      body: this.body,
+      bodyUsed: this.bodyUsed,
+      ok: this.ok,
+      redirected: this.redirected,
+      type: this.type,
+      url: this.url
+    }
+
+    return `Response ${nodeUtil.formatWithOptions(options, properties)}`
+  }
+}
+
+mixinBody(Response)
+
+Object.defineProperties(Response.prototype, {
+  type: kEnumerableProperty,
+  url: kEnumerableProperty,
+  status: kEnumerableProperty,
+  ok: kEnumerableProperty,
+  redirected: kEnumerableProperty,
+  statusText: kEnumerableProperty,
+  headers: kEnumerableProperty,
+  clone: kEnumerableProperty,
+  body: kEnumerableProperty,
+  bodyUsed: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'Response',
+    configurable: true
+  }
+})
+
+Object.defineProperties(Response, {
+  json: kEnumerableProperty,
+  redirect: kEnumerableProperty,
+  error: kEnumerableProperty
+})
+
+// https://fetch.spec.whatwg.org/#concept-response-clone
+function cloneResponse (response) {
+  // To clone a response response, run these steps:
+
+  // 1. If response is a filtered response, then return a new identical
+  // filtered response whose internal response is a clone of response’s
+  // internal response.
+  if (response.internalResponse) {
+    return filterResponse(
+      cloneResponse(response.internalResponse),
+      response.type
+    )
+  }
+
+  // 2. Let newResponse be a copy of response, except for its body.
+  const newResponse = makeResponse({ ...response, body: null })
+
+  // 3. If response’s body is non-null, then set newResponse’s body to the
+  // result of cloning response’s body.
+  if (response.body != null) {
+    newResponse.body = cloneBody(newResponse, response.body)
+  }
+
+  // 4. Return newResponse.
+  return newResponse
+}
+
+function makeResponse (init) {
+  return {
+    aborted: false,
+    rangeRequested: false,
+    timingAllowPassed: false,
+    requestIncludesCredentials: false,
+    type: 'default',
+    status: 200,
+    timingInfo: null,
+    cacheState: '',
+    statusText: '',
+    ...init,
+    headersList: init?.headersList
+      ? new HeadersList(init?.headersList)
+      : new HeadersList(),
+    urlList: init?.urlList ? [...init.urlList] : []
+  }
+}
+
+function makeNetworkError (reason) {
+  const isError = isErrorLike(reason)
+  return makeResponse({
+    type: 'error',
+    status: 0,
+    error: isError
+      ? reason
+      : new Error(reason ? String(reason) : reason),
+    aborted: reason && reason.name === 'AbortError'
+  })
+}
+
+// @see https://fetch.spec.whatwg.org/#concept-network-error
+function isNetworkError (response) {
+  return (
+    // A network error is a response whose type is "error",
+    response.type === 'error' &&
+    // status is 0
+    response.status === 0
+  )
+}
+
+function makeFilteredResponse (response, state) {
+  state = {
+    internalResponse: response,
+    ...state
+  }
+
+  return new Proxy(response, {
+    get (target, p) {
+      return p in state ? state[p] : target[p]
+    },
+    set (target, p, value) {
+      assert(!(p in state))
+      target[p] = value
+      return true
+    }
+  })
+}
+
+// https://fetch.spec.whatwg.org/#concept-filtered-response
+function filterResponse (response, type) {
+  // Set response to the following filtered response with response as its
+  // internal response, depending on request’s response tainting:
+  if (type === 'basic') {
+    // A basic filtered response is a filtered response whose type is "basic"
+    // and header list excludes any headers in internal response’s header list
+    // whose name is a forbidden response-header name.
+
+    // Note: undici does not implement forbidden response-header names
+    return makeFilteredResponse(response, {
+      type: 'basic',
+      headersList: response.headersList
+    })
+  } else if (type === 'cors') {
+    // A CORS filtered response is a filtered response whose type is "cors"
+    // and header list excludes any headers in internal response’s header
+    // list whose name is not a CORS-safelisted response-header name, given
+    // internal response’s CORS-exposed header-name list.
+
+    // Note: undici does not implement CORS-safelisted response-header names
+    return makeFilteredResponse(response, {
+      type: 'cors',
+      headersList: response.headersList
+    })
+  } else if (type === 'opaque') {
+    // An opaque filtered response is a filtered response whose type is
+    // "opaque", URL list is the empty list, status is 0, status message
+    // is the empty byte sequence, header list is empty, and body is null.
+
+    return makeFilteredResponse(response, {
+      type: 'opaque',
+      urlList: Object.freeze([]),
+      status: 0,
+      statusText: '',
+      body: null
+    })
+  } else if (type === 'opaqueredirect') {
+    // An opaque-redirect filtered response is a filtered response whose type
+    // is "opaqueredirect", status is 0, status message is the empty byte
+    // sequence, header list is empty, and body is null.
+
+    return makeFilteredResponse(response, {
+      type: 'opaqueredirect',
+      status: 0,
+      statusText: '',
+      headersList: [],
+      body: null
+    })
+  } else {
+    assert(false)
+  }
+}
+
+// https://fetch.spec.whatwg.org/#appropriate-network-error
+function makeAppropriateNetworkError (fetchParams, err = null) {
+  // 1. Assert: fetchParams is canceled.
+  assert(isCancelled(fetchParams))
+
+  // 2. Return an aborted network error if fetchParams is aborted;
+  // otherwise return a network error.
+  return isAborted(fetchParams)
+    ? makeNetworkError(Object.assign(new DOMException('The operation was aborted.', 'AbortError'), { cause: err }))
+    : makeNetworkError(Object.assign(new DOMException('Request was cancelled.'), { cause: err }))
+}
+
+// https://whatpr.org/fetch/1392.html#initialize-a-response
+function initializeResponse (response, init, body) {
+  // 1. If init["status"] is not in the range 200 to 599, inclusive, then
+  //    throw a RangeError.
+  if (init.status !== null && (init.status < 200 || init.status > 599)) {
+    throw new RangeError('init["status"] must be in the range of 200 to 599, inclusive.')
+  }
+
+  // 2. If init["statusText"] does not match the reason-phrase token production,
+  //    then throw a TypeError.
+  if ('statusText' in init && init.statusText != null) {
+    // See, https://datatracker.ietf.org/doc/html/rfc7230#section-3.1.2:
+    //   reason-phrase  = *( HTAB / SP / VCHAR / obs-text )
+    if (!isValidReasonPhrase(String(init.statusText))) {
+      throw new TypeError('Invalid statusText')
+    }
+  }
+
+  // 3. Set response’s response’s status to init["status"].
+  if ('status' in init && init.status != null) {
+    response[kState].status = init.status
+  }
+
+  // 4. Set response’s response’s status message to init["statusText"].
+  if ('statusText' in init && init.statusText != null) {
+    response[kState].statusText = init.statusText
+  }
+
+  // 5. If init["headers"] exists, then fill response’s headers with init["headers"].
+  if ('headers' in init && init.headers != null) {
+    fill(response[kHeaders], init.headers)
+  }
+
+  // 6. If body was given, then:
+  if (body) {
+    // 1. If response's status is a null body status, then throw a TypeError.
+    if (nullBodyStatus.includes(response.status)) {
+      throw webidl.errors.exception({
+        header: 'Response constructor',
+        message: `Invalid response status code ${response.status}`
+      })
+    }
+
+    // 2. Set response's body to body's body.
+    response[kState].body = body.body
+
+    // 3. If body's type is non-null and response's header list does not contain
+    //    `Content-Type`, then append (`Content-Type`, body's type) to response's header list.
+    if (body.type != null && !response[kState].headersList.contains('content-type', true)) {
+      response[kState].headersList.append('content-type', body.type, true)
+    }
+  }
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#response-create
+ * @param {any} innerResponse
+ * @param {'request' | 'immutable' | 'request-no-cors' | 'response' | 'none'} guard
+ * @returns {Response}
+ */
+function fromInnerResponse (innerResponse, guard) {
+  const response = new Response(kConstruct)
+  response[kState] = innerResponse
+  response[kHeaders] = new Headers(kConstruct)
+  setHeadersList(response[kHeaders], innerResponse.headersList)
+  setHeadersGuard(response[kHeaders], guard)
+
+  if (hasFinalizationRegistry && innerResponse.body?.stream) {
+    // If the target (response) is reclaimed, the cleanup callback may be called at some point with
+    // the held value provided for it (innerResponse.body.stream). The held value can be any value:
+    // a primitive or an object, even undefined. If the held value is an object, the registry keeps
+    // a strong reference to it (so it can pass it to the cleanup callback later). Reworded from
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/FinalizationRegistry
+    streamRegistry.register(response, new WeakRef(innerResponse.body.stream))
+  }
+
+  return response
+}
+
+webidl.converters.ReadableStream = webidl.interfaceConverter(
+  ReadableStream
+)
+
+webidl.converters.FormData = webidl.interfaceConverter(
+  FormData
+)
+
+webidl.converters.URLSearchParams = webidl.interfaceConverter(
+  URLSearchParams
+)
+
+// https://fetch.spec.whatwg.org/#typedefdef-xmlhttprequestbodyinit
+webidl.converters.XMLHttpRequestBodyInit = function (V, prefix, name) {
+  if (typeof V === 'string') {
+    return webidl.converters.USVString(V, prefix, name)
+  }
+
+  if (isBlobLike(V)) {
+    return webidl.converters.Blob(V, prefix, name, { strict: false })
+  }
+
+  if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
+    return webidl.converters.BufferSource(V, prefix, name)
+  }
+
+  if (util.isFormDataLike(V)) {
+    return webidl.converters.FormData(V, prefix, name, { strict: false })
+  }
+
+  if (V instanceof URLSearchParams) {
+    return webidl.converters.URLSearchParams(V, prefix, name)
+  }
+
+  return webidl.converters.DOMString(V, prefix, name)
+}
+
+// https://fetch.spec.whatwg.org/#bodyinit
+webidl.converters.BodyInit = function (V, prefix, argument) {
+  if (V instanceof ReadableStream) {
+    return webidl.converters.ReadableStream(V, prefix, argument)
+  }
+
+  // Note: the spec doesn't include async iterables,
+  // this is an undici extension.
+  if (V?.[Symbol.asyncIterator]) {
+    return V
+  }
+
+  return webidl.converters.XMLHttpRequestBodyInit(V, prefix, argument)
+}
+
+webidl.converters.ResponseInit = webidl.dictionaryConverter([
+  {
+    key: 'status',
+    converter: webidl.converters['unsigned short'],
+    defaultValue: () => 200
+  },
+  {
+    key: 'statusText',
+    converter: webidl.converters.ByteString,
+    defaultValue: () => ''
+  },
+  {
+    key: 'headers',
+    converter: webidl.converters.HeadersInit
+  }
+])
+
+module.exports = {
+  isNetworkError,
+  makeNetworkError,
+  makeResponse,
+  makeAppropriateNetworkError,
+  filterResponse,
+  Response,
+  cloneResponse,
+  fromInnerResponse
+}
+
+
+/***/ }),
+
+/***/ 78172:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = {
+  kUrl: Symbol('url'),
+  kHeaders: Symbol('headers'),
+  kSignal: Symbol('signal'),
+  kState: Symbol('state'),
+  kDispatcher: Symbol('dispatcher')
+}
+
+
+/***/ }),
+
+/***/ 91976:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Transform } = __nccwpck_require__(84492)
+const zlib = __nccwpck_require__(65628)
+const { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = __nccwpck_require__(87979)
+const { getGlobalOrigin } = __nccwpck_require__(71332)
+const { collectASequenceOfCodePoints, collectAnHTTPQuotedString, removeChars, parseMIMEType } = __nccwpck_require__(86954)
+const { performance } = __nccwpck_require__(38846)
+const { isBlobLike, ReadableStreamFrom, isValidHTTPToken, normalizedMethodRecordsBase } = __nccwpck_require__(94407)
+const assert = __nccwpck_require__(98061)
+const { isUint8Array } = __nccwpck_require__(93746)
+const { webidl } = __nccwpck_require__(37829)
+
+let supportedHashes = []
+
+// https://nodejs.org/api/crypto.html#determining-if-crypto-support-is-unavailable
+/** @type {import('crypto')} */
+let crypto
+try {
+  crypto = __nccwpck_require__(6005)
+  const possibleRelevantHashes = ['sha256', 'sha384', 'sha512']
+  supportedHashes = crypto.getHashes().filter((hash) => possibleRelevantHashes.includes(hash))
+/* c8 ignore next 3 */
+} catch {
+
+}
+
+function responseURL (response) {
+  // https://fetch.spec.whatwg.org/#responses
+  // A response has an associated URL. It is a pointer to the last URL
+  // in response’s URL list and null if response’s URL list is empty.
+  const urlList = response.urlList
+  const length = urlList.length
+  return length === 0 ? null : urlList[length - 1].toString()
+}
+
+// https://fetch.spec.whatwg.org/#concept-response-location-url
+function responseLocationURL (response, requestFragment) {
+  // 1. If response’s status is not a redirect status, then return null.
+  if (!redirectStatusSet.has(response.status)) {
+    return null
+  }
+
+  // 2. Let location be the result of extracting header list values given
+  // `Location` and response’s header list.
+  let location = response.headersList.get('location', true)
+
+  // 3. If location is a header value, then set location to the result of
+  //    parsing location with response’s URL.
+  if (location !== null && isValidHeaderValue(location)) {
+    if (!isValidEncodedURL(location)) {
+      // Some websites respond location header in UTF-8 form without encoding them as ASCII
+      // and major browsers redirect them to correctly UTF-8 encoded addresses.
+      // Here, we handle that behavior in the same way.
+      location = normalizeBinaryStringToUtf8(location)
+    }
+    location = new URL(location, responseURL(response))
+  }
+
+  // 4. If location is a URL whose fragment is null, then set location’s
+  // fragment to requestFragment.
+  if (location && !location.hash) {
+    location.hash = requestFragment
+  }
+
+  // 5. Return location.
+  return location
+}
+
+/**
+ * @see https://www.rfc-editor.org/rfc/rfc1738#section-2.2
+ * @param {string} url
+ * @returns {boolean}
+ */
+function isValidEncodedURL (url) {
+  for (let i = 0; i < url.length; ++i) {
+    const code = url.charCodeAt(i)
+
+    if (
+      code > 0x7E || // Non-US-ASCII + DEL
+      code < 0x20 // Control characters NUL - US
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * If string contains non-ASCII characters, assumes it's UTF-8 encoded and decodes it.
+ * Since UTF-8 is a superset of ASCII, this will work for ASCII strings as well.
+ * @param {string} value
+ * @returns {string}
+ */
+function normalizeBinaryStringToUtf8 (value) {
+  return Buffer.from(value, 'binary').toString('utf8')
+}
+
+/** @returns {URL} */
+function requestCurrentURL (request) {
+  return request.urlList[request.urlList.length - 1]
+}
+
+function requestBadPort (request) {
+  // 1. Let url be request’s current URL.
+  const url = requestCurrentURL(request)
+
+  // 2. If url’s scheme is an HTTP(S) scheme and url’s port is a bad port,
+  // then return blocked.
+  if (urlIsHttpHttpsScheme(url) && badPortsSet.has(url.port)) {
+    return 'blocked'
+  }
+
+  // 3. Return allowed.
+  return 'allowed'
+}
+
+function isErrorLike (object) {
+  return object instanceof Error || (
+    object?.constructor?.name === 'Error' ||
+    object?.constructor?.name === 'DOMException'
+  )
+}
+
+// Check whether |statusText| is a ByteString and
+// matches the Reason-Phrase token production.
+// RFC 2616: https://tools.ietf.org/html/rfc2616
+// RFC 7230: https://tools.ietf.org/html/rfc7230
+// "reason-phrase = *( HTAB / SP / VCHAR / obs-text )"
+// https://github.com/chromium/chromium/blob/94.0.4604.1/third_party/blink/renderer/core/fetch/response.cc#L116
+function isValidReasonPhrase (statusText) {
+  for (let i = 0; i < statusText.length; ++i) {
+    const c = statusText.charCodeAt(i)
+    if (
+      !(
+        (
+          c === 0x09 || // HTAB
+          (c >= 0x20 && c <= 0x7e) || // SP / VCHAR
+          (c >= 0x80 && c <= 0xff)
+        ) // obs-text
+      )
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#header-name
+ * @param {string} potentialValue
+ */
+const isValidHeaderName = isValidHTTPToken
+
+/**
+ * @see https://fetch.spec.whatwg.org/#header-value
+ * @param {string} potentialValue
+ */
+function isValidHeaderValue (potentialValue) {
+  // - Has no leading or trailing HTTP tab or space bytes.
+  // - Contains no 0x00 (NUL) or HTTP newline bytes.
+  return (
+    potentialValue[0] === '\t' ||
+    potentialValue[0] === ' ' ||
+    potentialValue[potentialValue.length - 1] === '\t' ||
+    potentialValue[potentialValue.length - 1] === ' ' ||
+    potentialValue.includes('\n') ||
+    potentialValue.includes('\r') ||
+    potentialValue.includes('\0')
+  ) === false
+}
+
+// https://w3c.github.io/webappsec-referrer-policy/#set-requests-referrer-policy-on-redirect
+function setRequestReferrerPolicyOnRedirect (request, actualResponse) {
+  //  Given a request request and a response actualResponse, this algorithm
+  //  updates request’s referrer policy according to the Referrer-Policy
+  //  header (if any) in actualResponse.
+
+  // 1. Let policy be the result of executing § 8.1 Parse a referrer policy
+  // from a Referrer-Policy header on actualResponse.
+
+  // 8.1 Parse a referrer policy from a Referrer-Policy header
+  // 1. Let policy-tokens be the result of extracting header list values given `Referrer-Policy` and response’s header list.
+  const { headersList } = actualResponse
+  // 2. Let policy be the empty string.
+  // 3. For each token in policy-tokens, if token is a referrer policy and token is not the empty string, then set policy to token.
+  // 4. Return policy.
+  const policyHeader = (headersList.get('referrer-policy', true) ?? '').split(',')
+
+  // Note: As the referrer-policy can contain multiple policies
+  // separated by comma, we need to loop through all of them
+  // and pick the first valid one.
+  // Ref: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy#specify_a_fallback_policy
+  let policy = ''
+  if (policyHeader.length > 0) {
+    // The right-most policy takes precedence.
+    // The left-most policy is the fallback.
+    for (let i = policyHeader.length; i !== 0; i--) {
+      const token = policyHeader[i - 1].trim()
+      if (referrerPolicyTokens.has(token)) {
+        policy = token
+        break
+      }
+    }
+  }
+
+  // 2. If policy is not the empty string, then set request’s referrer policy to policy.
+  if (policy !== '') {
+    request.referrerPolicy = policy
+  }
+}
+
+// https://fetch.spec.whatwg.org/#cross-origin-resource-policy-check
+function crossOriginResourcePolicyCheck () {
+  // TODO
+  return 'allowed'
+}
+
+// https://fetch.spec.whatwg.org/#concept-cors-check
+function corsCheck () {
+  // TODO
+  return 'success'
+}
+
+// https://fetch.spec.whatwg.org/#concept-tao-check
+function TAOCheck () {
+  // TODO
+  return 'success'
+}
+
+function appendFetchMetadata (httpRequest) {
+  //  https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-dest-header
+  //  TODO
+
+  //  https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-mode-header
+
+  //  1. Assert: r’s url is a potentially trustworthy URL.
+  //  TODO
+
+  //  2. Let header be a Structured Header whose value is a token.
+  let header = null
+
+  //  3. Set header’s value to r’s mode.
+  header = httpRequest.mode
+
+  //  4. Set a structured field value `Sec-Fetch-Mode`/header in r’s header list.
+  httpRequest.headersList.set('sec-fetch-mode', header, true)
+
+  //  https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-site-header
+  //  TODO
+
+  //  https://w3c.github.io/webappsec-fetch-metadata/#sec-fetch-user-header
+  //  TODO
+}
+
+// https://fetch.spec.whatwg.org/#append-a-request-origin-header
+function appendRequestOriginHeader (request) {
+  // 1. Let serializedOrigin be the result of byte-serializing a request origin
+  //    with request.
+  // TODO: implement "byte-serializing a request origin"
+  let serializedOrigin = request.origin
+
+  // - "'client' is changed to an origin during fetching."
+  //   This doesn't happen in undici (in most cases) because undici, by default,
+  //   has no concept of origin.
+  // - request.origin can also be set to request.client.origin (client being
+  //   an environment settings object), which is undefined without using
+  //   setGlobalOrigin.
+  if (serializedOrigin === 'client' || serializedOrigin === undefined) {
+    return
+  }
+
+  // 2. If request’s response tainting is "cors" or request’s mode is "websocket",
+  //    then append (`Origin`, serializedOrigin) to request’s header list.
+  // 3. Otherwise, if request’s method is neither `GET` nor `HEAD`, then:
+  if (request.responseTainting === 'cors' || request.mode === 'websocket') {
+    request.headersList.append('origin', serializedOrigin, true)
+  } else if (request.method !== 'GET' && request.method !== 'HEAD') {
+    // 1. Switch on request’s referrer policy:
+    switch (request.referrerPolicy) {
+      case 'no-referrer':
+        // Set serializedOrigin to `null`.
+        serializedOrigin = null
+        break
+      case 'no-referrer-when-downgrade':
+      case 'strict-origin':
+      case 'strict-origin-when-cross-origin':
+        // If request’s origin is a tuple origin, its scheme is "https", and
+        // request’s current URL’s scheme is not "https", then set
+        // serializedOrigin to `null`.
+        if (request.origin && urlHasHttpsScheme(request.origin) && !urlHasHttpsScheme(requestCurrentURL(request))) {
+          serializedOrigin = null
+        }
+        break
+      case 'same-origin':
+        // If request’s origin is not same origin with request’s current URL’s
+        // origin, then set serializedOrigin to `null`.
+        if (!sameOrigin(request, requestCurrentURL(request))) {
+          serializedOrigin = null
+        }
+        break
+      default:
+        // Do nothing.
+    }
+
+    // 2. Append (`Origin`, serializedOrigin) to request’s header list.
+    request.headersList.append('origin', serializedOrigin, true)
+  }
+}
+
+// https://w3c.github.io/hr-time/#dfn-coarsen-time
+function coarsenTime (timestamp, crossOriginIsolatedCapability) {
+  // TODO
+  return timestamp
+}
+
+// https://fetch.spec.whatwg.org/#clamp-and-coarsen-connection-timing-info
+function clampAndCoarsenConnectionTimingInfo (connectionTimingInfo, defaultStartTime, crossOriginIsolatedCapability) {
+  if (!connectionTimingInfo?.startTime || connectionTimingInfo.startTime < defaultStartTime) {
+    return {
+      domainLookupStartTime: defaultStartTime,
+      domainLookupEndTime: defaultStartTime,
+      connectionStartTime: defaultStartTime,
+      connectionEndTime: defaultStartTime,
+      secureConnectionStartTime: defaultStartTime,
+      ALPNNegotiatedProtocol: connectionTimingInfo?.ALPNNegotiatedProtocol
+    }
+  }
+
+  return {
+    domainLookupStartTime: coarsenTime(connectionTimingInfo.domainLookupStartTime, crossOriginIsolatedCapability),
+    domainLookupEndTime: coarsenTime(connectionTimingInfo.domainLookupEndTime, crossOriginIsolatedCapability),
+    connectionStartTime: coarsenTime(connectionTimingInfo.connectionStartTime, crossOriginIsolatedCapability),
+    connectionEndTime: coarsenTime(connectionTimingInfo.connectionEndTime, crossOriginIsolatedCapability),
+    secureConnectionStartTime: coarsenTime(connectionTimingInfo.secureConnectionStartTime, crossOriginIsolatedCapability),
+    ALPNNegotiatedProtocol: connectionTimingInfo.ALPNNegotiatedProtocol
+  }
+}
+
+// https://w3c.github.io/hr-time/#dfn-coarsened-shared-current-time
+function coarsenedSharedCurrentTime (crossOriginIsolatedCapability) {
+  return coarsenTime(performance.now(), crossOriginIsolatedCapability)
+}
+
+// https://fetch.spec.whatwg.org/#create-an-opaque-timing-info
+function createOpaqueTimingInfo (timingInfo) {
+  return {
+    startTime: timingInfo.startTime ?? 0,
+    redirectStartTime: 0,
+    redirectEndTime: 0,
+    postRedirectStartTime: timingInfo.startTime ?? 0,
+    finalServiceWorkerStartTime: 0,
+    finalNetworkResponseStartTime: 0,
+    finalNetworkRequestStartTime: 0,
+    endTime: 0,
+    encodedBodySize: 0,
+    decodedBodySize: 0,
+    finalConnectionTimingInfo: null
+  }
+}
+
+// https://html.spec.whatwg.org/multipage/origin.html#policy-container
+function makePolicyContainer () {
+  // Note: the fetch spec doesn't make use of embedder policy or CSP list
+  return {
+    referrerPolicy: 'strict-origin-when-cross-origin'
+  }
+}
+
+// https://html.spec.whatwg.org/multipage/origin.html#clone-a-policy-container
+function clonePolicyContainer (policyContainer) {
+  return {
+    referrerPolicy: policyContainer.referrerPolicy
+  }
+}
+
+// https://w3c.github.io/webappsec-referrer-policy/#determine-requests-referrer
+function determineRequestsReferrer (request) {
+  // 1. Let policy be request's referrer policy.
+  const policy = request.referrerPolicy
+
+  // Note: policy cannot (shouldn't) be null or an empty string.
+  assert(policy)
+
+  // 2. Let environment be request’s client.
+
+  let referrerSource = null
+
+  // 3. Switch on request’s referrer:
+  if (request.referrer === 'client') {
+    // Note: node isn't a browser and doesn't implement document/iframes,
+    // so we bypass this step and replace it with our own.
+
+    const globalOrigin = getGlobalOrigin()
+
+    if (!globalOrigin || globalOrigin.origin === 'null') {
+      return 'no-referrer'
+    }
+
+    // note: we need to clone it as it's mutated
+    referrerSource = new URL(globalOrigin)
+  } else if (request.referrer instanceof URL) {
+    // Let referrerSource be request’s referrer.
+    referrerSource = request.referrer
+  }
+
+  // 4. Let request’s referrerURL be the result of stripping referrerSource for
+  //    use as a referrer.
+  let referrerURL = stripURLForReferrer(referrerSource)
+
+  // 5. Let referrerOrigin be the result of stripping referrerSource for use as
+  //    a referrer, with the origin-only flag set to true.
+  const referrerOrigin = stripURLForReferrer(referrerSource, true)
+
+  // 6. If the result of serializing referrerURL is a string whose length is
+  //    greater than 4096, set referrerURL to referrerOrigin.
+  if (referrerURL.toString().length > 4096) {
+    referrerURL = referrerOrigin
+  }
+
+  const areSameOrigin = sameOrigin(request, referrerURL)
+  const isNonPotentiallyTrustWorthy = isURLPotentiallyTrustworthy(referrerURL) &&
+    !isURLPotentiallyTrustworthy(request.url)
+
+  // 8. Execute the switch statements corresponding to the value of policy:
+  switch (policy) {
+    case 'origin': return referrerOrigin != null ? referrerOrigin : stripURLForReferrer(referrerSource, true)
+    case 'unsafe-url': return referrerURL
+    case 'same-origin':
+      return areSameOrigin ? referrerOrigin : 'no-referrer'
+    case 'origin-when-cross-origin':
+      return areSameOrigin ? referrerURL : referrerOrigin
+    case 'strict-origin-when-cross-origin': {
+      const currentURL = requestCurrentURL(request)
+
+      // 1. If the origin of referrerURL and the origin of request’s current
+      //    URL are the same, then return referrerURL.
+      if (sameOrigin(referrerURL, currentURL)) {
+        return referrerURL
+      }
+
+      // 2. If referrerURL is a potentially trustworthy URL and request’s
+      //    current URL is not a potentially trustworthy URL, then return no
+      //    referrer.
+      if (isURLPotentiallyTrustworthy(referrerURL) && !isURLPotentiallyTrustworthy(currentURL)) {
+        return 'no-referrer'
+      }
+
+      // 3. Return referrerOrigin.
+      return referrerOrigin
+    }
+    case 'strict-origin': // eslint-disable-line
+      /**
+         * 1. If referrerURL is a potentially trustworthy URL and
+         * request’s current URL is not a potentially trustworthy URL,
+         * then return no referrer.
+         * 2. Return referrerOrigin
+        */
+    case 'no-referrer-when-downgrade': // eslint-disable-line
+      /**
+       * 1. If referrerURL is a potentially trustworthy URL and
+       * request’s current URL is not a potentially trustworthy URL,
+       * then return no referrer.
+       * 2. Return referrerOrigin
+      */
+
+    default: // eslint-disable-line
+      return isNonPotentiallyTrustWorthy ? 'no-referrer' : referrerOrigin
+  }
+}
+
+/**
+ * @see https://w3c.github.io/webappsec-referrer-policy/#strip-url
+ * @param {URL} url
+ * @param {boolean|undefined} originOnly
+ */
+function stripURLForReferrer (url, originOnly) {
+  // 1. Assert: url is a URL.
+  assert(url instanceof URL)
+
+  url = new URL(url)
+
+  // 2. If url’s scheme is a local scheme, then return no referrer.
+  if (url.protocol === 'file:' || url.protocol === 'about:' || url.protocol === 'blank:') {
+    return 'no-referrer'
+  }
+
+  // 3. Set url’s username to the empty string.
+  url.username = ''
+
+  // 4. Set url’s password to the empty string.
+  url.password = ''
+
+  // 5. Set url’s fragment to null.
+  url.hash = ''
+
+  // 6. If the origin-only flag is true, then:
+  if (originOnly) {
+    // 1. Set url’s path to « the empty string ».
+    url.pathname = ''
+
+    // 2. Set url’s query to null.
+    url.search = ''
+  }
+
+  // 7. Return url.
+  return url
+}
+
+function isURLPotentiallyTrustworthy (url) {
+  if (!(url instanceof URL)) {
+    return false
+  }
+
+  // If child of about, return true
+  if (url.href === 'about:blank' || url.href === 'about:srcdoc') {
+    return true
+  }
+
+  // If scheme is data, return true
+  if (url.protocol === 'data:') return true
+
+  // If file, return true
+  if (url.protocol === 'file:') return true
+
+  return isOriginPotentiallyTrustworthy(url.origin)
+
+  function isOriginPotentiallyTrustworthy (origin) {
+    // If origin is explicitly null, return false
+    if (origin == null || origin === 'null') return false
+
+    const originAsURL = new URL(origin)
+
+    // If secure, return true
+    if (originAsURL.protocol === 'https:' || originAsURL.protocol === 'wss:') {
+      return true
+    }
+
+    // If localhost or variants, return true
+    if (/^127(?:\.[0-9]+){0,2}\.[0-9]+$|^\[(?:0*:)*?:?0*1\]$/.test(originAsURL.hostname) ||
+     (originAsURL.hostname === 'localhost' || originAsURL.hostname.includes('localhost.')) ||
+     (originAsURL.hostname.endsWith('.localhost'))) {
+      return true
+    }
+
+    // If any other, return false
+    return false
+  }
+}
+
+/**
+ * @see https://w3c.github.io/webappsec-subresource-integrity/#does-response-match-metadatalist
+ * @param {Uint8Array} bytes
+ * @param {string} metadataList
+ */
+function bytesMatch (bytes, metadataList) {
+  // If node is not built with OpenSSL support, we cannot check
+  // a request's integrity, so allow it by default (the spec will
+  // allow requests if an invalid hash is given, as precedence).
+  /* istanbul ignore if: only if node is built with --without-ssl */
+  if (crypto === undefined) {
+    return true
+  }
+
+  // 1. Let parsedMetadata be the result of parsing metadataList.
+  const parsedMetadata = parseMetadata(metadataList)
+
+  // 2. If parsedMetadata is no metadata, return true.
+  if (parsedMetadata === 'no metadata') {
+    return true
+  }
+
+  // 3. If response is not eligible for integrity validation, return false.
+  // TODO
+
+  // 4. If parsedMetadata is the empty set, return true.
+  if (parsedMetadata.length === 0) {
+    return true
+  }
+
+  // 5. Let metadata be the result of getting the strongest
+  //    metadata from parsedMetadata.
+  const strongest = getStrongestMetadata(parsedMetadata)
+  const metadata = filterMetadataListByAlgorithm(parsedMetadata, strongest)
+
+  // 6. For each item in metadata:
+  for (const item of metadata) {
+    // 1. Let algorithm be the alg component of item.
+    const algorithm = item.algo
+
+    // 2. Let expectedValue be the val component of item.
+    const expectedValue = item.hash
+
+    // See https://github.com/web-platform-tests/wpt/commit/e4c5cc7a5e48093220528dfdd1c4012dc3837a0e
+    // "be liberal with padding". This is annoying, and it's not even in the spec.
+
+    // 3. Let actualValue be the result of applying algorithm to bytes.
+    let actualValue = crypto.createHash(algorithm).update(bytes).digest('base64')
+
+    if (actualValue[actualValue.length - 1] === '=') {
+      if (actualValue[actualValue.length - 2] === '=') {
+        actualValue = actualValue.slice(0, -2)
+      } else {
+        actualValue = actualValue.slice(0, -1)
+      }
+    }
+
+    // 4. If actualValue is a case-sensitive match for expectedValue,
+    //    return true.
+    if (compareBase64Mixed(actualValue, expectedValue)) {
+      return true
+    }
+  }
+
+  // 7. Return false.
+  return false
+}
+
+// https://w3c.github.io/webappsec-subresource-integrity/#grammardef-hash-with-options
+// https://www.w3.org/TR/CSP2/#source-list-syntax
+// https://www.rfc-editor.org/rfc/rfc5234#appendix-B.1
+const parseHashWithOptions = /(?<algo>sha256|sha384|sha512)-((?<hash>[A-Za-z0-9+/]+|[A-Za-z0-9_-]+)={0,2}(?:\s|$)( +[!-~]*)?)?/i
+
+/**
+ * @see https://w3c.github.io/webappsec-subresource-integrity/#parse-metadata
+ * @param {string} metadata
+ */
+function parseMetadata (metadata) {
+  // 1. Let result be the empty set.
+  /** @type {{ algo: string, hash: string }[]} */
+  const result = []
+
+  // 2. Let empty be equal to true.
+  let empty = true
+
+  // 3. For each token returned by splitting metadata on spaces:
+  for (const token of metadata.split(' ')) {
+    // 1. Set empty to false.
+    empty = false
+
+    // 2. Parse token as a hash-with-options.
+    const parsedToken = parseHashWithOptions.exec(token)
+
+    // 3. If token does not parse, continue to the next token.
+    if (
+      parsedToken === null ||
+      parsedToken.groups === undefined ||
+      parsedToken.groups.algo === undefined
+    ) {
+      // Note: Chromium blocks the request at this point, but Firefox
+      // gives a warning that an invalid integrity was given. The
+      // correct behavior is to ignore these, and subsequently not
+      // check the integrity of the resource.
+      continue
+    }
+
+    // 4. Let algorithm be the hash-algo component of token.
+    const algorithm = parsedToken.groups.algo.toLowerCase()
+
+    // 5. If algorithm is a hash function recognized by the user
+    //    agent, add the parsed token to result.
+    if (supportedHashes.includes(algorithm)) {
+      result.push(parsedToken.groups)
+    }
+  }
+
+  // 4. Return no metadata if empty is true, otherwise return result.
+  if (empty === true) {
+    return 'no metadata'
+  }
+
+  return result
+}
+
+/**
+ * @param {{ algo: 'sha256' | 'sha384' | 'sha512' }[]} metadataList
+ */
+function getStrongestMetadata (metadataList) {
+  // Let algorithm be the algo component of the first item in metadataList.
+  // Can be sha256
+  let algorithm = metadataList[0].algo
+  // If the algorithm is sha512, then it is the strongest
+  // and we can return immediately
+  if (algorithm[3] === '5') {
+    return algorithm
+  }
+
+  for (let i = 1; i < metadataList.length; ++i) {
+    const metadata = metadataList[i]
+    // If the algorithm is sha512, then it is the strongest
+    // and we can break the loop immediately
+    if (metadata.algo[3] === '5') {
+      algorithm = 'sha512'
+      break
+    // If the algorithm is sha384, then a potential sha256 or sha384 is ignored
+    } else if (algorithm[3] === '3') {
+      continue
+    // algorithm is sha256, check if algorithm is sha384 and if so, set it as
+    // the strongest
+    } else if (metadata.algo[3] === '3') {
+      algorithm = 'sha384'
+    }
+  }
+  return algorithm
+}
+
+function filterMetadataListByAlgorithm (metadataList, algorithm) {
+  if (metadataList.length === 1) {
+    return metadataList
+  }
+
+  let pos = 0
+  for (let i = 0; i < metadataList.length; ++i) {
+    if (metadataList[i].algo === algorithm) {
+      metadataList[pos++] = metadataList[i]
+    }
+  }
+
+  metadataList.length = pos
+
+  return metadataList
+}
+
+/**
+ * Compares two base64 strings, allowing for base64url
+ * in the second string.
+ *
+* @param {string} actualValue always base64
+ * @param {string} expectedValue base64 or base64url
+ * @returns {boolean}
+ */
+function compareBase64Mixed (actualValue, expectedValue) {
+  if (actualValue.length !== expectedValue.length) {
+    return false
+  }
+  for (let i = 0; i < actualValue.length; ++i) {
+    if (actualValue[i] !== expectedValue[i]) {
+      if (
+        (actualValue[i] === '+' && expectedValue[i] === '-') ||
+        (actualValue[i] === '/' && expectedValue[i] === '_')
+      ) {
+        continue
+      }
+      return false
+    }
+  }
+
+  return true
+}
+
+// https://w3c.github.io/webappsec-upgrade-insecure-requests/#upgrade-request
+function tryUpgradeRequestToAPotentiallyTrustworthyURL (request) {
+  // TODO
+}
+
+/**
+ * @link {https://html.spec.whatwg.org/multipage/origin.html#same-origin}
+ * @param {URL} A
+ * @param {URL} B
+ */
+function sameOrigin (A, B) {
+  // 1. If A and B are the same opaque origin, then return true.
+  if (A.origin === B.origin && A.origin === 'null') {
+    return true
+  }
+
+  // 2. If A and B are both tuple origins and their schemes,
+  //    hosts, and port are identical, then return true.
+  if (A.protocol === B.protocol && A.hostname === B.hostname && A.port === B.port) {
+    return true
+  }
+
+  // 3. Return false.
+  return false
+}
+
+function createDeferredPromise () {
+  let res
+  let rej
+  const promise = new Promise((resolve, reject) => {
+    res = resolve
+    rej = reject
+  })
+
+  return { promise, resolve: res, reject: rej }
+}
+
+function isAborted (fetchParams) {
+  return fetchParams.controller.state === 'aborted'
+}
+
+function isCancelled (fetchParams) {
+  return fetchParams.controller.state === 'aborted' ||
+    fetchParams.controller.state === 'terminated'
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-method-normalize
+ * @param {string} method
+ */
+function normalizeMethod (method) {
+  return normalizedMethodRecordsBase[method.toLowerCase()] ?? method
+}
+
+// https://infra.spec.whatwg.org/#serialize-a-javascript-value-to-a-json-string
+function serializeJavascriptValueToJSONString (value) {
+  // 1. Let result be ? Call(%JSON.stringify%, undefined, « value »).
+  const result = JSON.stringify(value)
+
+  // 2. If result is undefined, then throw a TypeError.
+  if (result === undefined) {
+    throw new TypeError('Value is not JSON serializable')
+  }
+
+  // 3. Assert: result is a string.
+  assert(typeof result === 'string')
+
+  // 4. Return result.
+  return result
+}
+
+// https://tc39.es/ecma262/#sec-%25iteratorprototype%25-object
+const esIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf([][Symbol.iterator]()))
+
+/**
+ * @see https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
+ * @param {string} name name of the instance
+ * @param {symbol} kInternalIterator
+ * @param {string | number} [keyIndex]
+ * @param {string | number} [valueIndex]
+ */
+function createIterator (name, kInternalIterator, keyIndex = 0, valueIndex = 1) {
+  class FastIterableIterator {
+    /** @type {any} */
+    #target
+    /** @type {'key' | 'value' | 'key+value'} */
+    #kind
+    /** @type {number} */
+    #index
+
+    /**
+     * @see https://webidl.spec.whatwg.org/#dfn-default-iterator-object
+     * @param {unknown} target
+     * @param {'key' | 'value' | 'key+value'} kind
+     */
+    constructor (target, kind) {
+      this.#target = target
+      this.#kind = kind
+      this.#index = 0
+    }
+
+    next () {
+      // 1. Let interface be the interface for which the iterator prototype object exists.
+      // 2. Let thisValue be the this value.
+      // 3. Let object be ? ToObject(thisValue).
+      // 4. If object is a platform object, then perform a security
+      //    check, passing:
+      // 5. If object is not a default iterator object for interface,
+      //    then throw a TypeError.
+      if (typeof this !== 'object' || this === null || !(#target in this)) {
+        throw new TypeError(
+          `'next' called on an object that does not implement interface ${name} Iterator.`
+        )
+      }
+
+      // 6. Let index be object’s index.
+      // 7. Let kind be object’s kind.
+      // 8. Let values be object’s target's value pairs to iterate over.
+      const index = this.#index
+      const values = this.#target[kInternalIterator]
+
+      // 9. Let len be the length of values.
+      const len = values.length
+
+      // 10. If index is greater than or equal to len, then return
+      //     CreateIterResultObject(undefined, true).
+      if (index >= len) {
+        return {
+          value: undefined,
+          done: true
+        }
+      }
+
+      // 11. Let pair be the entry in values at index index.
+      const { [keyIndex]: key, [valueIndex]: value } = values[index]
+
+      // 12. Set object’s index to index + 1.
+      this.#index = index + 1
+
+      // 13. Return the iterator result for pair and kind.
+
+      // https://webidl.spec.whatwg.org/#iterator-result
+
+      // 1. Let result be a value determined by the value of kind:
+      let result
+      switch (this.#kind) {
+        case 'key':
+          // 1. Let idlKey be pair’s key.
+          // 2. Let key be the result of converting idlKey to an
+          //    ECMAScript value.
+          // 3. result is key.
+          result = key
+          break
+        case 'value':
+          // 1. Let idlValue be pair’s value.
+          // 2. Let value be the result of converting idlValue to
+          //    an ECMAScript value.
+          // 3. result is value.
+          result = value
+          break
+        case 'key+value':
+          // 1. Let idlKey be pair’s key.
+          // 2. Let idlValue be pair’s value.
+          // 3. Let key be the result of converting idlKey to an
+          //    ECMAScript value.
+          // 4. Let value be the result of converting idlValue to
+          //    an ECMAScript value.
+          // 5. Let array be ! ArrayCreate(2).
+          // 6. Call ! CreateDataProperty(array, "0", key).
+          // 7. Call ! CreateDataProperty(array, "1", value).
+          // 8. result is array.
+          result = [key, value]
+          break
+      }
+
+      // 2. Return CreateIterResultObject(result, false).
+      return {
+        value: result,
+        done: false
+      }
+    }
+  }
+
+  // https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
+  // @ts-ignore
+  delete FastIterableIterator.prototype.constructor
+
+  Object.setPrototypeOf(FastIterableIterator.prototype, esIteratorPrototype)
+
+  Object.defineProperties(FastIterableIterator.prototype, {
+    [Symbol.toStringTag]: {
+      writable: false,
+      enumerable: false,
+      configurable: true,
+      value: `${name} Iterator`
+    },
+    next: { writable: true, enumerable: true, configurable: true }
+  })
+
+  /**
+   * @param {unknown} target
+   * @param {'key' | 'value' | 'key+value'} kind
+   * @returns {IterableIterator<any>}
+   */
+  return function (target, kind) {
+    return new FastIterableIterator(target, kind)
+  }
+}
+
+/**
+ * @see https://webidl.spec.whatwg.org/#dfn-iterator-prototype-object
+ * @param {string} name name of the instance
+ * @param {any} object class
+ * @param {symbol} kInternalIterator
+ * @param {string | number} [keyIndex]
+ * @param {string | number} [valueIndex]
+ */
+function iteratorMixin (name, object, kInternalIterator, keyIndex = 0, valueIndex = 1) {
+  const makeIterator = createIterator(name, kInternalIterator, keyIndex, valueIndex)
+
+  const properties = {
+    keys: {
+      writable: true,
+      enumerable: true,
+      configurable: true,
+      value: function keys () {
+        webidl.brandCheck(this, object)
+        return makeIterator(this, 'key')
+      }
+    },
+    values: {
+      writable: true,
+      enumerable: true,
+      configurable: true,
+      value: function values () {
+        webidl.brandCheck(this, object)
+        return makeIterator(this, 'value')
+      }
+    },
+    entries: {
+      writable: true,
+      enumerable: true,
+      configurable: true,
+      value: function entries () {
+        webidl.brandCheck(this, object)
+        return makeIterator(this, 'key+value')
+      }
+    },
+    forEach: {
+      writable: true,
+      enumerable: true,
+      configurable: true,
+      value: function forEach (callbackfn, thisArg = globalThis) {
+        webidl.brandCheck(this, object)
+        webidl.argumentLengthCheck(arguments, 1, `${name}.forEach`)
+        if (typeof callbackfn !== 'function') {
+          throw new TypeError(
+            `Failed to execute 'forEach' on '${name}': parameter 1 is not of type 'Function'.`
+          )
+        }
+        for (const { 0: key, 1: value } of makeIterator(this, 'key+value')) {
+          callbackfn.call(thisArg, value, key, this)
+        }
+      }
+    }
+  }
+
+  return Object.defineProperties(object.prototype, {
+    ...properties,
+    [Symbol.iterator]: {
+      writable: true,
+      enumerable: false,
+      configurable: true,
+      value: properties.entries.value
+    }
+  })
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#body-fully-read
+ */
+async function fullyReadBody (body, processBody, processBodyError) {
+  // 1. If taskDestination is null, then set taskDestination to
+  //    the result of starting a new parallel queue.
+
+  // 2. Let successSteps given a byte sequence bytes be to queue a
+  //    fetch task to run processBody given bytes, with taskDestination.
+  const successSteps = processBody
+
+  // 3. Let errorSteps be to queue a fetch task to run processBodyError,
+  //    with taskDestination.
+  const errorSteps = processBodyError
+
+  // 4. Let reader be the result of getting a reader for body’s stream.
+  //    If that threw an exception, then run errorSteps with that
+  //    exception and return.
+  let reader
+
+  try {
+    reader = body.stream.getReader()
+  } catch (e) {
+    errorSteps(e)
+    return
+  }
+
+  // 5. Read all bytes from reader, given successSteps and errorSteps.
+  try {
+    successSteps(await readAllBytes(reader))
+  } catch (e) {
+    errorSteps(e)
+  }
+}
+
+function isReadableStreamLike (stream) {
+  return stream instanceof ReadableStream || (
+    stream[Symbol.toStringTag] === 'ReadableStream' &&
+    typeof stream.tee === 'function'
+  )
+}
+
+/**
+ * @param {ReadableStreamController<Uint8Array>} controller
+ */
+function readableStreamClose (controller) {
+  try {
+    controller.close()
+    controller.byobRequest?.respond(0)
+  } catch (err) {
+    // TODO: add comment explaining why this error occurs.
+    if (!err.message.includes('Controller is already closed') && !err.message.includes('ReadableStream is already closed')) {
+      throw err
+    }
+  }
+}
+
+const invalidIsomorphicEncodeValueRegex = /[^\x00-\xFF]/ // eslint-disable-line
+
+/**
+ * @see https://infra.spec.whatwg.org/#isomorphic-encode
+ * @param {string} input
+ */
+function isomorphicEncode (input) {
+  // 1. Assert: input contains no code points greater than U+00FF.
+  assert(!invalidIsomorphicEncodeValueRegex.test(input))
+
+  // 2. Return a byte sequence whose length is equal to input’s code
+  //    point length and whose bytes have the same values as the
+  //    values of input’s code points, in the same order
+  return input
+}
+
+/**
+ * @see https://streams.spec.whatwg.org/#readablestreamdefaultreader-read-all-bytes
+ * @see https://streams.spec.whatwg.org/#read-loop
+ * @param {ReadableStreamDefaultReader} reader
+ */
+async function readAllBytes (reader) {
+  const bytes = []
+  let byteLength = 0
+
+  while (true) {
+    const { done, value: chunk } = await reader.read()
+
+    if (done) {
+      // 1. Call successSteps with bytes.
+      return Buffer.concat(bytes, byteLength)
+    }
+
+    // 1. If chunk is not a Uint8Array object, call failureSteps
+    //    with a TypeError and abort these steps.
+    if (!isUint8Array(chunk)) {
+      throw new TypeError('Received non-Uint8Array chunk')
+    }
+
+    // 2. Append the bytes represented by chunk to bytes.
+    bytes.push(chunk)
+    byteLength += chunk.length
+
+    // 3. Read-loop given reader, bytes, successSteps, and failureSteps.
+  }
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#is-local
+ * @param {URL} url
+ */
+function urlIsLocal (url) {
+  assert('protocol' in url) // ensure it's a url object
+
+  const protocol = url.protocol
+
+  return protocol === 'about:' || protocol === 'blob:' || protocol === 'data:'
+}
+
+/**
+ * @param {string|URL} url
+ * @returns {boolean}
+ */
+function urlHasHttpsScheme (url) {
+  return (
+    (
+      typeof url === 'string' &&
+      url[5] === ':' &&
+      url[0] === 'h' &&
+      url[1] === 't' &&
+      url[2] === 't' &&
+      url[3] === 'p' &&
+      url[4] === 's'
+    ) ||
+    url.protocol === 'https:'
+  )
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#http-scheme
+ * @param {URL} url
+ */
+function urlIsHttpHttpsScheme (url) {
+  assert('protocol' in url) // ensure it's a url object
+
+  const protocol = url.protocol
+
+  return protocol === 'http:' || protocol === 'https:'
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#simple-range-header-value
+ * @param {string} value
+ * @param {boolean} allowWhitespace
+ */
+function simpleRangeHeaderValue (value, allowWhitespace) {
+  // 1. Let data be the isomorphic decoding of value.
+  // Note: isomorphic decoding takes a sequence of bytes (ie. a Uint8Array) and turns it into a string,
+  // nothing more. We obviously don't need to do that if value is a string already.
+  const data = value
+
+  // 2. If data does not start with "bytes", then return failure.
+  if (!data.startsWith('bytes')) {
+    return 'failure'
+  }
+
+  // 3. Let position be a position variable for data, initially pointing at the 5th code point of data.
+  const position = { position: 5 }
+
+  // 4. If allowWhitespace is true, collect a sequence of code points that are HTTP tab or space,
+  //    from data given position.
+  if (allowWhitespace) {
+    collectASequenceOfCodePoints(
+      (char) => char === '\t' || char === ' ',
+      data,
+      position
+    )
+  }
+
+  // 5. If the code point at position within data is not U+003D (=), then return failure.
+  if (data.charCodeAt(position.position) !== 0x3D) {
+    return 'failure'
+  }
+
+  // 6. Advance position by 1.
+  position.position++
+
+  // 7. If allowWhitespace is true, collect a sequence of code points that are HTTP tab or space, from
+  //    data given position.
+  if (allowWhitespace) {
+    collectASequenceOfCodePoints(
+      (char) => char === '\t' || char === ' ',
+      data,
+      position
+    )
+  }
+
+  // 8. Let rangeStart be the result of collecting a sequence of code points that are ASCII digits,
+  //    from data given position.
+  const rangeStart = collectASequenceOfCodePoints(
+    (char) => {
+      const code = char.charCodeAt(0)
+
+      return code >= 0x30 && code <= 0x39
+    },
+    data,
+    position
+  )
+
+  // 9. Let rangeStartValue be rangeStart, interpreted as decimal number, if rangeStart is not the
+  //    empty string; otherwise null.
+  const rangeStartValue = rangeStart.length ? Number(rangeStart) : null
+
+  // 10. If allowWhitespace is true, collect a sequence of code points that are HTTP tab or space,
+  //     from data given position.
+  if (allowWhitespace) {
+    collectASequenceOfCodePoints(
+      (char) => char === '\t' || char === ' ',
+      data,
+      position
+    )
+  }
+
+  // 11. If the code point at position within data is not U+002D (-), then return failure.
+  if (data.charCodeAt(position.position) !== 0x2D) {
+    return 'failure'
+  }
+
+  // 12. Advance position by 1.
+  position.position++
+
+  // 13. If allowWhitespace is true, collect a sequence of code points that are HTTP tab
+  //     or space, from data given position.
+  // Note from Khafra: its the same step as in #8 again lol
+  if (allowWhitespace) {
+    collectASequenceOfCodePoints(
+      (char) => char === '\t' || char === ' ',
+      data,
+      position
+    )
+  }
+
+  // 14. Let rangeEnd be the result of collecting a sequence of code points that are
+  //     ASCII digits, from data given position.
+  // Note from Khafra: you wouldn't guess it, but this is also the same step as #8
+  const rangeEnd = collectASequenceOfCodePoints(
+    (char) => {
+      const code = char.charCodeAt(0)
+
+      return code >= 0x30 && code <= 0x39
+    },
+    data,
+    position
+  )
+
+  // 15. Let rangeEndValue be rangeEnd, interpreted as decimal number, if rangeEnd
+  //     is not the empty string; otherwise null.
+  // Note from Khafra: THE SAME STEP, AGAIN!!!
+  // Note: why interpret as a decimal if we only collect ascii digits?
+  const rangeEndValue = rangeEnd.length ? Number(rangeEnd) : null
+
+  // 16. If position is not past the end of data, then return failure.
+  if (position.position < data.length) {
+    return 'failure'
+  }
+
+  // 17. If rangeEndValue and rangeStartValue are null, then return failure.
+  if (rangeEndValue === null && rangeStartValue === null) {
+    return 'failure'
+  }
+
+  // 18. If rangeStartValue and rangeEndValue are numbers, and rangeStartValue is
+  //     greater than rangeEndValue, then return failure.
+  // Note: ... when can they not be numbers?
+  if (rangeStartValue > rangeEndValue) {
+    return 'failure'
+  }
+
+  // 19. Return (rangeStartValue, rangeEndValue).
+  return { rangeStartValue, rangeEndValue }
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#build-a-content-range
+ * @param {number} rangeStart
+ * @param {number} rangeEnd
+ * @param {number} fullLength
+ */
+function buildContentRange (rangeStart, rangeEnd, fullLength) {
+  // 1. Let contentRange be `bytes `.
+  let contentRange = 'bytes '
+
+  // 2. Append rangeStart, serialized and isomorphic encoded, to contentRange.
+  contentRange += isomorphicEncode(`${rangeStart}`)
+
+  // 3. Append 0x2D (-) to contentRange.
+  contentRange += '-'
+
+  // 4. Append rangeEnd, serialized and isomorphic encoded to contentRange.
+  contentRange += isomorphicEncode(`${rangeEnd}`)
+
+  // 5. Append 0x2F (/) to contentRange.
+  contentRange += '/'
+
+  // 6. Append fullLength, serialized and isomorphic encoded to contentRange.
+  contentRange += isomorphicEncode(`${fullLength}`)
+
+  // 7. Return contentRange.
+  return contentRange
+}
+
+// A Stream, which pipes the response to zlib.createInflate() or
+// zlib.createInflateRaw() depending on the first byte of the Buffer.
+// If the lower byte of the first byte is 0x08, then the stream is
+// interpreted as a zlib stream, otherwise it's interpreted as a
+// raw deflate stream.
+class InflateStream extends Transform {
+  #zlibOptions
+
+  /** @param {zlib.ZlibOptions} [zlibOptions] */
+  constructor (zlibOptions) {
+    super()
+    this.#zlibOptions = zlibOptions
+  }
+
+  _transform (chunk, encoding, callback) {
+    if (!this._inflateStream) {
+      if (chunk.length === 0) {
+        callback()
+        return
+      }
+      this._inflateStream = (chunk[0] & 0x0F) === 0x08
+        ? zlib.createInflate(this.#zlibOptions)
+        : zlib.createInflateRaw(this.#zlibOptions)
+
+      this._inflateStream.on('data', this.push.bind(this))
+      this._inflateStream.on('end', () => this.push(null))
+      this._inflateStream.on('error', (err) => this.destroy(err))
+    }
+
+    this._inflateStream.write(chunk, encoding, callback)
+  }
+
+  _final (callback) {
+    if (this._inflateStream) {
+      this._inflateStream.end()
+      this._inflateStream = null
+    }
+    callback()
+  }
+}
+
+/**
+ * @param {zlib.ZlibOptions} [zlibOptions]
+ * @returns {InflateStream}
+ */
+function createInflate (zlibOptions) {
+  return new InflateStream(zlibOptions)
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-header-extract-mime-type
+ * @param {import('./headers').HeadersList} headers
+ */
+function extractMimeType (headers) {
+  // 1. Let charset be null.
+  let charset = null
+
+  // 2. Let essence be null.
+  let essence = null
+
+  // 3. Let mimeType be null.
+  let mimeType = null
+
+  // 4. Let values be the result of getting, decoding, and splitting `Content-Type` from headers.
+  const values = getDecodeSplit('content-type', headers)
+
+  // 5. If values is null, then return failure.
+  if (values === null) {
+    return 'failure'
+  }
+
+  // 6. For each value of values:
+  for (const value of values) {
+    // 6.1. Let temporaryMimeType be the result of parsing value.
+    const temporaryMimeType = parseMIMEType(value)
+
+    // 6.2. If temporaryMimeType is failure or its essence is "*/*", then continue.
+    if (temporaryMimeType === 'failure' || temporaryMimeType.essence === '*/*') {
+      continue
+    }
+
+    // 6.3. Set mimeType to temporaryMimeType.
+    mimeType = temporaryMimeType
+
+    // 6.4. If mimeType’s essence is not essence, then:
+    if (mimeType.essence !== essence) {
+      // 6.4.1. Set charset to null.
+      charset = null
+
+      // 6.4.2. If mimeType’s parameters["charset"] exists, then set charset to
+      //        mimeType’s parameters["charset"].
+      if (mimeType.parameters.has('charset')) {
+        charset = mimeType.parameters.get('charset')
+      }
+
+      // 6.4.3. Set essence to mimeType’s essence.
+      essence = mimeType.essence
+    } else if (!mimeType.parameters.has('charset') && charset !== null) {
+      // 6.5. Otherwise, if mimeType’s parameters["charset"] does not exist, and
+      //      charset is non-null, set mimeType’s parameters["charset"] to charset.
+      mimeType.parameters.set('charset', charset)
+    }
+  }
+
+  // 7. If mimeType is null, then return failure.
+  if (mimeType == null) {
+    return 'failure'
+  }
+
+  // 8. Return mimeType.
+  return mimeType
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#header-value-get-decode-and-split
+ * @param {string|null} value
+ */
+function gettingDecodingSplitting (value) {
+  // 1. Let input be the result of isomorphic decoding value.
+  const input = value
+
+  // 2. Let position be a position variable for input, initially pointing at the start of input.
+  const position = { position: 0 }
+
+  // 3. Let values be a list of strings, initially empty.
+  const values = []
+
+  // 4. Let temporaryValue be the empty string.
+  let temporaryValue = ''
+
+  // 5. While position is not past the end of input:
+  while (position.position < input.length) {
+    // 5.1. Append the result of collecting a sequence of code points that are not U+0022 (")
+    //      or U+002C (,) from input, given position, to temporaryValue.
+    temporaryValue += collectASequenceOfCodePoints(
+      (char) => char !== '"' && char !== ',',
+      input,
+      position
+    )
+
+    // 5.2. If position is not past the end of input, then:
+    if (position.position < input.length) {
+      // 5.2.1. If the code point at position within input is U+0022 ("), then:
+      if (input.charCodeAt(position.position) === 0x22) {
+        // 5.2.1.1. Append the result of collecting an HTTP quoted string from input, given position, to temporaryValue.
+        temporaryValue += collectAnHTTPQuotedString(
+          input,
+          position
+        )
+
+        // 5.2.1.2. If position is not past the end of input, then continue.
+        if (position.position < input.length) {
+          continue
+        }
+      } else {
+        // 5.2.2. Otherwise:
+
+        // 5.2.2.1. Assert: the code point at position within input is U+002C (,).
+        assert(input.charCodeAt(position.position) === 0x2C)
+
+        // 5.2.2.2. Advance position by 1.
+        position.position++
+      }
+    }
+
+    // 5.3. Remove all HTTP tab or space from the start and end of temporaryValue.
+    temporaryValue = removeChars(temporaryValue, true, true, (char) => char === 0x9 || char === 0x20)
+
+    // 5.4. Append temporaryValue to values.
+    values.push(temporaryValue)
+
+    // 5.6. Set temporaryValue to the empty string.
+    temporaryValue = ''
+  }
+
+  // 6. Return values.
+  return values
+}
+
+/**
+ * @see https://fetch.spec.whatwg.org/#concept-header-list-get-decode-split
+ * @param {string} name lowercase header name
+ * @param {import('./headers').HeadersList} list
+ */
+function getDecodeSplit (name, list) {
+  // 1. Let value be the result of getting name from list.
+  const value = list.get(name, true)
+
+  // 2. If value is null, then return null.
+  if (value === null) {
+    return null
+  }
+
+  // 3. Return the result of getting, decoding, and splitting value.
+  return gettingDecodingSplitting(value)
+}
+
+const textDecoder = new TextDecoder()
+
+/**
+ * @see https://encoding.spec.whatwg.org/#utf-8-decode
+ * @param {Buffer} buffer
+ */
+function utf8DecodeBytes (buffer) {
+  if (buffer.length === 0) {
+    return ''
+  }
+
+  // 1. Let buffer be the result of peeking three bytes from
+  //    ioQueue, converted to a byte sequence.
+
+  // 2. If buffer is 0xEF 0xBB 0xBF, then read three
+  //    bytes from ioQueue. (Do nothing with those bytes.)
+  if (buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) {
+    buffer = buffer.subarray(3)
+  }
+
+  // 3. Process a queue with an instance of UTF-8’s
+  //    decoder, ioQueue, output, and "replacement".
+  const output = textDecoder.decode(buffer)
+
+  // 4. Return output.
+  return output
+}
+
+class EnvironmentSettingsObjectBase {
+  get baseUrl () {
+    return getGlobalOrigin()
+  }
+
+  get origin () {
+    return this.baseUrl?.origin
+  }
+
+  policyContainer = makePolicyContainer()
+}
+
+class EnvironmentSettingsObject {
+  settingsObject = new EnvironmentSettingsObjectBase()
+}
+
+const environmentSettingsObject = new EnvironmentSettingsObject()
+
+module.exports = {
+  isAborted,
+  isCancelled,
+  isValidEncodedURL,
+  createDeferredPromise,
+  ReadableStreamFrom,
+  tryUpgradeRequestToAPotentiallyTrustworthyURL,
+  clampAndCoarsenConnectionTimingInfo,
+  coarsenedSharedCurrentTime,
+  determineRequestsReferrer,
+  makePolicyContainer,
+  clonePolicyContainer,
+  appendFetchMetadata,
+  appendRequestOriginHeader,
+  TAOCheck,
+  corsCheck,
+  crossOriginResourcePolicyCheck,
+  createOpaqueTimingInfo,
+  setRequestReferrerPolicyOnRedirect,
+  isValidHTTPToken,
+  requestBadPort,
+  requestCurrentURL,
+  responseURL,
+  responseLocationURL,
+  isBlobLike,
+  isURLPotentiallyTrustworthy,
+  isValidReasonPhrase,
+  sameOrigin,
+  normalizeMethod,
+  serializeJavascriptValueToJSONString,
+  iteratorMixin,
+  createIterator,
+  isValidHeaderName,
+  isValidHeaderValue,
+  isErrorLike,
+  fullyReadBody,
+  bytesMatch,
+  isReadableStreamLike,
+  readableStreamClose,
+  isomorphicEncode,
+  urlIsLocal,
+  urlHasHttpsScheme,
+  urlIsHttpHttpsScheme,
+  readAllBytes,
+  simpleRangeHeaderValue,
+  buildContentRange,
+  parseMetadata,
+  createInflate,
+  extractMimeType,
+  getDecodeSplit,
+  utf8DecodeBytes,
+  environmentSettingsObject
+}
+
+
+/***/ }),
+
+/***/ 37829:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { types, inspect } = __nccwpck_require__(47261)
+const { markAsUncloneable } = __nccwpck_require__(24086)
+const { toUSVString } = __nccwpck_require__(94407)
+
+/** @type {import('../../../types/webidl').Webidl} */
+const webidl = {}
+webidl.converters = {}
+webidl.util = {}
+webidl.errors = {}
+
+webidl.errors.exception = function (message) {
+  return new TypeError(`${message.header}: ${message.message}`)
+}
+
+webidl.errors.conversionFailed = function (context) {
+  const plural = context.types.length === 1 ? '' : ' one of'
+  const message =
+    `${context.argument} could not be converted to` +
+    `${plural}: ${context.types.join(', ')}.`
+
+  return webidl.errors.exception({
+    header: context.prefix,
+    message
+  })
+}
+
+webidl.errors.invalidArgument = function (context) {
+  return webidl.errors.exception({
+    header: context.prefix,
+    message: `"${context.value}" is an invalid ${context.type}.`
+  })
+}
+
+// https://webidl.spec.whatwg.org/#implements
+webidl.brandCheck = function (V, I, opts) {
+  if (opts?.strict !== false) {
+    if (!(V instanceof I)) {
+      const err = new TypeError('Illegal invocation')
+      err.code = 'ERR_INVALID_THIS' // node compat.
+      throw err
+    }
+  } else {
+    if (V?.[Symbol.toStringTag] !== I.prototype[Symbol.toStringTag]) {
+      const err = new TypeError('Illegal invocation')
+      err.code = 'ERR_INVALID_THIS' // node compat.
+      throw err
+    }
+  }
+}
+
+webidl.argumentLengthCheck = function ({ length }, min, ctx) {
+  if (length < min) {
+    throw webidl.errors.exception({
+      message: `${min} argument${min !== 1 ? 's' : ''} required, ` +
+               `but${length ? ' only' : ''} ${length} found.`,
+      header: ctx
+    })
+  }
+}
+
+webidl.illegalConstructor = function () {
+  throw webidl.errors.exception({
+    header: 'TypeError',
+    message: 'Illegal constructor'
+  })
+}
+
+// https://tc39.es/ecma262/#sec-ecmascript-data-types-and-values
+webidl.util.Type = function (V) {
+  switch (typeof V) {
+    case 'undefined': return 'Undefined'
+    case 'boolean': return 'Boolean'
+    case 'string': return 'String'
+    case 'symbol': return 'Symbol'
+    case 'number': return 'Number'
+    case 'bigint': return 'BigInt'
+    case 'function':
+    case 'object': {
+      if (V === null) {
+        return 'Null'
+      }
+
+      return 'Object'
+    }
+  }
+}
+
+webidl.util.markAsUncloneable = markAsUncloneable || (() => {})
+// https://webidl.spec.whatwg.org/#abstract-opdef-converttoint
+webidl.util.ConvertToInt = function (V, bitLength, signedness, opts) {
+  let upperBound
+  let lowerBound
+
+  // 1. If bitLength is 64, then:
+  if (bitLength === 64) {
+    // 1. Let upperBound be 2^53 − 1.
+    upperBound = Math.pow(2, 53) - 1
+
+    // 2. If signedness is "unsigned", then let lowerBound be 0.
+    if (signedness === 'unsigned') {
+      lowerBound = 0
+    } else {
+      // 3. Otherwise let lowerBound be −2^53 + 1.
+      lowerBound = Math.pow(-2, 53) + 1
+    }
+  } else if (signedness === 'unsigned') {
+    // 2. Otherwise, if signedness is "unsigned", then:
+
+    // 1. Let lowerBound be 0.
+    lowerBound = 0
+
+    // 2. Let upperBound be 2^bitLength − 1.
+    upperBound = Math.pow(2, bitLength) - 1
+  } else {
+    // 3. Otherwise:
+
+    // 1. Let lowerBound be -2^bitLength − 1.
+    lowerBound = Math.pow(-2, bitLength) - 1
+
+    // 2. Let upperBound be 2^bitLength − 1 − 1.
+    upperBound = Math.pow(2, bitLength - 1) - 1
+  }
+
+  // 4. Let x be ? ToNumber(V).
+  let x = Number(V)
+
+  // 5. If x is −0, then set x to +0.
+  if (x === 0) {
+    x = 0
+  }
+
+  // 6. If the conversion is to an IDL type associated
+  //    with the [EnforceRange] extended attribute, then:
+  if (opts?.enforceRange === true) {
+    // 1. If x is NaN, +∞, or −∞, then throw a TypeError.
+    if (
+      Number.isNaN(x) ||
+      x === Number.POSITIVE_INFINITY ||
+      x === Number.NEGATIVE_INFINITY
+    ) {
+      throw webidl.errors.exception({
+        header: 'Integer conversion',
+        message: `Could not convert ${webidl.util.Stringify(V)} to an integer.`
+      })
+    }
+
+    // 2. Set x to IntegerPart(x).
+    x = webidl.util.IntegerPart(x)
+
+    // 3. If x < lowerBound or x > upperBound, then
+    //    throw a TypeError.
+    if (x < lowerBound || x > upperBound) {
+      throw webidl.errors.exception({
+        header: 'Integer conversion',
+        message: `Value must be between ${lowerBound}-${upperBound}, got ${x}.`
+      })
+    }
+
+    // 4. Return x.
+    return x
+  }
+
+  // 7. If x is not NaN and the conversion is to an IDL
+  //    type associated with the [Clamp] extended
+  //    attribute, then:
+  if (!Number.isNaN(x) && opts?.clamp === true) {
+    // 1. Set x to min(max(x, lowerBound), upperBound).
+    x = Math.min(Math.max(x, lowerBound), upperBound)
+
+    // 2. Round x to the nearest integer, choosing the
+    //    even integer if it lies halfway between two,
+    //    and choosing +0 rather than −0.
+    if (Math.floor(x) % 2 === 0) {
+      x = Math.floor(x)
+    } else {
+      x = Math.ceil(x)
+    }
+
+    // 3. Return x.
+    return x
+  }
+
+  // 8. If x is NaN, +0, +∞, or −∞, then return +0.
+  if (
+    Number.isNaN(x) ||
+    (x === 0 && Object.is(0, x)) ||
+    x === Number.POSITIVE_INFINITY ||
+    x === Number.NEGATIVE_INFINITY
+  ) {
+    return 0
+  }
+
+  // 9. Set x to IntegerPart(x).
+  x = webidl.util.IntegerPart(x)
+
+  // 10. Set x to x modulo 2^bitLength.
+  x = x % Math.pow(2, bitLength)
+
+  // 11. If signedness is "signed" and x ≥ 2^bitLength − 1,
+  //    then return x − 2^bitLength.
+  if (signedness === 'signed' && x >= Math.pow(2, bitLength) - 1) {
+    return x - Math.pow(2, bitLength)
+  }
+
+  // 12. Otherwise, return x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#abstract-opdef-integerpart
+webidl.util.IntegerPart = function (n) {
+  // 1. Let r be floor(abs(n)).
+  const r = Math.floor(Math.abs(n))
+
+  // 2. If n < 0, then return -1 × r.
+  if (n < 0) {
+    return -1 * r
+  }
+
+  // 3. Otherwise, return r.
+  return r
+}
+
+webidl.util.Stringify = function (V) {
+  const type = webidl.util.Type(V)
+
+  switch (type) {
+    case 'Symbol':
+      return `Symbol(${V.description})`
+    case 'Object':
+      return inspect(V)
+    case 'String':
+      return `"${V}"`
+    default:
+      return `${V}`
+  }
+}
+
+// https://webidl.spec.whatwg.org/#es-sequence
+webidl.sequenceConverter = function (converter) {
+  return (V, prefix, argument, Iterable) => {
+    // 1. If Type(V) is not Object, throw a TypeError.
+    if (webidl.util.Type(V) !== 'Object') {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: `${argument} (${webidl.util.Stringify(V)}) is not iterable.`
+      })
+    }
+
+    // 2. Let method be ? GetMethod(V, @@iterator).
+    /** @type {Generator} */
+    const method = typeof Iterable === 'function' ? Iterable() : V?.[Symbol.iterator]?.()
+    const seq = []
+    let index = 0
+
+    // 3. If method is undefined, throw a TypeError.
+    if (
+      method === undefined ||
+      typeof method.next !== 'function'
+    ) {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: `${argument} is not iterable.`
+      })
+    }
+
+    // https://webidl.spec.whatwg.org/#create-sequence-from-iterable
+    while (true) {
+      const { done, value } = method.next()
+
+      if (done) {
+        break
+      }
+
+      seq.push(converter(value, prefix, `${argument}[${index++}]`))
+    }
+
+    return seq
+  }
+}
+
+// https://webidl.spec.whatwg.org/#es-to-record
+webidl.recordConverter = function (keyConverter, valueConverter) {
+  return (O, prefix, argument) => {
+    // 1. If Type(O) is not Object, throw a TypeError.
+    if (webidl.util.Type(O) !== 'Object') {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: `${argument} ("${webidl.util.Type(O)}") is not an Object.`
+      })
+    }
+
+    // 2. Let result be a new empty instance of record<K, V>.
+    const result = {}
+
+    if (!types.isProxy(O)) {
+      // 1. Let desc be ? O.[[GetOwnProperty]](key).
+      const keys = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)]
+
+      for (const key of keys) {
+        // 1. Let typedKey be key converted to an IDL value of type K.
+        const typedKey = keyConverter(key, prefix, argument)
+
+        // 2. Let value be ? Get(O, key).
+        // 3. Let typedValue be value converted to an IDL value of type V.
+        const typedValue = valueConverter(O[key], prefix, argument)
+
+        // 4. Set result[typedKey] to typedValue.
+        result[typedKey] = typedValue
+      }
+
+      // 5. Return result.
+      return result
+    }
+
+    // 3. Let keys be ? O.[[OwnPropertyKeys]]().
+    const keys = Reflect.ownKeys(O)
+
+    // 4. For each key of keys.
+    for (const key of keys) {
+      // 1. Let desc be ? O.[[GetOwnProperty]](key).
+      const desc = Reflect.getOwnPropertyDescriptor(O, key)
+
+      // 2. If desc is not undefined and desc.[[Enumerable]] is true:
+      if (desc?.enumerable) {
+        // 1. Let typedKey be key converted to an IDL value of type K.
+        const typedKey = keyConverter(key, prefix, argument)
+
+        // 2. Let value be ? Get(O, key).
+        // 3. Let typedValue be value converted to an IDL value of type V.
+        const typedValue = valueConverter(O[key], prefix, argument)
+
+        // 4. Set result[typedKey] to typedValue.
+        result[typedKey] = typedValue
+      }
+    }
+
+    // 5. Return result.
+    return result
+  }
+}
+
+webidl.interfaceConverter = function (i) {
+  return (V, prefix, argument, opts) => {
+    if (opts?.strict !== false && !(V instanceof i)) {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: `Expected ${argument} ("${webidl.util.Stringify(V)}") to be an instance of ${i.name}.`
+      })
+    }
+
+    return V
+  }
+}
+
+webidl.dictionaryConverter = function (converters) {
+  return (dictionary, prefix, argument) => {
+    const type = webidl.util.Type(dictionary)
+    const dict = {}
+
+    if (type === 'Null' || type === 'Undefined') {
+      return dict
+    } else if (type !== 'Object') {
+      throw webidl.errors.exception({
+        header: prefix,
+        message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
+      })
+    }
+
+    for (const options of converters) {
+      const { key, defaultValue, required, converter } = options
+
+      if (required === true) {
+        if (!Object.hasOwn(dictionary, key)) {
+          throw webidl.errors.exception({
+            header: prefix,
+            message: `Missing required key "${key}".`
+          })
+        }
+      }
+
+      let value = dictionary[key]
+      const hasDefault = Object.hasOwn(options, 'defaultValue')
+
+      // Only use defaultValue if value is undefined and
+      // a defaultValue options was provided.
+      if (hasDefault && value !== null) {
+        value ??= defaultValue()
+      }
+
+      // A key can be optional and have no default value.
+      // When this happens, do not perform a conversion,
+      // and do not assign the key a value.
+      if (required || hasDefault || value !== undefined) {
+        value = converter(value, prefix, `${argument}.${key}`)
+
+        if (
+          options.allowedValues &&
+          !options.allowedValues.includes(value)
+        ) {
+          throw webidl.errors.exception({
+            header: prefix,
+            message: `${value} is not an accepted type. Expected one of ${options.allowedValues.join(', ')}.`
+          })
+        }
+
+        dict[key] = value
+      }
+    }
+
+    return dict
+  }
+}
+
+webidl.nullableConverter = function (converter) {
+  return (V, prefix, argument) => {
+    if (V === null) {
+      return V
+    }
+
+    return converter(V, prefix, argument)
+  }
+}
+
+// https://webidl.spec.whatwg.org/#es-DOMString
+webidl.converters.DOMString = function (V, prefix, argument, opts) {
+  // 1. If V is null and the conversion is to an IDL type
+  //    associated with the [LegacyNullToEmptyString]
+  //    extended attribute, then return the DOMString value
+  //    that represents the empty string.
+  if (V === null && opts?.legacyNullToEmptyString) {
+    return ''
+  }
+
+  // 2. Let x be ? ToString(V).
+  if (typeof V === 'symbol') {
+    throw webidl.errors.exception({
+      header: prefix,
+      message: `${argument} is a symbol, which cannot be converted to a DOMString.`
+    })
+  }
+
+  // 3. Return the IDL DOMString value that represents the
+  //    same sequence of code units as the one the
+  //    ECMAScript String value x represents.
+  return String(V)
+}
+
+// https://webidl.spec.whatwg.org/#es-ByteString
+webidl.converters.ByteString = function (V, prefix, argument) {
+  // 1. Let x be ? ToString(V).
+  // Note: DOMString converter perform ? ToString(V)
+  const x = webidl.converters.DOMString(V, prefix, argument)
+
+  // 2. If the value of any element of x is greater than
+  //    255, then throw a TypeError.
+  for (let index = 0; index < x.length; index++) {
+    if (x.charCodeAt(index) > 255) {
+      throw new TypeError(
+        'Cannot convert argument to a ByteString because the character at ' +
+        `index ${index} has a value of ${x.charCodeAt(index)} which is greater than 255.`
+      )
+    }
+  }
+
+  // 3. Return an IDL ByteString value whose length is the
+  //    length of x, and where the value of each element is
+  //    the value of the corresponding element of x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#es-USVString
+// TODO: rewrite this so we can control the errors thrown
+webidl.converters.USVString = toUSVString
+
+// https://webidl.spec.whatwg.org/#es-boolean
+webidl.converters.boolean = function (V) {
+  // 1. Let x be the result of computing ToBoolean(V).
+  const x = Boolean(V)
+
+  // 2. Return the IDL boolean value that is the one that represents
+  //    the same truth value as the ECMAScript Boolean value x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#es-any
+webidl.converters.any = function (V) {
+  return V
+}
+
+// https://webidl.spec.whatwg.org/#es-long-long
+webidl.converters['long long'] = function (V, prefix, argument) {
+  // 1. Let x be ? ConvertToInt(V, 64, "signed").
+  const x = webidl.util.ConvertToInt(V, 64, 'signed', undefined, prefix, argument)
+
+  // 2. Return the IDL long long value that represents
+  //    the same numeric value as x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#es-unsigned-long-long
+webidl.converters['unsigned long long'] = function (V, prefix, argument) {
+  // 1. Let x be ? ConvertToInt(V, 64, "unsigned").
+  const x = webidl.util.ConvertToInt(V, 64, 'unsigned', undefined, prefix, argument)
+
+  // 2. Return the IDL unsigned long long value that
+  //    represents the same numeric value as x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#es-unsigned-long
+webidl.converters['unsigned long'] = function (V, prefix, argument) {
+  // 1. Let x be ? ConvertToInt(V, 32, "unsigned").
+  const x = webidl.util.ConvertToInt(V, 32, 'unsigned', undefined, prefix, argument)
+
+  // 2. Return the IDL unsigned long value that
+  //    represents the same numeric value as x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#es-unsigned-short
+webidl.converters['unsigned short'] = function (V, prefix, argument, opts) {
+  // 1. Let x be ? ConvertToInt(V, 16, "unsigned").
+  const x = webidl.util.ConvertToInt(V, 16, 'unsigned', opts, prefix, argument)
+
+  // 2. Return the IDL unsigned short value that represents
+  //    the same numeric value as x.
+  return x
+}
+
+// https://webidl.spec.whatwg.org/#idl-ArrayBuffer
+webidl.converters.ArrayBuffer = function (V, prefix, argument, opts) {
+  // 1. If Type(V) is not Object, or V does not have an
+  //    [[ArrayBufferData]] internal slot, then throw a
+  //    TypeError.
+  // see: https://tc39.es/ecma262/#sec-properties-of-the-arraybuffer-instances
+  // see: https://tc39.es/ecma262/#sec-properties-of-the-sharedarraybuffer-instances
+  if (
+    webidl.util.Type(V) !== 'Object' ||
+    !types.isAnyArrayBuffer(V)
+  ) {
+    throw webidl.errors.conversionFailed({
+      prefix,
+      argument: `${argument} ("${webidl.util.Stringify(V)}")`,
+      types: ['ArrayBuffer']
+    })
+  }
+
+  // 2. If the conversion is not to an IDL type associated
+  //    with the [AllowShared] extended attribute, and
+  //    IsSharedArrayBuffer(V) is true, then throw a
+  //    TypeError.
+  if (opts?.allowShared === false && types.isSharedArrayBuffer(V)) {
+    throw webidl.errors.exception({
+      header: 'ArrayBuffer',
+      message: 'SharedArrayBuffer is not allowed.'
+    })
+  }
+
+  // 3. If the conversion is not to an IDL type associated
+  //    with the [AllowResizable] extended attribute, and
+  //    IsResizableArrayBuffer(V) is true, then throw a
+  //    TypeError.
+  if (V.resizable || V.growable) {
+    throw webidl.errors.exception({
+      header: 'ArrayBuffer',
+      message: 'Received a resizable ArrayBuffer.'
+    })
+  }
+
+  // 4. Return the IDL ArrayBuffer value that is a
+  //    reference to the same object as V.
+  return V
+}
+
+webidl.converters.TypedArray = function (V, T, prefix, name, opts) {
+  // 1. Let T be the IDL type V is being converted to.
+
+  // 2. If Type(V) is not Object, or V does not have a
+  //    [[TypedArrayName]] internal slot with a value
+  //    equal to T’s name, then throw a TypeError.
+  if (
+    webidl.util.Type(V) !== 'Object' ||
+    !types.isTypedArray(V) ||
+    V.constructor.name !== T.name
+  ) {
+    throw webidl.errors.conversionFailed({
+      prefix,
+      argument: `${name} ("${webidl.util.Stringify(V)}")`,
+      types: [T.name]
+    })
+  }
+
+  // 3. If the conversion is not to an IDL type associated
+  //    with the [AllowShared] extended attribute, and
+  //    IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is
+  //    true, then throw a TypeError.
+  if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
+    throw webidl.errors.exception({
+      header: 'ArrayBuffer',
+      message: 'SharedArrayBuffer is not allowed.'
+    })
+  }
+
+  // 4. If the conversion is not to an IDL type associated
+  //    with the [AllowResizable] extended attribute, and
+  //    IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is
+  //    true, then throw a TypeError.
+  if (V.buffer.resizable || V.buffer.growable) {
+    throw webidl.errors.exception({
+      header: 'ArrayBuffer',
+      message: 'Received a resizable ArrayBuffer.'
+    })
+  }
+
+  // 5. Return the IDL value of type T that is a reference
+  //    to the same object as V.
+  return V
+}
+
+webidl.converters.DataView = function (V, prefix, name, opts) {
+  // 1. If Type(V) is not Object, or V does not have a
+  //    [[DataView]] internal slot, then throw a TypeError.
+  if (webidl.util.Type(V) !== 'Object' || !types.isDataView(V)) {
+    throw webidl.errors.exception({
+      header: prefix,
+      message: `${name} is not a DataView.`
+    })
+  }
+
+  // 2. If the conversion is not to an IDL type associated
+  //    with the [AllowShared] extended attribute, and
+  //    IsSharedArrayBuffer(V.[[ViewedArrayBuffer]]) is true,
+  //    then throw a TypeError.
+  if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
+    throw webidl.errors.exception({
+      header: 'ArrayBuffer',
+      message: 'SharedArrayBuffer is not allowed.'
+    })
+  }
+
+  // 3. If the conversion is not to an IDL type associated
+  //    with the [AllowResizable] extended attribute, and
+  //    IsResizableArrayBuffer(V.[[ViewedArrayBuffer]]) is
+  //    true, then throw a TypeError.
+  if (V.buffer.resizable || V.buffer.growable) {
+    throw webidl.errors.exception({
+      header: 'ArrayBuffer',
+      message: 'Received a resizable ArrayBuffer.'
+    })
+  }
+
+  // 4. Return the IDL DataView value that is a reference
+  //    to the same object as V.
+  return V
+}
+
+// https://webidl.spec.whatwg.org/#BufferSource
+webidl.converters.BufferSource = function (V, prefix, name, opts) {
+  if (types.isAnyArrayBuffer(V)) {
+    return webidl.converters.ArrayBuffer(V, prefix, name, { ...opts, allowShared: false })
+  }
+
+  if (types.isTypedArray(V)) {
+    return webidl.converters.TypedArray(V, V.constructor, prefix, name, { ...opts, allowShared: false })
+  }
+
+  if (types.isDataView(V)) {
+    return webidl.converters.DataView(V, prefix, name, { ...opts, allowShared: false })
+  }
+
+  throw webidl.errors.conversionFailed({
+    prefix,
+    argument: `${name} ("${webidl.util.Stringify(V)}")`,
+    types: ['BufferSource']
+  })
+}
+
+webidl.converters['sequence<ByteString>'] = webidl.sequenceConverter(
+  webidl.converters.ByteString
+)
+
+webidl.converters['sequence<sequence<ByteString>>'] = webidl.sequenceConverter(
+  webidl.converters['sequence<ByteString>']
+)
+
+webidl.converters['record<ByteString, ByteString>'] = webidl.recordConverter(
+  webidl.converters.ByteString,
+  webidl.converters.ByteString
+)
+
+module.exports = {
+  webidl
+}
+
+
+/***/ }),
+
+/***/ 19420:
+/***/ ((module) => {
+
+"use strict";
+
+
+/**
+ * @see https://encoding.spec.whatwg.org/#concept-encoding-get
+ * @param {string|undefined} label
+ */
+function getEncoding (label) {
+  if (!label) {
+    return 'failure'
+  }
+
+  // 1. Remove any leading and trailing ASCII whitespace from label.
+  // 2. If label is an ASCII case-insensitive match for any of the
+  //    labels listed in the table below, then return the
+  //    corresponding encoding; otherwise return failure.
+  switch (label.trim().toLowerCase()) {
+    case 'unicode-1-1-utf-8':
+    case 'unicode11utf8':
+    case 'unicode20utf8':
+    case 'utf-8':
+    case 'utf8':
+    case 'x-unicode20utf8':
+      return 'UTF-8'
+    case '866':
+    case 'cp866':
+    case 'csibm866':
+    case 'ibm866':
+      return 'IBM866'
+    case 'csisolatin2':
+    case 'iso-8859-2':
+    case 'iso-ir-101':
+    case 'iso8859-2':
+    case 'iso88592':
+    case 'iso_8859-2':
+    case 'iso_8859-2:1987':
+    case 'l2':
+    case 'latin2':
+      return 'ISO-8859-2'
+    case 'csisolatin3':
+    case 'iso-8859-3':
+    case 'iso-ir-109':
+    case 'iso8859-3':
+    case 'iso88593':
+    case 'iso_8859-3':
+    case 'iso_8859-3:1988':
+    case 'l3':
+    case 'latin3':
+      return 'ISO-8859-3'
+    case 'csisolatin4':
+    case 'iso-8859-4':
+    case 'iso-ir-110':
+    case 'iso8859-4':
+    case 'iso88594':
+    case 'iso_8859-4':
+    case 'iso_8859-4:1988':
+    case 'l4':
+    case 'latin4':
+      return 'ISO-8859-4'
+    case 'csisolatincyrillic':
+    case 'cyrillic':
+    case 'iso-8859-5':
+    case 'iso-ir-144':
+    case 'iso8859-5':
+    case 'iso88595':
+    case 'iso_8859-5':
+    case 'iso_8859-5:1988':
+      return 'ISO-8859-5'
+    case 'arabic':
+    case 'asmo-708':
+    case 'csiso88596e':
+    case 'csiso88596i':
+    case 'csisolatinarabic':
+    case 'ecma-114':
+    case 'iso-8859-6':
+    case 'iso-8859-6-e':
+    case 'iso-8859-6-i':
+    case 'iso-ir-127':
+    case 'iso8859-6':
+    case 'iso88596':
+    case 'iso_8859-6':
+    case 'iso_8859-6:1987':
+      return 'ISO-8859-6'
+    case 'csisolatingreek':
+    case 'ecma-118':
+    case 'elot_928':
+    case 'greek':
+    case 'greek8':
+    case 'iso-8859-7':
+    case 'iso-ir-126':
+    case 'iso8859-7':
+    case 'iso88597':
+    case 'iso_8859-7':
+    case 'iso_8859-7:1987':
+    case 'sun_eu_greek':
+      return 'ISO-8859-7'
+    case 'csiso88598e':
+    case 'csisolatinhebrew':
+    case 'hebrew':
+    case 'iso-8859-8':
+    case 'iso-8859-8-e':
+    case 'iso-ir-138':
+    case 'iso8859-8':
+    case 'iso88598':
+    case 'iso_8859-8':
+    case 'iso_8859-8:1988':
+    case 'visual':
+      return 'ISO-8859-8'
+    case 'csiso88598i':
+    case 'iso-8859-8-i':
+    case 'logical':
+      return 'ISO-8859-8-I'
+    case 'csisolatin6':
+    case 'iso-8859-10':
+    case 'iso-ir-157':
+    case 'iso8859-10':
+    case 'iso885910':
+    case 'l6':
+    case 'latin6':
+      return 'ISO-8859-10'
+    case 'iso-8859-13':
+    case 'iso8859-13':
+    case 'iso885913':
+      return 'ISO-8859-13'
+    case 'iso-8859-14':
+    case 'iso8859-14':
+    case 'iso885914':
+      return 'ISO-8859-14'
+    case 'csisolatin9':
+    case 'iso-8859-15':
+    case 'iso8859-15':
+    case 'iso885915':
+    case 'iso_8859-15':
+    case 'l9':
+      return 'ISO-8859-15'
+    case 'iso-8859-16':
+      return 'ISO-8859-16'
+    case 'cskoi8r':
+    case 'koi':
+    case 'koi8':
+    case 'koi8-r':
+    case 'koi8_r':
+      return 'KOI8-R'
+    case 'koi8-ru':
+    case 'koi8-u':
+      return 'KOI8-U'
+    case 'csmacintosh':
+    case 'mac':
+    case 'macintosh':
+    case 'x-mac-roman':
+      return 'macintosh'
+    case 'iso-8859-11':
+    case 'iso8859-11':
+    case 'iso885911':
+    case 'tis-620':
+    case 'windows-874':
+      return 'windows-874'
+    case 'cp1250':
+    case 'windows-1250':
+    case 'x-cp1250':
+      return 'windows-1250'
+    case 'cp1251':
+    case 'windows-1251':
+    case 'x-cp1251':
+      return 'windows-1251'
+    case 'ansi_x3.4-1968':
+    case 'ascii':
+    case 'cp1252':
+    case 'cp819':
+    case 'csisolatin1':
+    case 'ibm819':
+    case 'iso-8859-1':
+    case 'iso-ir-100':
+    case 'iso8859-1':
+    case 'iso88591':
+    case 'iso_8859-1':
+    case 'iso_8859-1:1987':
+    case 'l1':
+    case 'latin1':
+    case 'us-ascii':
+    case 'windows-1252':
+    case 'x-cp1252':
+      return 'windows-1252'
+    case 'cp1253':
+    case 'windows-1253':
+    case 'x-cp1253':
+      return 'windows-1253'
+    case 'cp1254':
+    case 'csisolatin5':
+    case 'iso-8859-9':
+    case 'iso-ir-148':
+    case 'iso8859-9':
+    case 'iso88599':
+    case 'iso_8859-9':
+    case 'iso_8859-9:1989':
+    case 'l5':
+    case 'latin5':
+    case 'windows-1254':
+    case 'x-cp1254':
+      return 'windows-1254'
+    case 'cp1255':
+    case 'windows-1255':
+    case 'x-cp1255':
+      return 'windows-1255'
+    case 'cp1256':
+    case 'windows-1256':
+    case 'x-cp1256':
+      return 'windows-1256'
+    case 'cp1257':
+    case 'windows-1257':
+    case 'x-cp1257':
+      return 'windows-1257'
+    case 'cp1258':
+    case 'windows-1258':
+    case 'x-cp1258':
+      return 'windows-1258'
+    case 'x-mac-cyrillic':
+    case 'x-mac-ukrainian':
+      return 'x-mac-cyrillic'
+    case 'chinese':
+    case 'csgb2312':
+    case 'csiso58gb231280':
+    case 'gb2312':
+    case 'gb_2312':
+    case 'gb_2312-80':
+    case 'gbk':
+    case 'iso-ir-58':
+    case 'x-gbk':
+      return 'GBK'
+    case 'gb18030':
+      return 'gb18030'
+    case 'big5':
+    case 'big5-hkscs':
+    case 'cn-big5':
+    case 'csbig5':
+    case 'x-x-big5':
+      return 'Big5'
+    case 'cseucpkdfmtjapanese':
+    case 'euc-jp':
+    case 'x-euc-jp':
+      return 'EUC-JP'
+    case 'csiso2022jp':
+    case 'iso-2022-jp':
+      return 'ISO-2022-JP'
+    case 'csshiftjis':
+    case 'ms932':
+    case 'ms_kanji':
+    case 'shift-jis':
+    case 'shift_jis':
+    case 'sjis':
+    case 'windows-31j':
+    case 'x-sjis':
+      return 'Shift_JIS'
+    case 'cseuckr':
+    case 'csksc56011987':
+    case 'euc-kr':
+    case 'iso-ir-149':
+    case 'korean':
+    case 'ks_c_5601-1987':
+    case 'ks_c_5601-1989':
+    case 'ksc5601':
+    case 'ksc_5601':
+    case 'windows-949':
+      return 'EUC-KR'
+    case 'csiso2022kr':
+    case 'hz-gb-2312':
+    case 'iso-2022-cn':
+    case 'iso-2022-cn-ext':
+    case 'iso-2022-kr':
+    case 'replacement':
+      return 'replacement'
+    case 'unicodefffe':
+    case 'utf-16be':
+      return 'UTF-16BE'
+    case 'csunicode':
+    case 'iso-10646-ucs-2':
+    case 'ucs-2':
+    case 'unicode':
+    case 'unicodefeff':
+    case 'utf-16':
+    case 'utf-16le':
+      return 'UTF-16LE'
+    case 'x-user-defined':
+      return 'x-user-defined'
+    default: return 'failure'
+  }
+}
+
+module.exports = {
+  getEncoding
+}
+
+
+/***/ }),
+
+/***/ 70923:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  staticPropertyDescriptors,
+  readOperation,
+  fireAProgressEvent
+} = __nccwpck_require__(82947)
+const {
+  kState,
+  kError,
+  kResult,
+  kEvents,
+  kAborted
+} = __nccwpck_require__(24666)
+const { webidl } = __nccwpck_require__(37829)
+const { kEnumerableProperty } = __nccwpck_require__(94407)
+
+class FileReader extends EventTarget {
+  constructor () {
+    super()
+
+    this[kState] = 'empty'
+    this[kResult] = null
+    this[kError] = null
+    this[kEvents] = {
+      loadend: null,
+      error: null,
+      abort: null,
+      load: null,
+      progress: null,
+      loadstart: null
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dfn-readAsArrayBuffer
+   * @param {import('buffer').Blob} blob
+   */
+  readAsArrayBuffer (blob) {
+    webidl.brandCheck(this, FileReader)
+
+    webidl.argumentLengthCheck(arguments, 1, 'FileReader.readAsArrayBuffer')
+
+    blob = webidl.converters.Blob(blob, { strict: false })
+
+    // The readAsArrayBuffer(blob) method, when invoked,
+    // must initiate a read operation for blob with ArrayBuffer.
+    readOperation(this, blob, 'ArrayBuffer')
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#readAsBinaryString
+   * @param {import('buffer').Blob} blob
+   */
+  readAsBinaryString (blob) {
+    webidl.brandCheck(this, FileReader)
+
+    webidl.argumentLengthCheck(arguments, 1, 'FileReader.readAsBinaryString')
+
+    blob = webidl.converters.Blob(blob, { strict: false })
+
+    // The readAsBinaryString(blob) method, when invoked,
+    // must initiate a read operation for blob with BinaryString.
+    readOperation(this, blob, 'BinaryString')
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#readAsDataText
+   * @param {import('buffer').Blob} blob
+   * @param {string?} encoding
+   */
+  readAsText (blob, encoding = undefined) {
+    webidl.brandCheck(this, FileReader)
+
+    webidl.argumentLengthCheck(arguments, 1, 'FileReader.readAsText')
+
+    blob = webidl.converters.Blob(blob, { strict: false })
+
+    if (encoding !== undefined) {
+      encoding = webidl.converters.DOMString(encoding, 'FileReader.readAsText', 'encoding')
+    }
+
+    // The readAsText(blob, encoding) method, when invoked,
+    // must initiate a read operation for blob with Text and encoding.
+    readOperation(this, blob, 'Text', encoding)
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dfn-readAsDataURL
+   * @param {import('buffer').Blob} blob
+   */
+  readAsDataURL (blob) {
+    webidl.brandCheck(this, FileReader)
+
+    webidl.argumentLengthCheck(arguments, 1, 'FileReader.readAsDataURL')
+
+    blob = webidl.converters.Blob(blob, { strict: false })
+
+    // The readAsDataURL(blob) method, when invoked, must
+    // initiate a read operation for blob with DataURL.
+    readOperation(this, blob, 'DataURL')
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dfn-abort
+   */
+  abort () {
+    // 1. If this's state is "empty" or if this's state is
+    //    "done" set this's result to null and terminate
+    //    this algorithm.
+    if (this[kState] === 'empty' || this[kState] === 'done') {
+      this[kResult] = null
+      return
+    }
+
+    // 2. If this's state is "loading" set this's state to
+    //    "done" and set this's result to null.
+    if (this[kState] === 'loading') {
+      this[kState] = 'done'
+      this[kResult] = null
+    }
+
+    // 3. If there are any tasks from this on the file reading
+    //    task source in an affiliated task queue, then remove
+    //    those tasks from that task queue.
+    this[kAborted] = true
+
+    // 4. Terminate the algorithm for the read method being processed.
+    // TODO
+
+    // 5. Fire a progress event called abort at this.
+    fireAProgressEvent('abort', this)
+
+    // 6. If this's state is not "loading", fire a progress
+    //    event called loadend at this.
+    if (this[kState] !== 'loading') {
+      fireAProgressEvent('loadend', this)
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dom-filereader-readystate
+   */
+  get readyState () {
+    webidl.brandCheck(this, FileReader)
+
+    switch (this[kState]) {
+      case 'empty': return this.EMPTY
+      case 'loading': return this.LOADING
+      case 'done': return this.DONE
+    }
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dom-filereader-result
+   */
+  get result () {
+    webidl.brandCheck(this, FileReader)
+
+    // The result attribute’s getter, when invoked, must return
+    // this's result.
+    return this[kResult]
+  }
+
+  /**
+   * @see https://w3c.github.io/FileAPI/#dom-filereader-error
+   */
+  get error () {
+    webidl.brandCheck(this, FileReader)
+
+    // The error attribute’s getter, when invoked, must return
+    // this's error.
+    return this[kError]
+  }
+
+  get onloadend () {
+    webidl.brandCheck(this, FileReader)
+
+    return this[kEvents].loadend
+  }
+
+  set onloadend (fn) {
+    webidl.brandCheck(this, FileReader)
+
+    if (this[kEvents].loadend) {
+      this.removeEventListener('loadend', this[kEvents].loadend)
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].loadend = fn
+      this.addEventListener('loadend', fn)
+    } else {
+      this[kEvents].loadend = null
+    }
+  }
+
+  get onerror () {
+    webidl.brandCheck(this, FileReader)
+
+    return this[kEvents].error
+  }
+
+  set onerror (fn) {
+    webidl.brandCheck(this, FileReader)
+
+    if (this[kEvents].error) {
+      this.removeEventListener('error', this[kEvents].error)
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].error = fn
+      this.addEventListener('error', fn)
+    } else {
+      this[kEvents].error = null
+    }
+  }
+
+  get onloadstart () {
+    webidl.brandCheck(this, FileReader)
+
+    return this[kEvents].loadstart
+  }
+
+  set onloadstart (fn) {
+    webidl.brandCheck(this, FileReader)
+
+    if (this[kEvents].loadstart) {
+      this.removeEventListener('loadstart', this[kEvents].loadstart)
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].loadstart = fn
+      this.addEventListener('loadstart', fn)
+    } else {
+      this[kEvents].loadstart = null
+    }
+  }
+
+  get onprogress () {
+    webidl.brandCheck(this, FileReader)
+
+    return this[kEvents].progress
+  }
+
+  set onprogress (fn) {
+    webidl.brandCheck(this, FileReader)
+
+    if (this[kEvents].progress) {
+      this.removeEventListener('progress', this[kEvents].progress)
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].progress = fn
+      this.addEventListener('progress', fn)
+    } else {
+      this[kEvents].progress = null
+    }
+  }
+
+  get onload () {
+    webidl.brandCheck(this, FileReader)
+
+    return this[kEvents].load
+  }
+
+  set onload (fn) {
+    webidl.brandCheck(this, FileReader)
+
+    if (this[kEvents].load) {
+      this.removeEventListener('load', this[kEvents].load)
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].load = fn
+      this.addEventListener('load', fn)
+    } else {
+      this[kEvents].load = null
+    }
+  }
+
+  get onabort () {
+    webidl.brandCheck(this, FileReader)
+
+    return this[kEvents].abort
+  }
+
+  set onabort (fn) {
+    webidl.brandCheck(this, FileReader)
+
+    if (this[kEvents].abort) {
+      this.removeEventListener('abort', this[kEvents].abort)
+    }
+
+    if (typeof fn === 'function') {
+      this[kEvents].abort = fn
+      this.addEventListener('abort', fn)
+    } else {
+      this[kEvents].abort = null
+    }
+  }
+}
+
+// https://w3c.github.io/FileAPI/#dom-filereader-empty
+FileReader.EMPTY = FileReader.prototype.EMPTY = 0
+// https://w3c.github.io/FileAPI/#dom-filereader-loading
+FileReader.LOADING = FileReader.prototype.LOADING = 1
+// https://w3c.github.io/FileAPI/#dom-filereader-done
+FileReader.DONE = FileReader.prototype.DONE = 2
+
+Object.defineProperties(FileReader.prototype, {
+  EMPTY: staticPropertyDescriptors,
+  LOADING: staticPropertyDescriptors,
+  DONE: staticPropertyDescriptors,
+  readAsArrayBuffer: kEnumerableProperty,
+  readAsBinaryString: kEnumerableProperty,
+  readAsText: kEnumerableProperty,
+  readAsDataURL: kEnumerableProperty,
+  abort: kEnumerableProperty,
+  readyState: kEnumerableProperty,
+  result: kEnumerableProperty,
+  error: kEnumerableProperty,
+  onloadstart: kEnumerableProperty,
+  onprogress: kEnumerableProperty,
+  onload: kEnumerableProperty,
+  onabort: kEnumerableProperty,
+  onerror: kEnumerableProperty,
+  onloadend: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'FileReader',
+    writable: false,
+    enumerable: false,
+    configurable: true
+  }
+})
+
+Object.defineProperties(FileReader, {
+  EMPTY: staticPropertyDescriptors,
+  LOADING: staticPropertyDescriptors,
+  DONE: staticPropertyDescriptors
+})
+
+module.exports = {
+  FileReader
+}
+
+
+/***/ }),
+
+/***/ 62415:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { webidl } = __nccwpck_require__(37829)
+
+const kState = Symbol('ProgressEvent state')
+
+/**
+ * @see https://xhr.spec.whatwg.org/#progressevent
+ */
+class ProgressEvent extends Event {
+  constructor (type, eventInitDict = {}) {
+    type = webidl.converters.DOMString(type, 'ProgressEvent constructor', 'type')
+    eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {})
+
+    super(type, eventInitDict)
+
+    this[kState] = {
+      lengthComputable: eventInitDict.lengthComputable,
+      loaded: eventInitDict.loaded,
+      total: eventInitDict.total
+    }
+  }
+
+  get lengthComputable () {
+    webidl.brandCheck(this, ProgressEvent)
+
+    return this[kState].lengthComputable
+  }
+
+  get loaded () {
+    webidl.brandCheck(this, ProgressEvent)
+
+    return this[kState].loaded
+  }
+
+  get total () {
+    webidl.brandCheck(this, ProgressEvent)
+
+    return this[kState].total
+  }
+}
+
+webidl.converters.ProgressEventInit = webidl.dictionaryConverter([
+  {
+    key: 'lengthComputable',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'loaded',
+    converter: webidl.converters['unsigned long long'],
+    defaultValue: () => 0
+  },
+  {
+    key: 'total',
+    converter: webidl.converters['unsigned long long'],
+    defaultValue: () => 0
+  },
+  {
+    key: 'bubbles',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'cancelable',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'composed',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  }
+])
+
+module.exports = {
+  ProgressEvent
+}
+
+
+/***/ }),
+
+/***/ 24666:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = {
+  kState: Symbol('FileReader state'),
+  kResult: Symbol('FileReader result'),
+  kError: Symbol('FileReader error'),
+  kLastProgressEventFired: Symbol('FileReader last progress event fired timestamp'),
+  kEvents: Symbol('FileReader events'),
+  kAborted: Symbol('FileReader aborted')
+}
+
+
+/***/ }),
+
+/***/ 82947:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const {
+  kState,
+  kError,
+  kResult,
+  kAborted,
+  kLastProgressEventFired
+} = __nccwpck_require__(24666)
+const { ProgressEvent } = __nccwpck_require__(62415)
+const { getEncoding } = __nccwpck_require__(19420)
+const { serializeAMimeType, parseMIMEType } = __nccwpck_require__(86954)
+const { types } = __nccwpck_require__(47261)
+const { StringDecoder } = __nccwpck_require__(71576)
+const { btoa } = __nccwpck_require__(72254)
+
+/** @type {PropertyDescriptor} */
+const staticPropertyDescriptors = {
+  enumerable: true,
+  writable: false,
+  configurable: false
+}
+
+/**
+ * @see https://w3c.github.io/FileAPI/#readOperation
+ * @param {import('./filereader').FileReader} fr
+ * @param {import('buffer').Blob} blob
+ * @param {string} type
+ * @param {string?} encodingName
+ */
+function readOperation (fr, blob, type, encodingName) {
+  // 1. If fr’s state is "loading", throw an InvalidStateError
+  //    DOMException.
+  if (fr[kState] === 'loading') {
+    throw new DOMException('Invalid state', 'InvalidStateError')
+  }
+
+  // 2. Set fr’s state to "loading".
+  fr[kState] = 'loading'
+
+  // 3. Set fr’s result to null.
+  fr[kResult] = null
+
+  // 4. Set fr’s error to null.
+  fr[kError] = null
+
+  // 5. Let stream be the result of calling get stream on blob.
+  /** @type {import('stream/web').ReadableStream} */
+  const stream = blob.stream()
+
+  // 6. Let reader be the result of getting a reader from stream.
+  const reader = stream.getReader()
+
+  // 7. Let bytes be an empty byte sequence.
+  /** @type {Uint8Array[]} */
+  const bytes = []
+
+  // 8. Let chunkPromise be the result of reading a chunk from
+  //    stream with reader.
+  let chunkPromise = reader.read()
+
+  // 9. Let isFirstChunk be true.
+  let isFirstChunk = true
+
+  // 10. In parallel, while true:
+  // Note: "In parallel" just means non-blocking
+  // Note 2: readOperation itself cannot be async as double
+  // reading the body would then reject the promise, instead
+  // of throwing an error.
+  ;(async () => {
+    while (!fr[kAborted]) {
+      // 1. Wait for chunkPromise to be fulfilled or rejected.
+      try {
+        const { done, value } = await chunkPromise
+
+        // 2. If chunkPromise is fulfilled, and isFirstChunk is
+        //    true, queue a task to fire a progress event called
+        //    loadstart at fr.
+        if (isFirstChunk && !fr[kAborted]) {
+          queueMicrotask(() => {
+            fireAProgressEvent('loadstart', fr)
+          })
+        }
+
+        // 3. Set isFirstChunk to false.
+        isFirstChunk = false
+
+        // 4. If chunkPromise is fulfilled with an object whose
+        //    done property is false and whose value property is
+        //    a Uint8Array object, run these steps:
+        if (!done && types.isUint8Array(value)) {
+          // 1. Let bs be the byte sequence represented by the
+          //    Uint8Array object.
+
+          // 2. Append bs to bytes.
+          bytes.push(value)
+
+          // 3. If roughly 50ms have passed since these steps
+          //    were last invoked, queue a task to fire a
+          //    progress event called progress at fr.
+          if (
+            (
+              fr[kLastProgressEventFired] === undefined ||
+              Date.now() - fr[kLastProgressEventFired] >= 50
+            ) &&
+            !fr[kAborted]
+          ) {
+            fr[kLastProgressEventFired] = Date.now()
+            queueMicrotask(() => {
+              fireAProgressEvent('progress', fr)
+            })
+          }
+
+          // 4. Set chunkPromise to the result of reading a
+          //    chunk from stream with reader.
+          chunkPromise = reader.read()
+        } else if (done) {
+          // 5. Otherwise, if chunkPromise is fulfilled with an
+          //    object whose done property is true, queue a task
+          //    to run the following steps and abort this algorithm:
+          queueMicrotask(() => {
+            // 1. Set fr’s state to "done".
+            fr[kState] = 'done'
+
+            // 2. Let result be the result of package data given
+            //    bytes, type, blob’s type, and encodingName.
+            try {
+              const result = packageData(bytes, type, blob.type, encodingName)
+
+              // 4. Else:
+
+              if (fr[kAborted]) {
+                return
+              }
+
+              // 1. Set fr’s result to result.
+              fr[kResult] = result
+
+              // 2. Fire a progress event called load at the fr.
+              fireAProgressEvent('load', fr)
+            } catch (error) {
+              // 3. If package data threw an exception error:
+
+              // 1. Set fr’s error to error.
+              fr[kError] = error
+
+              // 2. Fire a progress event called error at fr.
+              fireAProgressEvent('error', fr)
+            }
+
+            // 5. If fr’s state is not "loading", fire a progress
+            //    event called loadend at the fr.
+            if (fr[kState] !== 'loading') {
+              fireAProgressEvent('loadend', fr)
+            }
+          })
+
+          break
+        }
+      } catch (error) {
+        if (fr[kAborted]) {
+          return
+        }
+
+        // 6. Otherwise, if chunkPromise is rejected with an
+        //    error error, queue a task to run the following
+        //    steps and abort this algorithm:
+        queueMicrotask(() => {
+          // 1. Set fr’s state to "done".
+          fr[kState] = 'done'
+
+          // 2. Set fr’s error to error.
+          fr[kError] = error
+
+          // 3. Fire a progress event called error at fr.
+          fireAProgressEvent('error', fr)
+
+          // 4. If fr’s state is not "loading", fire a progress
+          //    event called loadend at fr.
+          if (fr[kState] !== 'loading') {
+            fireAProgressEvent('loadend', fr)
+          }
+        })
+
+        break
+      }
+    }
+  })()
+}
+
+/**
+ * @see https://w3c.github.io/FileAPI/#fire-a-progress-event
+ * @see https://dom.spec.whatwg.org/#concept-event-fire
+ * @param {string} e The name of the event
+ * @param {import('./filereader').FileReader} reader
+ */
+function fireAProgressEvent (e, reader) {
+  // The progress event e does not bubble. e.bubbles must be false
+  // The progress event e is NOT cancelable. e.cancelable must be false
+  const event = new ProgressEvent(e, {
+    bubbles: false,
+    cancelable: false
+  })
+
+  reader.dispatchEvent(event)
+}
+
+/**
+ * @see https://w3c.github.io/FileAPI/#blob-package-data
+ * @param {Uint8Array[]} bytes
+ * @param {string} type
+ * @param {string?} mimeType
+ * @param {string?} encodingName
+ */
+function packageData (bytes, type, mimeType, encodingName) {
+  // 1. A Blob has an associated package data algorithm, given
+  //    bytes, a type, a optional mimeType, and a optional
+  //    encodingName, which switches on type and runs the
+  //    associated steps:
+
+  switch (type) {
+    case 'DataURL': {
+      // 1. Return bytes as a DataURL [RFC2397] subject to
+      //    the considerations below:
+      //  * Use mimeType as part of the Data URL if it is
+      //    available in keeping with the Data URL
+      //    specification [RFC2397].
+      //  * If mimeType is not available return a Data URL
+      //    without a media-type. [RFC2397].
+
+      // https://datatracker.ietf.org/doc/html/rfc2397#section-3
+      // dataurl    := "data:" [ mediatype ] [ ";base64" ] "," data
+      // mediatype  := [ type "/" subtype ] *( ";" parameter )
+      // data       := *urlchar
+      // parameter  := attribute "=" value
+      let dataURL = 'data:'
+
+      const parsed = parseMIMEType(mimeType || 'application/octet-stream')
+
+      if (parsed !== 'failure') {
+        dataURL += serializeAMimeType(parsed)
+      }
+
+      dataURL += ';base64,'
+
+      const decoder = new StringDecoder('latin1')
+
+      for (const chunk of bytes) {
+        dataURL += btoa(decoder.write(chunk))
+      }
+
+      dataURL += btoa(decoder.end())
+
+      return dataURL
+    }
+    case 'Text': {
+      // 1. Let encoding be failure
+      let encoding = 'failure'
+
+      // 2. If the encodingName is present, set encoding to the
+      //    result of getting an encoding from encodingName.
+      if (encodingName) {
+        encoding = getEncoding(encodingName)
+      }
+
+      // 3. If encoding is failure, and mimeType is present:
+      if (encoding === 'failure' && mimeType) {
+        // 1. Let type be the result of parse a MIME type
+        //    given mimeType.
+        const type = parseMIMEType(mimeType)
+
+        // 2. If type is not failure, set encoding to the result
+        //    of getting an encoding from type’s parameters["charset"].
+        if (type !== 'failure') {
+          encoding = getEncoding(type.parameters.get('charset'))
+        }
+      }
+
+      // 4. If encoding is failure, then set encoding to UTF-8.
+      if (encoding === 'failure') {
+        encoding = 'UTF-8'
+      }
+
+      // 5. Decode bytes using fallback encoding encoding, and
+      //    return the result.
+      return decode(bytes, encoding)
+    }
+    case 'ArrayBuffer': {
+      // Return a new ArrayBuffer whose contents are bytes.
+      const sequence = combineByteSequences(bytes)
+
+      return sequence.buffer
+    }
+    case 'BinaryString': {
+      // Return bytes as a binary string, in which every byte
+      //  is represented by a code unit of equal value [0..255].
+      let binaryString = ''
+
+      const decoder = new StringDecoder('latin1')
+
+      for (const chunk of bytes) {
+        binaryString += decoder.write(chunk)
+      }
+
+      binaryString += decoder.end()
+
+      return binaryString
+    }
+  }
+}
+
+/**
+ * @see https://encoding.spec.whatwg.org/#decode
+ * @param {Uint8Array[]} ioQueue
+ * @param {string} encoding
+ */
+function decode (ioQueue, encoding) {
+  const bytes = combineByteSequences(ioQueue)
+
+  // 1. Let BOMEncoding be the result of BOM sniffing ioQueue.
+  const BOMEncoding = BOMSniffing(bytes)
+
+  let slice = 0
+
+  // 2. If BOMEncoding is non-null:
+  if (BOMEncoding !== null) {
+    // 1. Set encoding to BOMEncoding.
+    encoding = BOMEncoding
+
+    // 2. Read three bytes from ioQueue, if BOMEncoding is
+    //    UTF-8; otherwise read two bytes.
+    //    (Do nothing with those bytes.)
+    slice = BOMEncoding === 'UTF-8' ? 3 : 2
+  }
+
+  // 3. Process a queue with an instance of encoding’s
+  //    decoder, ioQueue, output, and "replacement".
+
+  // 4. Return output.
+
+  const sliced = bytes.slice(slice)
+  return new TextDecoder(encoding).decode(sliced)
+}
+
+/**
+ * @see https://encoding.spec.whatwg.org/#bom-sniff
+ * @param {Uint8Array} ioQueue
+ */
+function BOMSniffing (ioQueue) {
+  // 1. Let BOM be the result of peeking 3 bytes from ioQueue,
+  //    converted to a byte sequence.
+  const [a, b, c] = ioQueue
+
+  // 2. For each of the rows in the table below, starting with
+  //    the first one and going down, if BOM starts with the
+  //    bytes given in the first column, then return the
+  //    encoding given in the cell in the second column of that
+  //    row. Otherwise, return null.
+  if (a === 0xEF && b === 0xBB && c === 0xBF) {
+    return 'UTF-8'
+  } else if (a === 0xFE && b === 0xFF) {
+    return 'UTF-16BE'
+  } else if (a === 0xFF && b === 0xFE) {
+    return 'UTF-16LE'
+  }
+
+  return null
+}
+
+/**
+ * @param {Uint8Array[]} sequences
+ */
+function combineByteSequences (sequences) {
+  const size = sequences.reduce((a, b) => {
+    return a + b.byteLength
+  }, 0)
+
+  let offset = 0
+
+  return sequences.reduce((a, b) => {
+    a.set(b, offset)
+    offset += b.byteLength
+    return a
+  }, new Uint8Array(size))
+}
+
+module.exports = {
+  staticPropertyDescriptors,
+  readOperation,
+  fireAProgressEvent
+}
+
+
+/***/ }),
+
+/***/ 19072:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { uid, states, sentCloseFrameState, emptyBuffer, opcodes } = __nccwpck_require__(15318)
+const {
+  kReadyState,
+  kSentClose,
+  kByteParser,
+  kReceivedClose,
+  kResponse
+} = __nccwpck_require__(38471)
+const { fireEvent, failWebsocketConnection, isClosing, isClosed, isEstablished, parseExtensions } = __nccwpck_require__(13187)
+const { channels } = __nccwpck_require__(8627)
+const { CloseEvent } = __nccwpck_require__(15135)
+const { makeRequest } = __nccwpck_require__(13925)
+const { fetching } = __nccwpck_require__(31158)
+const { Headers, getHeadersList } = __nccwpck_require__(24997)
+const { getDecodeSplit } = __nccwpck_require__(91976)
+const { WebsocketFrameSend } = __nccwpck_require__(61163)
+
+/** @type {import('crypto')} */
+let crypto
+try {
+  crypto = __nccwpck_require__(6005)
+/* c8 ignore next 3 */
+} catch {
+
+}
+
+/**
+ * @see https://websockets.spec.whatwg.org/#concept-websocket-establish
+ * @param {URL} url
+ * @param {string|string[]} protocols
+ * @param {import('./websocket').WebSocket} ws
+ * @param {(response: any, extensions: string[] | undefined) => void} onEstablish
+ * @param {Partial<import('../../types/websocket').WebSocketInit>} options
+ */
+function establishWebSocketConnection (url, protocols, client, ws, onEstablish, options) {
+  // 1. Let requestURL be a copy of url, with its scheme set to "http", if url’s
+  //    scheme is "ws", and to "https" otherwise.
+  const requestURL = url
+
+  requestURL.protocol = url.protocol === 'ws:' ? 'http:' : 'https:'
+
+  // 2. Let request be a new request, whose URL is requestURL, client is client,
+  //    service-workers mode is "none", referrer is "no-referrer", mode is
+  //    "websocket", credentials mode is "include", cache mode is "no-store" ,
+  //    and redirect mode is "error".
+  const request = makeRequest({
+    urlList: [requestURL],
+    client,
+    serviceWorkers: 'none',
+    referrer: 'no-referrer',
+    mode: 'websocket',
+    credentials: 'include',
+    cache: 'no-store',
+    redirect: 'error'
+  })
+
+  // Note: undici extension, allow setting custom headers.
+  if (options.headers) {
+    const headersList = getHeadersList(new Headers(options.headers))
+
+    request.headersList = headersList
+  }
+
+  // 3. Append (`Upgrade`, `websocket`) to request’s header list.
+  // 4. Append (`Connection`, `Upgrade`) to request’s header list.
+  // Note: both of these are handled by undici currently.
+  // https://github.com/nodejs/undici/blob/68c269c4144c446f3f1220951338daef4a6b5ec4/lib/client.js#L1397
+
+  // 5. Let keyValue be a nonce consisting of a randomly selected
+  //    16-byte value that has been forgiving-base64-encoded and
+  //    isomorphic encoded.
+  const keyValue = crypto.randomBytes(16).toString('base64')
+
+  // 6. Append (`Sec-WebSocket-Key`, keyValue) to request’s
+  //    header list.
+  request.headersList.append('sec-websocket-key', keyValue)
+
+  // 7. Append (`Sec-WebSocket-Version`, `13`) to request’s
+  //    header list.
+  request.headersList.append('sec-websocket-version', '13')
+
+  // 8. For each protocol in protocols, combine
+  //    (`Sec-WebSocket-Protocol`, protocol) in request’s header
+  //    list.
+  for (const protocol of protocols) {
+    request.headersList.append('sec-websocket-protocol', protocol)
+  }
+
+  // 9. Let permessageDeflate be a user-agent defined
+  //    "permessage-deflate" extension header value.
+  // https://github.com/mozilla/gecko-dev/blob/ce78234f5e653a5d3916813ff990f053510227bc/netwerk/protocol/websocket/WebSocketChannel.cpp#L2673
+  const permessageDeflate = 'permessage-deflate; client_max_window_bits'
+
+  // 10. Append (`Sec-WebSocket-Extensions`, permessageDeflate) to
+  //     request’s header list.
+  request.headersList.append('sec-websocket-extensions', permessageDeflate)
+
+  // 11. Fetch request with useParallelQueue set to true, and
+  //     processResponse given response being these steps:
+  const controller = fetching({
+    request,
+    useParallelQueue: true,
+    dispatcher: options.dispatcher,
+    processResponse (response) {
+      // 1. If response is a network error or its status is not 101,
+      //    fail the WebSocket connection.
+      if (response.type === 'error' || response.status !== 101) {
+        failWebsocketConnection(ws, 'Received network error or non-101 status code.')
+        return
+      }
+
+      // 2. If protocols is not the empty list and extracting header
+      //    list values given `Sec-WebSocket-Protocol` and response’s
+      //    header list results in null, failure, or the empty byte
+      //    sequence, then fail the WebSocket connection.
+      if (protocols.length !== 0 && !response.headersList.get('Sec-WebSocket-Protocol')) {
+        failWebsocketConnection(ws, 'Server did not respond with sent protocols.')
+        return
+      }
+
+      // 3. Follow the requirements stated step 2 to step 6, inclusive,
+      //    of the last set of steps in section 4.1 of The WebSocket
+      //    Protocol to validate response. This either results in fail
+      //    the WebSocket connection or the WebSocket connection is
+      //    established.
+
+      // 2. If the response lacks an |Upgrade| header field or the |Upgrade|
+      //    header field contains a value that is not an ASCII case-
+      //    insensitive match for the value "websocket", the client MUST
+      //    _Fail the WebSocket Connection_.
+      if (response.headersList.get('Upgrade')?.toLowerCase() !== 'websocket') {
+        failWebsocketConnection(ws, 'Server did not set Upgrade header to "websocket".')
+        return
+      }
+
+      // 3. If the response lacks a |Connection| header field or the
+      //    |Connection| header field doesn't contain a token that is an
+      //    ASCII case-insensitive match for the value "Upgrade", the client
+      //    MUST _Fail the WebSocket Connection_.
+      if (response.headersList.get('Connection')?.toLowerCase() !== 'upgrade') {
+        failWebsocketConnection(ws, 'Server did not set Connection header to "upgrade".')
+        return
+      }
+
+      // 4. If the response lacks a |Sec-WebSocket-Accept| header field or
+      //    the |Sec-WebSocket-Accept| contains a value other than the
+      //    base64-encoded SHA-1 of the concatenation of the |Sec-WebSocket-
+      //    Key| (as a string, not base64-decoded) with the string "258EAFA5-
+      //    E914-47DA-95CA-C5AB0DC85B11" but ignoring any leading and
+      //    trailing whitespace, the client MUST _Fail the WebSocket
+      //    Connection_.
+      const secWSAccept = response.headersList.get('Sec-WebSocket-Accept')
+      const digest = crypto.createHash('sha1').update(keyValue + uid).digest('base64')
+      if (secWSAccept !== digest) {
+        failWebsocketConnection(ws, 'Incorrect hash received in Sec-WebSocket-Accept header.')
+        return
+      }
+
+      // 5. If the response includes a |Sec-WebSocket-Extensions| header
+      //    field and this header field indicates the use of an extension
+      //    that was not present in the client's handshake (the server has
+      //    indicated an extension not requested by the client), the client
+      //    MUST _Fail the WebSocket Connection_.  (The parsing of this
+      //    header field to determine which extensions are requested is
+      //    discussed in Section 9.1.)
+      const secExtension = response.headersList.get('Sec-WebSocket-Extensions')
+      let extensions
+
+      if (secExtension !== null) {
+        extensions = parseExtensions(secExtension)
+
+        if (!extensions.has('permessage-deflate')) {
+          failWebsocketConnection(ws, 'Sec-WebSocket-Extensions header does not match.')
+          return
+        }
+      }
+
+      // 6. If the response includes a |Sec-WebSocket-Protocol| header field
+      //    and this header field indicates the use of a subprotocol that was
+      //    not present in the client's handshake (the server has indicated a
+      //    subprotocol not requested by the client), the client MUST _Fail
+      //    the WebSocket Connection_.
+      const secProtocol = response.headersList.get('Sec-WebSocket-Protocol')
+
+      if (secProtocol !== null) {
+        const requestProtocols = getDecodeSplit('sec-websocket-protocol', request.headersList)
+
+        // The client can request that the server use a specific subprotocol by
+        // including the |Sec-WebSocket-Protocol| field in its handshake.  If it
+        // is specified, the server needs to include the same field and one of
+        // the selected subprotocol values in its response for the connection to
+        // be established.
+        if (!requestProtocols.includes(secProtocol)) {
+          failWebsocketConnection(ws, 'Protocol was not set in the opening handshake.')
+          return
+        }
+      }
+
+      response.socket.on('data', onSocketData)
+      response.socket.on('close', onSocketClose)
+      response.socket.on('error', onSocketError)
+
+      if (channels.open.hasSubscribers) {
+        channels.open.publish({
+          address: response.socket.address(),
+          protocol: secProtocol,
+          extensions: secExtension
+        })
+      }
+
+      onEstablish(response, extensions)
+    }
+  })
+
+  return controller
+}
+
+function closeWebSocketConnection (ws, code, reason, reasonByteLength) {
+  if (isClosing(ws) || isClosed(ws)) {
+    // If this's ready state is CLOSING (2) or CLOSED (3)
+    // Do nothing.
+  } else if (!isEstablished(ws)) {
+    // If the WebSocket connection is not yet established
+    // Fail the WebSocket connection and set this's ready state
+    // to CLOSING (2).
+    failWebsocketConnection(ws, 'Connection was closed before it was established.')
+    ws[kReadyState] = states.CLOSING
+  } else if (ws[kSentClose] === sentCloseFrameState.NOT_SENT) {
+    // If the WebSocket closing handshake has not yet been started
+    // Start the WebSocket closing handshake and set this's ready
+    // state to CLOSING (2).
+    // - If neither code nor reason is present, the WebSocket Close
+    //   message must not have a body.
+    // - If code is present, then the status code to use in the
+    //   WebSocket Close message must be the integer given by code.
+    // - If reason is also present, then reasonBytes must be
+    //   provided in the Close message after the status code.
+
+    ws[kSentClose] = sentCloseFrameState.PROCESSING
+
+    const frame = new WebsocketFrameSend()
+
+    // If neither code nor reason is present, the WebSocket Close
+    // message must not have a body.
+
+    // If code is present, then the status code to use in the
+    // WebSocket Close message must be the integer given by code.
+    if (code !== undefined && reason === undefined) {
+      frame.frameData = Buffer.allocUnsafe(2)
+      frame.frameData.writeUInt16BE(code, 0)
+    } else if (code !== undefined && reason !== undefined) {
+      // If reason is also present, then reasonBytes must be
+      // provided in the Close message after the status code.
+      frame.frameData = Buffer.allocUnsafe(2 + reasonByteLength)
+      frame.frameData.writeUInt16BE(code, 0)
+      // the body MAY contain UTF-8-encoded data with value /reason/
+      frame.frameData.write(reason, 2, 'utf-8')
+    } else {
+      frame.frameData = emptyBuffer
+    }
+
+    /** @type {import('stream').Duplex} */
+    const socket = ws[kResponse].socket
+
+    socket.write(frame.createFrame(opcodes.CLOSE))
+
+    ws[kSentClose] = sentCloseFrameState.SENT
+
+    // Upon either sending or receiving a Close control frame, it is said
+    // that _The WebSocket Closing Handshake is Started_ and that the
+    // WebSocket connection is in the CLOSING state.
+    ws[kReadyState] = states.CLOSING
+  } else {
+    // Otherwise
+    // Set this's ready state to CLOSING (2).
+    ws[kReadyState] = states.CLOSING
+  }
+}
+
+/**
+ * @param {Buffer} chunk
+ */
+function onSocketData (chunk) {
+  if (!this.ws[kByteParser].write(chunk)) {
+    this.pause()
+  }
+}
+
+/**
+ * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
+ * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.4
+ */
+function onSocketClose () {
+  const { ws } = this
+  const { [kResponse]: response } = ws
+
+  response.socket.off('data', onSocketData)
+  response.socket.off('close', onSocketClose)
+  response.socket.off('error', onSocketError)
+
+  // If the TCP connection was closed after the
+  // WebSocket closing handshake was completed, the WebSocket connection
+  // is said to have been closed _cleanly_.
+  const wasClean = ws[kSentClose] === sentCloseFrameState.SENT && ws[kReceivedClose]
+
+  let code = 1005
+  let reason = ''
+
+  const result = ws[kByteParser].closingInfo
+
+  if (result && !result.error) {
+    code = result.code ?? 1005
+    reason = result.reason
+  } else if (!ws[kReceivedClose]) {
+    // If _The WebSocket
+    // Connection is Closed_ and no Close control frame was received by the
+    // endpoint (such as could occur if the underlying transport connection
+    // is lost), _The WebSocket Connection Close Code_ is considered to be
+    // 1006.
+    code = 1006
+  }
+
+  // 1. Change the ready state to CLOSED (3).
+  ws[kReadyState] = states.CLOSED
+
+  // 2. If the user agent was required to fail the WebSocket
+  //    connection, or if the WebSocket connection was closed
+  //    after being flagged as full, fire an event named error
+  //    at the WebSocket object.
+  // TODO
+
+  // 3. Fire an event named close at the WebSocket object,
+  //    using CloseEvent, with the wasClean attribute
+  //    initialized to true if the connection closed cleanly
+  //    and false otherwise, the code attribute initialized to
+  //    the WebSocket connection close code, and the reason
+  //    attribute initialized to the result of applying UTF-8
+  //    decode without BOM to the WebSocket connection close
+  //    reason.
+  // TODO: process.nextTick
+  fireEvent('close', ws, (type, init) => new CloseEvent(type, init), {
+    wasClean, code, reason
+  })
+
+  if (channels.close.hasSubscribers) {
+    channels.close.publish({
+      websocket: ws,
+      code,
+      reason
+    })
+  }
+}
+
+function onSocketError (error) {
+  const { ws } = this
+
+  ws[kReadyState] = states.CLOSING
+
+  if (channels.socketError.hasSubscribers) {
+    channels.socketError.publish(error)
+  }
+
+  this.destroy()
+}
+
+module.exports = {
+  establishWebSocketConnection,
+  closeWebSocketConnection
+}
+
+
+/***/ }),
+
+/***/ 15318:
+/***/ ((module) => {
+
+"use strict";
+
+
+// This is a Globally Unique Identifier unique used
+// to validate that the endpoint accepts websocket
+// connections.
+// See https://www.rfc-editor.org/rfc/rfc6455.html#section-1.3
+const uid = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+/** @type {PropertyDescriptor} */
+const staticPropertyDescriptors = {
+  enumerable: true,
+  writable: false,
+  configurable: false
+}
+
+const states = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+}
+
+const sentCloseFrameState = {
+  NOT_SENT: 0,
+  PROCESSING: 1,
+  SENT: 2
+}
+
+const opcodes = {
+  CONTINUATION: 0x0,
+  TEXT: 0x1,
+  BINARY: 0x2,
+  CLOSE: 0x8,
+  PING: 0x9,
+  PONG: 0xA
+}
+
+const maxUnsigned16Bit = 2 ** 16 - 1 // 65535
+
+const parserStates = {
+  INFO: 0,
+  PAYLOADLENGTH_16: 2,
+  PAYLOADLENGTH_64: 3,
+  READ_DATA: 4
+}
+
+const emptyBuffer = Buffer.allocUnsafe(0)
+
+const sendHints = {
+  string: 1,
+  typedArray: 2,
+  arrayBuffer: 3,
+  blob: 4
+}
+
+module.exports = {
+  uid,
+  sentCloseFrameState,
+  staticPropertyDescriptors,
+  states,
+  opcodes,
+  maxUnsigned16Bit,
+  parserStates,
+  emptyBuffer,
+  sendHints
+}
+
+
+/***/ }),
+
+/***/ 15135:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { webidl } = __nccwpck_require__(37829)
+const { kEnumerableProperty } = __nccwpck_require__(94407)
+const { kConstruct } = __nccwpck_require__(5392)
+const { MessagePort } = __nccwpck_require__(24086)
+
+/**
+ * @see https://html.spec.whatwg.org/multipage/comms.html#messageevent
+ */
+class MessageEvent extends Event {
+  #eventInit
+
+  constructor (type, eventInitDict = {}) {
+    if (type === kConstruct) {
+      super(arguments[1], arguments[2])
+      webidl.util.markAsUncloneable(this)
+      return
+    }
+
+    const prefix = 'MessageEvent constructor'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    type = webidl.converters.DOMString(type, prefix, 'type')
+    eventInitDict = webidl.converters.MessageEventInit(eventInitDict, prefix, 'eventInitDict')
+
+    super(type, eventInitDict)
+
+    this.#eventInit = eventInitDict
+    webidl.util.markAsUncloneable(this)
+  }
+
+  get data () {
+    webidl.brandCheck(this, MessageEvent)
+
+    return this.#eventInit.data
+  }
+
+  get origin () {
+    webidl.brandCheck(this, MessageEvent)
+
+    return this.#eventInit.origin
+  }
+
+  get lastEventId () {
+    webidl.brandCheck(this, MessageEvent)
+
+    return this.#eventInit.lastEventId
+  }
+
+  get source () {
+    webidl.brandCheck(this, MessageEvent)
+
+    return this.#eventInit.source
+  }
+
+  get ports () {
+    webidl.brandCheck(this, MessageEvent)
+
+    if (!Object.isFrozen(this.#eventInit.ports)) {
+      Object.freeze(this.#eventInit.ports)
+    }
+
+    return this.#eventInit.ports
+  }
+
+  initMessageEvent (
+    type,
+    bubbles = false,
+    cancelable = false,
+    data = null,
+    origin = '',
+    lastEventId = '',
+    source = null,
+    ports = []
+  ) {
+    webidl.brandCheck(this, MessageEvent)
+
+    webidl.argumentLengthCheck(arguments, 1, 'MessageEvent.initMessageEvent')
+
+    return new MessageEvent(type, {
+      bubbles, cancelable, data, origin, lastEventId, source, ports
+    })
+  }
+
+  static createFastMessageEvent (type, init) {
+    const messageEvent = new MessageEvent(kConstruct, type, init)
+    messageEvent.#eventInit = init
+    messageEvent.#eventInit.data ??= null
+    messageEvent.#eventInit.origin ??= ''
+    messageEvent.#eventInit.lastEventId ??= ''
+    messageEvent.#eventInit.source ??= null
+    messageEvent.#eventInit.ports ??= []
+    return messageEvent
+  }
+}
+
+const { createFastMessageEvent } = MessageEvent
+delete MessageEvent.createFastMessageEvent
+
+/**
+ * @see https://websockets.spec.whatwg.org/#the-closeevent-interface
+ */
+class CloseEvent extends Event {
+  #eventInit
+
+  constructor (type, eventInitDict = {}) {
+    const prefix = 'CloseEvent constructor'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    type = webidl.converters.DOMString(type, prefix, 'type')
+    eventInitDict = webidl.converters.CloseEventInit(eventInitDict)
+
+    super(type, eventInitDict)
+
+    this.#eventInit = eventInitDict
+    webidl.util.markAsUncloneable(this)
+  }
+
+  get wasClean () {
+    webidl.brandCheck(this, CloseEvent)
+
+    return this.#eventInit.wasClean
+  }
+
+  get code () {
+    webidl.brandCheck(this, CloseEvent)
+
+    return this.#eventInit.code
+  }
+
+  get reason () {
+    webidl.brandCheck(this, CloseEvent)
+
+    return this.#eventInit.reason
+  }
+}
+
+// https://html.spec.whatwg.org/multipage/webappapis.html#the-errorevent-interface
+class ErrorEvent extends Event {
+  #eventInit
+
+  constructor (type, eventInitDict) {
+    const prefix = 'ErrorEvent constructor'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    super(type, eventInitDict)
+    webidl.util.markAsUncloneable(this)
+
+    type = webidl.converters.DOMString(type, prefix, 'type')
+    eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {})
+
+    this.#eventInit = eventInitDict
+  }
+
+  get message () {
+    webidl.brandCheck(this, ErrorEvent)
+
+    return this.#eventInit.message
+  }
+
+  get filename () {
+    webidl.brandCheck(this, ErrorEvent)
+
+    return this.#eventInit.filename
+  }
+
+  get lineno () {
+    webidl.brandCheck(this, ErrorEvent)
+
+    return this.#eventInit.lineno
+  }
+
+  get colno () {
+    webidl.brandCheck(this, ErrorEvent)
+
+    return this.#eventInit.colno
+  }
+
+  get error () {
+    webidl.brandCheck(this, ErrorEvent)
+
+    return this.#eventInit.error
+  }
+}
+
+Object.defineProperties(MessageEvent.prototype, {
+  [Symbol.toStringTag]: {
+    value: 'MessageEvent',
+    configurable: true
+  },
+  data: kEnumerableProperty,
+  origin: kEnumerableProperty,
+  lastEventId: kEnumerableProperty,
+  source: kEnumerableProperty,
+  ports: kEnumerableProperty,
+  initMessageEvent: kEnumerableProperty
+})
+
+Object.defineProperties(CloseEvent.prototype, {
+  [Symbol.toStringTag]: {
+    value: 'CloseEvent',
+    configurable: true
+  },
+  reason: kEnumerableProperty,
+  code: kEnumerableProperty,
+  wasClean: kEnumerableProperty
+})
+
+Object.defineProperties(ErrorEvent.prototype, {
+  [Symbol.toStringTag]: {
+    value: 'ErrorEvent',
+    configurable: true
+  },
+  message: kEnumerableProperty,
+  filename: kEnumerableProperty,
+  lineno: kEnumerableProperty,
+  colno: kEnumerableProperty,
+  error: kEnumerableProperty
+})
+
+webidl.converters.MessagePort = webidl.interfaceConverter(MessagePort)
+
+webidl.converters['sequence<MessagePort>'] = webidl.sequenceConverter(
+  webidl.converters.MessagePort
+)
+
+const eventInit = [
+  {
+    key: 'bubbles',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'cancelable',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'composed',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  }
+]
+
+webidl.converters.MessageEventInit = webidl.dictionaryConverter([
+  ...eventInit,
+  {
+    key: 'data',
+    converter: webidl.converters.any,
+    defaultValue: () => null
+  },
+  {
+    key: 'origin',
+    converter: webidl.converters.USVString,
+    defaultValue: () => ''
+  },
+  {
+    key: 'lastEventId',
+    converter: webidl.converters.DOMString,
+    defaultValue: () => ''
+  },
+  {
+    key: 'source',
+    // Node doesn't implement WindowProxy or ServiceWorker, so the only
+    // valid value for source is a MessagePort.
+    converter: webidl.nullableConverter(webidl.converters.MessagePort),
+    defaultValue: () => null
+  },
+  {
+    key: 'ports',
+    converter: webidl.converters['sequence<MessagePort>'],
+    defaultValue: () => new Array(0)
+  }
+])
+
+webidl.converters.CloseEventInit = webidl.dictionaryConverter([
+  ...eventInit,
+  {
+    key: 'wasClean',
+    converter: webidl.converters.boolean,
+    defaultValue: () => false
+  },
+  {
+    key: 'code',
+    converter: webidl.converters['unsigned short'],
+    defaultValue: () => 0
+  },
+  {
+    key: 'reason',
+    converter: webidl.converters.USVString,
+    defaultValue: () => ''
+  }
+])
+
+webidl.converters.ErrorEventInit = webidl.dictionaryConverter([
+  ...eventInit,
+  {
+    key: 'message',
+    converter: webidl.converters.DOMString,
+    defaultValue: () => ''
+  },
+  {
+    key: 'filename',
+    converter: webidl.converters.USVString,
+    defaultValue: () => ''
+  },
+  {
+    key: 'lineno',
+    converter: webidl.converters['unsigned long'],
+    defaultValue: () => 0
+  },
+  {
+    key: 'colno',
+    converter: webidl.converters['unsigned long'],
+    defaultValue: () => 0
+  },
+  {
+    key: 'error',
+    converter: webidl.converters.any
+  }
+])
+
+module.exports = {
+  MessageEvent,
+  CloseEvent,
+  ErrorEvent,
+  createFastMessageEvent
+}
+
+
+/***/ }),
+
+/***/ 61163:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { maxUnsigned16Bit } = __nccwpck_require__(15318)
+
+const BUFFER_SIZE = 16386
+
+/** @type {import('crypto')} */
+let crypto
+let buffer = null
+let bufIdx = BUFFER_SIZE
+
+try {
+  crypto = __nccwpck_require__(6005)
+/* c8 ignore next 3 */
+} catch {
+  crypto = {
+    // not full compatibility, but minimum.
+    randomFillSync: function randomFillSync (buffer, _offset, _size) {
+      for (let i = 0; i < buffer.length; ++i) {
+        buffer[i] = Math.random() * 255 | 0
+      }
+      return buffer
+    }
+  }
+}
+
+function generateMask () {
+  if (bufIdx === BUFFER_SIZE) {
+    bufIdx = 0
+    crypto.randomFillSync((buffer ??= Buffer.allocUnsafe(BUFFER_SIZE)), 0, BUFFER_SIZE)
+  }
+  return [buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++], buffer[bufIdx++]]
+}
+
+class WebsocketFrameSend {
+  /**
+   * @param {Buffer|undefined} data
+   */
+  constructor (data) {
+    this.frameData = data
+  }
+
+  createFrame (opcode) {
+    const frameData = this.frameData
+    const maskKey = generateMask()
+    const bodyLength = frameData?.byteLength ?? 0
+
+    /** @type {number} */
+    let payloadLength = bodyLength // 0-125
+    let offset = 6
+
+    if (bodyLength > maxUnsigned16Bit) {
+      offset += 8 // payload length is next 8 bytes
+      payloadLength = 127
+    } else if (bodyLength > 125) {
+      offset += 2 // payload length is next 2 bytes
+      payloadLength = 126
+    }
+
+    const buffer = Buffer.allocUnsafe(bodyLength + offset)
+
+    // Clear first 2 bytes, everything else is overwritten
+    buffer[0] = buffer[1] = 0
+    buffer[0] |= 0x80 // FIN
+    buffer[0] = (buffer[0] & 0xF0) + opcode // opcode
+
+    /*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> */
+    buffer[offset - 4] = maskKey[0]
+    buffer[offset - 3] = maskKey[1]
+    buffer[offset - 2] = maskKey[2]
+    buffer[offset - 1] = maskKey[3]
+
+    buffer[1] = payloadLength
+
+    if (payloadLength === 126) {
+      buffer.writeUInt16BE(bodyLength, 2)
+    } else if (payloadLength === 127) {
+      // Clear extended payload length
+      buffer[2] = buffer[3] = 0
+      buffer.writeUIntBE(bodyLength, 4, 6)
+    }
+
+    buffer[1] |= 0x80 // MASK
+
+    // mask body
+    for (let i = 0; i < bodyLength; ++i) {
+      buffer[offset + i] = frameData[i] ^ maskKey[i & 3]
+    }
+
+    return buffer
+  }
+}
+
+module.exports = {
+  WebsocketFrameSend
+}
+
+
+/***/ }),
+
+/***/ 67356:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { createInflateRaw, Z_DEFAULT_WINDOWBITS } = __nccwpck_require__(65628)
+const { isValidClientWindowBits } = __nccwpck_require__(13187)
+
+const tail = Buffer.from([0x00, 0x00, 0xff, 0xff])
+const kBuffer = Symbol('kBuffer')
+const kLength = Symbol('kLength')
+
+class PerMessageDeflate {
+  /** @type {import('node:zlib').InflateRaw} */
+  #inflate
+
+  #options = {}
+
+  constructor (extensions) {
+    this.#options.serverNoContextTakeover = extensions.has('server_no_context_takeover')
+    this.#options.serverMaxWindowBits = extensions.get('server_max_window_bits')
+  }
+
+  decompress (chunk, fin, callback) {
+    // An endpoint uses the following algorithm to decompress a message.
+    // 1.  Append 4 octets of 0x00 0x00 0xff 0xff to the tail end of the
+    //     payload of the message.
+    // 2.  Decompress the resulting data using DEFLATE.
+
+    if (!this.#inflate) {
+      let windowBits = Z_DEFAULT_WINDOWBITS
+
+      if (this.#options.serverMaxWindowBits) { // empty values default to Z_DEFAULT_WINDOWBITS
+        if (!isValidClientWindowBits(this.#options.serverMaxWindowBits)) {
+          callback(new Error('Invalid server_max_window_bits'))
+          return
+        }
+
+        windowBits = Number.parseInt(this.#options.serverMaxWindowBits)
+      }
+
+      this.#inflate = createInflateRaw({ windowBits })
+      this.#inflate[kBuffer] = []
+      this.#inflate[kLength] = 0
+
+      this.#inflate.on('data', (data) => {
+        this.#inflate[kBuffer].push(data)
+        this.#inflate[kLength] += data.length
+      })
+
+      this.#inflate.on('error', (err) => {
+        this.#inflate = null
+        callback(err)
+      })
+    }
+
+    this.#inflate.write(chunk)
+    if (fin) {
+      this.#inflate.write(tail)
+    }
+
+    this.#inflate.flush(() => {
+      const full = Buffer.concat(this.#inflate[kBuffer], this.#inflate[kLength])
+
+      this.#inflate[kBuffer].length = 0
+      this.#inflate[kLength] = 0
+
+      callback(null, full)
+    })
+  }
+}
+
+module.exports = { PerMessageDeflate }
+
+
+/***/ }),
+
+/***/ 47879:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { Writable } = __nccwpck_require__(84492)
+const assert = __nccwpck_require__(98061)
+const { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = __nccwpck_require__(15318)
+const { kReadyState, kSentClose, kResponse, kReceivedClose } = __nccwpck_require__(38471)
+const { channels } = __nccwpck_require__(8627)
+const {
+  isValidStatusCode,
+  isValidOpcode,
+  failWebsocketConnection,
+  websocketMessageReceived,
+  utf8Decode,
+  isControlFrame,
+  isTextBinaryFrame,
+  isContinuationFrame
+} = __nccwpck_require__(13187)
+const { WebsocketFrameSend } = __nccwpck_require__(61163)
+const { closeWebSocketConnection } = __nccwpck_require__(19072)
+const { PerMessageDeflate } = __nccwpck_require__(67356)
+
+// This code was influenced by ws released under the MIT license.
+// Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
+// Copyright (c) 2013 Arnout Kazemier and contributors
+// Copyright (c) 2016 Luigi Pinca and contributors
+
+class ByteParser extends Writable {
+  #buffers = []
+  #byteOffset = 0
+  #loop = false
+
+  #state = parserStates.INFO
+
+  #info = {}
+  #fragments = []
+
+  /** @type {Map<string, PerMessageDeflate>} */
+  #extensions
+
+  constructor (ws, extensions) {
+    super()
+
+    this.ws = ws
+    this.#extensions = extensions == null ? new Map() : extensions
+
+    if (this.#extensions.has('permessage-deflate')) {
+      this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions))
+    }
+  }
+
+  /**
+   * @param {Buffer} chunk
+   * @param {() => void} callback
+   */
+  _write (chunk, _, callback) {
+    this.#buffers.push(chunk)
+    this.#byteOffset += chunk.length
+    this.#loop = true
+
+    this.run(callback)
+  }
+
+  /**
+   * Runs whenever a new chunk is received.
+   * Callback is called whenever there are no more chunks buffering,
+   * or not enough bytes are buffered to parse.
+   */
+  run (callback) {
+    while (this.#loop) {
+      if (this.#state === parserStates.INFO) {
+        // If there aren't enough bytes to parse the payload length, etc.
+        if (this.#byteOffset < 2) {
+          return callback()
+        }
+
+        const buffer = this.consume(2)
+        const fin = (buffer[0] & 0x80) !== 0
+        const opcode = buffer[0] & 0x0F
+        const masked = (buffer[1] & 0x80) === 0x80
+
+        const fragmented = !fin && opcode !== opcodes.CONTINUATION
+        const payloadLength = buffer[1] & 0x7F
+
+        const rsv1 = buffer[0] & 0x40
+        const rsv2 = buffer[0] & 0x20
+        const rsv3 = buffer[0] & 0x10
+
+        if (!isValidOpcode(opcode)) {
+          failWebsocketConnection(this.ws, 'Invalid opcode received')
+          return callback()
+        }
+
+        if (masked) {
+          failWebsocketConnection(this.ws, 'Frame cannot be masked')
+          return callback()
+        }
+
+        // MUST be 0 unless an extension is negotiated that defines meanings
+        // for non-zero values.  If a nonzero value is received and none of
+        // the negotiated extensions defines the meaning of such a nonzero
+        // value, the receiving endpoint MUST _Fail the WebSocket
+        // Connection_.
+        // This document allocates the RSV1 bit of the WebSocket header for
+        // PMCEs and calls the bit the "Per-Message Compressed" bit.  On a
+        // WebSocket connection where a PMCE is in use, this bit indicates
+        // whether a message is compressed or not.
+        if (rsv1 !== 0 && !this.#extensions.has('permessage-deflate')) {
+          failWebsocketConnection(this.ws, 'Expected RSV1 to be clear.')
+          return
+        }
+
+        if (rsv2 !== 0 || rsv3 !== 0) {
+          failWebsocketConnection(this.ws, 'RSV1, RSV2, RSV3 must be clear')
+          return
+        }
+
+        if (fragmented && !isTextBinaryFrame(opcode)) {
+          // Only text and binary frames can be fragmented
+          failWebsocketConnection(this.ws, 'Invalid frame type was fragmented.')
+          return
+        }
+
+        // If we are already parsing a text/binary frame and do not receive either
+        // a continuation frame or close frame, fail the connection.
+        if (isTextBinaryFrame(opcode) && this.#fragments.length > 0) {
+          failWebsocketConnection(this.ws, 'Expected continuation frame')
+          return
+        }
+
+        if (this.#info.fragmented && fragmented) {
+          // A fragmented frame can't be fragmented itself
+          failWebsocketConnection(this.ws, 'Fragmented frame exceeded 125 bytes.')
+          return
+        }
+
+        // "All control frames MUST have a payload length of 125 bytes or less
+        // and MUST NOT be fragmented."
+        if ((payloadLength > 125 || fragmented) && isControlFrame(opcode)) {
+          failWebsocketConnection(this.ws, 'Control frame either too large or fragmented')
+          return
+        }
+
+        if (isContinuationFrame(opcode) && this.#fragments.length === 0 && !this.#info.compressed) {
+          failWebsocketConnection(this.ws, 'Unexpected continuation frame')
+          return
+        }
+
+        if (payloadLength <= 125) {
+          this.#info.payloadLength = payloadLength
+          this.#state = parserStates.READ_DATA
+        } else if (payloadLength === 126) {
+          this.#state = parserStates.PAYLOADLENGTH_16
+        } else if (payloadLength === 127) {
+          this.#state = parserStates.PAYLOADLENGTH_64
+        }
+
+        if (isTextBinaryFrame(opcode)) {
+          this.#info.binaryType = opcode
+          this.#info.compressed = rsv1 !== 0
+        }
+
+        this.#info.opcode = opcode
+        this.#info.masked = masked
+        this.#info.fin = fin
+        this.#info.fragmented = fragmented
+      } else if (this.#state === parserStates.PAYLOADLENGTH_16) {
+        if (this.#byteOffset < 2) {
+          return callback()
+        }
+
+        const buffer = this.consume(2)
+
+        this.#info.payloadLength = buffer.readUInt16BE(0)
+        this.#state = parserStates.READ_DATA
+      } else if (this.#state === parserStates.PAYLOADLENGTH_64) {
+        if (this.#byteOffset < 8) {
+          return callback()
+        }
+
+        const buffer = this.consume(8)
+        const upper = buffer.readUInt32BE(0)
+
+        // 2^31 is the maximum bytes an arraybuffer can contain
+        // on 32-bit systems. Although, on 64-bit systems, this is
+        // 2^53-1 bytes.
+        // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_array_length
+        // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/common/globals.h;drc=1946212ac0100668f14eb9e2843bdd846e510a1e;bpv=1;bpt=1;l=1275
+        // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/objects/js-array-buffer.h;l=34;drc=1946212ac0100668f14eb9e2843bdd846e510a1e
+        if (upper > 2 ** 31 - 1) {
+          failWebsocketConnection(this.ws, 'Received payload length > 2^31 bytes.')
+          return
+        }
+
+        const lower = buffer.readUInt32BE(4)
+
+        this.#info.payloadLength = (upper << 8) + lower
+        this.#state = parserStates.READ_DATA
+      } else if (this.#state === parserStates.READ_DATA) {
+        if (this.#byteOffset < this.#info.payloadLength) {
+          return callback()
+        }
+
+        const body = this.consume(this.#info.payloadLength)
+
+        if (isControlFrame(this.#info.opcode)) {
+          this.#loop = this.parseControlFrame(body)
+          this.#state = parserStates.INFO
+        } else {
+          if (!this.#info.compressed) {
+            this.#fragments.push(body)
+
+            // If the frame is not fragmented, a message has been received.
+            // If the frame is fragmented, it will terminate with a fin bit set
+            // and an opcode of 0 (continuation), therefore we handle that when
+            // parsing continuation frames, not here.
+            if (!this.#info.fragmented && this.#info.fin) {
+              const fullMessage = Buffer.concat(this.#fragments)
+              websocketMessageReceived(this.ws, this.#info.binaryType, fullMessage)
+              this.#fragments.length = 0
+            }
+
+            this.#state = parserStates.INFO
+          } else {
+            this.#extensions.get('permessage-deflate').decompress(body, this.#info.fin, (error, data) => {
+              if (error) {
+                closeWebSocketConnection(this.ws, 1007, error.message, error.message.length)
+                return
+              }
+
+              this.#fragments.push(data)
+
+              if (!this.#info.fin) {
+                this.#state = parserStates.INFO
+                this.#loop = true
+                this.run(callback)
+                return
+              }
+
+              websocketMessageReceived(this.ws, this.#info.binaryType, Buffer.concat(this.#fragments))
+
+              this.#loop = true
+              this.#state = parserStates.INFO
+              this.#fragments.length = 0
+              this.run(callback)
+            })
+
+            this.#loop = false
+            break
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * Take n bytes from the buffered Buffers
+   * @param {number} n
+   * @returns {Buffer}
+   */
+  consume (n) {
+    if (n > this.#byteOffset) {
+      throw new Error('Called consume() before buffers satiated.')
+    } else if (n === 0) {
+      return emptyBuffer
+    }
+
+    if (this.#buffers[0].length === n) {
+      this.#byteOffset -= this.#buffers[0].length
+      return this.#buffers.shift()
+    }
+
+    const buffer = Buffer.allocUnsafe(n)
+    let offset = 0
+
+    while (offset !== n) {
+      const next = this.#buffers[0]
+      const { length } = next
+
+      if (length + offset === n) {
+        buffer.set(this.#buffers.shift(), offset)
+        break
+      } else if (length + offset > n) {
+        buffer.set(next.subarray(0, n - offset), offset)
+        this.#buffers[0] = next.subarray(n - offset)
+        break
+      } else {
+        buffer.set(this.#buffers.shift(), offset)
+        offset += next.length
+      }
+    }
+
+    this.#byteOffset -= n
+
+    return buffer
+  }
+
+  parseCloseBody (data) {
+    assert(data.length !== 1)
+
+    // https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.5
+    /** @type {number|undefined} */
+    let code
+
+    if (data.length >= 2) {
+      // _The WebSocket Connection Close Code_ is
+      // defined as the status code (Section 7.4) contained in the first Close
+      // control frame received by the application
+      code = data.readUInt16BE(0)
+    }
+
+    if (code !== undefined && !isValidStatusCode(code)) {
+      return { code: 1002, reason: 'Invalid status code', error: true }
+    }
+
+    // https://datatracker.ietf.org/doc/html/rfc6455#section-7.1.6
+    /** @type {Buffer} */
+    let reason = data.subarray(2)
+
+    // Remove BOM
+    if (reason[0] === 0xEF && reason[1] === 0xBB && reason[2] === 0xBF) {
+      reason = reason.subarray(3)
+    }
+
+    try {
+      reason = utf8Decode(reason)
+    } catch {
+      return { code: 1007, reason: 'Invalid UTF-8', error: true }
+    }
+
+    return { code, reason, error: false }
+  }
+
+  /**
+   * Parses control frames.
+   * @param {Buffer} body
+   */
+  parseControlFrame (body) {
+    const { opcode, payloadLength } = this.#info
+
+    if (opcode === opcodes.CLOSE) {
+      if (payloadLength === 1) {
+        failWebsocketConnection(this.ws, 'Received close frame with a 1-byte body.')
+        return false
+      }
+
+      this.#info.closeInfo = this.parseCloseBody(body)
+
+      if (this.#info.closeInfo.error) {
+        const { code, reason } = this.#info.closeInfo
+
+        closeWebSocketConnection(this.ws, code, reason, reason.length)
+        failWebsocketConnection(this.ws, reason)
+        return false
+      }
+
+      if (this.ws[kSentClose] !== sentCloseFrameState.SENT) {
+        // If an endpoint receives a Close frame and did not previously send a
+        // Close frame, the endpoint MUST send a Close frame in response.  (When
+        // sending a Close frame in response, the endpoint typically echos the
+        // status code it received.)
+        let body = emptyBuffer
+        if (this.#info.closeInfo.code) {
+          body = Buffer.allocUnsafe(2)
+          body.writeUInt16BE(this.#info.closeInfo.code, 0)
+        }
+        const closeFrame = new WebsocketFrameSend(body)
+
+        this.ws[kResponse].socket.write(
+          closeFrame.createFrame(opcodes.CLOSE),
+          (err) => {
+            if (!err) {
+              this.ws[kSentClose] = sentCloseFrameState.SENT
+            }
+          }
+        )
+      }
+
+      // Upon either sending or receiving a Close control frame, it is said
+      // that _The WebSocket Closing Handshake is Started_ and that the
+      // WebSocket connection is in the CLOSING state.
+      this.ws[kReadyState] = states.CLOSING
+      this.ws[kReceivedClose] = true
+
+      return false
+    } else if (opcode === opcodes.PING) {
+      // Upon receipt of a Ping frame, an endpoint MUST send a Pong frame in
+      // response, unless it already received a Close frame.
+      // A Pong frame sent in response to a Ping frame must have identical
+      // "Application data"
+
+      if (!this.ws[kReceivedClose]) {
+        const frame = new WebsocketFrameSend(body)
+
+        this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG))
+
+        if (channels.ping.hasSubscribers) {
+          channels.ping.publish({
+            payload: body
+          })
+        }
+      }
+    } else if (opcode === opcodes.PONG) {
+      // A Pong frame MAY be sent unsolicited.  This serves as a
+      // unidirectional heartbeat.  A response to an unsolicited Pong frame is
+      // not expected.
+
+      if (channels.pong.hasSubscribers) {
+        channels.pong.publish({
+          payload: body
+        })
+      }
+    }
+
+    return true
+  }
+
+  get closingInfo () {
+    return this.#info.closeInfo
+  }
+}
+
+module.exports = {
+  ByteParser
+}
+
+
+/***/ }),
+
+/***/ 91445:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { WebsocketFrameSend } = __nccwpck_require__(61163)
+const { opcodes, sendHints } = __nccwpck_require__(15318)
+const FixedQueue = __nccwpck_require__(82285)
+
+/** @type {typeof Uint8Array} */
+const FastBuffer = Buffer[Symbol.species]
+
+/**
+ * @typedef {object} SendQueueNode
+ * @property {Promise<void> | null} promise
+ * @property {((...args: any[]) => any)} callback
+ * @property {Buffer | null} frame
+ */
+
+class SendQueue {
+  /**
+   * @type {FixedQueue}
+   */
+  #queue = new FixedQueue()
+
+  /**
+   * @type {boolean}
+   */
+  #running = false
+
+  /** @type {import('node:net').Socket} */
+  #socket
+
+  constructor (socket) {
+    this.#socket = socket
+  }
+
+  add (item, cb, hint) {
+    if (hint !== sendHints.blob) {
+      const frame = createFrame(item, hint)
+      if (!this.#running) {
+        // fast-path
+        this.#socket.write(frame, cb)
+      } else {
+        /** @type {SendQueueNode} */
+        const node = {
+          promise: null,
+          callback: cb,
+          frame
+        }
+        this.#queue.push(node)
+      }
+      return
+    }
+
+    /** @type {SendQueueNode} */
+    const node = {
+      promise: item.arrayBuffer().then((ab) => {
+        node.promise = null
+        node.frame = createFrame(ab, hint)
+      }),
+      callback: cb,
+      frame: null
+    }
+
+    this.#queue.push(node)
+
+    if (!this.#running) {
+      this.#run()
+    }
+  }
+
+  async #run () {
+    this.#running = true
+    const queue = this.#queue
+    while (!queue.isEmpty()) {
+      const node = queue.shift()
+      // wait pending promise
+      if (node.promise !== null) {
+        await node.promise
+      }
+      // write
+      this.#socket.write(node.frame, node.callback)
+      // cleanup
+      node.callback = node.frame = null
+    }
+    this.#running = false
+  }
+}
+
+function createFrame (data, hint) {
+  return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.string ? opcodes.TEXT : opcodes.BINARY)
+}
+
+function toBuffer (data, hint) {
+  switch (hint) {
+    case sendHints.string:
+      return Buffer.from(data)
+    case sendHints.arrayBuffer:
+    case sendHints.blob:
+      return new FastBuffer(data)
+    case sendHints.typedArray:
+      return new FastBuffer(data.buffer, data.byteOffset, data.byteLength)
+  }
+}
+
+module.exports = { SendQueue }
+
+
+/***/ }),
+
+/***/ 38471:
+/***/ ((module) => {
+
+"use strict";
+
+
+module.exports = {
+  kWebSocketURL: Symbol('url'),
+  kReadyState: Symbol('ready state'),
+  kController: Symbol('controller'),
+  kResponse: Symbol('response'),
+  kBinaryType: Symbol('binary type'),
+  kSentClose: Symbol('sent close'),
+  kReceivedClose: Symbol('received close'),
+  kByteParser: Symbol('byte parser')
+}
+
+
+/***/ }),
+
+/***/ 13187:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = __nccwpck_require__(38471)
+const { states, opcodes } = __nccwpck_require__(15318)
+const { ErrorEvent, createFastMessageEvent } = __nccwpck_require__(15135)
+const { isUtf8 } = __nccwpck_require__(72254)
+const { collectASequenceOfCodePointsFast, removeHTTPWhitespace } = __nccwpck_require__(86954)
+
+/* globals Blob */
+
+/**
+ * @param {import('./websocket').WebSocket} ws
+ * @returns {boolean}
+ */
+function isConnecting (ws) {
+  // If the WebSocket connection is not yet established, and the connection
+  // is not yet closed, then the WebSocket connection is in the CONNECTING state.
+  return ws[kReadyState] === states.CONNECTING
+}
+
+/**
+ * @param {import('./websocket').WebSocket} ws
+ * @returns {boolean}
+ */
+function isEstablished (ws) {
+  // If the server's response is validated as provided for above, it is
+  // said that _The WebSocket Connection is Established_ and that the
+  // WebSocket Connection is in the OPEN state.
+  return ws[kReadyState] === states.OPEN
+}
+
+/**
+ * @param {import('./websocket').WebSocket} ws
+ * @returns {boolean}
+ */
+function isClosing (ws) {
+  // Upon either sending or receiving a Close control frame, it is said
+  // that _The WebSocket Closing Handshake is Started_ and that the
+  // WebSocket connection is in the CLOSING state.
+  return ws[kReadyState] === states.CLOSING
+}
+
+/**
+ * @param {import('./websocket').WebSocket} ws
+ * @returns {boolean}
+ */
+function isClosed (ws) {
+  return ws[kReadyState] === states.CLOSED
+}
+
+/**
+ * @see https://dom.spec.whatwg.org/#concept-event-fire
+ * @param {string} e
+ * @param {EventTarget} target
+ * @param {(...args: ConstructorParameters<typeof Event>) => Event} eventFactory
+ * @param {EventInit | undefined} eventInitDict
+ */
+function fireEvent (e, target, eventFactory = (type, init) => new Event(type, init), eventInitDict = {}) {
+  // 1. If eventConstructor is not given, then let eventConstructor be Event.
+
+  // 2. Let event be the result of creating an event given eventConstructor,
+  //    in the relevant realm of target.
+  // 3. Initialize event’s type attribute to e.
+  const event = eventFactory(e, eventInitDict)
+
+  // 4. Initialize any other IDL attributes of event as described in the
+  //    invocation of this algorithm.
+
+  // 5. Return the result of dispatching event at target, with legacy target
+  //    override flag set if set.
+  target.dispatchEvent(event)
+}
+
+/**
+ * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
+ * @param {import('./websocket').WebSocket} ws
+ * @param {number} type Opcode
+ * @param {Buffer} data application data
+ */
+function websocketMessageReceived (ws, type, data) {
+  // 1. If ready state is not OPEN (1), then return.
+  if (ws[kReadyState] !== states.OPEN) {
+    return
+  }
+
+  // 2. Let dataForEvent be determined by switching on type and binary type:
+  let dataForEvent
+
+  if (type === opcodes.TEXT) {
+    // -> type indicates that the data is Text
+    //      a new DOMString containing data
+    try {
+      dataForEvent = utf8Decode(data)
+    } catch {
+      failWebsocketConnection(ws, 'Received invalid UTF-8 in text frame.')
+      return
+    }
+  } else if (type === opcodes.BINARY) {
+    if (ws[kBinaryType] === 'blob') {
+      // -> type indicates that the data is Binary and binary type is "blob"
+      //      a new Blob object, created in the relevant Realm of the WebSocket
+      //      object, that represents data as its raw data
+      dataForEvent = new Blob([data])
+    } else {
+      // -> type indicates that the data is Binary and binary type is "arraybuffer"
+      //      a new ArrayBuffer object, created in the relevant Realm of the
+      //      WebSocket object, whose contents are data
+      dataForEvent = toArrayBuffer(data)
+    }
+  }
+
+  // 3. Fire an event named message at the WebSocket object, using MessageEvent,
+  //    with the origin attribute initialized to the serialization of the WebSocket
+  //    object’s url's origin, and the data attribute initialized to dataForEvent.
+  fireEvent('message', ws, createFastMessageEvent, {
+    origin: ws[kWebSocketURL].origin,
+    data: dataForEvent
+  })
+}
+
+function toArrayBuffer (buffer) {
+  if (buffer.byteLength === buffer.buffer.byteLength) {
+    return buffer.buffer
+  }
+  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
+}
+
+/**
+ * @see https://datatracker.ietf.org/doc/html/rfc6455
+ * @see https://datatracker.ietf.org/doc/html/rfc2616
+ * @see https://bugs.chromium.org/p/chromium/issues/detail?id=398407
+ * @param {string} protocol
+ */
+function isValidSubprotocol (protocol) {
+  // If present, this value indicates one
+  // or more comma-separated subprotocol the client wishes to speak,
+  // ordered by preference.  The elements that comprise this value
+  // MUST be non-empty strings with characters in the range U+0021 to
+  // U+007E not including separator characters as defined in
+  // [RFC2616] and MUST all be unique strings.
+  if (protocol.length === 0) {
+    return false
+  }
+
+  for (let i = 0; i < protocol.length; ++i) {
+    const code = protocol.charCodeAt(i)
+
+    if (
+      code < 0x21 || // CTL, contains SP (0x20) and HT (0x09)
+      code > 0x7E ||
+      code === 0x22 || // "
+      code === 0x28 || // (
+      code === 0x29 || // )
+      code === 0x2C || // ,
+      code === 0x2F || // /
+      code === 0x3A || // :
+      code === 0x3B || // ;
+      code === 0x3C || // <
+      code === 0x3D || // =
+      code === 0x3E || // >
+      code === 0x3F || // ?
+      code === 0x40 || // @
+      code === 0x5B || // [
+      code === 0x5C || // \
+      code === 0x5D || // ]
+      code === 0x7B || // {
+      code === 0x7D // }
+    ) {
+      return false
+    }
+  }
+
+  return true
+}
+
+/**
+ * @see https://datatracker.ietf.org/doc/html/rfc6455#section-7-4
+ * @param {number} code
+ */
+function isValidStatusCode (code) {
+  if (code >= 1000 && code < 1015) {
+    return (
+      code !== 1004 && // reserved
+      code !== 1005 && // "MUST NOT be set as a status code"
+      code !== 1006 // "MUST NOT be set as a status code"
+    )
+  }
+
+  return code >= 3000 && code <= 4999
+}
+
+/**
+ * @param {import('./websocket').WebSocket} ws
+ * @param {string|undefined} reason
+ */
+function failWebsocketConnection (ws, reason) {
+  const { [kController]: controller, [kResponse]: response } = ws
+
+  controller.abort()
+
+  if (response?.socket && !response.socket.destroyed) {
+    response.socket.destroy()
+  }
+
+  if (reason) {
+    // TODO: process.nextTick
+    fireEvent('error', ws, (type, init) => new ErrorEvent(type, init), {
+      error: new Error(reason),
+      message: reason
+    })
+  }
+}
+
+/**
+ * @see https://datatracker.ietf.org/doc/html/rfc6455#section-5.5
+ * @param {number} opcode
+ */
+function isControlFrame (opcode) {
+  return (
+    opcode === opcodes.CLOSE ||
+    opcode === opcodes.PING ||
+    opcode === opcodes.PONG
+  )
+}
+
+function isContinuationFrame (opcode) {
+  return opcode === opcodes.CONTINUATION
+}
+
+function isTextBinaryFrame (opcode) {
+  return opcode === opcodes.TEXT || opcode === opcodes.BINARY
+}
+
+function isValidOpcode (opcode) {
+  return isTextBinaryFrame(opcode) || isContinuationFrame(opcode) || isControlFrame(opcode)
+}
+
+/**
+ * Parses a Sec-WebSocket-Extensions header value.
+ * @param {string} extensions
+ * @returns {Map<string, string>}
+ */
+// TODO(@Uzlopak, @KhafraDev): make compliant https://datatracker.ietf.org/doc/html/rfc6455#section-9.1
+function parseExtensions (extensions) {
+  const position = { position: 0 }
+  const extensionList = new Map()
+
+  while (position.position < extensions.length) {
+    const pair = collectASequenceOfCodePointsFast(';', extensions, position)
+    const [name, value = ''] = pair.split('=')
+
+    extensionList.set(
+      removeHTTPWhitespace(name, true, false),
+      removeHTTPWhitespace(value, false, true)
+    )
+
+    position.position++
+  }
+
+  return extensionList
+}
+
+/**
+ * @see https://www.rfc-editor.org/rfc/rfc7692#section-7.1.2.2
+ * @description "client-max-window-bits = 1*DIGIT"
+ * @param {string} value
+ */
+function isValidClientWindowBits (value) {
+  for (let i = 0; i < value.length; i++) {
+    const byte = value.charCodeAt(i)
+
+    if (byte < 0x30 || byte > 0x39) {
+      return false
+    }
+  }
+
+  return true
+}
+
+// https://nodejs.org/api/intl.html#detecting-internationalization-support
+const hasIntl = typeof process.versions.icu === 'string'
+const fatalDecoder = hasIntl ? new TextDecoder('utf-8', { fatal: true }) : undefined
+
+/**
+ * Converts a Buffer to utf-8, even on platforms without icu.
+ * @param {Buffer} buffer
+ */
+const utf8Decode = hasIntl
+  ? fatalDecoder.decode.bind(fatalDecoder)
+  : function (buffer) {
+    if (isUtf8(buffer)) {
+      return buffer.toString('utf-8')
+    }
+    throw new TypeError('Invalid utf-8 received.')
+  }
+
+module.exports = {
+  isConnecting,
+  isEstablished,
+  isClosing,
+  isClosed,
+  fireEvent,
+  isValidSubprotocol,
+  isValidStatusCode,
+  failWebsocketConnection,
+  websocketMessageReceived,
+  utf8Decode,
+  isControlFrame,
+  isContinuationFrame,
+  isTextBinaryFrame,
+  isValidOpcode,
+  parseExtensions,
+  isValidClientWindowBits
+}
+
+
+/***/ }),
+
+/***/ 75860:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+const { webidl } = __nccwpck_require__(37829)
+const { URLSerializer } = __nccwpck_require__(86954)
+const { environmentSettingsObject } = __nccwpck_require__(91976)
+const { staticPropertyDescriptors, states, sentCloseFrameState, sendHints } = __nccwpck_require__(15318)
+const {
+  kWebSocketURL,
+  kReadyState,
+  kController,
+  kBinaryType,
+  kResponse,
+  kSentClose,
+  kByteParser
+} = __nccwpck_require__(38471)
+const {
+  isConnecting,
+  isEstablished,
+  isClosing,
+  isValidSubprotocol,
+  fireEvent
+} = __nccwpck_require__(13187)
+const { establishWebSocketConnection, closeWebSocketConnection } = __nccwpck_require__(19072)
+const { ByteParser } = __nccwpck_require__(47879)
+const { kEnumerableProperty, isBlobLike } = __nccwpck_require__(94407)
+const { getGlobalDispatcher } = __nccwpck_require__(72354)
+const { types } = __nccwpck_require__(47261)
+const { ErrorEvent, CloseEvent } = __nccwpck_require__(15135)
+const { SendQueue } = __nccwpck_require__(91445)
+
+// https://websockets.spec.whatwg.org/#interface-definition
+class WebSocket extends EventTarget {
+  #events = {
+    open: null,
+    error: null,
+    close: null,
+    message: null
+  }
+
+  #bufferedAmount = 0
+  #protocol = ''
+  #extensions = ''
+
+  /** @type {SendQueue} */
+  #sendQueue
+
+  /**
+   * @param {string} url
+   * @param {string|string[]} protocols
+   */
+  constructor (url, protocols = []) {
+    super()
+
+    webidl.util.markAsUncloneable(this)
+
+    const prefix = 'WebSocket constructor'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    const options = webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'](protocols, prefix, 'options')
+
+    url = webidl.converters.USVString(url, prefix, 'url')
+    protocols = options.protocols
+
+    // 1. Let baseURL be this's relevant settings object's API base URL.
+    const baseURL = environmentSettingsObject.settingsObject.baseUrl
+
+    // 1. Let urlRecord be the result of applying the URL parser to url with baseURL.
+    let urlRecord
+
+    try {
+      urlRecord = new URL(url, baseURL)
+    } catch (e) {
+      // 3. If urlRecord is failure, then throw a "SyntaxError" DOMException.
+      throw new DOMException(e, 'SyntaxError')
+    }
+
+    // 4. If urlRecord’s scheme is "http", then set urlRecord’s scheme to "ws".
+    if (urlRecord.protocol === 'http:') {
+      urlRecord.protocol = 'ws:'
+    } else if (urlRecord.protocol === 'https:') {
+      // 5. Otherwise, if urlRecord’s scheme is "https", set urlRecord’s scheme to "wss".
+      urlRecord.protocol = 'wss:'
+    }
+
+    // 6. If urlRecord’s scheme is not "ws" or "wss", then throw a "SyntaxError" DOMException.
+    if (urlRecord.protocol !== 'ws:' && urlRecord.protocol !== 'wss:') {
+      throw new DOMException(
+        `Expected a ws: or wss: protocol, got ${urlRecord.protocol}`,
+        'SyntaxError'
+      )
+    }
+
+    // 7. If urlRecord’s fragment is non-null, then throw a "SyntaxError"
+    //    DOMException.
+    if (urlRecord.hash || urlRecord.href.endsWith('#')) {
+      throw new DOMException('Got fragment', 'SyntaxError')
+    }
+
+    // 8. If protocols is a string, set protocols to a sequence consisting
+    //    of just that string.
+    if (typeof protocols === 'string') {
+      protocols = [protocols]
+    }
+
+    // 9. If any of the values in protocols occur more than once or otherwise
+    //    fail to match the requirements for elements that comprise the value
+    //    of `Sec-WebSocket-Protocol` fields as defined by The WebSocket
+    //    protocol, then throw a "SyntaxError" DOMException.
+    if (protocols.length !== new Set(protocols.map(p => p.toLowerCase())).size) {
+      throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError')
+    }
+
+    if (protocols.length > 0 && !protocols.every(p => isValidSubprotocol(p))) {
+      throw new DOMException('Invalid Sec-WebSocket-Protocol value', 'SyntaxError')
+    }
+
+    // 10. Set this's url to urlRecord.
+    this[kWebSocketURL] = new URL(urlRecord.href)
+
+    // 11. Let client be this's relevant settings object.
+    const client = environmentSettingsObject.settingsObject
+
+    // 12. Run this step in parallel:
+
+    //    1. Establish a WebSocket connection given urlRecord, protocols,
+    //       and client.
+    this[kController] = establishWebSocketConnection(
+      urlRecord,
+      protocols,
+      client,
+      this,
+      (response, extensions) => this.#onConnectionEstablished(response, extensions),
+      options
+    )
+
+    // Each WebSocket object has an associated ready state, which is a
+    // number representing the state of the connection. Initially it must
+    // be CONNECTING (0).
+    this[kReadyState] = WebSocket.CONNECTING
+
+    this[kSentClose] = sentCloseFrameState.NOT_SENT
+
+    // The extensions attribute must initially return the empty string.
+
+    // The protocol attribute must initially return the empty string.
+
+    // Each WebSocket object has an associated binary type, which is a
+    // BinaryType. Initially it must be "blob".
+    this[kBinaryType] = 'blob'
+  }
+
+  /**
+   * @see https://websockets.spec.whatwg.org/#dom-websocket-close
+   * @param {number|undefined} code
+   * @param {string|undefined} reason
+   */
+  close (code = undefined, reason = undefined) {
+    webidl.brandCheck(this, WebSocket)
+
+    const prefix = 'WebSocket.close'
+
+    if (code !== undefined) {
+      code = webidl.converters['unsigned short'](code, prefix, 'code', { clamp: true })
+    }
+
+    if (reason !== undefined) {
+      reason = webidl.converters.USVString(reason, prefix, 'reason')
+    }
+
+    // 1. If code is present, but is neither an integer equal to 1000 nor an
+    //    integer in the range 3000 to 4999, inclusive, throw an
+    //    "InvalidAccessError" DOMException.
+    if (code !== undefined) {
+      if (code !== 1000 && (code < 3000 || code > 4999)) {
+        throw new DOMException('invalid code', 'InvalidAccessError')
+      }
+    }
+
+    let reasonByteLength = 0
+
+    // 2. If reason is present, then run these substeps:
+    if (reason !== undefined) {
+      // 1. Let reasonBytes be the result of encoding reason.
+      // 2. If reasonBytes is longer than 123 bytes, then throw a
+      //    "SyntaxError" DOMException.
+      reasonByteLength = Buffer.byteLength(reason)
+
+      if (reasonByteLength > 123) {
+        throw new DOMException(
+          `Reason must be less than 123 bytes; received ${reasonByteLength}`,
+          'SyntaxError'
+        )
+      }
+    }
+
+    // 3. Run the first matching steps from the following list:
+    closeWebSocketConnection(this, code, reason, reasonByteLength)
+  }
+
+  /**
+   * @see https://websockets.spec.whatwg.org/#dom-websocket-send
+   * @param {NodeJS.TypedArray|ArrayBuffer|Blob|string} data
+   */
+  send (data) {
+    webidl.brandCheck(this, WebSocket)
+
+    const prefix = 'WebSocket.send'
+    webidl.argumentLengthCheck(arguments, 1, prefix)
+
+    data = webidl.converters.WebSocketSendData(data, prefix, 'data')
+
+    // 1. If this's ready state is CONNECTING, then throw an
+    //    "InvalidStateError" DOMException.
+    if (isConnecting(this)) {
+      throw new DOMException('Sent before connected.', 'InvalidStateError')
+    }
+
+    // 2. Run the appropriate set of steps from the following list:
+    // https://datatracker.ietf.org/doc/html/rfc6455#section-6.1
+    // https://datatracker.ietf.org/doc/html/rfc6455#section-5.2
+
+    if (!isEstablished(this) || isClosing(this)) {
+      return
+    }
+
+    // If data is a string
+    if (typeof data === 'string') {
+      // If the WebSocket connection is established and the WebSocket
+      // closing handshake has not yet started, then the user agent
+      // must send a WebSocket Message comprised of the data argument
+      // using a text frame opcode; if the data cannot be sent, e.g.
+      // because it would need to be buffered but the buffer is full,
+      // the user agent must flag the WebSocket as full and then close
+      // the WebSocket connection. Any invocation of this method with a
+      // string argument that does not throw an exception must increase
+      // the bufferedAmount attribute by the number of bytes needed to
+      // express the argument as UTF-8.
+
+      const length = Buffer.byteLength(data)
+
+      this.#bufferedAmount += length
+      this.#sendQueue.add(data, () => {
+        this.#bufferedAmount -= length
+      }, sendHints.string)
+    } else if (types.isArrayBuffer(data)) {
+      // If the WebSocket connection is established, and the WebSocket
+      // closing handshake has not yet started, then the user agent must
+      // send a WebSocket Message comprised of data using a binary frame
+      // opcode; if the data cannot be sent, e.g. because it would need
+      // to be buffered but the buffer is full, the user agent must flag
+      // the WebSocket as full and then close the WebSocket connection.
+      // The data to be sent is the data stored in the buffer described
+      // by the ArrayBuffer object. Any invocation of this method with an
+      // ArrayBuffer argument that does not throw an exception must
+      // increase the bufferedAmount attribute by the length of the
+      // ArrayBuffer in bytes.
+
+      this.#bufferedAmount += data.byteLength
+      this.#sendQueue.add(data, () => {
+        this.#bufferedAmount -= data.byteLength
+      }, sendHints.arrayBuffer)
+    } else if (ArrayBuffer.isView(data)) {
+      // If the WebSocket connection is established, and the WebSocket
+      // closing handshake has not yet started, then the user agent must
+      // send a WebSocket Message comprised of data using a binary frame
+      // opcode; if the data cannot be sent, e.g. because it would need to
+      // be buffered but the buffer is full, the user agent must flag the
+      // WebSocket as full and then close the WebSocket connection. The
+      // data to be sent is the data stored in the section of the buffer
+      // described by the ArrayBuffer object that data references. Any
+      // invocation of this method with this kind of argument that does
+      // not throw an exception must increase the bufferedAmount attribute
+      // by the length of data’s buffer in bytes.
+
+      this.#bufferedAmount += data.byteLength
+      this.#sendQueue.add(data, () => {
+        this.#bufferedAmount -= data.byteLength
+      }, sendHints.typedArray)
+    } else if (isBlobLike(data)) {
+      // If the WebSocket connection is established, and the WebSocket
+      // closing handshake has not yet started, then the user agent must
+      // send a WebSocket Message comprised of data using a binary frame
+      // opcode; if the data cannot be sent, e.g. because it would need to
+      // be buffered but the buffer is full, the user agent must flag the
+      // WebSocket as full and then close the WebSocket connection. The data
+      // to be sent is the raw data represented by the Blob object. Any
+      // invocation of this method with a Blob argument that does not throw
+      // an exception must increase the bufferedAmount attribute by the size
+      // of the Blob object’s raw data, in bytes.
+
+      this.#bufferedAmount += data.size
+      this.#sendQueue.add(data, () => {
+        this.#bufferedAmount -= data.size
+      }, sendHints.blob)
+    }
+  }
+
+  get readyState () {
+    webidl.brandCheck(this, WebSocket)
+
+    // The readyState getter steps are to return this's ready state.
+    return this[kReadyState]
+  }
+
+  get bufferedAmount () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#bufferedAmount
+  }
+
+  get url () {
+    webidl.brandCheck(this, WebSocket)
+
+    // The url getter steps are to return this's url, serialized.
+    return URLSerializer(this[kWebSocketURL])
+  }
+
+  get extensions () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#extensions
+  }
+
+  get protocol () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#protocol
+  }
+
+  get onopen () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#events.open
+  }
+
+  set onopen (fn) {
+    webidl.brandCheck(this, WebSocket)
+
+    if (this.#events.open) {
+      this.removeEventListener('open', this.#events.open)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.open = fn
+      this.addEventListener('open', fn)
+    } else {
+      this.#events.open = null
+    }
+  }
+
+  get onerror () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#events.error
+  }
+
+  set onerror (fn) {
+    webidl.brandCheck(this, WebSocket)
+
+    if (this.#events.error) {
+      this.removeEventListener('error', this.#events.error)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.error = fn
+      this.addEventListener('error', fn)
+    } else {
+      this.#events.error = null
+    }
+  }
+
+  get onclose () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#events.close
+  }
+
+  set onclose (fn) {
+    webidl.brandCheck(this, WebSocket)
+
+    if (this.#events.close) {
+      this.removeEventListener('close', this.#events.close)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.close = fn
+      this.addEventListener('close', fn)
+    } else {
+      this.#events.close = null
+    }
+  }
+
+  get onmessage () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this.#events.message
+  }
+
+  set onmessage (fn) {
+    webidl.brandCheck(this, WebSocket)
+
+    if (this.#events.message) {
+      this.removeEventListener('message', this.#events.message)
+    }
+
+    if (typeof fn === 'function') {
+      this.#events.message = fn
+      this.addEventListener('message', fn)
+    } else {
+      this.#events.message = null
+    }
+  }
+
+  get binaryType () {
+    webidl.brandCheck(this, WebSocket)
+
+    return this[kBinaryType]
+  }
+
+  set binaryType (type) {
+    webidl.brandCheck(this, WebSocket)
+
+    if (type !== 'blob' && type !== 'arraybuffer') {
+      this[kBinaryType] = 'blob'
+    } else {
+      this[kBinaryType] = type
+    }
+  }
+
+  /**
+   * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
+   */
+  #onConnectionEstablished (response, parsedExtensions) {
+    // processResponse is called when the "response’s header list has been received and initialized."
+    // once this happens, the connection is open
+    this[kResponse] = response
+
+    const parser = new ByteParser(this, parsedExtensions)
+    parser.on('drain', onParserDrain)
+    parser.on('error', onParserError.bind(this))
+
+    response.socket.ws = this
+    this[kByteParser] = parser
+
+    this.#sendQueue = new SendQueue(response.socket)
+
+    // 1. Change the ready state to OPEN (1).
+    this[kReadyState] = states.OPEN
+
+    // 2. Change the extensions attribute’s value to the extensions in use, if
+    //    it is not the null value.
+    // https://datatracker.ietf.org/doc/html/rfc6455#section-9.1
+    const extensions = response.headersList.get('sec-websocket-extensions')
+
+    if (extensions !== null) {
+      this.#extensions = extensions
+    }
+
+    // 3. Change the protocol attribute’s value to the subprotocol in use, if
+    //    it is not the null value.
+    // https://datatracker.ietf.org/doc/html/rfc6455#section-1.9
+    const protocol = response.headersList.get('sec-websocket-protocol')
+
+    if (protocol !== null) {
+      this.#protocol = protocol
+    }
+
+    // 4. Fire an event named open at the WebSocket object.
+    fireEvent('open', this)
+  }
+}
+
+// https://websockets.spec.whatwg.org/#dom-websocket-connecting
+WebSocket.CONNECTING = WebSocket.prototype.CONNECTING = states.CONNECTING
+// https://websockets.spec.whatwg.org/#dom-websocket-open
+WebSocket.OPEN = WebSocket.prototype.OPEN = states.OPEN
+// https://websockets.spec.whatwg.org/#dom-websocket-closing
+WebSocket.CLOSING = WebSocket.prototype.CLOSING = states.CLOSING
+// https://websockets.spec.whatwg.org/#dom-websocket-closed
+WebSocket.CLOSED = WebSocket.prototype.CLOSED = states.CLOSED
+
+Object.defineProperties(WebSocket.prototype, {
+  CONNECTING: staticPropertyDescriptors,
+  OPEN: staticPropertyDescriptors,
+  CLOSING: staticPropertyDescriptors,
+  CLOSED: staticPropertyDescriptors,
+  url: kEnumerableProperty,
+  readyState: kEnumerableProperty,
+  bufferedAmount: kEnumerableProperty,
+  onopen: kEnumerableProperty,
+  onerror: kEnumerableProperty,
+  onclose: kEnumerableProperty,
+  close: kEnumerableProperty,
+  onmessage: kEnumerableProperty,
+  binaryType: kEnumerableProperty,
+  send: kEnumerableProperty,
+  extensions: kEnumerableProperty,
+  protocol: kEnumerableProperty,
+  [Symbol.toStringTag]: {
+    value: 'WebSocket',
+    writable: false,
+    enumerable: false,
+    configurable: true
+  }
+})
+
+Object.defineProperties(WebSocket, {
+  CONNECTING: staticPropertyDescriptors,
+  OPEN: staticPropertyDescriptors,
+  CLOSING: staticPropertyDescriptors,
+  CLOSED: staticPropertyDescriptors
+})
+
+webidl.converters['sequence<DOMString>'] = webidl.sequenceConverter(
+  webidl.converters.DOMString
+)
+
+webidl.converters['DOMString or sequence<DOMString>'] = function (V, prefix, argument) {
+  if (webidl.util.Type(V) === 'Object' && Symbol.iterator in V) {
+    return webidl.converters['sequence<DOMString>'](V)
+  }
+
+  return webidl.converters.DOMString(V, prefix, argument)
+}
+
+// This implements the proposal made in https://github.com/whatwg/websockets/issues/42
+webidl.converters.WebSocketInit = webidl.dictionaryConverter([
+  {
+    key: 'protocols',
+    converter: webidl.converters['DOMString or sequence<DOMString>'],
+    defaultValue: () => new Array(0)
+  },
+  {
+    key: 'dispatcher',
+    converter: webidl.converters.any,
+    defaultValue: () => getGlobalDispatcher()
+  },
+  {
+    key: 'headers',
+    converter: webidl.nullableConverter(webidl.converters.HeadersInit)
+  }
+])
+
+webidl.converters['DOMString or sequence<DOMString> or WebSocketInit'] = function (V) {
+  if (webidl.util.Type(V) === 'Object' && !(Symbol.iterator in V)) {
+    return webidl.converters.WebSocketInit(V)
+  }
+
+  return { protocols: webidl.converters['DOMString or sequence<DOMString>'](V) }
+}
+
+webidl.converters.WebSocketSendData = function (V) {
+  if (webidl.util.Type(V) === 'Object') {
+    if (isBlobLike(V)) {
+      return webidl.converters.Blob(V, { strict: false })
+    }
+
+    if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
+      return webidl.converters.BufferSource(V)
+    }
+  }
+
+  return webidl.converters.USVString(V)
+}
+
+function onParserDrain () {
+  this.ws[kResponse].socket.resume()
+}
+
+function onParserError (err) {
+  let message
+  let code
+
+  if (err instanceof CloseEvent) {
+    message = err.reason
+    code = err.code
+  } else {
+    message = err.message
+  }
+
+  fireEvent('error', this, () => new ErrorEvent('error', { error: err, message }))
+
+  closeWebSocketConnection(this, code)
+}
+
+module.exports = {
+  WebSocket
+}
+
+
 /***/ }),
 
 /***/ 87351:
@@ -12987,7 +40401,7 @@ exports.RetryHelper = RetryHelper;
 
 /***/ }),
 
-/***/ 27784:
+/***/ 54188:
 /***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
@@ -15557,15 +42971,23 @@ exports.AbortSignal = AbortSignal;
 /***/ }),
 
 /***/ 32206:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.abort_add = abort_add;
-exports.abort_remove = abort_remove;
-exports.abort_signalAbort = abort_signalAbort;
-const EventAlgorithm_1 = __nccwpck_require__(28217);
+var EventAlgorithm_1 = __nccwpck_require__(28217);
 /**
  * Adds an algorithm to the given abort signal.
  *
@@ -15581,6 +43003,7 @@ function abort_add(algorithm, signal) {
         return;
     signal._abortAlgorithms.add(algorithm);
 }
+exports.abort_add = abort_add;
 /**
  * Removes an algorithm from the given abort signal.
  *
@@ -15594,12 +43017,14 @@ function abort_remove(algorithm, signal) {
      */
     signal._abortAlgorithms.delete(algorithm);
 }
+exports.abort_remove = abort_remove;
 /**
  * Signals abort on the given abort signal.
  *
  * @param signal - abort signal
  */
 function abort_signalAbort(signal) {
+    var e_1, _a;
     /**
      * 1. If signal’s aborted flag is set, then return.
      * 2. Set signal’s aborted flag.
@@ -15610,12 +43035,23 @@ function abort_signalAbort(signal) {
     if (signal._abortedFlag)
         return;
     signal._abortedFlag = true;
-    for (const algorithm of signal._abortAlgorithms) {
-        algorithm.call(signal);
+    try {
+        for (var _b = __values(signal._abortAlgorithms), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var algorithm = _c.value;
+            algorithm.call(signal);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
     }
     signal._abortAlgorithms.clear();
-    (0, EventAlgorithm_1.event_fireAnEvent)("abort", signal);
+    EventAlgorithm_1.event_fireAnEvent("abort", signal);
 }
+exports.abort_signalAbort = abort_signalAbort;
 //# sourceMappingURL=AbortAlgorithm.js.map
 
 /***/ }),
@@ -15626,8 +43062,7 @@ function abort_signalAbort(signal) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.attr_setAnExistingAttributeValue = attr_setAnExistingAttributeValue;
-const ElementAlgorithm_1 = __nccwpck_require__(51849);
+var ElementAlgorithm_1 = __nccwpck_require__(51849);
 /**
  * Changes the value of an existing attribute.
  *
@@ -15643,9 +43078,10 @@ function attr_setAnExistingAttributeValue(attribute, value) {
         attribute._value = value;
     }
     else {
-        (0, ElementAlgorithm_1.element_change)(attribute, attribute._element, value);
+        ElementAlgorithm_1.element_change(attribute, attribute._element, value);
     }
 }
+exports.attr_setAnExistingAttributeValue = attr_setAnExistingAttributeValue;
 //# sourceMappingURL=AttrAlgorithm.js.map
 
 /***/ }),
@@ -15656,9 +43092,8 @@ function attr_setAnExistingAttributeValue(attribute, value) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.boundaryPoint_position = boundaryPoint_position;
-const interfaces_1 = __nccwpck_require__(27305);
-const TreeAlgorithm_1 = __nccwpck_require__(16620);
+var interfaces_1 = __nccwpck_require__(27305);
+var TreeAlgorithm_1 = __nccwpck_require__(16620);
 /**
  * Defines the position of a boundary point relative to another.
  *
@@ -15666,14 +43101,14 @@ const TreeAlgorithm_1 = __nccwpck_require__(16620);
  * @param relativeTo - a boundary point to compare to
  */
 function boundaryPoint_position(bp, relativeTo) {
-    const nodeA = bp[0];
-    const offsetA = bp[1];
-    const nodeB = relativeTo[0];
-    const offsetB = relativeTo[1];
+    var nodeA = bp[0];
+    var offsetA = bp[1];
+    var nodeB = relativeTo[0];
+    var offsetB = relativeTo[1];
     /**
      * 1. Assert: nodeA and nodeB have the same root.
      */
-    console.assert((0, TreeAlgorithm_1.tree_rootNode)(nodeA) === (0, TreeAlgorithm_1.tree_rootNode)(nodeB), "Boundary points must share the same root node.");
+    console.assert(TreeAlgorithm_1.tree_rootNode(nodeA) === TreeAlgorithm_1.tree_rootNode(nodeB), "Boundary points must share the same root node.");
     /**
      * 2. If nodeA is nodeB, then return equal if offsetA is offsetB, before
      * if offsetA is less than offsetB, and after if offsetA is greater than
@@ -15695,8 +43130,8 @@ function boundaryPoint_position(bp, relativeTo) {
      * relative to (nodeA, offsetA) is before, return after, and if it is after,
      * return before.
      */
-    if ((0, TreeAlgorithm_1.tree_isFollowing)(nodeB, nodeA)) {
-        const pos = boundaryPoint_position([nodeB, offsetB], [nodeA, offsetA]);
+    if (TreeAlgorithm_1.tree_isFollowing(nodeB, nodeA)) {
+        var pos = boundaryPoint_position([nodeB, offsetB], [nodeA, offsetA]);
         if (pos === interfaces_1.BoundaryPosition.Before) {
             return interfaces_1.BoundaryPosition.After;
         }
@@ -15707,20 +43142,20 @@ function boundaryPoint_position(bp, relativeTo) {
     /**
      * 4. If nodeA is an ancestor of nodeB:
      */
-    if ((0, TreeAlgorithm_1.tree_isAncestorOf)(nodeB, nodeA)) {
+    if (TreeAlgorithm_1.tree_isAncestorOf(nodeB, nodeA)) {
         /**
          * 4.1. Let child be nodeB.
          * 4.2. While child is not a child of nodeA, set child to its parent.
          * 4.3. If child’s index is less than offsetA, then return after.
          */
-        let child = nodeB;
-        while (!(0, TreeAlgorithm_1.tree_isChildOf)(nodeA, child)) {
+        var child = nodeB;
+        while (!TreeAlgorithm_1.tree_isChildOf(nodeA, child)) {
             /* istanbul ignore else */
             if (child._parent !== null) {
                 child = child._parent;
             }
         }
-        if ((0, TreeAlgorithm_1.tree_index)(child) < offsetA) {
+        if (TreeAlgorithm_1.tree_index(child) < offsetA) {
             return interfaces_1.BoundaryPosition.After;
         }
     }
@@ -15729,24 +43164,34 @@ function boundaryPoint_position(bp, relativeTo) {
      */
     return interfaces_1.BoundaryPosition.Before;
 }
+exports.boundaryPoint_position = boundaryPoint_position;
 //# sourceMappingURL=BoundaryPointAlgorithm.js.map
 
 /***/ }),
 
 /***/ 19461:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.characterData_replaceData = characterData_replaceData;
-exports.characterData_substringData = characterData_substringData;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const util_1 = __nccwpck_require__(65282);
-const DOMException_1 = __nccwpck_require__(13166);
-const TreeAlgorithm_1 = __nccwpck_require__(16620);
-const MutationObserverAlgorithm_1 = __nccwpck_require__(78157);
-const DOMAlgorithm_1 = __nccwpck_require__(9628);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var util_1 = __nccwpck_require__(65282);
+var DOMException_1 = __nccwpck_require__(13166);
+var TreeAlgorithm_1 = __nccwpck_require__(16620);
+var MutationObserverAlgorithm_1 = __nccwpck_require__(78157);
+var DOMAlgorithm_1 = __nccwpck_require__(9628);
 /**
  * Replaces character data.
  *
@@ -15756,6 +43201,7 @@ const DOMAlgorithm_1 = __nccwpck_require__(9628);
  * @param data - new data
  */
 function characterData_replaceData(node, offset, count, data) {
+    var e_1, _a;
     /**
      * 1. Let length be node’s length.
      * 2. If offset is greater than length, then throw an "IndexSizeError"
@@ -15763,9 +43209,9 @@ function characterData_replaceData(node, offset, count, data) {
      * 3. If offset plus count is greater than length, then set count to length
      * minus offset.
      */
-    const length = (0, TreeAlgorithm_1.tree_nodeLength)(node);
+    var length = TreeAlgorithm_1.tree_nodeLength(node);
     if (offset > length) {
-        throw new DOMException_1.IndexSizeError(`Offset exceeds character data length. Offset: ${offset}, Length: ${length}, Node is ${node.nodeName}.`);
+        throw new DOMException_1.IndexSizeError("Offset exceeds character data length. Offset: " + offset + ", Length: " + length + ", Node is " + node.nodeName + ".");
     }
     if (offset + count > length) {
         count = length - offset;
@@ -15775,7 +43221,7 @@ function characterData_replaceData(node, offset, count, data) {
      * node’s data, « », « », null, and null.
      */
     if (DOMImpl_1.dom.features.mutationObservers) {
-        (0, MutationObserverAlgorithm_1.observer_queueMutationRecord)("characterData", node, null, null, node._data, [], [], null, null);
+        MutationObserverAlgorithm_1.observer_queueMutationRecord("characterData", node, null, null, node._data, [], [], null, null);
     }
     /**
      * 5. Insert data into node’s data after offset code units.
@@ -15783,36 +43229,46 @@ function characterData_replaceData(node, offset, count, data) {
      * 7. Starting from delete offset code units, remove count code units from
      * node’s data.
      */
-    const newData = node._data.substring(0, offset) + data +
+    var newData = node._data.substring(0, offset) + data +
         node._data.substring(offset + count);
     node._data = newData;
-    /**
-     * 8. For each live range whose start node is node and start offset is
-     * greater than offset but less than or equal to offset plus count, set its
-     * start offset to offset.
-     * 9. For each live range whose end node is node and end offset is greater
-     * than offset but less than or equal to offset plus count, set its end
-     * offset to offset.
-     * 10. For each live range whose start node is node and start offset is
-     * greater than offset plus count, increase its start offset by data’s
-     * length and decrease it by count.
-     * 11. For each live range whose end node is node and end offset is greater
-     * than offset plus count, increase its end offset by data’s length and
-     * decrease it by count.
-     */
-    for (const range of DOMImpl_1.dom.rangeList) {
-        if (range._start[0] === node && range._start[1] > offset && range._start[1] <= offset + count) {
-            range._start[1] = offset;
+    try {
+        /**
+         * 8. For each live range whose start node is node and start offset is
+         * greater than offset but less than or equal to offset plus count, set its
+         * start offset to offset.
+         * 9. For each live range whose end node is node and end offset is greater
+         * than offset but less than or equal to offset plus count, set its end
+         * offset to offset.
+         * 10. For each live range whose start node is node and start offset is
+         * greater than offset plus count, increase its start offset by data’s
+         * length and decrease it by count.
+         * 11. For each live range whose end node is node and end offset is greater
+         * than offset plus count, increase its end offset by data’s length and
+         * decrease it by count.
+         */
+        for (var _b = __values(DOMImpl_1.dom.rangeList), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var range = _c.value;
+            if (range._start[0] === node && range._start[1] > offset && range._start[1] <= offset + count) {
+                range._start[1] = offset;
+            }
+            if (range._end[0] === node && range._end[1] > offset && range._end[1] <= offset + count) {
+                range._end[1] = offset;
+            }
+            if (range._start[0] === node && range._start[1] > offset + count) {
+                range._start[1] += data.length - count;
+            }
+            if (range._end[0] === node && range._end[1] > offset + count) {
+                range._end[1] += data.length - count;
+            }
         }
-        if (range._end[0] === node && range._end[1] > offset && range._end[1] <= offset + count) {
-            range._end[1] = offset;
-        }
-        if (range._start[0] === node && range._start[1] > offset + count) {
-            range._start[1] += data.length - count;
-        }
-        if (range._end[0] === node && range._end[1] > offset + count) {
-            range._end[1] += data.length - count;
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
+        finally { if (e_1) throw e_1.error; }
     }
     /**
      * 12. If node is a Text node and its parent is not null, run the child
@@ -15820,10 +43276,11 @@ function characterData_replaceData(node, offset, count, data) {
      */
     if (DOMImpl_1.dom.features.steps) {
         if (util_1.Guard.isTextNode(node) && node._parent !== null) {
-            (0, DOMAlgorithm_1.dom_runChildTextContentChangeSteps)(node._parent);
+            DOMAlgorithm_1.dom_runChildTextContentChangeSteps(node._parent);
         }
     }
 }
+exports.characterData_replaceData = characterData_replaceData;
 /**
  * Returns `count` number of characters from `node`'s data starting at
  * the given `offset`.
@@ -15843,9 +43300,9 @@ function characterData_substringData(node, offset, count) {
      * 4. Return a string whose value is the code units from the offsetth code
      * unit to the offset+countth code unit in node’s data.
      */
-    const length = (0, TreeAlgorithm_1.tree_nodeLength)(node);
+    var length = TreeAlgorithm_1.tree_nodeLength(node);
     if (offset > length) {
-        throw new DOMException_1.IndexSizeError(`Offset exceeds character data length. Offset: ${offset}, Length: ${length}, Node is ${node.nodeName}.`);
+        throw new DOMException_1.IndexSizeError("Offset exceeds character data length. Offset: " + offset + ", Length: " + length + ", Node is " + node.nodeName + ".");
     }
     if (offset + count > length) {
         return node._data.substr(offset);
@@ -15854,6 +43311,7 @@ function characterData_substringData(node, offset, count) {
         return node._data.substr(offset, count);
     }
 }
+exports.characterData_substringData = characterData_substringData;
 //# sourceMappingURL=CharacterDataAlgorithm.js.map
 
 /***/ }),
@@ -15864,58 +43322,31 @@ function characterData_substringData(node, offset, count) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.create_domImplementation = create_domImplementation;
-exports.create_window = create_window;
-exports.create_xmlDocument = create_xmlDocument;
-exports.create_document = create_document;
-exports.create_abortController = create_abortController;
-exports.create_abortSignal = create_abortSignal;
-exports.create_documentType = create_documentType;
-exports.create_element = create_element;
-exports.create_htmlElement = create_htmlElement;
-exports.create_htmlUnknownElement = create_htmlUnknownElement;
-exports.create_documentFragment = create_documentFragment;
-exports.create_shadowRoot = create_shadowRoot;
-exports.create_attr = create_attr;
-exports.create_text = create_text;
-exports.create_cdataSection = create_cdataSection;
-exports.create_comment = create_comment;
-exports.create_processingInstruction = create_processingInstruction;
-exports.create_htmlCollection = create_htmlCollection;
-exports.create_nodeList = create_nodeList;
-exports.create_nodeListStatic = create_nodeListStatic;
-exports.create_namedNodeMap = create_namedNodeMap;
-exports.create_range = create_range;
-exports.create_nodeIterator = create_nodeIterator;
-exports.create_treeWalker = create_treeWalker;
-exports.create_nodeFilter = create_nodeFilter;
-exports.create_mutationRecord = create_mutationRecord;
-exports.create_domTokenList = create_domTokenList;
-const DOMImplementationImpl_1 = __nccwpck_require__(42197);
-const WindowImpl_1 = __nccwpck_require__(69067);
-const XMLDocumentImpl_1 = __nccwpck_require__(21685);
-const DocumentImpl_1 = __nccwpck_require__(14333);
-const AbortControllerImpl_1 = __nccwpck_require__(66461);
-const AbortSignalImpl_1 = __nccwpck_require__(10022);
-const DocumentTypeImpl_1 = __nccwpck_require__(3173);
-const ElementImpl_1 = __nccwpck_require__(35975);
-const DocumentFragmentImpl_1 = __nccwpck_require__(12585);
-const ShadowRootImpl_1 = __nccwpck_require__(61911);
-const AttrImpl_1 = __nccwpck_require__(13717);
-const TextImpl_1 = __nccwpck_require__(42191);
-const CDATASectionImpl_1 = __nccwpck_require__(23977);
-const CommentImpl_1 = __nccwpck_require__(20930);
-const ProcessingInstructionImpl_1 = __nccwpck_require__(99430);
-const HTMLCollectionImpl_1 = __nccwpck_require__(93969);
-const NodeListImpl_1 = __nccwpck_require__(43728);
-const NodeListStaticImpl_1 = __nccwpck_require__(65306);
-const NamedNodeMapImpl_1 = __nccwpck_require__(57206);
-const RangeImpl_1 = __nccwpck_require__(50166);
-const NodeIteratorImpl_1 = __nccwpck_require__(61997);
-const TreeWalkerImpl_1 = __nccwpck_require__(89261);
-const NodeFilterImpl_1 = __nccwpck_require__(12355);
-const MutationRecordImpl_1 = __nccwpck_require__(6219);
-const DOMTokenListImpl_1 = __nccwpck_require__(65096);
+var DOMImplementationImpl_1 = __nccwpck_require__(42197);
+var WindowImpl_1 = __nccwpck_require__(69067);
+var XMLDocumentImpl_1 = __nccwpck_require__(21685);
+var DocumentImpl_1 = __nccwpck_require__(14333);
+var AbortControllerImpl_1 = __nccwpck_require__(66461);
+var AbortSignalImpl_1 = __nccwpck_require__(10022);
+var DocumentTypeImpl_1 = __nccwpck_require__(3173);
+var ElementImpl_1 = __nccwpck_require__(35975);
+var DocumentFragmentImpl_1 = __nccwpck_require__(12585);
+var ShadowRootImpl_1 = __nccwpck_require__(61911);
+var AttrImpl_1 = __nccwpck_require__(13717);
+var TextImpl_1 = __nccwpck_require__(42191);
+var CDATASectionImpl_1 = __nccwpck_require__(23977);
+var CommentImpl_1 = __nccwpck_require__(20930);
+var ProcessingInstructionImpl_1 = __nccwpck_require__(99430);
+var HTMLCollectionImpl_1 = __nccwpck_require__(93969);
+var NodeListImpl_1 = __nccwpck_require__(43728);
+var NodeListStaticImpl_1 = __nccwpck_require__(65306);
+var NamedNodeMapImpl_1 = __nccwpck_require__(57206);
+var RangeImpl_1 = __nccwpck_require__(50166);
+var NodeIteratorImpl_1 = __nccwpck_require__(61997);
+var TreeWalkerImpl_1 = __nccwpck_require__(89261);
+var NodeFilterImpl_1 = __nccwpck_require__(12355);
+var MutationRecordImpl_1 = __nccwpck_require__(6219);
+var DOMTokenListImpl_1 = __nccwpck_require__(65096);
 /**
  * Creates a `DOMImplementation`.
  *
@@ -15924,36 +43355,42 @@ const DOMTokenListImpl_1 = __nccwpck_require__(65096);
 function create_domImplementation(document) {
     return DOMImplementationImpl_1.DOMImplementationImpl._create(document);
 }
+exports.create_domImplementation = create_domImplementation;
 /**
  * Creates a `Window` node.
  */
 function create_window() {
     return WindowImpl_1.WindowImpl._create();
 }
+exports.create_window = create_window;
 /**
  * Creates an `XMLDocument` node.
  */
 function create_xmlDocument() {
     return new XMLDocumentImpl_1.XMLDocumentImpl();
 }
+exports.create_xmlDocument = create_xmlDocument;
 /**
  * Creates a `Document` node.
  */
 function create_document() {
     return new DocumentImpl_1.DocumentImpl();
 }
+exports.create_document = create_document;
 /**
  * Creates an `AbortController`.
  */
 function create_abortController() {
     return new AbortControllerImpl_1.AbortControllerImpl();
 }
+exports.create_abortController = create_abortController;
 /**
  * Creates an `AbortSignal`.
  */
 function create_abortSignal() {
     return AbortSignalImpl_1.AbortSignalImpl._create();
 }
+exports.create_abortSignal = create_abortSignal;
 /**
  * Creates a `DocumentType` node.
  *
@@ -15965,6 +43402,7 @@ function create_abortSignal() {
 function create_documentType(document, name, publicId, systemId) {
     return DocumentTypeImpl_1.DocumentTypeImpl._create(document, name, publicId, systemId);
 }
+exports.create_documentType = create_documentType;
 /**
  * Creates a new `Element` node.
  *
@@ -15976,6 +43414,7 @@ function create_documentType(document, name, publicId, systemId) {
 function create_element(document, localName, namespace, prefix) {
     return ElementImpl_1.ElementImpl._create(document, localName, namespace, prefix);
 }
+exports.create_element = create_element;
 /**
  * Creates a new `HTMLElement` node.
  *
@@ -15988,6 +43427,7 @@ function create_htmlElement(document, localName, namespace, prefix) {
     // TODO: Implement in HTML DOM
     return ElementImpl_1.ElementImpl._create(document, localName, namespace, prefix);
 }
+exports.create_htmlElement = create_htmlElement;
 /**
  * Creates a new `HTMLUnknownElement` node.
  *
@@ -16000,6 +43440,7 @@ function create_htmlUnknownElement(document, localName, namespace, prefix) {
     // TODO: Implement in HTML DOM
     return ElementImpl_1.ElementImpl._create(document, localName, namespace, prefix);
 }
+exports.create_htmlUnknownElement = create_htmlUnknownElement;
 /**
  * Creates a new `DocumentFragment` node.
  *
@@ -16008,6 +43449,7 @@ function create_htmlUnknownElement(document, localName, namespace, prefix) {
 function create_documentFragment(document) {
     return DocumentFragmentImpl_1.DocumentFragmentImpl._create(document);
 }
+exports.create_documentFragment = create_documentFragment;
 /**
  * Creates a new `ShadowRoot` node.
  *
@@ -16017,6 +43459,7 @@ function create_documentFragment(document) {
 function create_shadowRoot(document, host) {
     return ShadowRootImpl_1.ShadowRootImpl._create(document, host);
 }
+exports.create_shadowRoot = create_shadowRoot;
 /**
  * Creates a new `Attr` node.
  *
@@ -16026,6 +43469,7 @@ function create_shadowRoot(document, host) {
 function create_attr(document, localName) {
     return AttrImpl_1.AttrImpl._create(document, localName);
 }
+exports.create_attr = create_attr;
 /**
  * Creates a new `Text` node.
  *
@@ -16035,6 +43479,7 @@ function create_attr(document, localName) {
 function create_text(document, data) {
     return TextImpl_1.TextImpl._create(document, data);
 }
+exports.create_text = create_text;
 /**
  * Creates a new `CDATASection` node.
  *
@@ -16044,6 +43489,7 @@ function create_text(document, data) {
 function create_cdataSection(document, data) {
     return CDATASectionImpl_1.CDATASectionImpl._create(document, data);
 }
+exports.create_cdataSection = create_cdataSection;
 /**
  * Creates a new `Comment` node.
  *
@@ -16053,6 +43499,7 @@ function create_cdataSection(document, data) {
 function create_comment(document, data) {
     return CommentImpl_1.CommentImpl._create(document, data);
 }
+exports.create_comment = create_comment;
 /**
  * Creates a new `ProcessingInstruction` node.
  *
@@ -16063,15 +43510,18 @@ function create_comment(document, data) {
 function create_processingInstruction(document, target, data) {
     return ProcessingInstructionImpl_1.ProcessingInstructionImpl._create(document, target, data);
 }
+exports.create_processingInstruction = create_processingInstruction;
 /**
  * Creates a new `HTMLCollection`.
  *
  * @param root - root node
  * @param filter - node filter
  */
-function create_htmlCollection(root, filter = (() => true)) {
+function create_htmlCollection(root, filter) {
+    if (filter === void 0) { filter = (function () { return true; }); }
     return HTMLCollectionImpl_1.HTMLCollectionImpl._create(root, filter);
 }
+exports.create_htmlCollection = create_htmlCollection;
 /**
  * Creates a new live `NodeList`.
  *
@@ -16080,6 +43530,7 @@ function create_htmlCollection(root, filter = (() => true)) {
 function create_nodeList(root) {
     return NodeListImpl_1.NodeListImpl._create(root);
 }
+exports.create_nodeList = create_nodeList;
 /**
  * Creates a new static `NodeList`.
  *
@@ -16089,6 +43540,7 @@ function create_nodeList(root) {
 function create_nodeListStatic(root, items) {
     return NodeListStaticImpl_1.NodeListStaticImpl._create(root, items);
 }
+exports.create_nodeListStatic = create_nodeListStatic;
 /**
  * Creates a new `NamedNodeMap`.
  *
@@ -16097,6 +43549,7 @@ function create_nodeListStatic(root, items) {
 function create_namedNodeMap(element) {
     return NamedNodeMapImpl_1.NamedNodeMapImpl._create(element);
 }
+exports.create_namedNodeMap = create_namedNodeMap;
 /**
  * Creates a new `Range`.
  *
@@ -16106,6 +43559,7 @@ function create_namedNodeMap(element) {
 function create_range(start, end) {
     return RangeImpl_1.RangeImpl._create(start, end);
 }
+exports.create_range = create_range;
 /**
  * Creates a new `NodeIterator`.
  *
@@ -16117,6 +43571,7 @@ function create_range(start, end) {
 function create_nodeIterator(root, reference, pointerBeforeReference) {
     return NodeIteratorImpl_1.NodeIteratorImpl._create(root, reference, pointerBeforeReference);
 }
+exports.create_nodeIterator = create_nodeIterator;
 /**
  * Creates a new `TreeWalker`.
  *
@@ -16126,12 +43581,14 @@ function create_nodeIterator(root, reference, pointerBeforeReference) {
 function create_treeWalker(root, current) {
     return TreeWalkerImpl_1.TreeWalkerImpl._create(root, current);
 }
+exports.create_treeWalker = create_treeWalker;
 /**
  * Creates a new `NodeFilter`.
  */
 function create_nodeFilter() {
     return NodeFilterImpl_1.NodeFilterImpl._create();
 }
+exports.create_nodeFilter = create_nodeFilter;
 /**
  * Creates a new `MutationRecord`.
  *
@@ -16154,6 +43611,7 @@ function create_nodeFilter() {
 function create_mutationRecord(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue) {
     return MutationRecordImpl_1.MutationRecordImpl._create(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue);
 }
+exports.create_mutationRecord = create_mutationRecord;
 /**
  * Creates a new `DOMTokenList`.
  *
@@ -16163,6 +43621,7 @@ function create_mutationRecord(type, target, addedNodes, removedNodes, previousS
 function create_domTokenList(element, attribute) {
     return DOMTokenListImpl_1.DOMTokenListImpl._create(element, attribute);
 }
+exports.create_domTokenList = create_domTokenList;
 //# sourceMappingURL=CreateAlgorithm.js.map
 
 /***/ }),
@@ -16173,26 +43632,17 @@ function create_domTokenList(element, attribute) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.customElement_isValidCustomElementName = customElement_isValidCustomElementName;
-exports.customElement_isValidElementName = customElement_isValidElementName;
-exports.customElement_isVoidElementName = customElement_isVoidElementName;
-exports.customElement_isValidShadowHostName = customElement_isValidShadowHostName;
-exports.customElement_enqueueACustomElementUpgradeReaction = customElement_enqueueACustomElementUpgradeReaction;
-exports.customElement_enqueueACustomElementCallbackReaction = customElement_enqueueACustomElementCallbackReaction;
-exports.customElement_upgrade = customElement_upgrade;
-exports.customElement_tryToUpgrade = customElement_tryToUpgrade;
-exports.customElement_lookUpACustomElementDefinition = customElement_lookUpACustomElementDefinition;
-const PotentialCustomElementName = /[a-z]([\0-\t\x2D\._a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*-([\0-\t\x2D\._a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*/;
-const NamesWithHyphen = new Set(['annotation-xml', 'color-profile',
+var PotentialCustomElementName = /[a-z]([\0-\t\x2D\._a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*-([\0-\t\x2D\._a-z\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C\u200D\u203F\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uDB7F][\uDC00-\uDFFF])*/;
+var NamesWithHyphen = new Set(['annotation-xml', 'color-profile',
     'font-face', 'font-face-src', 'font-face-uri', 'font-face-format',
     'font-face-name', 'missing-glyph']);
-const ElementNames = new Set(['article', 'aside', 'blockquote',
+var ElementNames = new Set(['article', 'aside', 'blockquote',
     'body', 'div', 'footer', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
     'header', 'main', 'nav', 'p', 'section', 'span']);
-const VoidElementNames = new Set(['area', 'base', 'basefont',
+var VoidElementNames = new Set(['area', 'base', 'basefont',
     'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
     'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
-const ShadowHostNames = new Set(['article', 'aside', 'blockquote', 'body',
+var ShadowHostNames = new Set(['article', 'aside', 'blockquote', 'body',
     'div', 'footer', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'header', 'main',
     'nav', 'p', 'section', 'span']);
 /**
@@ -16207,6 +43657,7 @@ function customElement_isValidCustomElementName(name) {
         return false;
     return true;
 }
+exports.customElement_isValidCustomElementName = customElement_isValidCustomElementName;
 /**
  * Determines if the given string is a valid element name.
  *
@@ -16215,6 +43666,7 @@ function customElement_isValidCustomElementName(name) {
 function customElement_isValidElementName(name) {
     return (ElementNames.has(name));
 }
+exports.customElement_isValidElementName = customElement_isValidElementName;
 /**
  * Determines if the given string is a void element name.
  *
@@ -16223,6 +43675,7 @@ function customElement_isValidElementName(name) {
 function customElement_isVoidElementName(name) {
     return (VoidElementNames.has(name));
 }
+exports.customElement_isVoidElementName = customElement_isVoidElementName;
 /**
  * Determines if the given string is a valid shadow host element name.
  *
@@ -16231,6 +43684,7 @@ function customElement_isVoidElementName(name) {
 function customElement_isValidShadowHostName(name) {
     return (ShadowHostNames.has(name));
 }
+exports.customElement_isValidShadowHostName = customElement_isValidShadowHostName;
 /**
  * Enqueues an upgrade reaction for a custom element.
  *
@@ -16240,6 +43694,7 @@ function customElement_isValidShadowHostName(name) {
 function customElement_enqueueACustomElementUpgradeReaction(element, definition) {
     // TODO: Implement in HTML DOM
 }
+exports.customElement_enqueueACustomElementUpgradeReaction = customElement_enqueueACustomElementUpgradeReaction;
 /**
  * Enqueues a callback reaction for a custom element.
  *
@@ -16250,6 +43705,7 @@ function customElement_enqueueACustomElementUpgradeReaction(element, definition)
 function customElement_enqueueACustomElementCallbackReaction(element, callbackName, args) {
     // TODO: Implement in HTML DOM
 }
+exports.customElement_enqueueACustomElementCallbackReaction = customElement_enqueueACustomElementCallbackReaction;
 /**
  * Upgrade a custom element.
  *
@@ -16258,6 +43714,7 @@ function customElement_enqueueACustomElementCallbackReaction(element, callbackNa
 function customElement_upgrade(definition, element) {
     // TODO: Implement in HTML DOM
 }
+exports.customElement_upgrade = customElement_upgrade;
 /**
  * Tries to upgrade a custom element.
  *
@@ -16266,6 +43723,7 @@ function customElement_upgrade(definition, element) {
 function customElement_tryToUpgrade(element) {
     // TODO: Implement in HTML DOM
 }
+exports.customElement_tryToUpgrade = customElement_tryToUpgrade;
 /**
  * Looks up a custom element definition.
  *
@@ -16278,31 +43736,33 @@ function customElement_lookUpACustomElementDefinition(document, namespace, local
     // TODO: Implement in HTML DOM
     return null;
 }
+exports.customElement_lookUpACustomElementDefinition = customElement_lookUpACustomElementDefinition;
 //# sourceMappingURL=CustomElementAlgorithm.js.map
 
 /***/ }),
 
 /***/ 9628:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.dom_runRemovingSteps = dom_runRemovingSteps;
-exports.dom_runCloningSteps = dom_runCloningSteps;
-exports.dom_runAdoptingSteps = dom_runAdoptingSteps;
-exports.dom_runAttributeChangeSteps = dom_runAttributeChangeSteps;
-exports.dom_runInsertionSteps = dom_runInsertionSteps;
-exports.dom_runNodeIteratorPreRemovingSteps = dom_runNodeIteratorPreRemovingSteps;
-exports.dom_hasSupportedTokens = dom_hasSupportedTokens;
-exports.dom_getSupportedTokens = dom_getSupportedTokens;
-exports.dom_runEventConstructingSteps = dom_runEventConstructingSteps;
-exports.dom_runChildTextContentChangeSteps = dom_runChildTextContentChangeSteps;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const TreeAlgorithm_1 = __nccwpck_require__(16620);
-const util_1 = __nccwpck_require__(65282);
-const ShadowTreeAlgorithm_1 = __nccwpck_require__(68733);
-const supportedTokens = new Map();
+var DOMImpl_1 = __nccwpck_require__(14177);
+var TreeAlgorithm_1 = __nccwpck_require__(16620);
+var util_1 = __nccwpck_require__(65282);
+var ShadowTreeAlgorithm_1 = __nccwpck_require__(68733);
+var supportedTokens = new Map();
 /**
  * Runs removing steps for node.
  *
@@ -16312,6 +43772,7 @@ const supportedTokens = new Map();
 function dom_runRemovingSteps(removedNode, oldParent) {
     // No steps defined
 }
+exports.dom_runRemovingSteps = dom_runRemovingSteps;
 /**
  * Runs cloning steps for node.
  *
@@ -16323,6 +43784,7 @@ function dom_runRemovingSteps(removedNode, oldParent) {
 function dom_runCloningSteps(copy, node, document, cloneChildrenFlag) {
     // No steps defined
 }
+exports.dom_runCloningSteps = dom_runCloningSteps;
 /**
  * Runs adopting steps for node.
  *
@@ -16332,6 +43794,7 @@ function dom_runCloningSteps(copy, node, document, cloneChildrenFlag) {
 function dom_runAdoptingSteps(node, oldDocument) {
     // No steps defined
 }
+exports.dom_runAdoptingSteps = dom_runAdoptingSteps;
 /**
  * Runs attribute change steps for an element node.
  *
@@ -16342,17 +43805,29 @@ function dom_runAdoptingSteps(node, oldDocument) {
  * @param namespace - attribute's namespace
  */
 function dom_runAttributeChangeSteps(element, localName, oldValue, value, namespace) {
+    var e_1, _a;
     // run default steps
     if (DOMImpl_1.dom.features.slots) {
         updateASlotablesName.call(element, element, localName, oldValue, value, namespace);
         updateASlotsName.call(element, element, localName, oldValue, value, namespace);
     }
     updateAnElementID.call(element, element, localName, value, namespace);
-    // run custom steps
-    for (const step of element._attributeChangeSteps) {
-        step.call(element, element, localName, oldValue, value, namespace);
+    try {
+        // run custom steps
+        for (var _b = __values(element._attributeChangeSteps), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var step = _c.value;
+            step.call(element, element, localName, oldValue, value, namespace);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
     }
 }
+exports.dom_runAttributeChangeSteps = dom_runAttributeChangeSteps;
 /**
  * Runs insertion steps for a node.
  *
@@ -16361,6 +43836,7 @@ function dom_runAttributeChangeSteps(element, localName, oldValue, value, namesp
 function dom_runInsertionSteps(insertedNode) {
     // No steps defined
 }
+exports.dom_runInsertionSteps = dom_runInsertionSteps;
 /**
  * Runs pre-removing steps for a node iterator and node.
  *
@@ -16370,6 +43846,7 @@ function dom_runInsertionSteps(insertedNode) {
 function dom_runNodeIteratorPreRemovingSteps(nodeIterator, toBeRemoved) {
     removeNodeIterator.call(nodeIterator, nodeIterator, toBeRemoved);
 }
+exports.dom_runNodeIteratorPreRemovingSteps = dom_runNodeIteratorPreRemovingSteps;
 /**
  * Determines if there are any supported tokens defined for the given
  * attribute name.
@@ -16379,6 +43856,7 @@ function dom_runNodeIteratorPreRemovingSteps(nodeIterator, toBeRemoved) {
 function dom_hasSupportedTokens(attributeName) {
     return supportedTokens.has(attributeName);
 }
+exports.dom_hasSupportedTokens = dom_hasSupportedTokens;
 /**
  * Returns the set of supported tokens defined for the given attribute name.
  *
@@ -16387,6 +43865,7 @@ function dom_hasSupportedTokens(attributeName) {
 function dom_getSupportedTokens(attributeName) {
     return supportedTokens.get(attributeName) || new Set();
 }
+exports.dom_getSupportedTokens = dom_getSupportedTokens;
 /**
  * Runs event construction steps.
  *
@@ -16395,6 +43874,7 @@ function dom_getSupportedTokens(attributeName) {
 function dom_runEventConstructingSteps(event) {
     // No steps defined
 }
+exports.dom_runEventConstructingSteps = dom_runEventConstructingSteps;
 /**
  * Runs child text content change steps for a parent node.
  *
@@ -16403,6 +43883,7 @@ function dom_runEventConstructingSteps(event) {
 function dom_runChildTextContentChangeSteps(parent) {
     // No steps defined
 }
+exports.dom_runChildTextContentChangeSteps = dom_runChildTextContentChangeSteps;
 /**
  * Defines pre-removing steps for a node iterator.
  */
@@ -16412,7 +43893,7 @@ function removeNodeIterator(nodeIterator, toBeRemovedNode) {
      * reference, or toBeRemovedNode is nodeIterator’s root, then return.
      */
     if (toBeRemovedNode === nodeIterator._root ||
-        !(0, TreeAlgorithm_1.tree_isAncestorOf)(nodeIterator._reference, toBeRemovedNode, true)) {
+        !TreeAlgorithm_1.tree_isAncestorOf(nodeIterator._reference, toBeRemovedNode, true)) {
         return;
     }
     /**
@@ -16425,10 +43906,10 @@ function removeNodeIterator(nodeIterator, toBeRemovedNode) {
          * descendant of toBeRemovedNode, and null if there is no such node.
          */
         while (true) {
-            const nextNode = (0, TreeAlgorithm_1.tree_getFollowingNode)(nodeIterator._root, toBeRemovedNode);
+            var nextNode = TreeAlgorithm_1.tree_getFollowingNode(nodeIterator._root, toBeRemovedNode);
             if (nextNode !== null &&
-                (0, TreeAlgorithm_1.tree_isDescendantOf)(nodeIterator._root, nextNode, true) &&
-                !(0, TreeAlgorithm_1.tree_isDescendantOf)(toBeRemovedNode, nextNode, true)) {
+                TreeAlgorithm_1.tree_isDescendantOf(nodeIterator._root, nextNode, true) &&
+                !TreeAlgorithm_1.tree_isDescendantOf(toBeRemovedNode, nextNode, true)) {
                 /**
                  * 2.2. If next is non-null, then set nodeIterator’s reference to next
                  * and return.
@@ -16457,14 +43938,14 @@ function removeNodeIterator(nodeIterator, toBeRemovedNode) {
         }
     }
     else {
-        let referenceNode = toBeRemovedNode._previousSibling;
-        let childNode = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(toBeRemovedNode._previousSibling, true, false);
+        var referenceNode = toBeRemovedNode._previousSibling;
+        var childNode = TreeAlgorithm_1.tree_getFirstDescendantNode(toBeRemovedNode._previousSibling, true, false);
         while (childNode !== null) {
             if (childNode !== null) {
                 referenceNode = childNode;
             }
             // loop through to get the last descendant node
-            childNode = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(toBeRemovedNode._previousSibling, childNode, true, false);
+            childNode = TreeAlgorithm_1.tree_getNextDescendantNode(toBeRemovedNode._previousSibling, childNode, true, false);
         }
         nodeIterator._reference = referenceNode;
     }
@@ -16496,7 +43977,7 @@ function updateASlotsName(element, localName, oldValue, value, namespace) {
         else {
             element._name = value;
         }
-        (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree)((0, TreeAlgorithm_1.tree_rootNode)(element));
+        ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(TreeAlgorithm_1.tree_rootNode(element));
     }
 }
 /**
@@ -16528,10 +44009,10 @@ function updateASlotablesName(element, localName, oldValue, value, namespace) {
         else {
             element._name = value;
         }
-        if ((0, ShadowTreeAlgorithm_1.shadowTree_isAssigned)(element)) {
-            (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotables)(element._assignedSlot);
+        if (ShadowTreeAlgorithm_1.shadowTree_isAssigned(element)) {
+            ShadowTreeAlgorithm_1.shadowTree_assignSlotables(element._assignedSlot);
         }
-        (0, ShadowTreeAlgorithm_1.shadowTree_assignASlot)(element);
+        ShadowTreeAlgorithm_1.shadowTree_assignASlot(element);
     }
 }
 /**
@@ -16561,12 +44042,9 @@ function updateAnElementID(element, localName, value, namespace) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.tokenList_validationSteps = tokenList_validationSteps;
-exports.tokenList_updateSteps = tokenList_updateSteps;
-exports.tokenList_serializeSteps = tokenList_serializeSteps;
-const OrderedSetAlgorithm_1 = __nccwpck_require__(53670);
-const DOMAlgorithm_1 = __nccwpck_require__(9628);
-const ElementAlgorithm_1 = __nccwpck_require__(51849);
+var OrderedSetAlgorithm_1 = __nccwpck_require__(53670);
+var DOMAlgorithm_1 = __nccwpck_require__(9628);
+var ElementAlgorithm_1 = __nccwpck_require__(51849);
 /**
  * Validates a given token against the supported tokens defined for the given
  * token lists' associated attribute.
@@ -16582,11 +44060,12 @@ function tokenList_validationSteps(tokenList, token) {
      * 3. If lowercase token is present in supported tokens, return true.
      * 4. Return false.
      */
-    if (!(0, DOMAlgorithm_1.dom_hasSupportedTokens)(tokenList._attribute._localName)) {
-        throw new TypeError(`There are no supported tokens defined for attribute name: '${tokenList._attribute._localName}'.`);
+    if (!DOMAlgorithm_1.dom_hasSupportedTokens(tokenList._attribute._localName)) {
+        throw new TypeError("There are no supported tokens defined for attribute name: '" + tokenList._attribute._localName + "'.");
     }
-    return (0, DOMAlgorithm_1.dom_getSupportedTokens)(tokenList._attribute._localName).has(token.toLowerCase());
+    return DOMAlgorithm_1.dom_getSupportedTokens(tokenList._attribute._localName).has(token.toLowerCase());
 }
+exports.tokenList_validationSteps = tokenList_validationSteps;
 /**
  * Updates the value of the token lists' associated attribute.
  *
@@ -16604,8 +44083,9 @@ function tokenList_updateSteps(tokenList) {
         tokenList._tokenSet.size === 0) {
         return;
     }
-    (0, ElementAlgorithm_1.element_setAnAttributeValue)(tokenList._element, tokenList._attribute._localName, (0, OrderedSetAlgorithm_1.orderedSet_serialize)(tokenList._tokenSet));
+    ElementAlgorithm_1.element_setAnAttributeValue(tokenList._element, tokenList._attribute._localName, OrderedSetAlgorithm_1.orderedSet_serialize(tokenList._tokenSet));
 }
+exports.tokenList_updateSteps = tokenList_updateSteps;
 /**
  * Gets the value of the token lists' associated attribute.
  *
@@ -16617,31 +44097,56 @@ function tokenList_serializeSteps(tokenList) {
      * running get an attribute value given the associated element and the
      * associated attribute’s local name.
      */
-    return (0, ElementAlgorithm_1.element_getAnAttributeValue)(tokenList._element, tokenList._attribute._localName);
+    return ElementAlgorithm_1.element_getAnAttributeValue(tokenList._element, tokenList._attribute._localName);
 }
+exports.tokenList_serializeSteps = tokenList_serializeSteps;
 //# sourceMappingURL=DOMTokenListAlgorithm.js.map
 
 /***/ }),
 
 /***/ 12793:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.document_elementInterface = document_elementInterface;
-exports.document_internalCreateElementNS = document_internalCreateElementNS;
-exports.document_adopt = document_adopt;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const util_1 = __nccwpck_require__(65282);
-const util_2 = __nccwpck_require__(76195);
-const ElementImpl_1 = __nccwpck_require__(35975);
-const CustomElementAlgorithm_1 = __nccwpck_require__(35648);
-const TreeAlgorithm_1 = __nccwpck_require__(16620);
-const NamespaceAlgorithm_1 = __nccwpck_require__(35856);
-const DOMAlgorithm_1 = __nccwpck_require__(9628);
-const ElementAlgorithm_1 = __nccwpck_require__(51849);
-const MutationAlgorithm_1 = __nccwpck_require__(45463);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var util_1 = __nccwpck_require__(65282);
+var util_2 = __nccwpck_require__(76195);
+var ElementImpl_1 = __nccwpck_require__(35975);
+var CustomElementAlgorithm_1 = __nccwpck_require__(35648);
+var TreeAlgorithm_1 = __nccwpck_require__(16620);
+var NamespaceAlgorithm_1 = __nccwpck_require__(35856);
+var DOMAlgorithm_1 = __nccwpck_require__(9628);
+var ElementAlgorithm_1 = __nccwpck_require__(51849);
+var MutationAlgorithm_1 = __nccwpck_require__(45463);
 /**
  * Returns an element interface for the given name and namespace.
  *
@@ -16651,6 +44156,7 @@ const MutationAlgorithm_1 = __nccwpck_require__(45463);
 function document_elementInterface(name, namespace) {
     return ElementImpl_1.ElementImpl;
 }
+exports.document_elementInterface = document_elementInterface;
 /**
  * Creates a new element node.
  * See: https://dom.spec.whatwg.org/#internal-createelementns-steps
@@ -16670,18 +44176,19 @@ function document_internalCreateElementNS(document, namespace, qualifiedName, op
      * 4. Return the result of creating an element given document, localName,
      * namespace, prefix, is, and with the synchronous custom elements flag set.
      */
-    const [ns, prefix, localName] = (0, NamespaceAlgorithm_1.namespace_validateAndExtract)(namespace, qualifiedName);
-    let is = null;
+    var _a = __read(NamespaceAlgorithm_1.namespace_validateAndExtract(namespace, qualifiedName), 3), ns = _a[0], prefix = _a[1], localName = _a[2];
+    var is = null;
     if (options !== undefined) {
-        if ((0, util_2.isString)(options)) {
+        if (util_2.isString(options)) {
             is = options;
         }
         else {
             is = options.is;
         }
     }
-    return (0, ElementAlgorithm_1.element_createAnElement)(document, localName, ns, prefix, is, true);
+    return ElementAlgorithm_1.element_createAnElement(document, localName, ns, prefix, is, true);
 }
+exports.document_internalCreateElementNS = document_internalCreateElementNS;
 /**
  * Removes `node` and its subtree from its document and changes
  * its owner document to `document` so that it can be inserted
@@ -16691,6 +44198,7 @@ function document_internalCreateElementNS(document, namespace, qualifiedName, op
  * @param document - document to receive the node and its subtree
  */
 function document_adopt(node, document) {
+    var e_1, _a;
     // Optimize for common case of inserting a fresh node
     if (node._nodeDocument === document && node._parent === null) {
         return;
@@ -16699,9 +44207,9 @@ function document_adopt(node, document) {
      * 1. Let oldDocument be node’s node document.
      * 2. If node’s parent is not null, remove node from its parent.
      */
-    const oldDocument = node._nodeDocument;
+    var oldDocument = node._nodeDocument;
     if (node._parent)
-        (0, MutationAlgorithm_1.mutation_remove)(node, node._parent);
+        MutationAlgorithm_1.mutation_remove(node, node._parent);
     /**
      * 3. If document is not oldDocument, then:
      */
@@ -16710,7 +44218,7 @@ function document_adopt(node, document) {
          * 3.1. For each inclusiveDescendant in node’s shadow-including inclusive
          * descendants:
          */
-        let inclusiveDescendant = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(node, true, true);
+        var inclusiveDescendant = TreeAlgorithm_1.tree_getFirstDescendantNode(node, true, true);
         while (inclusiveDescendant !== null) {
             /**
              * 3.1.1. Set inclusiveDescendant’s node document to document.
@@ -16720,8 +44228,18 @@ function document_adopt(node, document) {
              */
             inclusiveDescendant._nodeDocument = document;
             if (util_1.Guard.isElementNode(inclusiveDescendant)) {
-                for (const attr of inclusiveDescendant._attributeList._asArray()) {
-                    attr._nodeDocument = document;
+                try {
+                    for (var _b = (e_1 = void 0, __values(inclusiveDescendant._attributeList._asArray())), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var attr = _c.value;
+                        attr._nodeDocument = document;
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_1) throw e_1.error; }
                 }
             }
             /**
@@ -16734,7 +44252,7 @@ function document_adopt(node, document) {
             if (DOMImpl_1.dom.features.customElements) {
                 if (util_1.Guard.isElementNode(inclusiveDescendant) &&
                     inclusiveDescendant._customElementState === "custom") {
-                    (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(inclusiveDescendant, "adoptedCallback", [oldDocument, document]);
+                    CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(inclusiveDescendant, "adoptedCallback", [oldDocument, document]);
                 }
             }
             /**
@@ -16743,12 +44261,13 @@ function document_adopt(node, document) {
              * adopting steps with inclusiveDescendant and oldDocument.
              */
             if (DOMImpl_1.dom.features.steps) {
-                (0, DOMAlgorithm_1.dom_runAdoptingSteps)(inclusiveDescendant, oldDocument);
+                DOMAlgorithm_1.dom_runAdoptingSteps(inclusiveDescendant, oldDocument);
             }
-            inclusiveDescendant = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(node, inclusiveDescendant, true, true);
+            inclusiveDescendant = TreeAlgorithm_1.tree_getNextDescendantNode(node, inclusiveDescendant, true, true);
         }
     }
 }
+exports.document_adopt = document_adopt;
 //# sourceMappingURL=DocumentAlgorithm.js.map
 
 /***/ }),
@@ -16759,30 +44278,16 @@ function document_adopt(node, document) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.element_has = element_has;
-exports.element_change = element_change;
-exports.element_append = element_append;
-exports.element_remove = element_remove;
-exports.element_replace = element_replace;
-exports.element_getAnAttributeByName = element_getAnAttributeByName;
-exports.element_getAnAttributeByNamespaceAndLocalName = element_getAnAttributeByNamespaceAndLocalName;
-exports.element_getAnAttributeValue = element_getAnAttributeValue;
-exports.element_setAnAttribute = element_setAnAttribute;
-exports.element_setAnAttributeValue = element_setAnAttributeValue;
-exports.element_removeAnAttributeByName = element_removeAnAttributeByName;
-exports.element_removeAnAttributeByNamespaceAndLocalName = element_removeAnAttributeByNamespaceAndLocalName;
-exports.element_createAnElement = element_createAnElement;
-exports.element_insertAdjacent = element_insertAdjacent;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const infra_1 = __nccwpck_require__(84251);
-const util_1 = __nccwpck_require__(65282);
-const DOMException_1 = __nccwpck_require__(13166);
-const CreateAlgorithm_1 = __nccwpck_require__(57339);
-const CustomElementAlgorithm_1 = __nccwpck_require__(35648);
-const MutationObserverAlgorithm_1 = __nccwpck_require__(78157);
-const DOMAlgorithm_1 = __nccwpck_require__(9628);
-const MutationAlgorithm_1 = __nccwpck_require__(45463);
-const DocumentAlgorithm_1 = __nccwpck_require__(12793);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var infra_1 = __nccwpck_require__(84251);
+var util_1 = __nccwpck_require__(65282);
+var DOMException_1 = __nccwpck_require__(13166);
+var CreateAlgorithm_1 = __nccwpck_require__(57339);
+var CustomElementAlgorithm_1 = __nccwpck_require__(35648);
+var MutationObserverAlgorithm_1 = __nccwpck_require__(78157);
+var DOMAlgorithm_1 = __nccwpck_require__(9628);
+var MutationAlgorithm_1 = __nccwpck_require__(45463);
+var DocumentAlgorithm_1 = __nccwpck_require__(12793);
 /**
  * Determines whether the element's attribute list contains the given
  * attribute.
@@ -16796,6 +44301,7 @@ function element_has(attribute, element) {
      */
     return element._attributeList._asArray().indexOf(attribute) !== -1;
 }
+exports.element_has = element_has;
 /**
  * Changes the value of an attribute node.
  *
@@ -16809,7 +44315,7 @@ function element_change(attribute, element, value) {
      * local name, attribute’s namespace, and attribute’s value.
      */
     if (DOMImpl_1.dom.features.mutationObservers) {
-        (0, MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord)(element, attribute._localName, attribute._namespace, attribute._value);
+        MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord(element, attribute._localName, attribute._namespace, attribute._value);
     }
     /**
      * 2. If element is custom, then enqueue a custom element callback reaction
@@ -16819,7 +44325,7 @@ function element_change(attribute, element, value) {
      */
     if (DOMImpl_1.dom.features.customElements) {
         if (util_1.Guard.isCustomElementNode(element)) {
-            (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(element, "attributeChangedCallback", [attribute._localName, attribute._value, value, attribute._namespace]);
+            CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(element, "attributeChangedCallback", [attribute._localName, attribute._value, value, attribute._namespace]);
         }
     }
     /**
@@ -16828,10 +44334,11 @@ function element_change(attribute, element, value) {
      * 4. Set attribute’s value to value.
      */
     if (DOMImpl_1.dom.features.steps) {
-        (0, DOMAlgorithm_1.dom_runAttributeChangeSteps)(element, attribute._localName, attribute._value, value, attribute._namespace);
+        DOMAlgorithm_1.dom_runAttributeChangeSteps(element, attribute._localName, attribute._value, value, attribute._namespace);
     }
     attribute._value = value;
 }
+exports.element_change = element_change;
 /**
  * Appends an attribute to an element node.
  *
@@ -16844,7 +44351,7 @@ function element_append(attribute, element) {
      * local name, attribute’s namespace, and null.
      */
     if (DOMImpl_1.dom.features.mutationObservers) {
-        (0, MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord)(element, attribute._localName, attribute._namespace, null);
+        MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord(element, attribute._localName, attribute._namespace, null);
     }
     /**
      * 2. If element is custom, then enqueue a custom element callback reaction
@@ -16854,7 +44361,7 @@ function element_append(attribute, element) {
      */
     if (DOMImpl_1.dom.features.customElements) {
         if (util_1.Guard.isCustomElementNode(element)) {
-            (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(element, "attributeChangedCallback", [attribute._localName, null, attribute._value, attribute._namespace]);
+            CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(element, "attributeChangedCallback", [attribute._localName, null, attribute._value, attribute._namespace]);
         }
     }
     /**
@@ -16862,7 +44369,7 @@ function element_append(attribute, element) {
      * null, attribute’s value, and attribute’s namespace.
      */
     if (DOMImpl_1.dom.features.steps) {
-        (0, DOMAlgorithm_1.dom_runAttributeChangeSteps)(element, attribute._localName, null, attribute._value, attribute._namespace);
+        DOMAlgorithm_1.dom_runAttributeChangeSteps(element, attribute._localName, null, attribute._value, attribute._namespace);
     }
     /**
      * 4. Append attribute to element’s attribute list.
@@ -16876,6 +44383,7 @@ function element_append(attribute, element) {
         element._nodeDocument._hasNamespaces = true;
     }
 }
+exports.element_append = element_append;
 /**
  * Removes an attribute from an element node.
  *
@@ -16888,7 +44396,7 @@ function element_remove(attribute, element) {
      * local name, attribute’s namespace, and attribute’s value.
      */
     if (DOMImpl_1.dom.features.mutationObservers) {
-        (0, MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord)(element, attribute._localName, attribute._namespace, attribute._value);
+        MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord(element, attribute._localName, attribute._namespace, attribute._value);
     }
     /**
      * 2. If element is custom, then enqueue a custom element callback reaction
@@ -16898,7 +44406,7 @@ function element_remove(attribute, element) {
      */
     if (DOMImpl_1.dom.features.customElements) {
         if (util_1.Guard.isCustomElementNode(element)) {
-            (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(element, "attributeChangedCallback", [attribute._localName, attribute._value, null, attribute._namespace]);
+            CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(element, "attributeChangedCallback", [attribute._localName, attribute._value, null, attribute._namespace]);
         }
     }
     /**
@@ -16906,16 +44414,17 @@ function element_remove(attribute, element) {
      * attribute’s value, null, and attribute’s namespace.
      */
     if (DOMImpl_1.dom.features.steps) {
-        (0, DOMAlgorithm_1.dom_runAttributeChangeSteps)(element, attribute._localName, attribute._value, null, attribute._namespace);
+        DOMAlgorithm_1.dom_runAttributeChangeSteps(element, attribute._localName, attribute._value, null, attribute._namespace);
     }
     /**
      * 3. Remove attribute from element’s attribute list.
      * 5. Set attribute’s element to null.
      */
-    const index = element._attributeList._asArray().indexOf(attribute);
+    var index = element._attributeList._asArray().indexOf(attribute);
     element._attributeList._asArray().splice(index, 1);
     attribute._element = null;
 }
+exports.element_remove = element_remove;
 /**
  * Replaces an attribute with another of an element node.
  *
@@ -16929,7 +44438,7 @@ function element_replace(oldAttr, newAttr, element) {
      * local name, oldAttr’s namespace, and oldAttr’s value.
      */
     if (DOMImpl_1.dom.features.mutationObservers) {
-        (0, MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord)(element, oldAttr._localName, oldAttr._namespace, oldAttr._value);
+        MutationObserverAlgorithm_1.observer_queueAttributeMutationRecord(element, oldAttr._localName, oldAttr._namespace, oldAttr._value);
     }
     /**
      * 2. If element is custom, then enqueue a custom element callback reaction
@@ -16939,7 +44448,7 @@ function element_replace(oldAttr, newAttr, element) {
      */
     if (DOMImpl_1.dom.features.customElements) {
         if (util_1.Guard.isCustomElementNode(element)) {
-            (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(element, "attributeChangedCallback", [oldAttr._localName, oldAttr._value, newAttr._value, oldAttr._namespace]);
+            CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(element, "attributeChangedCallback", [oldAttr._localName, oldAttr._value, newAttr._value, oldAttr._namespace]);
         }
     }
     /**
@@ -16947,14 +44456,14 @@ function element_replace(oldAttr, newAttr, element) {
      * oldAttr’s value, newAttr’s value, and oldAttr’s namespace.
      */
     if (DOMImpl_1.dom.features.steps) {
-        (0, DOMAlgorithm_1.dom_runAttributeChangeSteps)(element, oldAttr._localName, oldAttr._value, newAttr._value, oldAttr._namespace);
+        DOMAlgorithm_1.dom_runAttributeChangeSteps(element, oldAttr._localName, oldAttr._value, newAttr._value, oldAttr._namespace);
     }
     /**
      * 4. Replace oldAttr by newAttr in element’s attribute list.
      * 5. Set oldAttr’s element to null.
      * 6. Set newAttr’s element to element.
      */
-    const index = element._attributeList._asArray().indexOf(oldAttr);
+    var index = element._attributeList._asArray().indexOf(oldAttr);
     if (index !== -1) {
         element._attributeList._asArray()[index] = newAttr;
     }
@@ -16966,6 +44475,7 @@ function element_replace(oldAttr, newAttr, element) {
         element._nodeDocument._hasNamespaces = true;
     }
 }
+exports.element_replace = element_replace;
 /**
  * Retrieves an attribute with the given name from an element node.
  *
@@ -16982,8 +44492,9 @@ function element_getAnAttributeByName(qualifiedName, element) {
     if (element._namespace === infra_1.namespace.HTML && element._nodeDocument._type === "html") {
         qualifiedName = qualifiedName.toLowerCase();
     }
-    return element._attributeList._asArray().find(attr => attr._qualifiedName === qualifiedName) || null;
+    return element._attributeList._asArray().find(function (attr) { return attr._qualifiedName === qualifiedName; }) || null;
 }
+exports.element_getAnAttributeByName = element_getAnAttributeByName;
 /**
  * Retrieves an attribute with the given namespace and local name from an
  * element node.
@@ -16998,9 +44509,10 @@ function element_getAnAttributeByNamespaceAndLocalName(namespace, localName, ele
      * 2. Return the attribute in element’s attribute list whose namespace is
      * namespace and local name is localName, if any, and null otherwise.
      */
-    const ns = namespace || null;
-    return element._attributeList._asArray().find(attr => attr._namespace === ns && attr._localName === localName) || null;
+    var ns = namespace || null;
+    return element._attributeList._asArray().find(function (attr) { return attr._namespace === ns && attr._localName === localName; }) || null;
 }
+exports.element_getAnAttributeByNamespaceAndLocalName = element_getAnAttributeByNamespaceAndLocalName;
 /**
  * Retrieves an attribute's value with the given name namespace and local
  * name from an element node.
@@ -17009,19 +44521,21 @@ function element_getAnAttributeByNamespaceAndLocalName(namespace, localName, ele
  * @param localName - an attribute local name
  * @param namespace - an attribute namespace
  */
-function element_getAnAttributeValue(element, localName, namespace = '') {
+function element_getAnAttributeValue(element, localName, namespace) {
+    if (namespace === void 0) { namespace = ''; }
     /**
      * 1. Let attr be the result of getting an attribute given namespace,
      * localName, and element.
      * 2. If attr is null, then return the empty string.
      * 3. Return attr’s value.
      */
-    const attr = element_getAnAttributeByNamespaceAndLocalName(namespace, localName, element);
+    var attr = element_getAnAttributeByNamespaceAndLocalName(namespace, localName, element);
     if (attr === null)
         return '';
     else
         return attr._value;
 }
+exports.element_getAnAttributeValue = element_getAnAttributeValue;
 /**
  * Sets an attribute of an element node.
  *
@@ -17040,8 +44554,8 @@ function element_setAnAttribute(attr, element) {
      * 6. Return oldAttr.
      */
     if (attr._element !== null && attr._element !== element)
-        throw new DOMException_1.InUseAttributeError(`This attribute already exists in the document: ${attr._qualifiedName} as a child of ${attr._element._qualifiedName}.`);
-    const oldAttr = element_getAnAttributeByNamespaceAndLocalName(attr._namespace || '', attr._localName, element);
+        throw new DOMException_1.InUseAttributeError("This attribute already exists in the document: " + attr._qualifiedName + " as a child of " + attr._element._qualifiedName + ".");
+    var oldAttr = element_getAnAttributeByNamespaceAndLocalName(attr._namespace || '', attr._localName, element);
     if (oldAttr === attr)
         return attr;
     if (oldAttr !== null) {
@@ -17052,6 +44566,7 @@ function element_setAnAttribute(attr, element) {
     }
     return oldAttr;
 }
+exports.element_setAnAttribute = element_setAnAttribute;
 /**
  * Sets an attribute's value of an element node.
  *
@@ -17061,7 +44576,9 @@ function element_setAnAttribute(attr, element) {
  * @param prefix - an attribute prefix
  * @param namespace - an attribute namespace
  */
-function element_setAnAttributeValue(element, localName, value, prefix = null, namespace = null) {
+function element_setAnAttributeValue(element, localName, value, prefix, namespace) {
+    if (prefix === void 0) { prefix = null; }
+    if (namespace === void 0) { namespace = null; }
     /**
      * 1. If prefix is not given, set it to null.
      * 2. If namespace is not given, set it to null.
@@ -17073,9 +44590,9 @@ function element_setAnAttributeValue(element, localName, value, prefix = null, n
      * attribute to element, and then return.
      * 5. Change attribute from element to value.
      */
-    const attribute = element_getAnAttributeByNamespaceAndLocalName(namespace || '', localName, element);
+    var attribute = element_getAnAttributeByNamespaceAndLocalName(namespace || '', localName, element);
     if (attribute === null) {
-        const newAttr = (0, CreateAlgorithm_1.create_attr)(element._nodeDocument, localName);
+        var newAttr = CreateAlgorithm_1.create_attr(element._nodeDocument, localName);
         newAttr._namespace = namespace;
         newAttr._namespacePrefix = prefix;
         newAttr._value = value;
@@ -17084,6 +44601,7 @@ function element_setAnAttributeValue(element, localName, value, prefix = null, n
     }
     element_change(attribute, element, value);
 }
+exports.element_setAnAttributeValue = element_setAnAttributeValue;
 /**
  * Removes an attribute with the given name from an element node.
  *
@@ -17097,12 +44615,13 @@ function element_removeAnAttributeByName(qualifiedName, element) {
      * 2. If attr is non-null, remove it from element.
      * 3. Return attr.
      */
-    const attr = element_getAnAttributeByName(qualifiedName, element);
+    var attr = element_getAnAttributeByName(qualifiedName, element);
     if (attr !== null) {
         element_remove(attr, element);
     }
     return attr;
 }
+exports.element_removeAnAttributeByName = element_removeAnAttributeByName;
 /**
  * Removes an attribute with the given namespace and local name from an
  * element node.
@@ -17117,12 +44636,13 @@ function element_removeAnAttributeByNamespaceAndLocalName(namespace, localName,
      * 2. If attr is non-null, remove it from element.
      * 3. Return attr.
      */
-    const attr = element_getAnAttributeByNamespaceAndLocalName(namespace, localName, element);
+    var attr = element_getAnAttributeByNamespaceAndLocalName(namespace, localName, element);
     if (attr !== null) {
         element_remove(attr, element);
     }
     return attr;
 }
+exports.element_removeAnAttributeByNamespaceAndLocalName = element_removeAnAttributeByNamespaceAndLocalName;
 /**
  * Creates an element node.
  * See: https://dom.spec.whatwg.org/#concept-create-element.
@@ -17134,15 +44654,18 @@ function element_removeAnAttributeByNamespaceAndLocalName(namespace, localName,
  * @param is - the "is" value
  * @param synchronousCustomElementsFlag - synchronous custom elements flag
  */
-function element_createAnElement(document, localName, namespace, prefix = null, is = null, synchronousCustomElementsFlag = false) {
+function element_createAnElement(document, localName, namespace, prefix, is, synchronousCustomElementsFlag) {
+    if (prefix === void 0) { prefix = null; }
+    if (is === void 0) { is = null; }
+    if (synchronousCustomElementsFlag === void 0) { synchronousCustomElementsFlag = false; }
     /**
      * 1. If prefix was not given, let prefix be null.
      * 2. If is was not given, let is be null.
      * 3. Let result be null.
      */
-    let result = null;
+    var result = null;
     if (!DOMImpl_1.dom.features.customElements) {
-        result = (0, CreateAlgorithm_1.create_element)(document, localName, namespace, prefix);
+        result = CreateAlgorithm_1.create_element(document, localName, namespace, prefix);
         result._customElementState = "uncustomized";
         result._customElementDefinition = null;
         result._is = is;
@@ -17152,7 +44675,7 @@ function element_createAnElement(document, localName, namespace, prefix = null,
      * 4. Let definition be the result of looking up a custom element definition
      * given document, namespace, localName, and is.
      */
-    const definition = (0, CustomElementAlgorithm_1.customElement_lookUpACustomElementDefinition)(document, namespace, localName, is);
+    var definition = CustomElementAlgorithm_1.customElement_lookUpACustomElementDefinition(document, namespace, localName, is);
     if (definition !== null && definition.name !== definition.localName) {
         /**
         * 5. If definition is non-null, and definition’s name is not equal to
@@ -17170,7 +44693,7 @@ function element_createAnElement(document, localName, namespace, prefix = null,
           * 5.4. Otherwise, enqueue a custom element upgrade reaction given result
           * and definition.
           */
-        const elemenInterface = (0, DocumentAlgorithm_1.document_elementInterface)(localName, infra_1.namespace.HTML);
+        var elemenInterface = DocumentAlgorithm_1.document_elementInterface(localName, infra_1.namespace.HTML);
         result = new elemenInterface();
         result._localName = localName;
         result._namespace = infra_1.namespace.HTML;
@@ -17180,10 +44703,10 @@ function element_createAnElement(document, localName, namespace, prefix = null,
         result._is = is;
         result._nodeDocument = document;
         if (synchronousCustomElementsFlag) {
-            (0, CustomElementAlgorithm_1.customElement_upgrade)(definition, result);
+            CustomElementAlgorithm_1.customElement_upgrade(definition, result);
         }
         else {
-            (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementUpgradeReaction)(result, definition);
+            CustomElementAlgorithm_1.customElement_enqueueACustomElementUpgradeReaction(result, definition);
         }
     }
     else if (definition !== null) {
@@ -17205,11 +44728,11 @@ function element_createAnElement(document, localName, namespace, prefix = null,
                  * _Note:_ IDL enforces that result is an HTMLElement object, which all
                  * use the HTML namespace.
                  */
-                const C = definition.constructor;
-                const result = new C();
-                console.assert(result._customElementState !== undefined);
-                console.assert(result._customElementDefinition !== undefined);
-                console.assert(result._namespace === infra_1.namespace.HTML);
+                var C = definition.constructor;
+                var result_1 = new C();
+                console.assert(result_1._customElementState !== undefined);
+                console.assert(result_1._customElementDefinition !== undefined);
+                console.assert(result_1._namespace === infra_1.namespace.HTML);
                 /**
                  * 6.1.5. If result’s attribute list is not empty, then throw a
                  * "NotSupportedError" DOMException.
@@ -17222,22 +44745,22 @@ function element_createAnElement(document, localName, namespace, prefix = null,
                  * 6.1.9. If result’s local name is not equal to localName, then throw
                  * a "NotSupportedError" DOMException.
                  */
-                if (result._attributeList.length !== 0)
+                if (result_1._attributeList.length !== 0)
                     throw new DOMException_1.NotSupportedError("Custom element already has attributes.");
-                if (result._children.size !== 0)
+                if (result_1._children.size !== 0)
                     throw new DOMException_1.NotSupportedError("Custom element already has child nodes.");
-                if (result._parent !== null)
+                if (result_1._parent !== null)
                     throw new DOMException_1.NotSupportedError("Custom element already has a parent node.");
-                if (result._nodeDocument !== document)
+                if (result_1._nodeDocument !== document)
                     throw new DOMException_1.NotSupportedError("Custom element is already in a document.");
-                if (result._localName !== localName)
+                if (result_1._localName !== localName)
                     throw new DOMException_1.NotSupportedError("Custom element has a different local name.");
                 /**
                  * 6.1.10. Set result’s namespace prefix to prefix.
                  * 6.1.11. Set result’s is value to null.
                  */
-                result._namespacePrefix = prefix;
-                result._is = null;
+                result_1._namespacePrefix = prefix;
+                result_1._is = null;
             }
             catch (e) {
                 /**
@@ -17250,7 +44773,7 @@ function element_createAnElement(document, localName, namespace, prefix = null,
                  * is value set to null, and node document set to document.
                  */
                 // TODO: Report the exception
-                result = (0, CreateAlgorithm_1.create_htmlUnknownElement)(document, localName, infra_1.namespace.HTML, prefix);
+                result = CreateAlgorithm_1.create_htmlUnknownElement(document, localName, infra_1.namespace.HTML, prefix);
                 result._customElementState = "failed";
                 result._customElementDefinition = null;
                 result._is = null;
@@ -17267,11 +44790,11 @@ function element_createAnElement(document, localName, namespace, prefix = null,
              * 6.2.2. Enqueue a custom element upgrade reaction given result and
              * definition.
              */
-            result = (0, CreateAlgorithm_1.create_htmlElement)(document, localName, infra_1.namespace.HTML, prefix);
+            result = CreateAlgorithm_1.create_htmlElement(document, localName, infra_1.namespace.HTML, prefix);
             result._customElementState = "undefined";
             result._customElementDefinition = null;
             result._is = null;
-            (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementUpgradeReaction)(result, definition);
+            CustomElementAlgorithm_1.customElement_enqueueACustomElementUpgradeReaction(result, definition);
         }
     }
     else {
@@ -17285,7 +44808,7 @@ function element_createAnElement(document, localName, namespace, prefix = null,
          * "uncustomized", custom element definition set to null, is value set to
          * is, and node document set to document.
          */
-        const elementInterface = (0, DocumentAlgorithm_1.document_elementInterface)(localName, namespace);
+        var elementInterface = DocumentAlgorithm_1.document_elementInterface(localName, namespace);
         result = new elementInterface();
         result._localName = localName;
         result._namespace = namespace;
@@ -17300,7 +44823,7 @@ function element_createAnElement(document, localName, namespace, prefix = null,
          * custom element state to "undefined".
          */
         if (namespace === infra_1.namespace.HTML && (is !== null ||
-            (0, CustomElementAlgorithm_1.customElement_isValidCustomElementName)(localName))) {
+            CustomElementAlgorithm_1.customElement_isValidCustomElementName(localName))) {
             result._customElementState = "undefined";
         }
     }
@@ -17313,6 +44836,7 @@ function element_createAnElement(document, localName, namespace, prefix = null,
      */
     return result;
 }
+exports.element_createAnElement = element_createAnElement;
 /**
  * Inserts a new node adjacent to this element.
  *
@@ -17345,54 +44869,70 @@ function element_insertAdjacent(element, where, node) {
         case 'beforebegin':
             if (element._parent === null)
                 return null;
-            return (0, MutationAlgorithm_1.mutation_preInsert)(node, element._parent, element);
+            return MutationAlgorithm_1.mutation_preInsert(node, element._parent, element);
         case 'afterbegin':
-            return (0, MutationAlgorithm_1.mutation_preInsert)(node, element, element._firstChild);
+            return MutationAlgorithm_1.mutation_preInsert(node, element, element._firstChild);
         case 'beforeend':
-            return (0, MutationAlgorithm_1.mutation_preInsert)(node, element, null);
+            return MutationAlgorithm_1.mutation_preInsert(node, element, null);
         case 'afterend':
             if (element._parent === null)
                 return null;
-            return (0, MutationAlgorithm_1.mutation_preInsert)(node, element._parent, element._nextSibling);
+            return MutationAlgorithm_1.mutation_preInsert(node, element._parent, element._nextSibling);
         default:
-            throw new DOMException_1.SyntaxError(`Invalid 'where' argument. "beforebegin", "afterbegin", "beforeend" or "afterend" expected`);
+            throw new DOMException_1.SyntaxError("Invalid 'where' argument. \"beforebegin\", \"afterbegin\", \"beforeend\" or \"afterend\" expected");
     }
 }
+exports.element_insertAdjacent = element_insertAdjacent;
 //# sourceMappingURL=ElementAlgorithm.js.map
 
 /***/ }),
 
 /***/ 28217:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.event_setTheCanceledFlag = event_setTheCanceledFlag;
-exports.event_initialize = event_initialize;
-exports.event_createAnEvent = event_createAnEvent;
-exports.event_innerEventCreationSteps = event_innerEventCreationSteps;
-exports.event_dispatch = event_dispatch;
-exports.event_appendToAnEventPath = event_appendToAnEventPath;
-exports.event_invoke = event_invoke;
-exports.event_innerInvoke = event_innerInvoke;
-exports.event_fireAnEvent = event_fireAnEvent;
-exports.event_createLegacyEvent = event_createLegacyEvent;
-exports.event_getterEventHandlerIDLAttribute = event_getterEventHandlerIDLAttribute;
-exports.event_setterEventHandlerIDLAttribute = event_setterEventHandlerIDLAttribute;
-exports.event_determineTheTargetOfAnEventHandler = event_determineTheTargetOfAnEventHandler;
-exports.event_getTheCurrentValueOfAnEventHandler = event_getTheCurrentValueOfAnEventHandler;
-exports.event_activateAnEventHandler = event_activateAnEventHandler;
-exports.event_deactivateAnEventHandler = event_deactivateAnEventHandler;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const interfaces_1 = __nccwpck_require__(27305);
-const util_1 = __nccwpck_require__(65282);
-const CustomEventImpl_1 = __nccwpck_require__(59857);
-const EventImpl_1 = __nccwpck_require__(38245);
-const DOMException_1 = __nccwpck_require__(13166);
-const TreeAlgorithm_1 = __nccwpck_require__(16620);
-const ShadowTreeAlgorithm_1 = __nccwpck_require__(68733);
-const DOMAlgorithm_1 = __nccwpck_require__(9628);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var interfaces_1 = __nccwpck_require__(27305);
+var util_1 = __nccwpck_require__(65282);
+var CustomEventImpl_1 = __nccwpck_require__(59857);
+var EventImpl_1 = __nccwpck_require__(38245);
+var DOMException_1 = __nccwpck_require__(13166);
+var TreeAlgorithm_1 = __nccwpck_require__(16620);
+var ShadowTreeAlgorithm_1 = __nccwpck_require__(68733);
+var DOMAlgorithm_1 = __nccwpck_require__(9628);
 /**
  * Sets the canceled flag of an event.
  *
@@ -17403,6 +44943,7 @@ function event_setTheCanceledFlag(event) {
         event._canceledFlag = true;
     }
 }
+exports.event_setTheCanceledFlag = event_setTheCanceledFlag;
 /**
  * Initializes the value of an event.
  *
@@ -17422,13 +44963,15 @@ function event_initialize(event, type, bubbles, cancelable) {
     event._bubbles = bubbles;
     event._cancelable = cancelable;
 }
+exports.event_initialize = event_initialize;
 /**
  * Creates a new event.
  *
  * @param eventInterface - event interface
  * @param realm - realm
  */
-function event_createAnEvent(eventInterface, realm = undefined) {
+function event_createAnEvent(eventInterface, realm) {
+    if (realm === void 0) { realm = undefined; }
     /**
      * 1. If realm is not given, then set it to null.
      * 2. Let dictionary be the result of converting the JavaScript value
@@ -17443,11 +44986,12 @@ function event_createAnEvent(eventInterface, realm = undefined) {
      */
     if (realm === undefined)
         realm = null;
-    const dictionary = {};
-    const event = event_innerEventCreationSteps(eventInterface, realm, new Date(), dictionary);
+    var dictionary = {};
+    var event = event_innerEventCreationSteps(eventInterface, realm, new Date(), dictionary);
     event._isTrusted = true;
     return event;
 }
+exports.event_createAnEvent = event_createAnEvent;
 /**
  * Performs event creation steps.
  *
@@ -17464,7 +45008,7 @@ function event_innerEventCreationSteps(eventInterface, realm, time, dictionary)
      * If realm is non-null, then use that Realm; otherwise, use the default
      * behavior defined in Web IDL.
      */
-    const event = new eventInterface("");
+    var event = new eventInterface("");
     /**
      * 2. Set event’s initialized flag.
      * 3. Initialize event’s timeStamp attribute to a DOMHighResTimeStamp
@@ -17478,10 +45022,11 @@ function event_innerEventCreationSteps(eventInterface, realm, time, dictionary)
     event._timeStamp = time.getTime();
     Object.assign(event, dictionary);
     if (DOMImpl_1.dom.features.steps) {
-        (0, DOMAlgorithm_1.dom_runEventConstructingSteps)(event);
+        DOMAlgorithm_1.dom_runEventConstructingSteps(event);
     }
     return event;
 }
+exports.event_innerEventCreationSteps = event_innerEventCreationSteps;
 /**
  * Dispatches an event to an event target.
  *
@@ -17491,8 +45036,11 @@ function event_innerEventCreationSteps(eventInterface, realm, time, dictionary)
  * @param legacyOutputDidListenersThrowFlag - legacy output flag that returns
  * whether the event listener's callback threw an exception
  */
-function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyOutputDidListenersThrowFlag = { value: false }) {
-    let clearTargets = false;
+function event_dispatch(event, target, legacyTargetOverrideFlag, legacyOutputDidListenersThrowFlag) {
+    var e_1, _a, e_2, _b;
+    if (legacyTargetOverrideFlag === void 0) { legacyTargetOverrideFlag = false; }
+    if (legacyOutputDidListenersThrowFlag === void 0) { legacyOutputDidListenersThrowFlag = { value: false }; }
+    var clearTargets = false;
     /**
      * 1. Set event's dispatch flag.
      */
@@ -17504,9 +45052,9 @@ function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyO
      * _Note:_ legacy target override flag is only used by HTML and only when
      * target is a Window object.
      */
-    let targetOverride = target;
+    var targetOverride = target;
     if (legacyTargetOverrideFlag) {
-        const doc = target._associatedDocument;
+        var doc = target._associatedDocument;
         if (util_1.Guard.isDocumentNode(doc)) {
             targetOverride = doc;
         }
@@ -17518,8 +45066,8 @@ function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyO
      * 5. If target is not relatedTarget or target is event's relatedTarget,
      * then:
     */
-    let activationTarget = null;
-    let relatedTarget = (0, TreeAlgorithm_1.tree_retarget)(event._relatedTarget, target);
+    var activationTarget = null;
+    var relatedTarget = TreeAlgorithm_1.tree_retarget(event._relatedTarget, target);
     if (target !== relatedTarget || target === event._relatedTarget) {
         /**
          * 5.1. Let touchTargets be a new list.
@@ -17537,19 +45085,29 @@ function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyO
          * 5.8. Let parent be the result of invoking target's get the parent with
          * event.
          */
-        let touchTargets = [];
-        for (const touchTarget of event._touchTargetList) {
-            touchTargets.push((0, TreeAlgorithm_1.tree_retarget)(touchTarget, target));
+        var touchTargets = [];
+        try {
+            for (var _c = __values(event._touchTargetList), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var touchTarget = _d.value;
+                touchTargets.push(TreeAlgorithm_1.tree_retarget(touchTarget, target));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
         event_appendToAnEventPath(event, target, targetOverride, relatedTarget, touchTargets, false);
-        const isActivationEvent = (util_1.Guard.isMouseEvent(event) && event._type === "click");
+        var isActivationEvent = (util_1.Guard.isMouseEvent(event) && event._type === "click");
         if (isActivationEvent && target._activationBehavior !== undefined) {
             activationTarget = target;
         }
-        let slotable = (util_1.Guard.isSlotable(target) && (0, ShadowTreeAlgorithm_1.shadowTree_isAssigned)(target)) ?
+        var slotable = (util_1.Guard.isSlotable(target) && ShadowTreeAlgorithm_1.shadowTree_isAssigned(target)) ?
             target : null;
-        let slotInClosedTree = false;
-        let parent = target._getTheParent(event);
+        var slotInClosedTree = false;
+        var parent = target._getTheParent(event);
         /**
          * 5.9. While parent is non-null:
          */
@@ -17566,7 +45124,7 @@ function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyO
                     throw new Error("Parent node of a slotable should be a slot.");
                 }
                 slotable = null;
-                const root = (0, TreeAlgorithm_1.tree_rootNode)(parent, true);
+                var root = TreeAlgorithm_1.tree_rootNode(parent, true);
                 if (util_1.Guard.isShadowRoot(root) && root._mode === "closed") {
                     slotInClosedTree = true;
                 }
@@ -17580,20 +45138,30 @@ function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyO
              * 5.9.4. For each touchTarget of event's touch target list, append the
              * result of retargeting touchTarget against parent to touchTargets.
              */
-            if (util_1.Guard.isSlotable(parent) && (0, ShadowTreeAlgorithm_1.shadowTree_isAssigned)(parent)) {
+            if (util_1.Guard.isSlotable(parent) && ShadowTreeAlgorithm_1.shadowTree_isAssigned(parent)) {
                 slotable = parent;
             }
-            relatedTarget = (0, TreeAlgorithm_1.tree_retarget)(event._relatedTarget, parent);
+            relatedTarget = TreeAlgorithm_1.tree_retarget(event._relatedTarget, parent);
             touchTargets = [];
-            for (const touchTarget of event._touchTargetList) {
-                touchTargets.push((0, TreeAlgorithm_1.tree_retarget)(touchTarget, parent));
+            try {
+                for (var _e = (e_2 = void 0, __values(event._touchTargetList)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var touchTarget = _f.value;
+                    touchTargets.push(TreeAlgorithm_1.tree_retarget(touchTarget, parent));
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
             }
             /**
              * 5.9.6. If parent is a Window object, or parent is a node and target's
              * root is a shadow-including inclusive ancestor of parent, then:
              */
             if (util_1.Guard.isWindow(parent) || (util_1.Guard.isNode(parent) && util_1.Guard.isNode(target) &&
-                (0, TreeAlgorithm_1.tree_isAncestorOf)((0, TreeAlgorithm_1.tree_rootNode)(target, true), parent, true, true))) {
+                TreeAlgorithm_1.tree_isAncestorOf(TreeAlgorithm_1.tree_rootNode(target, true), parent, true, true))) {
                 /**
                  * 5.9.6.1. If isActivationEvent is true, event's bubbles attribute
                  * is true, activationTarget is null, and parent has activation
@@ -17644,10 +45212,10 @@ function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyO
          * 5.10. Let clearTargetsStruct be the last struct in event's path whose
          * shadow-adjusted target is non-null.
          */
-        let clearTargetsStruct = null;
-        const path = event._path;
-        for (let i = path.length - 1; i >= 0; i--) {
-            const struct = path[i];
+        var clearTargetsStruct = null;
+        var path = event._path;
+        for (var i = path.length - 1; i >= 0; i--) {
+            var struct = path[i];
             if (struct.shadowAdjustedTarget !== null) {
                 clearTargetsStruct = struct;
                 break;
@@ -17661,18 +45229,18 @@ function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyO
          */
         if (clearTargetsStruct !== null) {
             if (util_1.Guard.isNode(clearTargetsStruct.shadowAdjustedTarget) &&
-                util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(clearTargetsStruct.shadowAdjustedTarget, true))) {
+                util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(clearTargetsStruct.shadowAdjustedTarget, true))) {
                 clearTargets = true;
             }
             else if (util_1.Guard.isNode(clearTargetsStruct.relatedTarget) &&
-                util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(clearTargetsStruct.relatedTarget, true))) {
+                util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(clearTargetsStruct.relatedTarget, true))) {
                 clearTargets = true;
             }
             else {
-                for (let j = 0; j < clearTargetsStruct.touchTargetList.length; j++) {
-                    const struct = clearTargetsStruct.touchTargetList[j];
+                for (var j = 0; j < clearTargetsStruct.touchTargetList.length; j++) {
+                    var struct = clearTargetsStruct.touchTargetList[j];
                     if (util_1.Guard.isNode(struct) &&
-                        util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(struct, true))) {
+                        util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(struct, true))) {
                         clearTargets = true;
                         break;
                     }
@@ -17691,8 +45259,8 @@ function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyO
         /**
          * 5.13. For each struct in event's path, in reverse order:
          */
-        for (let i = path.length - 1; i >= 0; i--) {
-            const struct = path[i];
+        for (var i = path.length - 1; i >= 0; i--) {
+            var struct = path[i];
             /**
              * 5.13.1. If struct's shadow-adjusted target is non-null, then set
              * event's eventPhase attribute to AT_TARGET.
@@ -17712,8 +45280,8 @@ function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyO
         /**
          * 5.14. For each struct in event's path
          */
-        for (let i = 0; i < path.length; i++) {
-            const struct = path[i];
+        for (var i = 0; i < path.length; i++) {
+            var struct = path[i];
             /**
              * 5.14.1. If struct's shadow-adjusted target is non-null, then set
              * event's eventPhase attribute to AT_TARGET.
@@ -17779,6 +45347,7 @@ function event_dispatch(event, target, legacyTargetOverrideFlag = false, legacyO
      */
     return !event._canceledFlag;
 }
+exports.event_dispatch = event_dispatch;
 /**
  * Appends a new struct to an event's path.
  *
@@ -17795,9 +45364,9 @@ function event_appendToAnEventPath(event, invocationTarget, shadowAdjustedTarget
      * 2. If invocationTarget is a node and its root is a shadow root, then
      * set invocationTargetInShadowTree to true.
      */
-    let invocationTargetInShadowTree = false;
+    var invocationTargetInShadowTree = false;
     if (util_1.Guard.isNode(invocationTarget) &&
-        util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(invocationTarget))) {
+        util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(invocationTarget))) {
         invocationTargetInShadowTree = true;
     }
     /**
@@ -17805,7 +45374,7 @@ function event_appendToAnEventPath(event, invocationTarget, shadowAdjustedTarget
      * 4. If invocationTarget is a shadow root whose mode is "closed", then
      * set root-of-closed-tree to true.
      */
-    let rootOfClosedTree = false;
+    var rootOfClosedTree = false;
     if (util_1.Guard.isShadowRoot(invocationTarget) &&
         invocationTarget._mode === "closed") {
         rootOfClosedTree = true;
@@ -17828,6 +45397,7 @@ function event_appendToAnEventPath(event, invocationTarget, shadowAdjustedTarget
         slotInClosedTree: slotInClosedTree
     });
 }
+exports.event_appendToAnEventPath = event_appendToAnEventPath;
 /**
  * Invokes an event.
  *
@@ -17837,22 +45407,23 @@ function event_appendToAnEventPath(event, invocationTarget, shadowAdjustedTarget
  * @param legacyOutputDidListenersThrowFlag - legacy output flag that returns
  * whether the event listener's callback threw an exception
  */
-function event_invoke(struct, event, phase, legacyOutputDidListenersThrowFlag = { value: false }) {
+function event_invoke(struct, event, phase, legacyOutputDidListenersThrowFlag) {
+    if (legacyOutputDidListenersThrowFlag === void 0) { legacyOutputDidListenersThrowFlag = { value: false }; }
     /**
      * 1. Set event's target to the shadow-adjusted target of the last struct
      * in event's path, that is either struct or preceding struct, whose
      * shadow-adjusted target is non-null.
      */
-    const path = event._path;
-    let index = -1;
-    for (let i = 0; i < path.length; i++) {
+    var path = event._path;
+    var index = -1;
+    for (var i = 0; i < path.length; i++) {
         if (path[i] === struct) {
             index = i;
             break;
         }
     }
     if (index !== -1) {
-        let item = path[index];
+        var item = path[index];
         if (item.shadowAdjustedTarget !== null) {
             event._target = item.shadowAdjustedTarget;
         }
@@ -17880,14 +45451,14 @@ function event_invoke(struct, event, phase, legacyOutputDidListenersThrowFlag =
     if (event._stopPropagationFlag)
         return;
     event._currentTarget = struct.invocationTarget;
-    const currentTarget = event._currentTarget;
-    const targetListeners = currentTarget._eventListenerList;
-    let listeners = new Array(...targetListeners);
+    var currentTarget = event._currentTarget;
+    var targetListeners = currentTarget._eventListenerList;
+    var listeners = new (Array.bind.apply(Array, __spread([void 0], targetListeners)))();
     /**
      * 7. Let found be the result of running inner invoke with event, listeners,
      * phase, and legacyOutputDidListenersThrowFlag if given.
      */
-    const found = event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag);
+    var found = event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag);
     /**
      * 8. If found is false and event's isTrusted attribute is true, then:
      */
@@ -17906,7 +45477,7 @@ function event_invoke(struct, event, phase, legacyOutputDidListenersThrowFlag =
          * "animationstart"     | "webkitAnimationStart"
          * "transitionend"      | "webkitTransitionEnd"
          */
-        const originalEventType = event._type;
+        var originalEventType = event._type;
         if (originalEventType === "animationend") {
             event._type = "webkitAnimationEnd";
         }
@@ -17928,6 +45499,7 @@ function event_invoke(struct, event, phase, legacyOutputDidListenersThrowFlag =
         event._type = originalEventType;
     }
 }
+exports.event_invoke = event_invoke;
 /**
  * Invokes an event.
  *
@@ -17938,14 +45510,15 @@ function event_invoke(struct, event, phase, legacyOutputDidListenersThrowFlag =
  * @param legacyOutputDidListenersThrowFlag - legacy output flag that returns
  * whether the event listener's callback threw an exception
  */
-function event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag = { value: false }) {
+function event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListenersThrowFlag) {
+    if (legacyOutputDidListenersThrowFlag === void 0) { legacyOutputDidListenersThrowFlag = { value: false }; }
     /**
      * 1. Let found be false.
      * 2. For each listener in listeners, whose removed is false:
      */
-    let found = false;
-    for (let i = 0; i < listeners.length; i++) {
-        const listener = listeners[i];
+    var found = false;
+    for (var i = 0; i < listeners.length; i++) {
+        var listener = listeners[i];
         if (!listener.removed) {
             /**
              * 2.1. If event's type attribute value is not listener's type, then
@@ -17968,11 +45541,11 @@ function event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListe
              * currentTarget attribute value's event listener list.
              */
             if (listener.once && event._currentTarget !== null) {
-                const impl = event._currentTarget;
-                let index = -1;
-                for (let i = 0; i < impl._eventListenerList.length; i++) {
-                    if (impl._eventListenerList[i] === listener) {
-                        index = i;
+                var impl = event._currentTarget;
+                var index = -1;
+                for (var i_1 = 0; i_1 < impl._eventListenerList.length; i_1++) {
+                    if (impl._eventListenerList[i_1] === listener) {
+                        index = i_1;
                         break;
                     }
                 }
@@ -17986,7 +45559,7 @@ function event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListe
              * 2.6. Let global be listener callback's associated Realm's global
              * object.
              */
-            const globalObject = undefined;
+            var globalObject = undefined;
             /**
              * 2.7. Let currentEvent be undefined.
              * 2.8. If global is a Window object, then:
@@ -17994,7 +45567,7 @@ function event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListe
              * 2.8.2. If struct's invocation-target-in-shadow-tree is false, then
              * set global's current event to event.
              */
-            let currentEvent = undefined;
+            var currentEvent = undefined;
             if (util_1.Guard.isWindow(globalObject)) {
                 currentEvent = globalObject._currentEvent;
                 if (struct.invocationTargetInShadowTree === false) {
@@ -18050,6 +45623,7 @@ function event_innerInvoke(event, listeners, phase, struct, legacyOutputDidListe
      */
     return found;
 }
+exports.event_innerInvoke = event_innerInvoke;
 /**
  * Fires an event at target.
  * @param e - event name
@@ -18071,7 +45645,7 @@ function event_fireAnEvent(e, target, eventConstructor, idlAttributes, legacyTar
      * 2. Let event be the result of creating an event given eventConstructor,
      * in the relevant Realm of target.
      */
-    const event = event_createAnEvent(eventConstructor);
+    var event = event_createAnEvent(eventConstructor);
     /**
      * 3. Initialize event’s type attribute to e.
      */
@@ -18082,8 +45656,8 @@ function event_fireAnEvent(e, target, eventConstructor, idlAttributes, legacyTar
      * _Note:_ This also allows for the isTrusted attribute to be set to false.
      */
     if (idlAttributes) {
-        for (const key in idlAttributes) {
-            const idlObj = event;
+        for (var key in idlAttributes) {
+            var idlObj = event;
             idlObj[key] = idlAttributes[key];
         }
     }
@@ -18093,6 +45667,7 @@ function event_fireAnEvent(e, target, eventConstructor, idlAttributes, legacyTar
      */
     return event_dispatch(event, target, legacyTargetOverrideFlag);
 }
+exports.event_fireAnEvent = event_fireAnEvent;
 /**
  * Creates an event.
  *
@@ -18102,7 +45677,7 @@ function event_createLegacyEvent(eventInterface) {
     /**
      * 1. Let constructor be null.
      */
-    let constructor = null;
+    var constructor = null;
     /**
      * TODO: Implement in HTML DOM
      * 2. If interface is an ASCII case-insensitive match for any of the strings
@@ -18182,7 +45757,7 @@ function event_createLegacyEvent(eventInterface) {
      * 3. If constructor is null, then throw a "NotSupportedError" DOMException.
      */
     if (constructor === null) {
-        throw new DOMException_1.NotSupportedError(`Event constructor not found for interface ${eventInterface}.`);
+        throw new DOMException_1.NotSupportedError("Event constructor not found for interface " + eventInterface + ".");
     }
     /**
      * 4. If the interface indicated by constructor is not exposed on the
@@ -18201,7 +45776,7 @@ function event_createLegacyEvent(eventInterface) {
      * 8. Initialize event’s isTrusted attribute to false.
      * 9. Unset event’s initialized flag.
      */
-    const event = new constructor("");
+    var event = new constructor("");
     event._type = "";
     event._timeStamp = new Date().getTime();
     event._isTrusted = false;
@@ -18211,6 +45786,7 @@ function event_createLegacyEvent(eventInterface) {
      */
     return event;
 }
+exports.event_createLegacyEvent = event_createLegacyEvent;
 /**
  * Getter of an event handler IDL attribute.
  *
@@ -18225,11 +45801,12 @@ function event_getterEventHandlerIDLAttribute(thisObj, name) {
      * 3. Return the result of getting the current value of the event handler
      * given eventTarget and name.
      */
-    const eventTarget = event_determineTheTargetOfAnEventHandler(thisObj, name);
+    var eventTarget = event_determineTheTargetOfAnEventHandler(thisObj, name);
     if (eventTarget === null)
         return null;
     return event_getTheCurrentValueOfAnEventHandler(eventTarget, name);
 }
+exports.event_getterEventHandlerIDLAttribute = event_getterEventHandlerIDLAttribute;
 /**
  * Setter of an event handler IDL attribute.
  *
@@ -18250,21 +45827,22 @@ function event_setterEventHandlerIDLAttribute(thisObj, name, value) {
      * 4.3. Set eventHandler's value to the given value.
      * 4.4. Activate an event handler given eventTarget and name.
      */
-    const eventTarget = event_determineTheTargetOfAnEventHandler(thisObj, name);
+    var eventTarget = event_determineTheTargetOfAnEventHandler(thisObj, name);
     if (eventTarget === null)
         return;
     if (value === null) {
         event_deactivateAnEventHandler(eventTarget, name);
     }
     else {
-        const handlerMap = eventTarget._eventHandlerMap;
-        const eventHandler = handlerMap["onabort"];
+        var handlerMap = eventTarget._eventHandlerMap;
+        var eventHandler = handlerMap["onabort"];
         if (eventHandler !== undefined) {
             eventHandler.value = value;
         }
         event_activateAnEventHandler(eventTarget, name);
     }
 }
+exports.event_setterEventHandlerIDLAttribute = event_setterEventHandlerIDLAttribute;
 /**
  * Determines the target of an event handler.
  *
@@ -18275,6 +45853,7 @@ function event_determineTheTargetOfAnEventHandler(eventTarget, name) {
     // TODO: Implement in HTML DOM
     return null;
 }
+exports.event_determineTheTargetOfAnEventHandler = event_determineTheTargetOfAnEventHandler;
 /**
  * Gets the current value of an event handler.
  *
@@ -18285,6 +45864,7 @@ function event_getTheCurrentValueOfAnEventHandler(eventTarget, name) {
     // TODO: Implement in HTML DOM
     return null;
 }
+exports.event_getTheCurrentValueOfAnEventHandler = event_getTheCurrentValueOfAnEventHandler;
 /**
  * Activates an event handler.
  *
@@ -18294,6 +45874,7 @@ function event_getTheCurrentValueOfAnEventHandler(eventTarget, name) {
 function event_activateAnEventHandler(eventTarget, name) {
     // TODO: Implement in HTML DOM
 }
+exports.event_activateAnEventHandler = event_activateAnEventHandler;
 /**
  * Deactivates an event handler.
  *
@@ -18303,22 +45884,29 @@ function event_activateAnEventHandler(eventTarget, name) {
 function event_deactivateAnEventHandler(eventTarget, name) {
     // TODO: Implement in HTML DOM
 }
+exports.event_deactivateAnEventHandler = event_deactivateAnEventHandler;
 //# sourceMappingURL=EventAlgorithm.js.map
 
 /***/ }),
 
 /***/ 21312:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.eventTarget_flatten = eventTarget_flatten;
-exports.eventTarget_flattenMore = eventTarget_flattenMore;
-exports.eventTarget_addEventListener = eventTarget_addEventListener;
-exports.eventTarget_removeEventListener = eventTarget_removeEventListener;
-exports.eventTarget_removeAllEventListeners = eventTarget_removeAllEventListeners;
-const util_1 = __nccwpck_require__(76195);
+var util_1 = __nccwpck_require__(76195);
 /**
  * Flattens the given options argument.
  *
@@ -18329,13 +45917,14 @@ function eventTarget_flatten(options) {
      * 1. If options is a boolean, then return options.
      * 2. Return options’s capture.
      */
-    if ((0, util_1.isBoolean)(options)) {
+    if (util_1.isBoolean(options)) {
         return options;
     }
     else {
         return options.capture || false;
     }
 }
+exports.eventTarget_flatten = eventTarget_flatten;
 /**
  * Flattens the given options argument.
  *
@@ -18349,15 +45938,16 @@ function eventTarget_flattenMore(options) {
      * once to options’s once.
      * 4. Return capture, passive, and once.
      */
-    const capture = eventTarget_flatten(options);
-    let once = false;
-    let passive = false;
-    if (!(0, util_1.isBoolean)(options)) {
+    var capture = eventTarget_flatten(options);
+    var once = false;
+    var passive = false;
+    if (!util_1.isBoolean(options)) {
         once = options.once || false;
         passive = options.passive || false;
     }
     return [capture, passive, once];
 }
+exports.eventTarget_flattenMore = eventTarget_flattenMore;
 /**
  * Adds a new event listener.
  *
@@ -18384,8 +45974,8 @@ function eventTarget_addEventListener(eventTarget, listener) {
      * is listener’s capture, then append listener to eventTarget’s event listener
      * list.
      */
-    for (let i = 0; i < eventTarget._eventListenerList.length; i++) {
-        const entry = eventTarget._eventListenerList[i];
+    for (var i = 0; i < eventTarget._eventListenerList.length; i++) {
+        var entry = eventTarget._eventListenerList[i];
         if (entry.type === listener.type && entry.callback.handleEvent === listener.callback.handleEvent
             && entry.capture === listener.capture) {
             return;
@@ -18393,6 +45983,7 @@ function eventTarget_addEventListener(eventTarget, listener) {
     }
     eventTarget._eventListenerList.push(listener);
 }
+exports.eventTarget_addEventListener = eventTarget_addEventListener;
 /**
  * Removes an event listener.
  *
@@ -18414,6 +46005,7 @@ function eventTarget_removeEventListener(eventTarget, listener, index) {
     listener.removed = true;
     eventTarget._eventListenerList.splice(index, 1);
 }
+exports.eventTarget_removeEventListener = eventTarget_removeEventListener;
 /**
  * Removes all event listeners.
  *
@@ -18425,42 +46017,77 @@ function eventTarget_removeAllEventListeners(eventTarget) {
      * for each listener of eventTarget’s event listener list, remove an event
      * listener with eventTarget and listener.
      */
-    for (const e of eventTarget._eventListenerList) {
-        e.removed = true;
+    var e_1, _a;
+    try {
+        for (var _b = __values(eventTarget._eventListenerList), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var e = _c.value;
+            e.removed = true;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
     }
     eventTarget._eventListenerList.length = 0;
 }
+exports.eventTarget_removeAllEventListeners = eventTarget_removeAllEventListeners;
 //# sourceMappingURL=EventTargetAlgorithm.js.map
 
 /***/ }),
 
 /***/ 45463:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.mutation_ensurePreInsertionValidity = mutation_ensurePreInsertionValidity;
-exports.mutation_preInsert = mutation_preInsert;
-exports.mutation_insert = mutation_insert;
-exports.mutation_append = mutation_append;
-exports.mutation_replace = mutation_replace;
-exports.mutation_replaceAll = mutation_replaceAll;
-exports.mutation_preRemove = mutation_preRemove;
-exports.mutation_remove = mutation_remove;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const DOMException_1 = __nccwpck_require__(13166);
-const interfaces_1 = __nccwpck_require__(27305);
-const util_1 = __nccwpck_require__(65282);
-const util_2 = __nccwpck_require__(76195);
-const infra_1 = __nccwpck_require__(84251);
-const CustomElementAlgorithm_1 = __nccwpck_require__(35648);
-const TreeAlgorithm_1 = __nccwpck_require__(16620);
-const NodeIteratorAlgorithm_1 = __nccwpck_require__(3973);
-const ShadowTreeAlgorithm_1 = __nccwpck_require__(68733);
-const MutationObserverAlgorithm_1 = __nccwpck_require__(78157);
-const DOMAlgorithm_1 = __nccwpck_require__(9628);
-const DocumentAlgorithm_1 = __nccwpck_require__(12793);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var DOMException_1 = __nccwpck_require__(13166);
+var interfaces_1 = __nccwpck_require__(27305);
+var util_1 = __nccwpck_require__(65282);
+var util_2 = __nccwpck_require__(76195);
+var infra_1 = __nccwpck_require__(84251);
+var CustomElementAlgorithm_1 = __nccwpck_require__(35648);
+var TreeAlgorithm_1 = __nccwpck_require__(16620);
+var NodeIteratorAlgorithm_1 = __nccwpck_require__(3973);
+var ShadowTreeAlgorithm_1 = __nccwpck_require__(68733);
+var MutationObserverAlgorithm_1 = __nccwpck_require__(78157);
+var DOMAlgorithm_1 = __nccwpck_require__(9628);
+var DocumentAlgorithm_1 = __nccwpck_require__(12793);
 /**
  * Ensures pre-insertion validity of a node into a parent before a
  * child.
@@ -18470,9 +46097,10 @@ const DocumentAlgorithm_1 = __nccwpck_require__(12793);
  * @param child - child node to insert node before
  */
 function mutation_ensurePreInsertionValidity(node, parent, child) {
-    const parentNodeType = parent._nodeType;
-    const nodeNodeType = node._nodeType;
-    const childNodeType = child ? child._nodeType : null;
+    var e_1, _a, e_2, _b, e_3, _c, e_4, _d;
+    var parentNodeType = parent._nodeType;
+    var nodeNodeType = node._nodeType;
+    var childNodeType = child ? child._nodeType : null;
     /**
      * 1. If parent is not a Document, DocumentFragment, or Element node,
      * throw a "HierarchyRequestError" DOMException.
@@ -18480,19 +46108,19 @@ function mutation_ensurePreInsertionValidity(node, parent, child) {
     if (parentNodeType !== interfaces_1.NodeType.Document &&
         parentNodeType !== interfaces_1.NodeType.DocumentFragment &&
         parentNodeType !== interfaces_1.NodeType.Element)
-        throw new DOMException_1.HierarchyRequestError(`Only document, document fragment and element nodes can contain child nodes. Parent node is ${parent.nodeName}.`);
+        throw new DOMException_1.HierarchyRequestError("Only document, document fragment and element nodes can contain child nodes. Parent node is " + parent.nodeName + ".");
     /**
      * 2. If node is a host-including inclusive ancestor of parent, throw a
      * "HierarchyRequestError" DOMException.
      */
-    if ((0, TreeAlgorithm_1.tree_isHostIncludingAncestorOf)(parent, node, true))
-        throw new DOMException_1.HierarchyRequestError(`The node to be inserted cannot be an inclusive ancestor of parent node. Node is ${node.nodeName}, parent node is ${parent.nodeName}.`);
+    if (TreeAlgorithm_1.tree_isHostIncludingAncestorOf(parent, node, true))
+        throw new DOMException_1.HierarchyRequestError("The node to be inserted cannot be an inclusive ancestor of parent node. Node is " + node.nodeName + ", parent node is " + parent.nodeName + ".");
     /**
      * 3. If child is not null and its parent is not parent, then throw a
      * "NotFoundError" DOMException.
      */
     if (child !== null && child._parent !== parent)
-        throw new DOMException_1.NotFoundError(`The reference child node cannot be found under parent node. Child node is ${child.nodeName}, parent node is ${parent.nodeName}.`);
+        throw new DOMException_1.NotFoundError("The reference child node cannot be found under parent node. Child node is " + child.nodeName + ", parent node is " + parent.nodeName + ".");
     /**
      * 4. If node is not a DocumentFragment, DocumentType, Element, Text,
      * ProcessingInstruction, or Comment node, throw a "HierarchyRequestError"
@@ -18505,7 +46133,7 @@ function mutation_ensurePreInsertionValidity(node, parent, child) {
         nodeNodeType !== interfaces_1.NodeType.ProcessingInstruction &&
         nodeNodeType !== interfaces_1.NodeType.CData &&
         nodeNodeType !== interfaces_1.NodeType.Comment)
-        throw new DOMException_1.HierarchyRequestError(`Only document fragment, document type, element, text, processing instruction, cdata section or comment nodes can be inserted. Node is ${node.nodeName}.`);
+        throw new DOMException_1.HierarchyRequestError("Only document fragment, document type, element, text, processing instruction, cdata section or comment nodes can be inserted. Node is " + node.nodeName + ".");
     /**
      * 5. If either node is a Text node and parent is a document, or node is a
      * doctype and parent is not a document, throw a "HierarchyRequestError"
@@ -18513,10 +46141,10 @@ function mutation_ensurePreInsertionValidity(node, parent, child) {
      */
     if (nodeNodeType === interfaces_1.NodeType.Text &&
         parentNodeType === interfaces_1.NodeType.Document)
-        throw new DOMException_1.HierarchyRequestError(`Cannot insert a text node as a child of a document node. Node is ${node.nodeName}.`);
+        throw new DOMException_1.HierarchyRequestError("Cannot insert a text node as a child of a document node. Node is " + node.nodeName + ".");
     if (nodeNodeType === interfaces_1.NodeType.DocumentType &&
         parentNodeType !== interfaces_1.NodeType.Document)
-        throw new DOMException_1.HierarchyRequestError(`A document type node can only be inserted under a document node. Parent node is ${parent.nodeName}.`);
+        throw new DOMException_1.HierarchyRequestError("A document type node can only be inserted under a document node. Parent node is " + parent.nodeName + ".");
     /**
      * 6. If parent is a document, and any of the statements below, switched on
      * node, are true, throw a "HierarchyRequestError" DOMException.
@@ -18534,73 +46162,114 @@ function mutation_ensurePreInsertionValidity(node, parent, child) {
      */
     if (parentNodeType === interfaces_1.NodeType.Document) {
         if (nodeNodeType === interfaces_1.NodeType.DocumentFragment) {
-            let eleCount = 0;
-            for (const childNode of node._children) {
-                if (childNode._nodeType === interfaces_1.NodeType.Element)
-                    eleCount++;
-                else if (childNode._nodeType === interfaces_1.NodeType.Text)
-                    throw new DOMException_1.HierarchyRequestError(`Cannot insert text a node as a child of a document node. Node is ${childNode.nodeName}.`);
+            var eleCount = 0;
+            try {
+                for (var _e = __values(node._children), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var childNode = _f.value;
+                    if (childNode._nodeType === interfaces_1.NodeType.Element)
+                        eleCount++;
+                    else if (childNode._nodeType === interfaces_1.NodeType.Text)
+                        throw new DOMException_1.HierarchyRequestError("Cannot insert text a node as a child of a document node. Node is " + childNode.nodeName + ".");
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                }
+                finally { if (e_1) throw e_1.error; }
             }
             if (eleCount > 1) {
-                throw new DOMException_1.HierarchyRequestError(`A document node can only have one document element node. Document fragment to be inserted has ${eleCount} element nodes.`);
+                throw new DOMException_1.HierarchyRequestError("A document node can only have one document element node. Document fragment to be inserted has " + eleCount + " element nodes.");
             }
             else if (eleCount === 1) {
-                for (const ele of parent._children) {
-                    if (ele._nodeType === interfaces_1.NodeType.Element)
-                        throw new DOMException_1.HierarchyRequestError(`The document node already has a document element node.`);
+                try {
+                    for (var _g = __values(parent._children), _h = _g.next(); !_h.done; _h = _g.next()) {
+                        var ele = _h.value;
+                        if (ele._nodeType === interfaces_1.NodeType.Element)
+                            throw new DOMException_1.HierarchyRequestError("The document node already has a document element node.");
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                    }
+                    finally { if (e_2) throw e_2.error; }
                 }
                 if (child) {
                     if (childNodeType === interfaces_1.NodeType.DocumentType)
-                        throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node.`);
-                    let doctypeChild = child._nextSibling;
+                        throw new DOMException_1.HierarchyRequestError("Cannot insert an element node before a document type node.");
+                    var doctypeChild = child._nextSibling;
                     while (doctypeChild) {
                         if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType)
-                            throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node.`);
+                            throw new DOMException_1.HierarchyRequestError("Cannot insert an element node before a document type node.");
                         doctypeChild = doctypeChild._nextSibling;
                     }
                 }
             }
         }
         else if (nodeNodeType === interfaces_1.NodeType.Element) {
-            for (const ele of parent._children) {
-                if (ele._nodeType === interfaces_1.NodeType.Element)
-                    throw new DOMException_1.HierarchyRequestError(`Document already has a document element node. Node is ${node.nodeName}.`);
+            try {
+                for (var _j = __values(parent._children), _k = _j.next(); !_k.done; _k = _j.next()) {
+                    var ele = _k.value;
+                    if (ele._nodeType === interfaces_1.NodeType.Element)
+                        throw new DOMException_1.HierarchyRequestError("Document already has a document element node. Node is " + node.nodeName + ".");
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                }
+                finally { if (e_3) throw e_3.error; }
             }
             if (child) {
                 if (childNodeType === interfaces_1.NodeType.DocumentType)
-                    throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node. Node is ${node.nodeName}.`);
-                let doctypeChild = child._nextSibling;
+                    throw new DOMException_1.HierarchyRequestError("Cannot insert an element node before a document type node. Node is " + node.nodeName + ".");
+                var doctypeChild = child._nextSibling;
                 while (doctypeChild) {
                     if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType)
-                        throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node. Node is ${node.nodeName}.`);
+                        throw new DOMException_1.HierarchyRequestError("Cannot insert an element node before a document type node. Node is " + node.nodeName + ".");
                     doctypeChild = doctypeChild._nextSibling;
                 }
             }
         }
         else if (nodeNodeType === interfaces_1.NodeType.DocumentType) {
-            for (const ele of parent._children) {
-                if (ele._nodeType === interfaces_1.NodeType.DocumentType)
-                    throw new DOMException_1.HierarchyRequestError(`Document already has a document type node. Node is ${node.nodeName}.`);
+            try {
+                for (var _l = __values(parent._children), _m = _l.next(); !_m.done; _m = _l.next()) {
+                    var ele = _m.value;
+                    if (ele._nodeType === interfaces_1.NodeType.DocumentType)
+                        throw new DOMException_1.HierarchyRequestError("Document already has a document type node. Node is " + node.nodeName + ".");
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+                }
+                finally { if (e_4) throw e_4.error; }
             }
             if (child) {
-                let elementChild = child._previousSibling;
+                var elementChild = child._previousSibling;
                 while (elementChild) {
                     if (elementChild._nodeType === interfaces_1.NodeType.Element)
-                        throw new DOMException_1.HierarchyRequestError(`Cannot insert a document type node before an element node. Node is ${node.nodeName}.`);
+                        throw new DOMException_1.HierarchyRequestError("Cannot insert a document type node before an element node. Node is " + node.nodeName + ".");
                     elementChild = elementChild._previousSibling;
                 }
             }
             else {
-                let elementChild = parent._firstChild;
+                var elementChild = parent._firstChild;
                 while (elementChild) {
                     if (elementChild._nodeType === interfaces_1.NodeType.Element)
-                        throw new DOMException_1.HierarchyRequestError(`Cannot insert a document type node before an element node. Node is ${node.nodeName}.`);
+                        throw new DOMException_1.HierarchyRequestError("Cannot insert a document type node before an element node. Node is " + node.nodeName + ".");
                     elementChild = elementChild._nextSibling;
                 }
             }
         }
     }
 }
+exports.mutation_ensurePreInsertionValidity = mutation_ensurePreInsertionValidity;
 /**
  * Ensures pre-insertion validity of a node into a parent before a
  * child, then adopts the node to the tree and inserts it.
@@ -18619,13 +46288,14 @@ function mutation_preInsert(node, parent, child) {
      * 6. Return node.
      */
     mutation_ensurePreInsertionValidity(node, parent, child);
-    let referenceChild = child;
+    var referenceChild = child;
     if (referenceChild === node)
         referenceChild = node._nextSibling;
-    (0, DocumentAlgorithm_1.document_adopt)(node, parent._nodeDocument);
+    DocumentAlgorithm_1.document_adopt(node, parent._nodeDocument);
     mutation_insert(node, parent, referenceChild);
     return node;
 }
+exports.mutation_preInsert = mutation_preInsert;
 /**
  * Inserts a node into a parent node before the given child node.
  *
@@ -18635,6 +46305,7 @@ function mutation_preInsert(node, parent, child) {
  * @param suppressObservers - whether to notify observers
  */
 function mutation_insert(node, parent, child, suppressObservers) {
+    var e_5, _a;
     // Optimized common case
     if (child === null && node._nodeType !== interfaces_1.NodeType.DocumentFragment) {
         mutation_insert_single(node, parent, suppressObservers);
@@ -18644,7 +46315,7 @@ function mutation_insert(node, parent, child, suppressObservers) {
      * 1. Let count be the number of children of node if it is a
      * DocumentFragment node, and one otherwise.
      */
-    const count = (node._nodeType === interfaces_1.NodeType.DocumentFragment ?
+    var count = (node._nodeType === interfaces_1.NodeType.DocumentFragment ?
         node._children.size : 1);
     /**
      * 2. If child is non-null, then:
@@ -18659,14 +46330,24 @@ function mutation_insert(node, parent, child, suppressObservers) {
          * offset by count.
          */
         if (DOMImpl_1.dom.rangeList.size !== 0) {
-            const index = (0, TreeAlgorithm_1.tree_index)(child);
-            for (const range of DOMImpl_1.dom.rangeList) {
-                if (range._start[0] === parent && range._start[1] > index) {
-                    range._start[1] += count;
+            var index_1 = TreeAlgorithm_1.tree_index(child);
+            try {
+                for (var _b = __values(DOMImpl_1.dom.rangeList), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var range = _c.value;
+                    if (range._start[0] === parent && range._start[1] > index_1) {
+                        range._start[1] += count;
+                    }
+                    if (range._end[0] === parent && range._end[1] > index_1) {
+                        range._end[1] += count;
+                    }
                 }
-                if (range._end[0] === parent && range._end[1] > index) {
-                    range._end[1] += count;
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
+                finally { if (e_5) throw e_5.error; }
             }
         }
     }
@@ -18674,8 +46355,7 @@ function mutation_insert(node, parent, child, suppressObservers) {
      * 3. Let nodes be node’s children, if node is a DocumentFragment node;
      * otherwise « node ».
      */
-    const nodes = node._nodeType === interfaces_1.NodeType.DocumentFragment ?
-        new Array(...node._children) : [node];
+    var nodes = node._nodeType === interfaces_1.NodeType.DocumentFragment ? new (Array.bind.apply(Array, __spread([void 0], node._children)))() : [node];
     /**
      * 4. If node is a DocumentFragment node, remove its children with the
      * suppress observers flag set.
@@ -18691,29 +46371,29 @@ function mutation_insert(node, parent, child, suppressObservers) {
      */
     if (DOMImpl_1.dom.features.mutationObservers) {
         if (node._nodeType === interfaces_1.NodeType.DocumentFragment) {
-            (0, MutationObserverAlgorithm_1.observer_queueTreeMutationRecord)(node, [], nodes, null, null);
+            MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(node, [], nodes, null, null);
         }
     }
     /**
      * 6. Let previousSibling be child’s previous sibling or parent’s last
      * child if child is null.
      */
-    const previousSibling = (child ? child._previousSibling : parent._lastChild);
-    let index = child === null ? -1 : (0, TreeAlgorithm_1.tree_index)(child);
+    var previousSibling = (child ? child._previousSibling : parent._lastChild);
+    var index = child === null ? -1 : TreeAlgorithm_1.tree_index(child);
     /**
      * 7. For each node in nodes, in tree order:
      */
-    for (let i = 0; i < nodes.length; i++) {
-        const node = nodes[i];
-        if (util_1.Guard.isElementNode(node)) {
+    for (var i = 0; i < nodes.length; i++) {
+        var node_1 = nodes[i];
+        if (util_1.Guard.isElementNode(node_1)) {
             // set document element node
             if (util_1.Guard.isDocumentNode(parent)) {
-                parent._documentElement = node;
+                parent._documentElement = node_1;
             }
             // mark that the document has namespaces
-            if (!node._nodeDocument._hasNamespaces && (node._namespace !== null ||
-                node._namespacePrefix !== null)) {
-                node._nodeDocument._hasNamespaces = true;
+            if (!node_1._nodeDocument._hasNamespaces && (node_1._namespace !== null ||
+                node_1._namespacePrefix !== null)) {
+                node_1._nodeDocument._hasNamespaces = true;
             }
         }
         /**
@@ -18721,42 +46401,42 @@ function mutation_insert(node, parent, child, suppressObservers) {
          * 7.2. Otherwise, insert node into parent’s children before child’s
          * index.
          */
-        node._parent = parent;
+        node_1._parent = parent;
         if (child === null) {
-            infra_1.set.append(parent._children, node);
+            infra_1.set.append(parent._children, node_1);
         }
         else {
-            infra_1.set.insert(parent._children, node, index);
+            infra_1.set.insert(parent._children, node_1, index);
             index++;
         }
         // assign siblings and children for quick lookups
         if (parent._firstChild === null) {
-            node._previousSibling = null;
-            node._nextSibling = null;
-            parent._firstChild = node;
-            parent._lastChild = node;
+            node_1._previousSibling = null;
+            node_1._nextSibling = null;
+            parent._firstChild = node_1;
+            parent._lastChild = node_1;
         }
         else {
-            const prev = (child ? child._previousSibling : parent._lastChild);
-            const next = (child ? child : null);
-            node._previousSibling = prev;
-            node._nextSibling = next;
+            var prev = (child ? child._previousSibling : parent._lastChild);
+            var next = (child ? child : null);
+            node_1._previousSibling = prev;
+            node_1._nextSibling = next;
             if (prev)
-                prev._nextSibling = node;
+                prev._nextSibling = node_1;
             if (next)
-                next._previousSibling = node;
+                next._previousSibling = node_1;
             if (!prev)
-                parent._firstChild = node;
+                parent._firstChild = node_1;
             if (!next)
-                parent._lastChild = node;
+                parent._lastChild = node_1;
         }
         /**
          * 7.3. If parent is a shadow host and node is a slotable, then
          * assign a slot for node.
          */
         if (DOMImpl_1.dom.features.slots) {
-            if (parent._shadowRoot !== null && util_1.Guard.isSlotable(node)) {
-                (0, ShadowTreeAlgorithm_1.shadowTree_assignASlot)(node);
+            if (parent._shadowRoot !== null && util_1.Guard.isSlotable(node_1)) {
+                ShadowTreeAlgorithm_1.shadowTree_assignASlot(node_1);
             }
         }
         /**
@@ -18764,8 +46444,8 @@ function mutation_insert(node, parent, child, suppressObservers) {
          * steps for parent.
          */
         if (DOMImpl_1.dom.features.steps) {
-            if (util_1.Guard.isTextNode(node)) {
-                (0, DOMAlgorithm_1.dom_runChildTextContentChangeSteps)(parent);
+            if (util_1.Guard.isTextNode(node_1)) {
+                DOMAlgorithm_1.dom_runChildTextContentChangeSteps(parent);
             }
         }
         /**
@@ -18774,53 +46454,53 @@ function mutation_insert(node, parent, child, suppressObservers) {
          * a slot change for parent.
          */
         if (DOMImpl_1.dom.features.slots) {
-            if (util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(parent)) &&
-                util_1.Guard.isSlot(parent) && (0, util_2.isEmpty)(parent._assignedNodes)) {
-                (0, ShadowTreeAlgorithm_1.shadowTree_signalASlotChange)(parent);
+            if (util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(parent)) &&
+                util_1.Guard.isSlot(parent) && util_2.isEmpty(parent._assignedNodes)) {
+                ShadowTreeAlgorithm_1.shadowTree_signalASlotChange(parent);
             }
         }
         /**
          * 7.6. Run assign slotables for a tree with node's root.
          */
         if (DOMImpl_1.dom.features.slots) {
-            (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree)((0, TreeAlgorithm_1.tree_rootNode)(node));
+            ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(TreeAlgorithm_1.tree_rootNode(node_1));
         }
         /**
          * 7.7. For each shadow-including inclusive descendant
          * inclusiveDescendant of node, in shadow-including tree
          * order:
          */
-        let inclusiveDescendant = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(node, true, true);
+        var inclusiveDescendant = TreeAlgorithm_1.tree_getFirstDescendantNode(node_1, true, true);
         while (inclusiveDescendant !== null) {
             /**
              * 7.7.1. Run the insertion steps with inclusiveDescendant.
              */
             if (DOMImpl_1.dom.features.steps) {
-                (0, DOMAlgorithm_1.dom_runInsertionSteps)(inclusiveDescendant);
+                DOMAlgorithm_1.dom_runInsertionSteps(inclusiveDescendant);
             }
             if (DOMImpl_1.dom.features.customElements) {
                 /**
                  * 7.7.2. If inclusiveDescendant is connected, then:
                  */
                 if (util_1.Guard.isElementNode(inclusiveDescendant) &&
-                    (0, ShadowTreeAlgorithm_1.shadowTree_isConnected)(inclusiveDescendant)) {
+                    ShadowTreeAlgorithm_1.shadowTree_isConnected(inclusiveDescendant)) {
                     if (util_1.Guard.isCustomElementNode(inclusiveDescendant)) {
                         /**
                          * 7.7.2.1. If inclusiveDescendant is custom, then enqueue a custom
                          * element callback reaction with inclusiveDescendant, callback name
                          * "connectedCallback", and an empty argument list.
                          */
-                        (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(inclusiveDescendant, "connectedCallback", []);
+                        CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(inclusiveDescendant, "connectedCallback", []);
                     }
                     else {
                         /**
                          * 7.7.2.2. Otherwise, try to upgrade inclusiveDescendant.
                          */
-                        (0, CustomElementAlgorithm_1.customElement_tryToUpgrade)(inclusiveDescendant);
+                        CustomElementAlgorithm_1.customElement_tryToUpgrade(inclusiveDescendant);
                     }
                 }
             }
-            inclusiveDescendant = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(node, inclusiveDescendant, true, true);
+            inclusiveDescendant = TreeAlgorithm_1.tree_getNextDescendantNode(node_1, inclusiveDescendant, true, true);
         }
     }
     /**
@@ -18829,10 +46509,11 @@ function mutation_insert(node, parent, child, suppressObservers) {
      */
     if (DOMImpl_1.dom.features.mutationObservers) {
         if (!suppressObservers) {
-            (0, MutationObserverAlgorithm_1.observer_queueTreeMutationRecord)(parent, nodes, [], previousSibling, child);
+            MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, nodes, [], previousSibling, child);
         }
     }
 }
+exports.mutation_insert = mutation_insert;
 /**
  * Inserts a node into a parent node. Optimized routine for the common case where
  * node is not a document fragment node and it has no child nodes.
@@ -18863,7 +46544,7 @@ function mutation_insert_single(node, parent, suppressObservers) {
      * 6. Let previousSibling be child’s previous sibling or parent’s last
      * child if child is null.
      */
-    const previousSibling = parent._lastChild;
+    var previousSibling = parent._lastChild;
     // set document element node
     if (util_1.Guard.isElementNode(node)) {
         // set document element node
@@ -18892,7 +46573,7 @@ function mutation_insert_single(node, parent, suppressObservers) {
         parent._lastChild = node;
     }
     else {
-        const prev = parent._lastChild;
+        var prev = parent._lastChild;
         node._previousSibling = prev;
         node._nextSibling = null;
         if (prev)
@@ -18907,7 +46588,7 @@ function mutation_insert_single(node, parent, suppressObservers) {
      */
     if (DOMImpl_1.dom.features.slots) {
         if (parent._shadowRoot !== null && util_1.Guard.isSlotable(node)) {
-            (0, ShadowTreeAlgorithm_1.shadowTree_assignASlot)(node);
+            ShadowTreeAlgorithm_1.shadowTree_assignASlot(node);
         }
     }
     /**
@@ -18916,7 +46597,7 @@ function mutation_insert_single(node, parent, suppressObservers) {
      */
     if (DOMImpl_1.dom.features.steps) {
         if (util_1.Guard.isTextNode(node)) {
-            (0, DOMAlgorithm_1.dom_runChildTextContentChangeSteps)(parent);
+            DOMAlgorithm_1.dom_runChildTextContentChangeSteps(parent);
         }
     }
     /**
@@ -18925,16 +46606,16 @@ function mutation_insert_single(node, parent, suppressObservers) {
      * a slot change for parent.
      */
     if (DOMImpl_1.dom.features.slots) {
-        if (util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(parent)) &&
-            util_1.Guard.isSlot(parent) && (0, util_2.isEmpty)(parent._assignedNodes)) {
-            (0, ShadowTreeAlgorithm_1.shadowTree_signalASlotChange)(parent);
+        if (util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(parent)) &&
+            util_1.Guard.isSlot(parent) && util_2.isEmpty(parent._assignedNodes)) {
+            ShadowTreeAlgorithm_1.shadowTree_signalASlotChange(parent);
         }
     }
     /**
      * 7.6. Run assign slotables for a tree with node's root.
      */
     if (DOMImpl_1.dom.features.slots) {
-        (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree)((0, TreeAlgorithm_1.tree_rootNode)(node));
+        ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(TreeAlgorithm_1.tree_rootNode(node));
     }
     /**
      * 7.7. For each shadow-including inclusive descendant
@@ -18943,27 +46624,27 @@ function mutation_insert_single(node, parent, suppressObservers) {
      * 7.7.1. Run the insertion steps with inclusiveDescendant.
      */
     if (DOMImpl_1.dom.features.steps) {
-        (0, DOMAlgorithm_1.dom_runInsertionSteps)(node);
+        DOMAlgorithm_1.dom_runInsertionSteps(node);
     }
     if (DOMImpl_1.dom.features.customElements) {
         /**
          * 7.7.2. If inclusiveDescendant is connected, then:
          */
         if (util_1.Guard.isElementNode(node) &&
-            (0, ShadowTreeAlgorithm_1.shadowTree_isConnected)(node)) {
+            ShadowTreeAlgorithm_1.shadowTree_isConnected(node)) {
             if (util_1.Guard.isCustomElementNode(node)) {
                 /**
                  * 7.7.2.1. If inclusiveDescendant is custom, then enqueue a custom
                  * element callback reaction with inclusiveDescendant, callback name
                  * "connectedCallback", and an empty argument list.
                  */
-                (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(node, "connectedCallback", []);
+                CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(node, "connectedCallback", []);
             }
             else {
                 /**
                  * 7.7.2.2. Otherwise, try to upgrade inclusiveDescendant.
                  */
-                (0, CustomElementAlgorithm_1.customElement_tryToUpgrade)(node);
+                CustomElementAlgorithm_1.customElement_tryToUpgrade(node);
             }
         }
     }
@@ -18973,7 +46654,7 @@ function mutation_insert_single(node, parent, suppressObservers) {
      */
     if (DOMImpl_1.dom.features.mutationObservers) {
         if (!suppressObservers) {
-            (0, MutationObserverAlgorithm_1.observer_queueTreeMutationRecord)(parent, [node], [], previousSibling, null);
+            MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, [node], [], previousSibling, null);
         }
     }
 }
@@ -18989,6 +46670,7 @@ function mutation_append(node, parent) {
      */
     return mutation_preInsert(node, parent, null);
 }
+exports.mutation_append = mutation_append;
 /**
  * Replaces a node with another node.
  *
@@ -18997,6 +46679,7 @@ function mutation_append(node, parent) {
  * @param parent - parent node to receive node
  */
 function mutation_replace(child, node, parent) {
+    var e_6, _a, e_7, _b, e_8, _c, e_9, _d;
     /**
      * 1. If parent is not a Document, DocumentFragment, or Element node,
      * throw a "HierarchyRequestError" DOMException.
@@ -19004,19 +46687,19 @@ function mutation_replace(child, node, parent) {
     if (parent._nodeType !== interfaces_1.NodeType.Document &&
         parent._nodeType !== interfaces_1.NodeType.DocumentFragment &&
         parent._nodeType !== interfaces_1.NodeType.Element)
-        throw new DOMException_1.HierarchyRequestError(`Only document, document fragment and element nodes can contain child nodes. Parent node is ${parent.nodeName}.`);
+        throw new DOMException_1.HierarchyRequestError("Only document, document fragment and element nodes can contain child nodes. Parent node is " + parent.nodeName + ".");
     /**
      * 2. If node is a host-including inclusive ancestor of parent, throw a
      * "HierarchyRequestError" DOMException.
      */
-    if ((0, TreeAlgorithm_1.tree_isHostIncludingAncestorOf)(parent, node, true))
-        throw new DOMException_1.HierarchyRequestError(`The node to be inserted cannot be an ancestor of parent node. Node is ${node.nodeName}, parent node is ${parent.nodeName}.`);
+    if (TreeAlgorithm_1.tree_isHostIncludingAncestorOf(parent, node, true))
+        throw new DOMException_1.HierarchyRequestError("The node to be inserted cannot be an ancestor of parent node. Node is " + node.nodeName + ", parent node is " + parent.nodeName + ".");
     /**
      * 3. If child’s parent is not parent, then throw a "NotFoundError"
      * DOMException.
      */
     if (child._parent !== parent)
-        throw new DOMException_1.NotFoundError(`The reference child node cannot be found under parent node. Child node is ${child.nodeName}, parent node is ${parent.nodeName}.`);
+        throw new DOMException_1.NotFoundError("The reference child node cannot be found under parent node. Child node is " + child.nodeName + ", parent node is " + parent.nodeName + ".");
     /**
      * 4. If node is not a DocumentFragment, DocumentType, Element, Text,
      * ProcessingInstruction, or Comment node, throw a "HierarchyRequestError"
@@ -19029,7 +46712,7 @@ function mutation_replace(child, node, parent) {
         node._nodeType !== interfaces_1.NodeType.ProcessingInstruction &&
         node._nodeType !== interfaces_1.NodeType.CData &&
         node._nodeType !== interfaces_1.NodeType.Comment)
-        throw new DOMException_1.HierarchyRequestError(`Only document fragment, document type, element, text, processing instruction, cdata section or comment nodes can be inserted. Node is ${node.nodeName}.`);
+        throw new DOMException_1.HierarchyRequestError("Only document fragment, document type, element, text, processing instruction, cdata section or comment nodes can be inserted. Node is " + node.nodeName + ".");
     /**
      * 5. If either node is a Text node and parent is a document, or node is a
      * doctype and parent is not a document, throw a "HierarchyRequestError"
@@ -19037,10 +46720,10 @@ function mutation_replace(child, node, parent) {
      */
     if (node._nodeType === interfaces_1.NodeType.Text &&
         parent._nodeType === interfaces_1.NodeType.Document)
-        throw new DOMException_1.HierarchyRequestError(`Cannot insert a text node as a child of a document node. Node is ${node.nodeName}.`);
+        throw new DOMException_1.HierarchyRequestError("Cannot insert a text node as a child of a document node. Node is " + node.nodeName + ".");
     if (node._nodeType === interfaces_1.NodeType.DocumentType &&
         parent._nodeType !== interfaces_1.NodeType.Document)
-        throw new DOMException_1.HierarchyRequestError(`A document type node can only be inserted under a document node. Parent node is ${parent.nodeName}.`);
+        throw new DOMException_1.HierarchyRequestError("A document type node can only be inserted under a document node. Parent node is " + parent.nodeName + ".");
     /**
      * 6. If parent is a document, and any of the statements below, switched on
      * node, are true, throw a "HierarchyRequestError" DOMException.
@@ -19057,50 +46740,90 @@ function mutation_replace(child, node, parent) {
      */
     if (parent._nodeType === interfaces_1.NodeType.Document) {
         if (node._nodeType === interfaces_1.NodeType.DocumentFragment) {
-            let eleCount = 0;
-            for (const childNode of node._children) {
-                if (childNode._nodeType === interfaces_1.NodeType.Element)
-                    eleCount++;
-                else if (childNode._nodeType === interfaces_1.NodeType.Text)
-                    throw new DOMException_1.HierarchyRequestError(`Cannot insert text a node as a child of a document node. Node is ${childNode.nodeName}.`);
+            var eleCount = 0;
+            try {
+                for (var _e = __values(node._children), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var childNode = _f.value;
+                    if (childNode._nodeType === interfaces_1.NodeType.Element)
+                        eleCount++;
+                    else if (childNode._nodeType === interfaces_1.NodeType.Text)
+                        throw new DOMException_1.HierarchyRequestError("Cannot insert text a node as a child of a document node. Node is " + childNode.nodeName + ".");
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                }
+                finally { if (e_6) throw e_6.error; }
             }
             if (eleCount > 1) {
-                throw new DOMException_1.HierarchyRequestError(`A document node can only have one document element node. Document fragment to be inserted has ${eleCount} element nodes.`);
+                throw new DOMException_1.HierarchyRequestError("A document node can only have one document element node. Document fragment to be inserted has " + eleCount + " element nodes.");
             }
             else if (eleCount === 1) {
-                for (const ele of parent._children) {
-                    if (ele._nodeType === interfaces_1.NodeType.Element && ele !== child)
-                        throw new DOMException_1.HierarchyRequestError(`The document node already has a document element node.`);
+                try {
+                    for (var _g = __values(parent._children), _h = _g.next(); !_h.done; _h = _g.next()) {
+                        var ele = _h.value;
+                        if (ele._nodeType === interfaces_1.NodeType.Element && ele !== child)
+                            throw new DOMException_1.HierarchyRequestError("The document node already has a document element node.");
+                    }
                 }
-                let doctypeChild = child._nextSibling;
+                catch (e_7_1) { e_7 = { error: e_7_1 }; }
+                finally {
+                    try {
+                        if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                    }
+                    finally { if (e_7) throw e_7.error; }
+                }
+                var doctypeChild = child._nextSibling;
                 while (doctypeChild) {
                     if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType)
-                        throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node.`);
+                        throw new DOMException_1.HierarchyRequestError("Cannot insert an element node before a document type node.");
                     doctypeChild = doctypeChild._nextSibling;
                 }
             }
         }
         else if (node._nodeType === interfaces_1.NodeType.Element) {
-            for (const ele of parent._children) {
-                if (ele._nodeType === interfaces_1.NodeType.Element && ele !== child)
-                    throw new DOMException_1.HierarchyRequestError(`Document already has a document element node. Node is ${node.nodeName}.`);
+            try {
+                for (var _j = __values(parent._children), _k = _j.next(); !_k.done; _k = _j.next()) {
+                    var ele = _k.value;
+                    if (ele._nodeType === interfaces_1.NodeType.Element && ele !== child)
+                        throw new DOMException_1.HierarchyRequestError("Document already has a document element node. Node is " + node.nodeName + ".");
+                }
             }
-            let doctypeChild = child._nextSibling;
+            catch (e_8_1) { e_8 = { error: e_8_1 }; }
+            finally {
+                try {
+                    if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+                }
+                finally { if (e_8) throw e_8.error; }
+            }
+            var doctypeChild = child._nextSibling;
             while (doctypeChild) {
                 if (doctypeChild._nodeType === interfaces_1.NodeType.DocumentType)
-                    throw new DOMException_1.HierarchyRequestError(`Cannot insert an element node before a document type node. Node is ${node.nodeName}.`);
+                    throw new DOMException_1.HierarchyRequestError("Cannot insert an element node before a document type node. Node is " + node.nodeName + ".");
                 doctypeChild = doctypeChild._nextSibling;
             }
         }
         else if (node._nodeType === interfaces_1.NodeType.DocumentType) {
-            for (const ele of parent._children) {
-                if (ele._nodeType === interfaces_1.NodeType.DocumentType && ele !== child)
-                    throw new DOMException_1.HierarchyRequestError(`Document already has a document type node. Node is ${node.nodeName}.`);
+            try {
+                for (var _l = __values(parent._children), _m = _l.next(); !_m.done; _m = _l.next()) {
+                    var ele = _m.value;
+                    if (ele._nodeType === interfaces_1.NodeType.DocumentType && ele !== child)
+                        throw new DOMException_1.HierarchyRequestError("Document already has a document type node. Node is " + node.nodeName + ".");
+                }
             }
-            let elementChild = child._previousSibling;
+            catch (e_9_1) { e_9 = { error: e_9_1 }; }
+            finally {
+                try {
+                    if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+                }
+                finally { if (e_9) throw e_9.error; }
+            }
+            var elementChild = child._previousSibling;
             while (elementChild) {
                 if (elementChild._nodeType === interfaces_1.NodeType.Element)
-                    throw new DOMException_1.HierarchyRequestError(`Cannot insert a document type node before an element node. Node is ${node.nodeName}.`);
+                    throw new DOMException_1.HierarchyRequestError("Cannot insert a document type node before an element node. Node is " + node.nodeName + ".");
                 elementChild = elementChild._previousSibling;
             }
         }
@@ -19110,16 +46833,16 @@ function mutation_replace(child, node, parent) {
      * 8. If reference child is node, set it to node’s next sibling.
      * 8. Let previousSibling be child’s previous sibling.
      */
-    let referenceChild = child._nextSibling;
+    var referenceChild = child._nextSibling;
     if (referenceChild === node)
         referenceChild = node._nextSibling;
-    let previousSibling = child._previousSibling;
+    var previousSibling = child._previousSibling;
     /**
      * 10. Adopt node into parent’s node document.
      * 11. Let removedNodes be the empty list.
      */
-    (0, DocumentAlgorithm_1.document_adopt)(node, parent._nodeDocument);
-    const removedNodes = [];
+    DocumentAlgorithm_1.document_adopt(node, parent._nodeDocument);
+    var removedNodes = [];
     /**
      * 12. If child’s parent is not null, then:
      */
@@ -19136,7 +46859,7 @@ function mutation_replace(child, node, parent) {
      * 13. Let nodes be node’s children if node is a DocumentFragment node;
      * otherwise [node].
      */
-    let nodes = [];
+    var nodes = [];
     if (node._nodeType === interfaces_1.NodeType.DocumentFragment) {
         nodes = Array.from(node._children);
     }
@@ -19153,13 +46876,14 @@ function mutation_replace(child, node, parent) {
      * previousSibling, and reference child.
      */
     if (DOMImpl_1.dom.features.mutationObservers) {
-        (0, MutationObserverAlgorithm_1.observer_queueTreeMutationRecord)(parent, nodes, removedNodes, previousSibling, referenceChild);
+        MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, nodes, removedNodes, previousSibling, referenceChild);
     }
     /**
      * 16. Return child.
      */
     return child;
 }
+exports.mutation_replace = mutation_replace;
 /**
  * Replaces all nodes of a parent with the given node.
  *
@@ -19167,35 +46891,46 @@ function mutation_replace(child, node, parent) {
  * @param parent - parent node to receive node
  */
 function mutation_replaceAll(node, parent) {
+    var e_10, _a;
     /**
      * 1. If node is not null, adopt node into parent’s node document.
      */
     if (node !== null) {
-        (0, DocumentAlgorithm_1.document_adopt)(node, parent._nodeDocument);
+        DocumentAlgorithm_1.document_adopt(node, parent._nodeDocument);
     }
     /**
      * 2. Let removedNodes be parent’s children.
      */
-    const removedNodes = Array.from(parent._children);
+    var removedNodes = Array.from(parent._children);
     /**
      * 3. Let addedNodes be the empty list.
      * 4. If node is DocumentFragment node, then set addedNodes to node’s
      * children.
      * 5. Otherwise, if node is non-null, set addedNodes to [node].
      */
-    let addedNodes = [];
+    var addedNodes = [];
     if (node && node._nodeType === interfaces_1.NodeType.DocumentFragment) {
         addedNodes = Array.from(node._children);
     }
     else if (node !== null) {
         addedNodes.push(node);
     }
-    /**
-     * 6. Remove all parent’s children, in tree order, with the suppress
-     * observers flag set.
-     */
-    for (const childNode of removedNodes) {
-        mutation_remove(childNode, parent, true);
+    try {
+        /**
+         * 6. Remove all parent’s children, in tree order, with the suppress
+         * observers flag set.
+         */
+        for (var removedNodes_1 = __values(removedNodes), removedNodes_1_1 = removedNodes_1.next(); !removedNodes_1_1.done; removedNodes_1_1 = removedNodes_1.next()) {
+            var childNode = removedNodes_1_1.value;
+            mutation_remove(childNode, parent, true);
+        }
+    }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (removedNodes_1_1 && !removedNodes_1_1.done && (_a = removedNodes_1.return)) _a.call(removedNodes_1);
+        }
+        finally { if (e_10) throw e_10.error; }
     }
     /**
      * 7. If node is not null, then insert node into parent before null with the
@@ -19209,9 +46944,10 @@ function mutation_replaceAll(node, parent) {
      * null, and null.
      */
     if (DOMImpl_1.dom.features.mutationObservers) {
-        (0, MutationObserverAlgorithm_1.observer_queueTreeMutationRecord)(parent, addedNodes, removedNodes, null, null);
+        MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, addedNodes, removedNodes, null, null);
     }
 }
+exports.mutation_replaceAll = mutation_replaceAll;
 /**
  * Ensures pre-removal validity of a child node from a parent, then
  * removes it.
@@ -19227,10 +46963,11 @@ function mutation_preRemove(child, parent) {
      * 3. Return child.
      */
     if (child._parent !== parent)
-        throw new DOMException_1.NotFoundError(`The child node cannot be found under parent node. Child node is ${child.nodeName}, parent node is ${parent.nodeName}.`);
+        throw new DOMException_1.NotFoundError("The child node cannot be found under parent node. Child node is " + child.nodeName + ", parent node is " + parent.nodeName + ".");
     mutation_remove(child, parent);
     return child;
 }
+exports.mutation_preRemove = mutation_preRemove;
 /**
  * Removes a child node from its parent.
  *
@@ -19239,45 +46976,66 @@ function mutation_preRemove(child, parent) {
  * @param suppressObservers - whether to notify observers
  */
 function mutation_remove(node, parent, suppressObservers) {
+    var e_11, _a, e_12, _b, e_13, _c, e_14, _d;
     if (DOMImpl_1.dom.rangeList.size !== 0) {
         /**
          * 1. Let index be node’s index.
          */
-        const index = (0, TreeAlgorithm_1.tree_index)(node);
-        /**
-         * 2. For each live range whose start node is an inclusive descendant of
-         * node, set its start to (parent, index).
-         * 3. For each live range whose end node is an inclusive descendant of
-         * node, set its end to (parent, index).
-         */
-        for (const range of DOMImpl_1.dom.rangeList) {
-            if ((0, TreeAlgorithm_1.tree_isDescendantOf)(node, range._start[0], true)) {
-                range._start = [parent, index];
-            }
-            if ((0, TreeAlgorithm_1.tree_isDescendantOf)(node, range._end[0], true)) {
-                range._end = [parent, index];
-            }
-            if (range._start[0] === parent && range._start[1] > index) {
-                range._start[1]--;
-            }
-            if (range._end[0] === parent && range._end[1] > index) {
-                range._end[1]--;
+        var index = TreeAlgorithm_1.tree_index(node);
+        try {
+            /**
+             * 2. For each live range whose start node is an inclusive descendant of
+             * node, set its start to (parent, index).
+             * 3. For each live range whose end node is an inclusive descendant of
+             * node, set its end to (parent, index).
+             */
+            for (var _e = __values(DOMImpl_1.dom.rangeList), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var range = _f.value;
+                if (TreeAlgorithm_1.tree_isDescendantOf(node, range._start[0], true)) {
+                    range._start = [parent, index];
+                }
+                if (TreeAlgorithm_1.tree_isDescendantOf(node, range._end[0], true)) {
+                    range._end = [parent, index];
+                }
+                if (range._start[0] === parent && range._start[1] > index) {
+                    range._start[1]--;
+                }
+                if (range._end[0] === parent && range._end[1] > index) {
+                    range._end[1]--;
+                }
             }
         }
-        /**
-         * 4. For each live range whose start node is parent and start offset is
-         * greater than index, decrease its start offset by 1.
-         * 5. For each live range whose end node is parent and end offset is greater
-         * than index, decrease its end offset by 1.
-         */
-        for (const range of DOMImpl_1.dom.rangeList) {
-            if (range._start[0] === parent && range._start[1] > index) {
-                range._start[1] -= 1;
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
             }
-            if (range._end[0] === parent && range._end[1] > index) {
-                range._end[1] -= 1;
+            finally { if (e_11) throw e_11.error; }
+        }
+        try {
+            /**
+             * 4. For each live range whose start node is parent and start offset is
+             * greater than index, decrease its start offset by 1.
+             * 5. For each live range whose end node is parent and end offset is greater
+             * than index, decrease its end offset by 1.
+             */
+            for (var _g = __values(DOMImpl_1.dom.rangeList), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var range = _h.value;
+                if (range._start[0] === parent && range._start[1] > index) {
+                    range._start[1] -= 1;
+                }
+                if (range._end[0] === parent && range._end[1] > index) {
+                    range._end[1] -= 1;
+                }
             }
         }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
     }
     /**
      * 6. For each NodeIterator object iterator whose root’s node document is
@@ -19285,18 +47043,28 @@ function mutation_remove(node, parent, suppressObservers) {
      * and iterator.
      */
     if (DOMImpl_1.dom.features.steps) {
-        for (const iterator of (0, NodeIteratorAlgorithm_1.nodeIterator_iteratorList)()) {
-            if (iterator._root._nodeDocument === node._nodeDocument) {
-                (0, DOMAlgorithm_1.dom_runNodeIteratorPreRemovingSteps)(iterator, node);
+        try {
+            for (var _j = __values(NodeIteratorAlgorithm_1.nodeIterator_iteratorList()), _k = _j.next(); !_k.done; _k = _j.next()) {
+                var iterator = _k.value;
+                if (iterator._root._nodeDocument === node._nodeDocument) {
+                    DOMAlgorithm_1.dom_runNodeIteratorPreRemovingSteps(iterator, node);
+                }
             }
         }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (_k && !_k.done && (_c = _j.return)) _c.call(_j);
+            }
+            finally { if (e_13) throw e_13.error; }
+        }
     }
     /**
      * 7. Let oldPreviousSibling be node’s previous sibling.
      * 8. Let oldNextSibling be node’s next sibling.
      */
-    const oldPreviousSibling = node._previousSibling;
-    const oldNextSibling = node._nextSibling;
+    var oldPreviousSibling = node._previousSibling;
+    var oldNextSibling = node._nextSibling;
     // set document element node
     if (util_1.Guard.isDocumentNode(parent) && util_1.Guard.isElementNode(node)) {
         parent._documentElement = null;
@@ -19307,8 +47075,8 @@ function mutation_remove(node, parent, suppressObservers) {
     node._parent = null;
     parent._children.delete(node);
     // assign siblings and children for quick lookups
-    const prev = node._previousSibling;
-    const next = node._nextSibling;
+    var prev = node._previousSibling;
+    var next = node._nextSibling;
     node._previousSibling = null;
     node._nextSibling = null;
     if (prev)
@@ -19324,8 +47092,8 @@ function mutation_remove(node, parent, suppressObservers) {
      * slot.
      */
     if (DOMImpl_1.dom.features.slots) {
-        if (util_1.Guard.isSlotable(node) && node._assignedSlot !== null && (0, ShadowTreeAlgorithm_1.shadowTree_isAssigned)(node)) {
-            (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotables)(node._assignedSlot);
+        if (util_1.Guard.isSlotable(node) && node._assignedSlot !== null && ShadowTreeAlgorithm_1.shadowTree_isAssigned(node)) {
+            ShadowTreeAlgorithm_1.shadowTree_assignSlotables(node._assignedSlot);
         }
     }
     /**
@@ -19334,9 +47102,9 @@ function mutation_remove(node, parent, suppressObservers) {
      * parent.
      */
     if (DOMImpl_1.dom.features.slots) {
-        if (util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(parent)) &&
-            util_1.Guard.isSlot(parent) && (0, util_2.isEmpty)(parent._assignedNodes)) {
-            (0, ShadowTreeAlgorithm_1.shadowTree_signalASlotChange)(parent);
+        if (util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(parent)) &&
+            util_1.Guard.isSlot(parent) && util_2.isEmpty(parent._assignedNodes)) {
+            ShadowTreeAlgorithm_1.shadowTree_signalASlotChange(parent);
         }
     }
     /**
@@ -19345,17 +47113,17 @@ function mutation_remove(node, parent, suppressObservers) {
      * 12.2. Run assign slotables for a tree with node.
      */
     if (DOMImpl_1.dom.features.slots) {
-        const descendant = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(node, true, false, (e) => util_1.Guard.isSlot(e));
-        if (descendant !== null) {
-            (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree)((0, TreeAlgorithm_1.tree_rootNode)(parent));
-            (0, ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree)(node);
+        var descendant_1 = TreeAlgorithm_1.tree_getFirstDescendantNode(node, true, false, function (e) { return util_1.Guard.isSlot(e); });
+        if (descendant_1 !== null) {
+            ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(TreeAlgorithm_1.tree_rootNode(parent));
+            ShadowTreeAlgorithm_1.shadowTree_assignSlotablesForATree(node);
         }
     }
     /**
      * 13. Run the removing steps with node and parent.
      */
     if (DOMImpl_1.dom.features.steps) {
-        (0, DOMAlgorithm_1.dom_runRemovingSteps)(node, parent);
+        DOMAlgorithm_1.dom_runRemovingSteps(node, parent);
     }
     /**
      * 14. If node is custom, then enqueue a custom element callback
@@ -19364,20 +47132,20 @@ function mutation_remove(node, parent, suppressObservers) {
      */
     if (DOMImpl_1.dom.features.customElements) {
         if (util_1.Guard.isCustomElementNode(node)) {
-            (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(node, "disconnectedCallback", []);
+            CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(node, "disconnectedCallback", []);
         }
     }
     /**
      * 15. For each shadow-including descendant descendant of node,
      * in shadow-including tree order, then:
      */
-    let descendant = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(node, false, true);
+    var descendant = TreeAlgorithm_1.tree_getFirstDescendantNode(node, false, true);
     while (descendant !== null) {
         /**
          * 15.1. Run the removing steps with descendant.
          */
         if (DOMImpl_1.dom.features.steps) {
-            (0, DOMAlgorithm_1.dom_runRemovingSteps)(descendant, node);
+            DOMAlgorithm_1.dom_runRemovingSteps(descendant, node);
         }
         /**
          * 15.2. If descendant is custom, then enqueue a custom element
@@ -19386,10 +47154,10 @@ function mutation_remove(node, parent, suppressObservers) {
          */
         if (DOMImpl_1.dom.features.customElements) {
             if (util_1.Guard.isCustomElementNode(descendant)) {
-                (0, CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction)(descendant, "disconnectedCallback", []);
+                CustomElementAlgorithm_1.customElement_enqueueACustomElementCallbackReaction(descendant, "disconnectedCallback", []);
             }
         }
-        descendant = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(node, descendant, false, true);
+        descendant = TreeAlgorithm_1.tree_getNextDescendantNode(node, descendant, false, true);
     }
     /**
      * 16. For each inclusive ancestor inclusiveAncestor of parent, and
@@ -19401,18 +47169,28 @@ function mutation_remove(node, parent, suppressObservers) {
      * observer list.
      */
     if (DOMImpl_1.dom.features.mutationObservers) {
-        let inclusiveAncestor = (0, TreeAlgorithm_1.tree_getFirstAncestorNode)(parent, true);
+        var inclusiveAncestor = TreeAlgorithm_1.tree_getFirstAncestorNode(parent, true);
         while (inclusiveAncestor !== null) {
-            for (const registered of inclusiveAncestor._registeredObserverList) {
-                if (registered.options.subtree) {
-                    node._registeredObserverList.push({
-                        observer: registered.observer,
-                        options: registered.options,
-                        source: registered
-                    });
+            try {
+                for (var _l = (e_14 = void 0, __values(inclusiveAncestor._registeredObserverList)), _m = _l.next(); !_m.done; _m = _l.next()) {
+                    var registered = _m.value;
+                    if (registered.options.subtree) {
+                        node._registeredObserverList.push({
+                            observer: registered.observer,
+                            options: registered.options,
+                            source: registered
+                        });
+                    }
                 }
             }
-            inclusiveAncestor = (0, TreeAlgorithm_1.tree_getNextAncestorNode)(parent, inclusiveAncestor, true);
+            catch (e_14_1) { e_14 = { error: e_14_1 }; }
+            finally {
+                try {
+                    if (_m && !_m.done && (_d = _l.return)) _d.call(_l);
+                }
+                finally { if (e_14) throw e_14.error; }
+            }
+            inclusiveAncestor = TreeAlgorithm_1.tree_getNextAncestorNode(parent, inclusiveAncestor, true);
         }
     }
     /**
@@ -19422,7 +47200,7 @@ function mutation_remove(node, parent, suppressObservers) {
      */
     if (DOMImpl_1.dom.features.mutationObservers) {
         if (!suppressObservers) {
-            (0, MutationObserverAlgorithm_1.observer_queueTreeMutationRecord)(parent, [], [node], oldPreviousSibling, oldNextSibling);
+            MutationObserverAlgorithm_1.observer_queueTreeMutationRecord(parent, [], [node], oldPreviousSibling, oldNextSibling);
         }
     }
     /**
@@ -19431,31 +47209,54 @@ function mutation_remove(node, parent, suppressObservers) {
      */
     if (DOMImpl_1.dom.features.steps) {
         if (util_1.Guard.isTextNode(node)) {
-            (0, DOMAlgorithm_1.dom_runChildTextContentChangeSteps)(parent);
+            DOMAlgorithm_1.dom_runChildTextContentChangeSteps(parent);
         }
     }
 }
+exports.mutation_remove = mutation_remove;
 //# sourceMappingURL=MutationAlgorithm.js.map
 
 /***/ }),
 
 /***/ 78157:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.observer_queueAMutationObserverMicrotask = observer_queueAMutationObserverMicrotask;
-exports.observer_notifyMutationObservers = observer_notifyMutationObservers;
-exports.observer_queueMutationRecord = observer_queueMutationRecord;
-exports.observer_queueTreeMutationRecord = observer_queueTreeMutationRecord;
-exports.observer_queueAttributeMutationRecord = observer_queueAttributeMutationRecord;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const util_1 = __nccwpck_require__(65282);
-const infra_1 = __nccwpck_require__(84251);
-const CreateAlgorithm_1 = __nccwpck_require__(57339);
-const TreeAlgorithm_1 = __nccwpck_require__(16620);
-const EventAlgorithm_1 = __nccwpck_require__(28217);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var util_1 = __nccwpck_require__(65282);
+var infra_1 = __nccwpck_require__(84251);
+var CreateAlgorithm_1 = __nccwpck_require__(57339);
+var TreeAlgorithm_1 = __nccwpck_require__(16620);
+var EventAlgorithm_1 = __nccwpck_require__(28217);
 /**
  * Queues a mutation observer microtask to the surrounding agent’s mutation
  * observers.
@@ -19467,44 +47268,43 @@ function observer_queueAMutationObserverMicrotask() {
      * 2. Set the surrounding agent’s mutation observer microtask queued to true.
      * 3. Queue a microtask to notify mutation observers.
      */
-    const window = DOMImpl_1.dom.window;
+    var window = DOMImpl_1.dom.window;
     if (window._mutationObserverMicrotaskQueued)
         return;
     window._mutationObserverMicrotaskQueued = true;
-    Promise.resolve().then(() => { observer_notifyMutationObservers(); });
+    Promise.resolve().then(function () { observer_notifyMutationObservers(); });
 }
+exports.observer_queueAMutationObserverMicrotask = observer_queueAMutationObserverMicrotask;
 /**
  * Notifies the surrounding agent’s mutation observers.
  */
 function observer_notifyMutationObservers() {
+    var e_1, _a, e_2, _b;
     /**
      * 1. Set the surrounding agent’s mutation observer microtask queued to false.
      * 2. Let notifySet be a clone of the surrounding agent’s mutation observers.
      * 3. Let signalSet be a clone of the surrounding agent’s signal slots.
      * 4. Empty the surrounding agent’s signal slots.
      */
-    const window = DOMImpl_1.dom.window;
+    var window = DOMImpl_1.dom.window;
     window._mutationObserverMicrotaskQueued = false;
-    const notifySet = infra_1.set.clone(window._mutationObservers);
-    const signalSet = infra_1.set.clone(window._signalSlots);
+    var notifySet = infra_1.set.clone(window._mutationObservers);
+    var signalSet = infra_1.set.clone(window._signalSlots);
     infra_1.set.empty(window._signalSlots);
-    /**
-     * 5. For each mo of notifySet:
-     */
-    for (const mo of notifySet) {
+    var _loop_1 = function (mo) {
         /**
          * 5.1. Let records be a clone of mo’s record queue.
          * 5.2. Empty mo’s record queue.
          */
-        const records = infra_1.list.clone(mo._recordQueue);
+        var records = infra_1.list.clone(mo._recordQueue);
         infra_1.list.empty(mo._recordQueue);
         /**
          * 5.3. For each node of mo’s node list, remove all transient registered
          * observers whose observer is mo from node’s registered observer list.
          */
-        for (let i = 0; i < mo._nodeList.length; i++) {
-            const node = mo._nodeList[i];
-            infra_1.list.remove(node._registeredObserverList, (observer) => {
+        for (var i = 0; i < mo._nodeList.length; i++) {
+            var node = mo._nodeList[i];
+            infra_1.list.remove(node._registeredObserverList, function (observer) {
                 return util_1.Guard.isTransientRegisteredObserver(observer) && observer.observer === mo;
             });
         }
@@ -19520,17 +47320,44 @@ function observer_notifyMutationObservers() {
                 // TODO: Report the exception
             }
         }
+    };
+    try {
+        /**
+         * 5. For each mo of notifySet:
+         */
+        for (var notifySet_1 = __values(notifySet), notifySet_1_1 = notifySet_1.next(); !notifySet_1_1.done; notifySet_1_1 = notifySet_1.next()) {
+            var mo = notifySet_1_1.value;
+            _loop_1(mo);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (notifySet_1_1 && !notifySet_1_1.done && (_a = notifySet_1.return)) _a.call(notifySet_1);
+        }
+        finally { if (e_1) throw e_1.error; }
     }
     /**
      * 6. For each slot of signalSet, fire an event named slotchange, with its
      * bubbles attribute set to true, at slot.
      */
     if (DOMImpl_1.dom.features.slots) {
-        for (const slot of signalSet) {
-            (0, EventAlgorithm_1.event_fireAnEvent)("slotchange", slot, undefined, { bubbles: true });
+        try {
+            for (var signalSet_1 = __values(signalSet), signalSet_1_1 = signalSet_1.next(); !signalSet_1_1.done; signalSet_1_1 = signalSet_1.next()) {
+                var slot = signalSet_1_1.value;
+                EventAlgorithm_1.event_fireAnEvent("slotchange", slot, undefined, { bubbles: true });
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (signalSet_1_1 && !signalSet_1_1.done && (_b = signalSet_1.return)) _b.call(signalSet_1);
+            }
+            finally { if (e_2) throw e_2.error; }
         }
     }
 }
+exports.observer_notifyMutationObservers = observer_notifyMutationObservers;
 /**
  * Queues a mutation record of the given type for target.
  *
@@ -19545,17 +47372,18 @@ function observer_notifyMutationObservers() {
  * @param nextSibling - next sibling of target before mutation
  */
 function observer_queueMutationRecord(type, target, name, namespace, oldValue, addedNodes, removedNodes, previousSibling, nextSibling) {
+    var e_3, _a;
     /**
      * 1. Let interestedObservers be an empty map.
      * 2. Let nodes be the inclusive ancestors of target.
      * 3. For each node in nodes, and then for each registered of node’s
      * registered observer list:
      */
-    const interestedObservers = new Map();
-    let node = (0, TreeAlgorithm_1.tree_getFirstAncestorNode)(target, true);
+    var interestedObservers = new Map();
+    var node = TreeAlgorithm_1.tree_getFirstAncestorNode(target, true);
     while (node !== null) {
-        for (let i = 0; i < node._registeredObserverList.length; i++) {
-            const registered = node._registeredObserverList[i];
+        for (var i = 0; i < node._registeredObserverList.length; i++) {
+            var registered = node._registeredObserverList[i];
             /**
              * 3.1. Let options be registered’s options.
              * 3.2. If none of the following are true
@@ -19567,7 +47395,7 @@ function observer_queueMutationRecord(type, target, name, namespace, oldValue, a
              * - type is "characterData" and options’s characterData is not true
              * - type is "childList" and options’s childList is false
              */
-            const options = registered.options;
+            var options = registered.options;
             if (node !== target && !options.subtree)
                 continue;
             if (type === "attributes" && !options.attributes)
@@ -19589,7 +47417,7 @@ function observer_queueMutationRecord(type, target, name, namespace, oldValue, a
              * characterDataOldValue is true, then set interestedObservers[mo]
              * to oldValue.
              */
-            const mo = registered.observer;
+            var mo = registered.observer;
             if (!interestedObservers.has(mo)) {
                 interestedObservers.set(mo, null);
             }
@@ -19598,30 +47426,41 @@ function observer_queueMutationRecord(type, target, name, namespace, oldValue, a
                 interestedObservers.set(mo, oldValue);
             }
         }
-        node = (0, TreeAlgorithm_1.tree_getNextAncestorNode)(target, node, true);
+        node = TreeAlgorithm_1.tree_getNextAncestorNode(target, node, true);
     }
-    /**
-     * 4. For each observer → mappedOldValue of interestedObservers:
-     */
-    for (const [observer, mappedOldValue] of interestedObservers) {
+    try {
         /**
-         * 4.1. Let record be a new MutationRecord object with its type set to
-         * type, target set to target, attributeName set to name,
-         * attributeNamespace set to namespace, oldValue set to mappedOldValue,
-         * addedNodes set to addedNodes, removedNodes set to removedNodes,
-         * previousSibling set to previousSibling, and nextSibling set to
-         * nextSibling.
-         * 4.2. Enqueue record to observer’s record queue.
+         * 4. For each observer → mappedOldValue of interestedObservers:
          */
-        const record = (0, CreateAlgorithm_1.create_mutationRecord)(type, target, (0, CreateAlgorithm_1.create_nodeListStatic)(target, addedNodes), (0, CreateAlgorithm_1.create_nodeListStatic)(target, removedNodes), previousSibling, nextSibling, name, namespace, mappedOldValue);
-        const queue = observer._recordQueue;
-        queue.push(record);
+        for (var interestedObservers_1 = __values(interestedObservers), interestedObservers_1_1 = interestedObservers_1.next(); !interestedObservers_1_1.done; interestedObservers_1_1 = interestedObservers_1.next()) {
+            var _b = __read(interestedObservers_1_1.value, 2), observer = _b[0], mappedOldValue = _b[1];
+            /**
+             * 4.1. Let record be a new MutationRecord object with its type set to
+             * type, target set to target, attributeName set to name,
+             * attributeNamespace set to namespace, oldValue set to mappedOldValue,
+             * addedNodes set to addedNodes, removedNodes set to removedNodes,
+             * previousSibling set to previousSibling, and nextSibling set to
+             * nextSibling.
+             * 4.2. Enqueue record to observer’s record queue.
+             */
+            var record = CreateAlgorithm_1.create_mutationRecord(type, target, CreateAlgorithm_1.create_nodeListStatic(target, addedNodes), CreateAlgorithm_1.create_nodeListStatic(target, removedNodes), previousSibling, nextSibling, name, namespace, mappedOldValue);
+            var queue = observer._recordQueue;
+            queue.push(record);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (interestedObservers_1_1 && !interestedObservers_1_1.done && (_a = interestedObservers_1.return)) _a.call(interestedObservers_1);
+        }
+        finally { if (e_3) throw e_3.error; }
     }
     /**
      * 5. Queue a mutation observer microtask.
      */
     observer_queueAMutationObserverMicrotask();
 }
+exports.observer_queueMutationRecord = observer_queueMutationRecord;
 /**
  * Queues a tree mutation record for target.
  *
@@ -19640,6 +47479,7 @@ function observer_queueTreeMutationRecord(target, addedNodes, removedNodes, prev
      */
     observer_queueMutationRecord("childList", target, null, null, null, addedNodes, removedNodes, previousSibling, nextSibling);
 }
+exports.observer_queueTreeMutationRecord = observer_queueTreeMutationRecord;
 /**
  * Queues an attribute mutation record for target.
  *
@@ -19656,6 +47496,7 @@ function observer_queueAttributeMutationRecord(target, name, namespace, oldValue
      */
     observer_queueMutationRecord("attributes", target, name, namespace, oldValue, [], [], null, null);
 }
+exports.observer_queueAttributeMutationRecord = observer_queueAttributeMutationRecord;
 //# sourceMappingURL=MutationObserverAlgorithm.js.map
 
 /***/ }),
@@ -19666,12 +47507,9 @@ function observer_queueAttributeMutationRecord(target, name, namespace, oldValue
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.namespace_validate = namespace_validate;
-exports.namespace_validateAndExtract = namespace_validateAndExtract;
-exports.namespace_extractQName = namespace_extractQName;
-const DOMException_1 = __nccwpck_require__(13166);
-const infra_1 = __nccwpck_require__(84251);
-const XMLAlgorithm_1 = __nccwpck_require__(57030);
+var DOMException_1 = __nccwpck_require__(13166);
+var infra_1 = __nccwpck_require__(84251);
+var XMLAlgorithm_1 = __nccwpck_require__(57030);
 /**
  * Validates the given qualified name.
  *
@@ -19683,11 +47521,12 @@ function namespace_validate(qualifiedName) {
      * DOMException if qualifiedName does not match the Name or QName
      * production.
      */
-    if (!(0, XMLAlgorithm_1.xml_isName)(qualifiedName))
-        throw new DOMException_1.InvalidCharacterError(`Invalid XML name: ${qualifiedName}`);
-    if (!(0, XMLAlgorithm_1.xml_isQName)(qualifiedName))
-        throw new DOMException_1.InvalidCharacterError(`Invalid XML qualified name: ${qualifiedName}.`);
+    if (!XMLAlgorithm_1.xml_isName(qualifiedName))
+        throw new DOMException_1.InvalidCharacterError("Invalid XML name: " + qualifiedName);
+    if (!XMLAlgorithm_1.xml_isQName(qualifiedName))
+        throw new DOMException_1.InvalidCharacterError("Invalid XML qualified name: " + qualifiedName + ".");
 }
+exports.namespace_validate = namespace_validate;
 /**
  * Validates and extracts a namespace, prefix and localName from the
  * given namespace and qualified name.
@@ -19719,21 +47558,22 @@ function namespace_validateAndExtract(namespace, qualifiedName) {
     if (!namespace)
         namespace = null;
     namespace_validate(qualifiedName);
-    const parts = qualifiedName.split(':');
-    const prefix = (parts.length === 2 ? parts[0] : null);
-    const localName = (parts.length === 2 ? parts[1] : qualifiedName);
+    var parts = qualifiedName.split(':');
+    var prefix = (parts.length === 2 ? parts[0] : null);
+    var localName = (parts.length === 2 ? parts[1] : qualifiedName);
     if (prefix && namespace === null)
         throw new DOMException_1.NamespaceError("Qualified name includes a prefix but the namespace is null.");
     if (prefix === "xml" && namespace !== infra_1.namespace.XML)
-        throw new DOMException_1.NamespaceError(`Qualified name includes the "xml" prefix but the namespace is not the XML namespace.`);
+        throw new DOMException_1.NamespaceError("Qualified name includes the \"xml\" prefix but the namespace is not the XML namespace.");
     if (namespace !== infra_1.namespace.XMLNS &&
         (prefix === "xmlns" || qualifiedName === "xmlns"))
-        throw new DOMException_1.NamespaceError(`Qualified name includes the "xmlns" prefix but the namespace is not the XMLNS namespace.`);
+        throw new DOMException_1.NamespaceError("Qualified name includes the \"xmlns\" prefix but the namespace is not the XMLNS namespace.");
     if (namespace === infra_1.namespace.XMLNS &&
         (prefix !== "xmlns" && qualifiedName !== "xmlns"))
-        throw new DOMException_1.NamespaceError(`Qualified name does not include the "xmlns" prefix but the namespace is the XMLNS namespace.`);
+        throw new DOMException_1.NamespaceError("Qualified name does not include the \"xmlns\" prefix but the namespace is the XMLNS namespace.");
     return [namespace, prefix, localName];
 }
+exports.namespace_validateAndExtract = namespace_validateAndExtract;
 /**
  * Extracts a prefix and localName from the given qualified name.
  *
@@ -19743,37 +47583,41 @@ function namespace_validateAndExtract(namespace, qualifiedName) {
  */
 function namespace_extractQName(qualifiedName) {
     namespace_validate(qualifiedName);
-    const parts = qualifiedName.split(':');
-    const prefix = (parts.length === 2 ? parts[0] : null);
-    const localName = (parts.length === 2 ? parts[1] : qualifiedName);
+    var parts = qualifiedName.split(':');
+    var prefix = (parts.length === 2 ? parts[0] : null);
+    var localName = (parts.length === 2 ? parts[1] : qualifiedName);
     return [prefix, localName];
 }
+exports.namespace_extractQName = namespace_extractQName;
 //# sourceMappingURL=NamespaceAlgorithm.js.map
 
 /***/ }),
 
 /***/ 74924:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.node_stringReplaceAll = node_stringReplaceAll;
-exports.node_clone = node_clone;
-exports.node_equals = node_equals;
-exports.node_listOfElementsWithQualifiedName = node_listOfElementsWithQualifiedName;
-exports.node_listOfElementsWithNamespace = node_listOfElementsWithNamespace;
-exports.node_listOfElementsWithClassNames = node_listOfElementsWithClassNames;
-exports.node_locateANamespacePrefix = node_locateANamespacePrefix;
-exports.node_locateANamespace = node_locateANamespace;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const util_1 = __nccwpck_require__(65282);
-const infra_1 = __nccwpck_require__(84251);
-const CreateAlgorithm_1 = __nccwpck_require__(57339);
-const OrderedSetAlgorithm_1 = __nccwpck_require__(53670);
-const DOMAlgorithm_1 = __nccwpck_require__(9628);
-const MutationAlgorithm_1 = __nccwpck_require__(45463);
-const ElementAlgorithm_1 = __nccwpck_require__(51849);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var util_1 = __nccwpck_require__(65282);
+var infra_1 = __nccwpck_require__(84251);
+var CreateAlgorithm_1 = __nccwpck_require__(57339);
+var OrderedSetAlgorithm_1 = __nccwpck_require__(53670);
+var DOMAlgorithm_1 = __nccwpck_require__(9628);
+var MutationAlgorithm_1 = __nccwpck_require__(45463);
+var ElementAlgorithm_1 = __nccwpck_require__(51849);
 /**
  * Replaces the contents of the given node with a single text node.
  *
@@ -19787,12 +47631,13 @@ function node_stringReplaceAll(str, parent) {
      * whose data is string and node document is parent’s node document.
      * 3. Replace all with node within parent.
      */
-    let node = null;
+    var node = null;
     if (str !== '') {
-        node = (0, CreateAlgorithm_1.create_text)(parent._nodeDocument, str);
+        node = CreateAlgorithm_1.create_text(parent._nodeDocument, str);
     }
-    (0, MutationAlgorithm_1.mutation_replaceAll)(node, parent);
+    MutationAlgorithm_1.mutation_replaceAll(node, parent);
 }
+exports.node_stringReplaceAll = node_stringReplaceAll;
 /**
  * Clones a node.
  *
@@ -19800,13 +47645,16 @@ function node_stringReplaceAll(str, parent) {
  * @param document - the document to own the cloned node
  * @param cloneChildrenFlag - whether to clone node's children
  */
-function node_clone(node, document = null, cloneChildrenFlag = false) {
+function node_clone(node, document, cloneChildrenFlag) {
+    var e_1, _a, e_2, _b;
+    if (document === void 0) { document = null; }
+    if (cloneChildrenFlag === void 0) { cloneChildrenFlag = false; }
     /**
      * 1. If document is not given, let document be node’s node document.
      */
     if (document === null)
         document = node._nodeDocument;
-    let copy;
+    var copy;
     if (util_1.Guard.isElementNode(node)) {
         /**
          * 2. If node is an element, then:
@@ -19817,10 +47665,20 @@ function node_clone(node, document = null, cloneChildrenFlag = false) {
          * 2.2.1. Let copyAttribute be a clone of attribute.
          * 2.2.2. Append copyAttribute to copy.
          */
-        copy = (0, ElementAlgorithm_1.element_createAnElement)(document, node._localName, node._namespace, node._namespacePrefix, node._is, false);
-        for (const attribute of node._attributeList) {
-            const copyAttribute = node_clone(attribute, document);
-            (0, ElementAlgorithm_1.element_append)(copyAttribute, copy);
+        copy = ElementAlgorithm_1.element_createAnElement(document, node._localName, node._namespace, node._namespacePrefix, node._is, false);
+        try {
+            for (var _c = __values(node._attributeList), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var attribute = _d.value;
+                var copyAttribute = node_clone(attribute, document);
+                ElementAlgorithm_1.element_append(copyAttribute, copy);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
     }
     else {
@@ -19843,7 +47701,7 @@ function node_clone(node, document = null, cloneChildrenFlag = false) {
          * - Any other node
          */
         if (util_1.Guard.isDocumentNode(node)) {
-            const doc = (0, CreateAlgorithm_1.create_document)();
+            var doc = CreateAlgorithm_1.create_document();
             doc._encoding = node._encoding;
             doc._contentType = node._contentType;
             doc._URL = node._URL;
@@ -19853,30 +47711,30 @@ function node_clone(node, document = null, cloneChildrenFlag = false) {
             copy = doc;
         }
         else if (util_1.Guard.isDocumentTypeNode(node)) {
-            const doctype = (0, CreateAlgorithm_1.create_documentType)(document, node._name, node._publicId, node._systemId);
+            var doctype = CreateAlgorithm_1.create_documentType(document, node._name, node._publicId, node._systemId);
             copy = doctype;
         }
         else if (util_1.Guard.isAttrNode(node)) {
-            const attr = (0, CreateAlgorithm_1.create_attr)(document, node.localName);
+            var attr = CreateAlgorithm_1.create_attr(document, node.localName);
             attr._namespace = node._namespace;
             attr._namespacePrefix = node._namespacePrefix;
             attr._value = node._value;
             copy = attr;
         }
         else if (util_1.Guard.isExclusiveTextNode(node)) {
-            copy = (0, CreateAlgorithm_1.create_text)(document, node._data);
+            copy = CreateAlgorithm_1.create_text(document, node._data);
         }
         else if (util_1.Guard.isCDATASectionNode(node)) {
-            copy = (0, CreateAlgorithm_1.create_cdataSection)(document, node._data);
+            copy = CreateAlgorithm_1.create_cdataSection(document, node._data);
         }
         else if (util_1.Guard.isCommentNode(node)) {
-            copy = (0, CreateAlgorithm_1.create_comment)(document, node._data);
+            copy = CreateAlgorithm_1.create_comment(document, node._data);
         }
         else if (util_1.Guard.isProcessingInstructionNode(node)) {
-            copy = (0, CreateAlgorithm_1.create_processingInstruction)(document, node._target, node._data);
+            copy = CreateAlgorithm_1.create_processingInstruction(document, node._target, node._data);
         }
         else if (util_1.Guard.isDocumentFragmentNode(node)) {
-            copy = (0, CreateAlgorithm_1.create_documentFragment)(document);
+            copy = CreateAlgorithm_1.create_documentFragment(document);
         }
         else {
             copy = Object.create(node);
@@ -19899,7 +47757,7 @@ function node_clone(node, document = null, cloneChildrenFlag = false) {
      * if set, as parameters.
      */
     if (DOMImpl_1.dom.features.steps) {
-        (0, DOMAlgorithm_1.dom_runCloningSteps)(copy, node, document, cloneChildrenFlag);
+        DOMAlgorithm_1.dom_runCloningSteps(copy, node, document, cloneChildrenFlag);
     }
     /**
      * 6. If the clone children flag is set, clone all the children of node and
@@ -19907,9 +47765,19 @@ function node_clone(node, document = null, cloneChildrenFlag = false) {
      * flag being set.
      */
     if (cloneChildrenFlag) {
-        for (const child of node._children) {
-            const childCopy = node_clone(child, document, true);
-            (0, MutationAlgorithm_1.mutation_append)(childCopy, copy);
+        try {
+            for (var _e = __values(node._children), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var child = _f.value;
+                var childCopy = node_clone(child, document, true);
+                MutationAlgorithm_1.mutation_append(childCopy, copy);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_2) throw e_2.error; }
         }
     }
     /**
@@ -19917,6 +47785,7 @@ function node_clone(node, document = null, cloneChildrenFlag = false) {
      */
     return copy;
 }
+exports.node_clone = node_clone;
 /**
  * Determines if two nodes can be considered equal.
  *
@@ -19924,6 +47793,7 @@ function node_clone(node, document = null, cloneChildrenFlag = false) {
  * @param b - node to compare
  */
 function node_equals(a, b) {
+    var e_3, _a, e_4, _b;
     /**
      * 1. A and B’s nodeType attribute value is identical.
      */
@@ -19972,16 +47842,36 @@ function node_equals(a, b) {
      * that equals an attribute in B’s attribute list.
      */
     if (util_1.Guard.isElementNode(a) && util_1.Guard.isElementNode(b)) {
-        const attrMap = {};
-        for (const attrA of a._attributeList) {
-            attrMap[attrA._localName] = attrA;
+        var attrMap = {};
+        try {
+            for (var _c = __values(a._attributeList), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var attrA = _d.value;
+                attrMap[attrA._localName] = attrA;
+            }
         }
-        for (const attrB of b._attributeList) {
-            const attrA = attrMap[attrB._localName];
-            if (!attrA)
-                return false;
-            if (!node_equals(attrA, attrB))
-                return false;
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        try {
+            for (var _e = __values(b._attributeList), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var attrB = _f.value;
+                var attrA = attrMap[attrB._localName];
+                if (!attrA)
+                    return false;
+                if (!node_equals(attrA, attrB))
+                    return false;
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_4) throw e_4.error; }
         }
     }
     /**
@@ -19990,13 +47880,13 @@ function node_equals(a, b) {
      */
     if (a._children.size !== b._children.size)
         return false;
-    const itA = a._children[Symbol.iterator]();
-    const itB = b._children[Symbol.iterator]();
-    let resultA = itA.next();
-    let resultB = itB.next();
+    var itA = a._children[Symbol.iterator]();
+    var itB = b._children[Symbol.iterator]();
+    var resultA = itA.next();
+    var resultB = itB.next();
     while (!resultA.done && !resultB.done) {
-        const child1 = resultA.value;
-        const child2 = resultB.value;
+        var child1 = resultA.value;
+        var child2 = resultB.value;
         if (!node_equals(child1, child2))
             return false;
         resultA = itA.next();
@@ -20004,6 +47894,7 @@ function node_equals(a, b) {
     }
     return true;
 }
+exports.node_equals = node_equals;
 /**
  * Returns a collection of elements with the given qualified name which are
  * descendants of the given root node.
@@ -20027,10 +47918,10 @@ function node_listOfElementsWithQualifiedName(qualifiedName, root) {
      * matches descendant elements whose qualified name is qualifiedName.
      */
     if (qualifiedName === "*") {
-        return (0, CreateAlgorithm_1.create_htmlCollection)(root);
+        return CreateAlgorithm_1.create_htmlCollection(root);
     }
     else if (root._nodeDocument._type === "html") {
-        return (0, CreateAlgorithm_1.create_htmlCollection)(root, function (ele) {
+        return CreateAlgorithm_1.create_htmlCollection(root, function (ele) {
             if (ele._namespace === infra_1.namespace.HTML &&
                 ele._qualifiedName === qualifiedName.toLowerCase()) {
                 return true;
@@ -20045,11 +47936,12 @@ function node_listOfElementsWithQualifiedName(qualifiedName, root) {
         });
     }
     else {
-        return (0, CreateAlgorithm_1.create_htmlCollection)(root, function (ele) {
+        return CreateAlgorithm_1.create_htmlCollection(root, function (ele) {
             return (ele._qualifiedName === qualifiedName);
         });
     }
 }
+exports.node_listOfElementsWithQualifiedName = node_listOfElementsWithQualifiedName;
 /**
  * Returns a collection of elements with the given namespace which are
  * descendants of the given root node.
@@ -20077,24 +47969,25 @@ function node_listOfElementsWithNamespace(namespace, localName, root) {
     if (namespace === '')
         namespace = null;
     if (namespace === "*" && localName === "*") {
-        return (0, CreateAlgorithm_1.create_htmlCollection)(root);
+        return CreateAlgorithm_1.create_htmlCollection(root);
     }
     else if (namespace === "*") {
-        return (0, CreateAlgorithm_1.create_htmlCollection)(root, function (ele) {
+        return CreateAlgorithm_1.create_htmlCollection(root, function (ele) {
             return (ele._localName === localName);
         });
     }
     else if (localName === "*") {
-        return (0, CreateAlgorithm_1.create_htmlCollection)(root, function (ele) {
+        return CreateAlgorithm_1.create_htmlCollection(root, function (ele) {
             return (ele._namespace === namespace);
         });
     }
     else {
-        return (0, CreateAlgorithm_1.create_htmlCollection)(root, function (ele) {
+        return CreateAlgorithm_1.create_htmlCollection(root, function (ele) {
             return (ele._localName === localName && ele._namespace === namespace);
         });
     }
 }
+exports.node_listOfElementsWithNamespace = node_listOfElementsWithNamespace;
 /**
  * Returns a collection of elements with the given class names which are
  * descendants of the given root node.
@@ -20115,16 +48008,17 @@ function node_listOfElementsWithClassNames(classNames, root) {
      * manner if root’s node document’s mode is "quirks", and in a
      * case-sensitive manner otherwise.
      */
-    const classes = (0, OrderedSetAlgorithm_1.orderedSet_parse)(classNames);
+    var classes = OrderedSetAlgorithm_1.orderedSet_parse(classNames);
     if (classes.size === 0) {
-        return (0, CreateAlgorithm_1.create_htmlCollection)(root, () => false);
+        return CreateAlgorithm_1.create_htmlCollection(root, function () { return false; });
     }
-    const caseSensitive = (root._nodeDocument._mode !== "quirks");
-    return (0, CreateAlgorithm_1.create_htmlCollection)(root, function (ele) {
-        const eleClasses = ele.classList;
-        return (0, OrderedSetAlgorithm_1.orderedSet_contains)(eleClasses._tokenSet, classes, caseSensitive);
+    var caseSensitive = (root._nodeDocument._mode !== "quirks");
+    return CreateAlgorithm_1.create_htmlCollection(root, function (ele) {
+        var eleClasses = ele.classList;
+        return OrderedSetAlgorithm_1.orderedSet_contains(eleClasses._tokenSet, classes, caseSensitive);
     });
 }
+exports.node_listOfElementsWithClassNames = node_listOfElementsWithClassNames;
 /**
  * Searches for a namespace prefix associated with the given namespace
  * starting from the given element through its ancestors.
@@ -20145,8 +48039,8 @@ function node_locateANamespacePrefix(element, namespace) {
      * value is namespace, then return element’s first such attribute’s
      * local name.
      */
-    for (let i = 0; i < element._attributeList.length; i++) {
-        const attr = element._attributeList[i];
+    for (var i = 0; i < element._attributeList.length; i++) {
+        var attr = element._attributeList[i];
         if (attr._namespacePrefix === "xmlns" && attr._value === namespace) {
             return attr._localName;
         }
@@ -20163,6 +48057,7 @@ function node_locateANamespacePrefix(element, namespace) {
      */
     return null;
 }
+exports.node_locateANamespacePrefix = node_locateANamespacePrefix;
 /**
  * Searches for a namespace associated with the given namespace prefix
  * starting from the given node through its ancestors.
@@ -20186,8 +48081,8 @@ function node_locateANamespace(node, prefix) {
          * namespace prefix is null, and local name is "xmlns", then return its
          * value if it is not the empty string, and null otherwise.
          */
-        for (let i = 0; i < node._attributeList.length; i++) {
-            const attr = node._attributeList[i];
+        for (var i = 0; i < node._attributeList.length; i++) {
+            var attr = node._attributeList[i];
             if (attr._namespace === infra_1.namespace.XMLNS &&
                 attr._namespacePrefix === "xmlns" &&
                 attr._localName === prefix) {
@@ -20243,6 +48138,7 @@ function node_locateANamespace(node, prefix) {
         return node_locateANamespace(node._parent, prefix);
     }
 }
+exports.node_locateANamespace = node_locateANamespace;
 //# sourceMappingURL=NodeAlgorithm.js.map
 
 /***/ }),
@@ -20253,12 +48149,10 @@ function node_locateANamespace(node, prefix) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.nodeIterator_traverse = nodeIterator_traverse;
-exports.nodeIterator_iteratorList = nodeIterator_iteratorList;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const interfaces_1 = __nccwpck_require__(27305);
-const TraversalAlgorithm_1 = __nccwpck_require__(80998);
-const TreeAlgorithm_1 = __nccwpck_require__(16620);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var interfaces_1 = __nccwpck_require__(27305);
+var TraversalAlgorithm_1 = __nccwpck_require__(80998);
+var TreeAlgorithm_1 = __nccwpck_require__(16620);
 /**
  * Returns the next or previous node in the subtree, or `null` if
  * there are none.
@@ -20272,8 +48166,8 @@ function nodeIterator_traverse(iterator, forward) {
      * 1. Let node be iterator’s reference.
      * 2. Let beforeNode be iterator’s pointer before reference.
      */
-    let node = iterator._reference;
-    let beforeNode = iterator._pointerBeforeReference;
+    var node = iterator._reference;
+    var beforeNode = iterator._pointerBeforeReference;
     /**
      * 3. While true:
      */
@@ -20291,7 +48185,7 @@ function nodeIterator_traverse(iterator, forward) {
                  * node in iterator’s iterator collection. If there is no such node,
                  * then return null.
                  */
-                const nextNode = (0, TreeAlgorithm_1.tree_getFollowingNode)(iterator._root, node);
+                var nextNode = TreeAlgorithm_1.tree_getFollowingNode(iterator._root, node);
                 if (nextNode) {
                     node = nextNode;
                 }
@@ -20316,7 +48210,7 @@ function nodeIterator_traverse(iterator, forward) {
                  * node in iterator’s iterator collection. If there is no such node,
                  * then return null.
                  */
-                const prevNode = (0, TreeAlgorithm_1.tree_getPrecedingNode)(iterator.root, node);
+                var prevNode = TreeAlgorithm_1.tree_getPrecedingNode(iterator.root, node);
                 if (prevNode) {
                     node = prevNode;
                 }
@@ -20335,7 +48229,7 @@ function nodeIterator_traverse(iterator, forward) {
          * 3.2. Let result be the result of filtering node within iterator.
          * 3.3. If result is FILTER_ACCEPT, then break.
          */
-        const result = (0, TraversalAlgorithm_1.traversal_filter)(iterator, node);
+        var result = TraversalAlgorithm_1.traversal_filter(iterator, node);
         if (result === interfaces_1.FilterResult.Accept) {
             break;
         }
@@ -20349,27 +48243,56 @@ function nodeIterator_traverse(iterator, forward) {
     iterator._pointerBeforeReference = beforeNode;
     return node;
 }
+exports.nodeIterator_traverse = nodeIterator_traverse;
 /**
  * Gets the global iterator list.
  */
 function nodeIterator_iteratorList() {
     return DOMImpl_1.dom.window._iteratorList;
 }
+exports.nodeIterator_iteratorList = nodeIterator_iteratorList;
 //# sourceMappingURL=NodeIteratorAlgorithm.js.map
 
 /***/ }),
 
 /***/ 53670:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.orderedSet_parse = orderedSet_parse;
-exports.orderedSet_serialize = orderedSet_serialize;
-exports.orderedSet_sanitize = orderedSet_sanitize;
-exports.orderedSet_contains = orderedSet_contains;
-const infra_1 = __nccwpck_require__(84251);
+var infra_1 = __nccwpck_require__(84251);
 /**
  * Converts a whitespace separated string into an array of tokens.
  *
@@ -20382,9 +48305,10 @@ function orderedSet_parse(value) {
      * 3. For each token in inputTokens, append token to tokens.
      * 4. Return tokens.
      */
-    const inputTokens = infra_1.string.splitAStringOnASCIIWhitespace(value);
+    var inputTokens = infra_1.string.splitAStringOnASCIIWhitespace(value);
     return new Set(inputTokens);
 }
+exports.orderedSet_parse = orderedSet_parse;
 /**
  * Converts an array of tokens into a space separated string.
  *
@@ -20395,8 +48319,9 @@ function orderedSet_serialize(tokens) {
      * The ordered set serializer takes a set and returns the concatenation of
      * set using U+0020 SPACE.
      */
-    return [...tokens].join(' ');
+    return __spread(tokens).join(' ');
 }
+exports.orderedSet_serialize = orderedSet_serialize;
 /**
  * Removes duplicate tokens and convert all whitespace characters
  * to space.
@@ -20406,6 +48331,7 @@ function orderedSet_serialize(tokens) {
 function orderedSet_sanitize(value) {
     return orderedSet_serialize(orderedSet_parse(value));
 }
+exports.orderedSet_sanitize = orderedSet_sanitize;
 /**
  * Determines whether a set contains the other.
  *
@@ -20414,40 +48340,72 @@ function orderedSet_sanitize(value) {
  * @param caseSensitive - whether matches are case-sensitive
  */
 function orderedSet_contains(set1, set2, caseSensitive) {
-    for (const val2 of set2) {
-        let found = false;
-        for (const val1 of set1) {
-            if (caseSensitive) {
-                if (val1 === val2) {
-                    found = true;
-                    break;
+    var e_1, _a, e_2, _b;
+    try {
+        for (var set2_1 = __values(set2), set2_1_1 = set2_1.next(); !set2_1_1.done; set2_1_1 = set2_1.next()) {
+            var val2 = set2_1_1.value;
+            var found = false;
+            try {
+                for (var set1_1 = (e_2 = void 0, __values(set1)), set1_1_1 = set1_1.next(); !set1_1_1.done; set1_1_1 = set1_1.next()) {
+                    var val1 = set1_1_1.value;
+                    if (caseSensitive) {
+                        if (val1 === val2) {
+                            found = true;
+                            break;
+                        }
+                    }
+                    else {
+                        if (val1.toUpperCase() === val2.toUpperCase()) {
+                            found = true;
+                            break;
+                        }
+                    }
                 }
             }
-            else {
-                if (val1.toUpperCase() === val2.toUpperCase()) {
-                    found = true;
-                    break;
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (set1_1_1 && !set1_1_1.done && (_b = set1_1.return)) _b.call(set1_1);
                 }
+                finally { if (e_2) throw e_2.error; }
             }
+            if (!found)
+                return false;
         }
-        if (!found)
-            return false;
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (set2_1_1 && !set2_1_1.done && (_a = set2_1.return)) _a.call(set2_1);
+        }
+        finally { if (e_1) throw e_1.error; }
     }
     return true;
 }
+exports.orderedSet_contains = orderedSet_contains;
 //# sourceMappingURL=OrderedSetAlgorithm.js.map
 
 /***/ }),
 
 /***/ 2328:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.parentNode_convertNodesIntoANode = parentNode_convertNodesIntoANode;
-const util_1 = __nccwpck_require__(76195);
-const CreateAlgorithm_1 = __nccwpck_require__(57339);
+var util_1 = __nccwpck_require__(76195);
+var CreateAlgorithm_1 = __nccwpck_require__(57339);
 /**
  * Converts the given nodes or strings into a node (if `nodes` has
  * only one element) or a document fragment.
@@ -20456,16 +48414,17 @@ const CreateAlgorithm_1 = __nccwpck_require__(57339);
  * @param document - owner document
  */
 function parentNode_convertNodesIntoANode(nodes, document) {
+    var e_1, _a;
     /**
      * 1. Let node be null.
      * 2. Replace each string in nodes with a new Text node whose data is the
      * string and node document is document.
      */
-    let node = null;
-    for (let i = 0; i < nodes.length; i++) {
-        const item = nodes[i];
-        if ((0, util_1.isString)(item)) {
-            const text = (0, CreateAlgorithm_1.create_text)(document, item);
+    var node = null;
+    for (var i = 0; i < nodes.length; i++) {
+        var item = nodes[i];
+        if (util_1.isString(item)) {
+            var text = CreateAlgorithm_1.create_text(document, item);
             nodes[i] = text;
         }
     }
@@ -20478,10 +48437,20 @@ function parentNode_convertNodesIntoANode(nodes, document) {
         node = nodes[0];
     }
     else {
-        node = (0, CreateAlgorithm_1.create_documentFragment)(document);
-        const ns = node;
-        for (const item of nodes) {
-            ns.appendChild(item);
+        node = CreateAlgorithm_1.create_documentFragment(document);
+        var ns = node;
+        try {
+            for (var nodes_1 = __values(nodes), nodes_1_1 = nodes_1.next(); !nodes_1_1.done; nodes_1_1 = nodes_1.next()) {
+                var item = nodes_1_1.value;
+                ns.appendChild(item);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (nodes_1_1 && !nodes_1_1.done && (_a = nodes_1.return)) _a.call(nodes_1);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
     }
     /**
@@ -20489,38 +48458,58 @@ function parentNode_convertNodesIntoANode(nodes, document) {
      */
     return node;
 }
+exports.parentNode_convertNodesIntoANode = parentNode_convertNodesIntoANode;
 //# sourceMappingURL=ParentNodeAlgorithm.js.map
 
 /***/ }),
 
 /***/ 30457:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.range_collapsed = range_collapsed;
-exports.range_root = range_root;
-exports.range_isContained = range_isContained;
-exports.range_isPartiallyContained = range_isPartiallyContained;
-exports.range_setTheStart = range_setTheStart;
-exports.range_setTheEnd = range_setTheEnd;
-exports.range_select = range_select;
-exports.range_extract = range_extract;
-exports.range_cloneTheContents = range_cloneTheContents;
-exports.range_insert = range_insert;
-exports.range_getContainedNodes = range_getContainedNodes;
-exports.range_getPartiallyContainedNodes = range_getPartiallyContainedNodes;
-const interfaces_1 = __nccwpck_require__(27305);
-const DOMException_1 = __nccwpck_require__(13166);
-const util_1 = __nccwpck_require__(65282);
-const CreateAlgorithm_1 = __nccwpck_require__(57339);
-const TreeAlgorithm_1 = __nccwpck_require__(16620);
-const BoundaryPointAlgorithm_1 = __nccwpck_require__(81054);
-const CharacterDataAlgorithm_1 = __nccwpck_require__(19461);
-const NodeAlgorithm_1 = __nccwpck_require__(74924);
-const MutationAlgorithm_1 = __nccwpck_require__(45463);
-const TextAlgorithm_1 = __nccwpck_require__(13512);
+var interfaces_1 = __nccwpck_require__(27305);
+var DOMException_1 = __nccwpck_require__(13166);
+var util_1 = __nccwpck_require__(65282);
+var CreateAlgorithm_1 = __nccwpck_require__(57339);
+var TreeAlgorithm_1 = __nccwpck_require__(16620);
+var BoundaryPointAlgorithm_1 = __nccwpck_require__(81054);
+var CharacterDataAlgorithm_1 = __nccwpck_require__(19461);
+var NodeAlgorithm_1 = __nccwpck_require__(74924);
+var MutationAlgorithm_1 = __nccwpck_require__(45463);
+var TextAlgorithm_1 = __nccwpck_require__(13512);
 /**
  * Determines if the node's start boundary point is at its end boundary
  * point.
@@ -20533,6 +48522,7 @@ function range_collapsed(range) {
      */
     return (range._startNode === range._endNode && range._startOffset === range._endOffset);
 }
+exports.range_collapsed = range_collapsed;
 /**
  * Gets the root node of a range.
  *
@@ -20542,8 +48532,9 @@ function range_root(range) {
     /**
      * The root of a live range is the root of its start node.
      */
-    return (0, TreeAlgorithm_1.tree_rootNode)(range._startNode);
+    return TreeAlgorithm_1.tree_rootNode(range._startNode);
 }
+exports.range_root = range_root;
 /**
  * Determines if a node is fully contained in a range.
  *
@@ -20556,10 +48547,11 @@ function range_isContained(node, range) {
      * root, and (node, 0) is after range’s start, and (node, node’s length) is
      * before range’s end.
      */
-    return ((0, TreeAlgorithm_1.tree_rootNode)(node) === range_root(range) &&
-        (0, BoundaryPointAlgorithm_1.boundaryPoint_position)([node, 0], range._start) === interfaces_1.BoundaryPosition.After &&
-        (0, BoundaryPointAlgorithm_1.boundaryPoint_position)([node, (0, TreeAlgorithm_1.tree_nodeLength)(node)], range._end) === interfaces_1.BoundaryPosition.Before);
+    return (TreeAlgorithm_1.tree_rootNode(node) === range_root(range) &&
+        BoundaryPointAlgorithm_1.boundaryPoint_position([node, 0], range._start) === interfaces_1.BoundaryPosition.After &&
+        BoundaryPointAlgorithm_1.boundaryPoint_position([node, TreeAlgorithm_1.tree_nodeLength(node)], range._end) === interfaces_1.BoundaryPosition.Before);
 }
+exports.range_isContained = range_isContained;
 /**
  * Determines if a node is partially contained in a range.
  *
@@ -20572,10 +48564,11 @@ function range_isPartiallyContained(node, range) {
      * ancestor of the live range’s start node but not its end node,
      * or vice versa.
      */
-    const startCheck = (0, TreeAlgorithm_1.tree_isAncestorOf)(range._startNode, node, true);
-    const endCheck = (0, TreeAlgorithm_1.tree_isAncestorOf)(range._endNode, node, true);
+    var startCheck = TreeAlgorithm_1.tree_isAncestorOf(range._startNode, node, true);
+    var endCheck = TreeAlgorithm_1.tree_isAncestorOf(range._endNode, node, true);
     return (startCheck && !endCheck) || (!startCheck && endCheck);
 }
+exports.range_isPartiallyContained = range_isPartiallyContained;
 /**
  * Sets the start boundary point of a range.
  *
@@ -20597,16 +48590,17 @@ function range_setTheStart(range, node, offset) {
     if (util_1.Guard.isDocumentTypeNode(node)) {
         throw new DOMException_1.InvalidNodeTypeError();
     }
-    if (offset > (0, TreeAlgorithm_1.tree_nodeLength)(node)) {
+    if (offset > TreeAlgorithm_1.tree_nodeLength(node)) {
         throw new DOMException_1.IndexSizeError();
     }
-    const bp = [node, offset];
-    if (range_root(range) !== (0, TreeAlgorithm_1.tree_rootNode)(node) ||
-        (0, BoundaryPointAlgorithm_1.boundaryPoint_position)(bp, range._end) === interfaces_1.BoundaryPosition.After) {
+    var bp = [node, offset];
+    if (range_root(range) !== TreeAlgorithm_1.tree_rootNode(node) ||
+        BoundaryPointAlgorithm_1.boundaryPoint_position(bp, range._end) === interfaces_1.BoundaryPosition.After) {
         range._end = bp;
     }
     range._start = bp;
 }
+exports.range_setTheStart = range_setTheStart;
 /**
  * Sets the end boundary point of a range.
  *
@@ -20628,16 +48622,17 @@ function range_setTheEnd(range, node, offset) {
     if (util_1.Guard.isDocumentTypeNode(node)) {
         throw new DOMException_1.InvalidNodeTypeError();
     }
-    if (offset > (0, TreeAlgorithm_1.tree_nodeLength)(node)) {
+    if (offset > TreeAlgorithm_1.tree_nodeLength(node)) {
         throw new DOMException_1.IndexSizeError();
     }
-    const bp = [node, offset];
-    if (range_root(range) !== (0, TreeAlgorithm_1.tree_rootNode)(node) ||
-        (0, BoundaryPointAlgorithm_1.boundaryPoint_position)(bp, range._start) === interfaces_1.BoundaryPosition.Before) {
+    var bp = [node, offset];
+    if (range_root(range) !== TreeAlgorithm_1.tree_rootNode(node) ||
+        BoundaryPointAlgorithm_1.boundaryPoint_position(bp, range._start) === interfaces_1.BoundaryPosition.Before) {
         range._start = bp;
     }
     range._end = bp;
 }
+exports.range_setTheEnd = range_setTheEnd;
 /**
  * Selects a node.
  *
@@ -20649,7 +48644,7 @@ function range_select(node, range) {
      * 1. Let parent be node’s parent.
      * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException.
      */
-    const parent = node._parent;
+    var parent = node._parent;
     if (parent === null)
         throw new DOMException_1.InvalidNodeTypeError();
     /**
@@ -20657,22 +48652,24 @@ function range_select(node, range) {
      * 4. Set range’s start to boundary point (parent, index).
      * 5. Set range’s end to boundary point (parent, index plus 1).
      */
-    const index = (0, TreeAlgorithm_1.tree_index)(node);
+    var index = TreeAlgorithm_1.tree_index(node);
     range._start = [parent, index];
     range._end = [parent, index + 1];
 }
+exports.range_select = range_select;
 /**
  * EXtracts the contents of range as a document fragment.
  *
  * @param range - a range
  */
 function range_extract(range) {
+    var e_1, _a, e_2, _b, e_3, _c;
     /**
      * 1. Let fragment be a new DocumentFragment node whose node document is
      * range’s start node’s node document.
      * 2. If range is collapsed, then return fragment.
      */
-    const fragment = (0, CreateAlgorithm_1.create_documentFragment)(range._startNode._nodeDocument);
+    var fragment = CreateAlgorithm_1.create_documentFragment(range._startNode._nodeDocument);
     if (range_collapsed(range))
         return fragment;
     /**
@@ -20680,10 +48677,10 @@ function range_extract(range) {
      * and original end offset be range’s start node, start offset, end node,
      * and end offset, respectively.
      */
-    const originalStartNode = range._startNode;
-    const originalStartOffset = range._startOffset;
-    const originalEndNode = range._endNode;
-    const originalEndOffset = range._endOffset;
+    var originalStartNode = range._startNode;
+    var originalStartOffset = range._startOffset;
+    var originalEndNode = range._endNode;
+    var originalEndOffset = range._endOffset;
     /**
      * 4. If original start node is original end node, and they are a Text,
      * ProcessingInstruction, or Comment node:
@@ -20699,10 +48696,10 @@ function range_extract(range) {
      */
     if (originalStartNode === originalEndNode &&
         util_1.Guard.isCharacterDataNode(originalStartNode)) {
-        const clone = (0, NodeAlgorithm_1.node_clone)(originalStartNode);
-        clone._data = (0, CharacterDataAlgorithm_1.characterData_substringData)(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset);
-        (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
-        (0, CharacterDataAlgorithm_1.characterData_replaceData)(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset, '');
+        var clone = NodeAlgorithm_1.node_clone(originalStartNode);
+        clone._data = CharacterDataAlgorithm_1.characterData_substringData(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset);
+        MutationAlgorithm_1.mutation_append(clone, fragment);
+        CharacterDataAlgorithm_1.characterData_replaceData(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset, '');
         return fragment;
     }
     /**
@@ -20710,8 +48707,8 @@ function range_extract(range) {
      * 6. While common ancestor is not an inclusive ancestor of original end
      * node, set common ancestor to its own parent.
      */
-    let commonAncestor = originalStartNode;
-    while (!(0, TreeAlgorithm_1.tree_isAncestorOf)(originalEndNode, commonAncestor, true)) {
+    var commonAncestor = originalStartNode;
+    while (!TreeAlgorithm_1.tree_isAncestorOf(originalEndNode, commonAncestor, true)) {
         if (commonAncestor._parent === null) {
             throw new Error("Parent node  is null.");
         }
@@ -20723,14 +48720,24 @@ function range_extract(range) {
      * node, set first partially contained child to the first child of common
      * ancestor that is partially contained in range.
      */
-    let firstPartiallyContainedChild = null;
-    if (!(0, TreeAlgorithm_1.tree_isAncestorOf)(originalEndNode, originalStartNode, true)) {
-        for (const node of commonAncestor._children) {
-            if (range_isPartiallyContained(node, range)) {
-                firstPartiallyContainedChild = node;
-                break;
+    var firstPartiallyContainedChild = null;
+    if (!TreeAlgorithm_1.tree_isAncestorOf(originalEndNode, originalStartNode, true)) {
+        try {
+            for (var _d = __values(commonAncestor._children), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var node = _e.value;
+                if (range_isPartiallyContained(node, range)) {
+                    firstPartiallyContainedChild = node;
+                    break;
+                }
             }
         }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
     }
     /**
      * 9. Let last partially contained child be null.
@@ -20738,11 +48745,11 @@ function range_extract(range) {
      * node, set last partially contained child to the last child of common
      * ancestor that is partially contained in range.
      */
-    let lastPartiallyContainedChild = null;
-    if (!(0, TreeAlgorithm_1.tree_isAncestorOf)(originalStartNode, originalEndNode, true)) {
-        const children = [...commonAncestor._children];
-        for (let i = children.length - 1; i > 0; i--) {
-            const node = children[i];
+    var lastPartiallyContainedChild = null;
+    if (!TreeAlgorithm_1.tree_isAncestorOf(originalStartNode, originalEndNode, true)) {
+        var children = __spread(commonAncestor._children);
+        for (var i = children.length - 1; i > 0; i--) {
+            var node = children[i];
             if (range_isPartiallyContained(node, range)) {
                 lastPartiallyContainedChild = node;
                 break;
@@ -20755,18 +48762,28 @@ function range_extract(range) {
      * 12. If any member of contained children is a doctype, then throw a
      * "HierarchyRequestError" DOMException.
      */
-    const containedChildren = [];
-    for (const child of commonAncestor._children) {
-        if (range_isContained(child, range)) {
-            if (util_1.Guard.isDocumentTypeNode(child)) {
-                throw new DOMException_1.HierarchyRequestError();
+    var containedChildren = [];
+    try {
+        for (var _f = __values(commonAncestor._children), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var child = _g.value;
+            if (range_isContained(child, range)) {
+                if (util_1.Guard.isDocumentTypeNode(child)) {
+                    throw new DOMException_1.HierarchyRequestError();
+                }
+                containedChildren.push(child);
             }
-            containedChildren.push(child);
         }
     }
-    let newNode;
-    let newOffset;
-    if ((0, TreeAlgorithm_1.tree_isAncestorOf)(originalEndNode, originalStartNode, true)) {
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    var newNode;
+    var newOffset;
+    if (TreeAlgorithm_1.tree_isAncestorOf(originalEndNode, originalStartNode, true)) {
         /**
          * 13. If original start node is an inclusive ancestor of original end node,
          * set new node to original start node and new offset to original start
@@ -20784,9 +48801,9 @@ function range_extract(range) {
          * 14.3. Set new node to the parent of reference node, and new offset to
          * one plus reference node’s index.
          */
-        let referenceNode = originalStartNode;
+        var referenceNode = originalStartNode;
         while (referenceNode._parent !== null &&
-            !(0, TreeAlgorithm_1.tree_isAncestorOf)(originalEndNode, referenceNode._parent)) {
+            !TreeAlgorithm_1.tree_isAncestorOf(originalEndNode, referenceNode._parent)) {
             referenceNode = referenceNode._parent;
         }
         /* istanbul ignore next */
@@ -20799,7 +48816,7 @@ function range_extract(range) {
             throw new Error("Parent node is null.");
         }
         newNode = referenceNode._parent;
-        newOffset = 1 + (0, TreeAlgorithm_1.tree_index)(referenceNode);
+        newOffset = 1 + TreeAlgorithm_1.tree_index(referenceNode);
     }
     if (util_1.Guard.isCharacterDataNode(firstPartiallyContainedChild)) {
         /**
@@ -20814,10 +48831,10 @@ function range_extract(range) {
          * start offset, count original start node’s length minus original start
          * offset, and data the empty string.
          */
-        const clone = (0, NodeAlgorithm_1.node_clone)(originalStartNode);
-        clone._data = (0, CharacterDataAlgorithm_1.characterData_substringData)(originalStartNode, originalStartOffset, (0, TreeAlgorithm_1.tree_nodeLength)(originalStartNode) - originalStartOffset);
-        (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
-        (0, CharacterDataAlgorithm_1.characterData_replaceData)(originalStartNode, originalStartOffset, (0, TreeAlgorithm_1.tree_nodeLength)(originalStartNode) - originalStartOffset, '');
+        var clone = NodeAlgorithm_1.node_clone(originalStartNode);
+        clone._data = CharacterDataAlgorithm_1.characterData_substringData(originalStartNode, originalStartOffset, TreeAlgorithm_1.tree_nodeLength(originalStartNode) - originalStartOffset);
+        MutationAlgorithm_1.mutation_append(clone, fragment);
+        CharacterDataAlgorithm_1.characterData_replaceData(originalStartNode, originalStartOffset, TreeAlgorithm_1.tree_nodeLength(originalStartNode) - originalStartOffset, '');
     }
     else if (firstPartiallyContainedChild !== null) {
         /**
@@ -20830,18 +48847,28 @@ function range_extract(range) {
          * 16.4. Let subfragment be the result of extracting subrange.
          * 16.5. Append subfragment to clone.
          */
-        const clone = (0, NodeAlgorithm_1.node_clone)(firstPartiallyContainedChild);
-        (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
-        const subrange = (0, CreateAlgorithm_1.create_range)([originalStartNode, originalStartOffset], [firstPartiallyContainedChild, (0, TreeAlgorithm_1.tree_nodeLength)(firstPartiallyContainedChild)]);
-        const subfragment = range_extract(subrange);
-        (0, MutationAlgorithm_1.mutation_append)(subfragment, clone);
+        var clone = NodeAlgorithm_1.node_clone(firstPartiallyContainedChild);
+        MutationAlgorithm_1.mutation_append(clone, fragment);
+        var subrange = CreateAlgorithm_1.create_range([originalStartNode, originalStartOffset], [firstPartiallyContainedChild, TreeAlgorithm_1.tree_nodeLength(firstPartiallyContainedChild)]);
+        var subfragment = range_extract(subrange);
+        MutationAlgorithm_1.mutation_append(subfragment, clone);
     }
-    /**
-     * 17. For each contained child in contained children, append contained
-     * child to fragment.
-     */
-    for (const child of containedChildren) {
-        (0, MutationAlgorithm_1.mutation_append)(child, fragment);
+    try {
+        /**
+         * 17. For each contained child in contained children, append contained
+         * child to fragment.
+         */
+        for (var containedChildren_1 = __values(containedChildren), containedChildren_1_1 = containedChildren_1.next(); !containedChildren_1_1.done; containedChildren_1_1 = containedChildren_1.next()) {
+            var child = containedChildren_1_1.value;
+            MutationAlgorithm_1.mutation_append(child, fragment);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (containedChildren_1_1 && !containedChildren_1_1.done && (_c = containedChildren_1.return)) _c.call(containedChildren_1);
+        }
+        finally { if (e_3) throw e_3.error; }
     }
     if (util_1.Guard.isCharacterDataNode(lastPartiallyContainedChild)) {
         /**
@@ -20854,10 +48881,10 @@ function range_extract(range) {
          * 18.4. Replace data with node original end node, offset 0, count
          * original end offset, and data the empty string.
          */
-        const clone = (0, NodeAlgorithm_1.node_clone)(originalEndNode);
-        clone._data = (0, CharacterDataAlgorithm_1.characterData_substringData)(originalEndNode, 0, originalEndOffset);
-        (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
-        (0, CharacterDataAlgorithm_1.characterData_replaceData)(originalEndNode, 0, originalEndOffset, '');
+        var clone = NodeAlgorithm_1.node_clone(originalEndNode);
+        clone._data = CharacterDataAlgorithm_1.characterData_substringData(originalEndNode, 0, originalEndOffset);
+        MutationAlgorithm_1.mutation_append(clone, fragment);
+        CharacterDataAlgorithm_1.characterData_replaceData(originalEndNode, 0, originalEndOffset, '');
     }
     else if (lastPartiallyContainedChild !== null) {
         /**
@@ -20870,11 +48897,11 @@ function range_extract(range) {
          * 19.4. Let subfragment be the result of extracting subrange.
          * 19.5. Append subfragment to clone.
          */
-        const clone = (0, NodeAlgorithm_1.node_clone)(lastPartiallyContainedChild);
-        (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
-        const subrange = (0, CreateAlgorithm_1.create_range)([lastPartiallyContainedChild, 0], [originalEndNode, originalEndOffset]);
-        const subfragment = range_extract(subrange);
-        (0, MutationAlgorithm_1.mutation_append)(subfragment, clone);
+        var clone = NodeAlgorithm_1.node_clone(lastPartiallyContainedChild);
+        MutationAlgorithm_1.mutation_append(clone, fragment);
+        var subrange = CreateAlgorithm_1.create_range([lastPartiallyContainedChild, 0], [originalEndNode, originalEndOffset]);
+        var subfragment = range_extract(subrange);
+        MutationAlgorithm_1.mutation_append(subfragment, clone);
     }
     /**
      * 20. Set range’s start and end to (new node, new offset).
@@ -20886,18 +48913,20 @@ function range_extract(range) {
      */
     return fragment;
 }
+exports.range_extract = range_extract;
 /**
  * Clones the contents of range as a document fragment.
  *
  * @param range - a range
  */
 function range_cloneTheContents(range) {
+    var e_4, _a, e_5, _b, e_6, _c;
     /**
      * 1. Let fragment be a new DocumentFragment node whose node document
      * is range’s start node’s node document.
      * 2. If range is collapsed, then return fragment.
      */
-    const fragment = (0, CreateAlgorithm_1.create_documentFragment)(range._startNode._nodeDocument);
+    var fragment = CreateAlgorithm_1.create_documentFragment(range._startNode._nodeDocument);
     if (range_collapsed(range))
         return fragment;
     /**
@@ -20913,23 +48942,23 @@ function range_cloneTheContents(range) {
      * 4.3. Append clone to fragment.
      * 4.5. Return fragment.
      */
-    const originalStartNode = range._startNode;
-    const originalStartOffset = range._startOffset;
-    const originalEndNode = range._endNode;
-    const originalEndOffset = range._endOffset;
+    var originalStartNode = range._startNode;
+    var originalStartOffset = range._startOffset;
+    var originalEndNode = range._endNode;
+    var originalEndOffset = range._endOffset;
     if (originalStartNode === originalEndNode &&
         util_1.Guard.isCharacterDataNode(originalStartNode)) {
-        const clone = (0, NodeAlgorithm_1.node_clone)(originalStartNode);
-        clone._data = (0, CharacterDataAlgorithm_1.characterData_substringData)(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset);
-        (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
+        var clone = NodeAlgorithm_1.node_clone(originalStartNode);
+        clone._data = CharacterDataAlgorithm_1.characterData_substringData(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset);
+        MutationAlgorithm_1.mutation_append(clone, fragment);
     }
     /**
      * 5. Let common ancestor be original start node.
      * 6. While common ancestor is not an inclusive ancestor of original end
      * node, set common ancestor to its own parent.
      */
-    let commonAncestor = originalStartNode;
-    while (!(0, TreeAlgorithm_1.tree_isAncestorOf)(originalEndNode, commonAncestor, true)) {
+    var commonAncestor = originalStartNode;
+    while (!TreeAlgorithm_1.tree_isAncestorOf(originalEndNode, commonAncestor, true)) {
         if (commonAncestor._parent === null) {
             throw new Error("Parent node  is null.");
         }
@@ -20941,14 +48970,24 @@ function range_cloneTheContents(range) {
      * node, set first partially contained child to the first child of common
      * ancestor that is partially contained in range.
      */
-    let firstPartiallyContainedChild = null;
-    if (!(0, TreeAlgorithm_1.tree_isAncestorOf)(originalEndNode, originalStartNode, true)) {
-        for (const node of commonAncestor._children) {
-            if (range_isPartiallyContained(node, range)) {
-                firstPartiallyContainedChild = node;
-                break;
+    var firstPartiallyContainedChild = null;
+    if (!TreeAlgorithm_1.tree_isAncestorOf(originalEndNode, originalStartNode, true)) {
+        try {
+            for (var _d = __values(commonAncestor._children), _e = _d.next(); !_e.done; _e = _d.next()) {
+                var node = _e.value;
+                if (range_isPartiallyContained(node, range)) {
+                    firstPartiallyContainedChild = node;
+                    break;
+                }
             }
         }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
     }
     /**
      * 9. Let last partially contained child be null.
@@ -20956,11 +48995,11 @@ function range_cloneTheContents(range) {
      * node, set last partially contained child to the last child of common
      * ancestor that is partially contained in range.
      */
-    let lastPartiallyContainedChild = null;
-    if (!(0, TreeAlgorithm_1.tree_isAncestorOf)(originalStartNode, originalEndNode, true)) {
-        const children = [...commonAncestor._children];
-        for (let i = children.length - 1; i > 0; i--) {
-            const node = children[i];
+    var lastPartiallyContainedChild = null;
+    if (!TreeAlgorithm_1.tree_isAncestorOf(originalStartNode, originalEndNode, true)) {
+        var children = __spread(commonAncestor._children);
+        for (var i = children.length - 1; i > 0; i--) {
+            var node = children[i];
             if (range_isPartiallyContained(node, range)) {
                 lastPartiallyContainedChild = node;
                 break;
@@ -20973,15 +49012,25 @@ function range_cloneTheContents(range) {
      * 12. If any member of contained children is a doctype, then throw a
      * "HierarchyRequestError" DOMException.
      */
-    const containedChildren = [];
-    for (const child of commonAncestor._children) {
-        if (range_isContained(child, range)) {
-            if (util_1.Guard.isDocumentTypeNode(child)) {
-                throw new DOMException_1.HierarchyRequestError();
+    var containedChildren = [];
+    try {
+        for (var _f = __values(commonAncestor._children), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var child = _g.value;
+            if (range_isContained(child, range)) {
+                if (util_1.Guard.isDocumentTypeNode(child)) {
+                    throw new DOMException_1.HierarchyRequestError();
+                }
+                containedChildren.push(child);
             }
-            containedChildren.push(child);
         }
     }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
     if (util_1.Guard.isCharacterDataNode(firstPartiallyContainedChild)) {
         /**
          * 13. If first partially contained child is a Text, ProcessingInstruction,
@@ -20992,9 +49041,9 @@ function range_cloneTheContents(range) {
          * original start node’s length minus original start offset.
          * 13.3. Append clone to fragment.
          */
-        const clone = (0, NodeAlgorithm_1.node_clone)(originalStartNode);
-        clone._data = (0, CharacterDataAlgorithm_1.characterData_substringData)(originalStartNode, originalStartOffset, (0, TreeAlgorithm_1.tree_nodeLength)(originalStartNode) - originalStartOffset);
-        (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
+        var clone = NodeAlgorithm_1.node_clone(originalStartNode);
+        clone._data = CharacterDataAlgorithm_1.characterData_substringData(originalStartNode, originalStartOffset, TreeAlgorithm_1.tree_nodeLength(originalStartNode) - originalStartOffset);
+        MutationAlgorithm_1.mutation_append(clone, fragment);
     }
     else if (firstPartiallyContainedChild !== null) {
         /**
@@ -21008,22 +49057,32 @@ function range_cloneTheContents(range) {
          * subrange.
          * 14.5. Append subfragment to clone.
          */
-        const clone = (0, NodeAlgorithm_1.node_clone)(firstPartiallyContainedChild);
-        (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
-        const subrange = (0, CreateAlgorithm_1.create_range)([originalStartNode, originalStartOffset], [firstPartiallyContainedChild, (0, TreeAlgorithm_1.tree_nodeLength)(firstPartiallyContainedChild)]);
-        const subfragment = range_cloneTheContents(subrange);
-        (0, MutationAlgorithm_1.mutation_append)(subfragment, clone);
+        var clone = NodeAlgorithm_1.node_clone(firstPartiallyContainedChild);
+        MutationAlgorithm_1.mutation_append(clone, fragment);
+        var subrange = CreateAlgorithm_1.create_range([originalStartNode, originalStartOffset], [firstPartiallyContainedChild, TreeAlgorithm_1.tree_nodeLength(firstPartiallyContainedChild)]);
+        var subfragment = range_cloneTheContents(subrange);
+        MutationAlgorithm_1.mutation_append(subfragment, clone);
     }
-    /**
-     * 15. For each contained child in contained children, append contained
-     * child to fragment.
-     * 15.1. Let clone be a clone of contained child with the clone children
-     * flag set.
-     * 15.2. Append clone to fragment.
-     */
-    for (const child of containedChildren) {
-        const clone = (0, NodeAlgorithm_1.node_clone)(child);
-        (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
+    try {
+        /**
+         * 15. For each contained child in contained children, append contained
+         * child to fragment.
+         * 15.1. Let clone be a clone of contained child with the clone children
+         * flag set.
+         * 15.2. Append clone to fragment.
+         */
+        for (var containedChildren_2 = __values(containedChildren), containedChildren_2_1 = containedChildren_2.next(); !containedChildren_2_1.done; containedChildren_2_1 = containedChildren_2.next()) {
+            var child = containedChildren_2_1.value;
+            var clone = NodeAlgorithm_1.node_clone(child);
+            MutationAlgorithm_1.mutation_append(clone, fragment);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (containedChildren_2_1 && !containedChildren_2_1.done && (_c = containedChildren_2.return)) _c.call(containedChildren_2);
+        }
+        finally { if (e_6) throw e_6.error; }
     }
     if (util_1.Guard.isCharacterDataNode(lastPartiallyContainedChild)) {
         /**
@@ -21034,9 +49093,9 @@ function range_cloneTheContents(range) {
          * node original end node, offset 0, and count original end offset.
          * 16.3. Append clone to fragment.
          */
-        const clone = (0, NodeAlgorithm_1.node_clone)(originalEndNode);
-        clone._data = (0, CharacterDataAlgorithm_1.characterData_substringData)(originalEndNode, 0, originalEndOffset);
-        (0, MutationAlgorithm_1.mutation_append)(clone, fragment);
+        var clone = NodeAlgorithm_1.node_clone(originalEndNode);
+        clone._data = CharacterDataAlgorithm_1.characterData_substringData(originalEndNode, 0, originalEndOffset);
+        MutationAlgorithm_1.mutation_append(clone, fragment);
     }
     else if (lastPartiallyContainedChild !== null) {
         /**
@@ -21049,17 +49108,18 @@ function range_cloneTheContents(range) {
          * 17.4. Let subfragment be the result of cloning the contents of subrange.
          * 17.5. Append subfragment to clone.
          */
-        const clone = (0, NodeAlgorithm_1.node_clone)(lastPartiallyContainedChild);
+        var clone = NodeAlgorithm_1.node_clone(lastPartiallyContainedChild);
         fragment.append(clone);
-        const subrange = (0, CreateAlgorithm_1.create_range)([lastPartiallyContainedChild, 0], [originalEndNode, originalEndOffset]);
-        const subfragment = range_extract(subrange);
-        (0, MutationAlgorithm_1.mutation_append)(subfragment, clone);
+        var subrange = CreateAlgorithm_1.create_range([lastPartiallyContainedChild, 0], [originalEndNode, originalEndOffset]);
+        var subfragment = range_extract(subrange);
+        MutationAlgorithm_1.mutation_append(subfragment, clone);
     }
     /**
      * 18. Return fragment.
      */
     return fragment;
 }
+exports.range_cloneTheContents = range_cloneTheContents;
 /**
  * Inserts a node into a range at the start boundary point.
  *
@@ -21067,6 +49127,7 @@ function range_cloneTheContents(range) {
  * @param range - a range
  */
 function range_insert(node, range) {
+    var e_7, _a;
     /**
      * 1. If range’s start node is a ProcessingInstruction or Comment node, is a
      * Text node whose parent is null, or is node, then throw a
@@ -21085,25 +49146,35 @@ function range_insert(node, range) {
      * 4. Otherwise, set referenceNode to the child of start node whose index is
      * start offset, and null if there is no such child.
      */
-    let referenceNode = null;
+    var referenceNode = null;
     if (util_1.Guard.isTextNode(range._startNode)) {
         referenceNode = range._startNode;
     }
     else {
-        let index = 0;
-        for (const child of range._startNode._children) {
-            if (index === range._startOffset) {
-                referenceNode = child;
-                break;
+        var index = 0;
+        try {
+            for (var _b = __values(range._startNode._children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (index === range._startOffset) {
+                    referenceNode = child;
+                    break;
+                }
+                index++;
             }
-            index++;
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
         }
     }
     /**
      * 5. Let parent be range’s start node if referenceNode is null, and
      * referenceNode’s parent otherwise.
      */
-    let parent;
+    var parent;
     if (referenceNode === null) {
         parent = range._startNode;
     }
@@ -21116,13 +49187,13 @@ function range_insert(node, range) {
     /**
      * 6. Ensure pre-insertion validity of node into parent before referenceNode.
      */
-    (0, MutationAlgorithm_1.mutation_ensurePreInsertionValidity)(node, parent, referenceNode);
+    MutationAlgorithm_1.mutation_ensurePreInsertionValidity(node, parent, referenceNode);
     /**
      * 7. If range’s start node is a Text node, set referenceNode to the result
      * of splitting it with offset range’s start offset.
      */
     if (util_1.Guard.isTextNode(range._startNode)) {
-        referenceNode = (0, TextAlgorithm_1.text_split)(range._startNode, range._startOffset);
+        referenceNode = TextAlgorithm_1.text_split(range._startNode, range._startOffset);
     }
     /**
      * 8. If node is referenceNode, set referenceNode to its next sibling.
@@ -21134,20 +49205,20 @@ function range_insert(node, range) {
      * 9. If node’s parent is not null, remove node from its parent.
      */
     if (node._parent !== null) {
-        (0, MutationAlgorithm_1.mutation_remove)(node, node._parent);
+        MutationAlgorithm_1.mutation_remove(node, node._parent);
     }
     /**
      * 10. Let newOffset be parent’s length if referenceNode is null, and
      * referenceNode’s index otherwise.
      */
-    let newOffset = (referenceNode === null ?
-        (0, TreeAlgorithm_1.tree_nodeLength)(parent) : (0, TreeAlgorithm_1.tree_index)(referenceNode));
+    var newOffset = (referenceNode === null ?
+        TreeAlgorithm_1.tree_nodeLength(parent) : TreeAlgorithm_1.tree_index(referenceNode));
     /**
      * 11. Increase newOffset by node’s length if node is a DocumentFragment
      * node, and one otherwise.
      */
     if (util_1.Guard.isDocumentFragmentNode(node)) {
-        newOffset += (0, TreeAlgorithm_1.tree_nodeLength)(node);
+        newOffset += TreeAlgorithm_1.tree_nodeLength(node);
     }
     else {
         newOffset++;
@@ -21155,7 +49226,7 @@ function range_insert(node, range) {
     /**
      * 12. Pre-insert node into parent before referenceNode.
      */
-    (0, MutationAlgorithm_1.mutation_preInsert)(node, parent, referenceNode);
+    MutationAlgorithm_1.mutation_preInsert(node, parent, referenceNode);
     /**
      * 13. If range is collapsed, then set range’s end to (parent, newOffset).
      */
@@ -21163,62 +49234,67 @@ function range_insert(node, range) {
         range._end = [parent, newOffset];
     }
 }
+exports.range_insert = range_insert;
 /**
  * Traverses through all contained nodes of a range.
  *
  * @param range - a range
  */
 function range_getContainedNodes(range) {
-    return {
-        [Symbol.iterator]: () => {
-            const container = range.commonAncestorContainer;
-            let currentNode = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(container);
+    var _a;
+    return _a = {},
+        _a[Symbol.iterator] = function () {
+            var container = range.commonAncestorContainer;
+            var currentNode = TreeAlgorithm_1.tree_getFirstDescendantNode(container);
             return {
-                next: () => {
+                next: function () {
                     while (currentNode && !range_isContained(currentNode, range)) {
-                        currentNode = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(container, currentNode);
+                        currentNode = TreeAlgorithm_1.tree_getNextDescendantNode(container, currentNode);
                     }
                     if (currentNode === null) {
                         return { done: true, value: null };
                     }
                     else {
-                        const result = { done: false, value: currentNode };
-                        currentNode = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(container, currentNode);
+                        var result = { done: false, value: currentNode };
+                        currentNode = TreeAlgorithm_1.tree_getNextDescendantNode(container, currentNode);
                         return result;
                     }
                 }
             };
-        }
-    };
+        },
+        _a;
 }
+exports.range_getContainedNodes = range_getContainedNodes;
 /**
  * Traverses through all partially contained nodes of a range.
  *
  * @param range - a range
  */
 function range_getPartiallyContainedNodes(range) {
-    return {
-        [Symbol.iterator]: () => {
-            const container = range.commonAncestorContainer;
-            let currentNode = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(container);
+    var _a;
+    return _a = {},
+        _a[Symbol.iterator] = function () {
+            var container = range.commonAncestorContainer;
+            var currentNode = TreeAlgorithm_1.tree_getFirstDescendantNode(container);
             return {
-                next: () => {
+                next: function () {
                     while (currentNode && !range_isPartiallyContained(currentNode, range)) {
-                        currentNode = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(container, currentNode);
+                        currentNode = TreeAlgorithm_1.tree_getNextDescendantNode(container, currentNode);
                     }
                     if (currentNode === null) {
                         return { done: true, value: null };
                     }
                     else {
-                        const result = { done: false, value: currentNode };
-                        currentNode = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(container, currentNode);
+                        var result = { done: false, value: currentNode };
+                        currentNode = TreeAlgorithm_1.tree_getNextDescendantNode(container, currentNode);
                         return result;
                     }
                 }
             };
-        }
-    };
+        },
+        _a;
 }
+exports.range_getPartiallyContainedNodes = range_getPartiallyContainedNodes;
 //# sourceMappingURL=RangeAlgorithm.js.map
 
 /***/ }),
@@ -21229,8 +49305,7 @@ function range_getPartiallyContainedNodes(range) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.selectors_scopeMatchASelectorsString = selectors_scopeMatchASelectorsString;
-const DOMException_1 = __nccwpck_require__(13166);
+var DOMException_1 = __nccwpck_require__(13166);
 /**
  * Matches elements with the given selectors.
  *
@@ -21247,30 +49322,53 @@ function selectors_scopeMatchASelectorsString(selectors, node) {
      */
     throw new DOMException_1.NotSupportedError();
 }
+exports.selectors_scopeMatchASelectorsString = selectors_scopeMatchASelectorsString;
 //# sourceMappingURL=SelectorsAlgorithm.js.map
 
 /***/ }),
 
 /***/ 68733:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.shadowTree_signalASlotChange = shadowTree_signalASlotChange;
-exports.shadowTree_isConnected = shadowTree_isConnected;
-exports.shadowTree_isAssigned = shadowTree_isAssigned;
-exports.shadowTree_findASlot = shadowTree_findASlot;
-exports.shadowTree_findSlotables = shadowTree_findSlotables;
-exports.shadowTree_findFlattenedSlotables = shadowTree_findFlattenedSlotables;
-exports.shadowTree_assignSlotables = shadowTree_assignSlotables;
-exports.shadowTree_assignSlotablesForATree = shadowTree_assignSlotablesForATree;
-exports.shadowTree_assignASlot = shadowTree_assignASlot;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const util_1 = __nccwpck_require__(65282);
-const util_2 = __nccwpck_require__(76195);
-const TreeAlgorithm_1 = __nccwpck_require__(16620);
-const MutationObserverAlgorithm_1 = __nccwpck_require__(78157);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var util_1 = __nccwpck_require__(65282);
+var util_2 = __nccwpck_require__(76195);
+var TreeAlgorithm_1 = __nccwpck_require__(16620);
+var MutationObserverAlgorithm_1 = __nccwpck_require__(78157);
 /**
  * Signals a slot change to the given slot.
  *
@@ -21281,10 +49379,11 @@ function shadowTree_signalASlotChange(slot) {
      * 1. Append slot to slot’s relevant agent’s signal slots.
      * 2. Queue a mutation observer microtask.
      */
-    const window = DOMImpl_1.dom.window;
+    var window = DOMImpl_1.dom.window;
     window._signalSlots.add(slot);
-    (0, MutationObserverAlgorithm_1.observer_queueAMutationObserverMicrotask)();
+    MutationObserverAlgorithm_1.observer_queueAMutationObserverMicrotask();
 }
+exports.shadowTree_signalASlotChange = shadowTree_signalASlotChange;
 /**
  * Determines whether a the shadow tree of the given element node is
  * connected to a document node.
@@ -21295,8 +49394,9 @@ function shadowTree_isConnected(element) {
     /**
      * An element is connected if its shadow-including root is a document.
      */
-    return util_1.Guard.isDocumentNode((0, TreeAlgorithm_1.tree_rootNode)(element, true));
+    return util_1.Guard.isDocumentNode(TreeAlgorithm_1.tree_rootNode(element, true));
 }
+exports.shadowTree_isConnected = shadowTree_isConnected;
 /**
  * Determines whether a slotable is assigned.
  *
@@ -21308,13 +49408,15 @@ function shadowTree_isAssigned(slotable) {
      */
     return (slotable._assignedSlot !== null);
 }
+exports.shadowTree_isAssigned = shadowTree_isAssigned;
 /**
  * Finds a slot for the given slotable.
  *
  * @param slotable - a slotable
  * @param openFlag - `true` to search open shadow tree's only
  */
-function shadowTree_findASlot(slotable, openFlag = false) {
+function shadowTree_findASlot(slotable, openFlag) {
+    if (openFlag === void 0) { openFlag = false; }
     /**
      * 1. If slotable’s parent is null, then return null.
      * 2. Let shadow be slotable’s parent’s shadow root.
@@ -21324,71 +49426,85 @@ function shadowTree_findASlot(slotable, openFlag = false) {
      * 5. Return the first slot in tree order in shadow’s descendants whose name
      * is slotable’s name, if any, and null otherwise.
      */
-    const node = util_1.Cast.asNode(slotable);
-    const parent = node._parent;
+    var node = util_1.Cast.asNode(slotable);
+    var parent = node._parent;
     if (parent === null)
         return null;
-    const shadow = parent._shadowRoot || null;
+    var shadow = parent._shadowRoot || null;
     if (shadow === null)
         return null;
     if (openFlag && shadow._mode !== "open")
         return null;
-    let child = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(shadow, false, true, (e) => util_1.Guard.isSlot(e));
+    var child = TreeAlgorithm_1.tree_getFirstDescendantNode(shadow, false, true, function (e) { return util_1.Guard.isSlot(e); });
     while (child !== null) {
         if (child._name === slotable._name)
             return child;
-        child = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(shadow, child, false, true, (e) => util_1.Guard.isSlot(e));
+        child = TreeAlgorithm_1.tree_getNextDescendantNode(shadow, child, false, true, function (e) { return util_1.Guard.isSlot(e); });
     }
     return null;
 }
+exports.shadowTree_findASlot = shadowTree_findASlot;
 /**
  * Finds slotables for the given slot.
  *
  * @param slot - a slot
  */
 function shadowTree_findSlotables(slot) {
+    var e_1, _a;
     /**
      * 1. Let result be an empty list.
      * 2. If slot’s root is not a shadow root, then return result.
      */
-    const result = [];
-    const root = (0, TreeAlgorithm_1.tree_rootNode)(slot);
+    var result = [];
+    var root = TreeAlgorithm_1.tree_rootNode(slot);
     if (!util_1.Guard.isShadowRoot(root))
         return result;
     /**
      * 3. Let host be slot’s root’s host.
      * 4. For each slotable child of host, slotable, in tree order:
      */
-    const host = root._host;
-    for (const slotable of host._children) {
-        if (util_1.Guard.isSlotable(slotable)) {
-            /**
-             * 4.1. Let foundSlot be the result of finding a slot given slotable.
-             * 4.2. If foundSlot is slot, then append slotable to result.
-             */
-            const foundSlot = shadowTree_findASlot(slotable);
-            if (foundSlot === slot) {
-                result.push(slotable);
+    var host = root._host;
+    try {
+        for (var _b = __values(host._children), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var slotable = _c.value;
+            if (util_1.Guard.isSlotable(slotable)) {
+                /**
+                 * 4.1. Let foundSlot be the result of finding a slot given slotable.
+                 * 4.2. If foundSlot is slot, then append slotable to result.
+                 */
+                var foundSlot = shadowTree_findASlot(slotable);
+                if (foundSlot === slot) {
+                    result.push(slotable);
+                }
             }
         }
     }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
     /**
      * 5. Return result.
      */
     return result;
 }
+exports.shadowTree_findSlotables = shadowTree_findSlotables;
 /**
  * Finds slotables for the given slot.
  *
  * @param slot - a slot
  */
 function shadowTree_findFlattenedSlotables(slot) {
+    var e_2, _a, e_3, _b;
     /**
      * 1. Let result be an empty list.
      * 2. If slot’s root is not a shadow root, then return result.
      */
-    const result = [];
-    const root = (0, TreeAlgorithm_1.tree_rootNode)(slot);
+    var result = [];
+    var root = TreeAlgorithm_1.tree_rootNode(slot);
     if (!util_1.Guard.isShadowRoot(root))
         return result;
     /**
@@ -21396,56 +49512,78 @@ function shadowTree_findFlattenedSlotables(slot) {
      * 4. If slotables is the empty list, then append each slotable child of
      * slot, in tree order, to slotables.
      */
-    const slotables = shadowTree_findSlotables(slot);
-    if ((0, util_2.isEmpty)(slotables)) {
-        for (const slotable of slot._children) {
-            if (util_1.Guard.isSlotable(slotable)) {
-                slotables.push(slotable);
+    var slotables = shadowTree_findSlotables(slot);
+    if (util_2.isEmpty(slotables)) {
+        try {
+            for (var _c = __values(slot._children), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var slotable = _d.value;
+                if (util_1.Guard.isSlotable(slotable)) {
+                    slotables.push(slotable);
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    }
+    try {
+        /**
+         * 5. For each node in slotables:
+         */
+        for (var slotables_1 = __values(slotables), slotables_1_1 = slotables_1.next(); !slotables_1_1.done; slotables_1_1 = slotables_1.next()) {
+            var node = slotables_1_1.value;
+            /**
+             * 5.1. If node is a slot whose root is a shadow root, then:
+             */
+            if (util_1.Guard.isSlot(node) && util_1.Guard.isShadowRoot(TreeAlgorithm_1.tree_rootNode(node))) {
+                /**
+                 * 5.1.1. Let temporaryResult be the result of finding flattened slotables given node.
+                 * 5.1.2. Append each slotable in temporaryResult, in order, to result.
+                 */
+                var temporaryResult = shadowTree_findFlattenedSlotables(node);
+                result.push.apply(result, __spread(temporaryResult));
+            }
+            else {
+                /**
+                 * 5.2. Otherwise, append node to result.
+                 */
+                result.push(node);
             }
         }
     }
-    /**
-     * 5. For each node in slotables:
-     */
-    for (const node of slotables) {
-        /**
-         * 5.1. If node is a slot whose root is a shadow root, then:
-         */
-        if (util_1.Guard.isSlot(node) && util_1.Guard.isShadowRoot((0, TreeAlgorithm_1.tree_rootNode)(node))) {
-            /**
-             * 5.1.1. Let temporaryResult be the result of finding flattened slotables given node.
-             * 5.1.2. Append each slotable in temporaryResult, in order, to result.
-             */
-            const temporaryResult = shadowTree_findFlattenedSlotables(node);
-            result.push(...temporaryResult);
-        }
-        else {
-            /**
-             * 5.2. Otherwise, append node to result.
-             */
-            result.push(node);
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (slotables_1_1 && !slotables_1_1.done && (_b = slotables_1.return)) _b.call(slotables_1);
         }
+        finally { if (e_3) throw e_3.error; }
     }
     /**
      * 6. Return result.
      */
     return result;
 }
+exports.shadowTree_findFlattenedSlotables = shadowTree_findFlattenedSlotables;
 /**
  * Assigns slotables to the given slot.
  *
  * @param slot - a slot
  */
 function shadowTree_assignSlotables(slot) {
+    var e_4, _a;
     /**
      * 1. Let slotables be the result of finding slotables for slot.
      * 2. If slotables and slot’s assigned nodes are not identical, then run
      * signal a slot change for slot.
      */
-    const slotables = shadowTree_findSlotables(slot);
+    var slotables = shadowTree_findSlotables(slot);
     if (slotables.length === slot._assignedNodes.length) {
-        let nodesIdentical = true;
-        for (let i = 0; i < slotables.length; i++) {
+        var nodesIdentical = true;
+        for (var i = 0; i < slotables.length; i++) {
             if (slotables[i] !== slot._assignedNodes[i]) {
                 nodesIdentical = false;
                 break;
@@ -21460,10 +49598,21 @@ function shadowTree_assignSlotables(slot) {
      * 4. For each slotable in slotables, set slotable’s assigned slot to slot.
      */
     slot._assignedNodes = slotables;
-    for (const slotable of slotables) {
-        slotable._assignedSlot = slot;
+    try {
+        for (var slotables_2 = __values(slotables), slotables_2_1 = slotables_2.next(); !slotables_2_1.done; slotables_2_1 = slotables_2.next()) {
+            var slotable = slotables_2_1.value;
+            slotable._assignedSlot = slot;
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (slotables_2_1 && !slotables_2_1.done && (_a = slotables_2.return)) _a.call(slotables_2);
+        }
+        finally { if (e_4) throw e_4.error; }
     }
 }
+exports.shadowTree_assignSlotables = shadowTree_assignSlotables;
 /**
  * Assigns slotables to all nodes of a tree.
  *
@@ -21474,12 +49623,13 @@ function shadowTree_assignSlotablesForATree(root) {
      * To assign slotables for a tree, given a node root, run assign slotables
      * for each slot slot in root’s inclusive descendants, in tree order.
      */
-    let descendant = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(root, true, false, (e) => util_1.Guard.isSlot(e));
+    var descendant = TreeAlgorithm_1.tree_getFirstDescendantNode(root, true, false, function (e) { return util_1.Guard.isSlot(e); });
     while (descendant !== null) {
         shadowTree_assignSlotables(descendant);
-        descendant = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(root, descendant, true, false, (e) => util_1.Guard.isSlot(e));
+        descendant = TreeAlgorithm_1.tree_getNextDescendantNode(root, descendant, true, false, function (e) { return util_1.Guard.isSlot(e); });
     }
 }
+exports.shadowTree_assignSlotablesForATree = shadowTree_assignSlotablesForATree;
 /**
  * Assigns a slot to a slotables.
  *
@@ -21490,53 +49640,63 @@ function shadowTree_assignASlot(slotable) {
      * 1. Let slot be the result of finding a slot with slotable.
      * 2. If slot is non-null, then run assign slotables for slot.
      */
-    const slot = shadowTree_findASlot(slotable);
+    var slot = shadowTree_findASlot(slotable);
     if (slot !== null) {
         shadowTree_assignSlotables(slot);
     }
 }
+exports.shadowTree_assignASlot = shadowTree_assignASlot;
 //# sourceMappingURL=ShadowTreeAlgorithm.js.map
 
 /***/ }),
 
 /***/ 13512:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.text_contiguousTextNodes = text_contiguousTextNodes;
-exports.text_contiguousExclusiveTextNodes = text_contiguousExclusiveTextNodes;
-exports.text_descendantTextContent = text_descendantTextContent;
-exports.text_split = text_split;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const util_1 = __nccwpck_require__(65282);
-const DOMException_1 = __nccwpck_require__(13166);
-const CreateAlgorithm_1 = __nccwpck_require__(57339);
-const TreeAlgorithm_1 = __nccwpck_require__(16620);
-const CharacterDataAlgorithm_1 = __nccwpck_require__(19461);
-const MutationAlgorithm_1 = __nccwpck_require__(45463);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var util_1 = __nccwpck_require__(65282);
+var DOMException_1 = __nccwpck_require__(13166);
+var CreateAlgorithm_1 = __nccwpck_require__(57339);
+var TreeAlgorithm_1 = __nccwpck_require__(16620);
+var CharacterDataAlgorithm_1 = __nccwpck_require__(19461);
+var MutationAlgorithm_1 = __nccwpck_require__(45463);
 /**
  * Returns node with its adjacent text and cdata node siblings.
  *
  * @param node - a node
  * @param self - whether to include node itself
  */
-function text_contiguousTextNodes(node, self = false) {
+function text_contiguousTextNodes(node, self) {
+    var _a;
+    if (self === void 0) { self = false; }
     /**
      * The contiguous Text nodes of a node node are node, node’s previous
      * sibling Text node, if any, and its contiguous Text nodes, and node’s next
      * sibling Text node, if any, and its contiguous Text nodes, avoiding any
      * duplicates.
      */
-    return {
-        [Symbol.iterator]() {
-            let currentNode = node;
+    return _a = {},
+        _a[Symbol.iterator] = function () {
+            var currentNode = node;
             while (currentNode && util_1.Guard.isTextNode(currentNode._previousSibling)) {
                 currentNode = currentNode._previousSibling;
             }
             return {
-                next() {
+                next: function () {
                     if (currentNode && (!self && currentNode === node)) {
                         if (util_1.Guard.isTextNode(currentNode._nextSibling)) {
                             currentNode = currentNode._nextSibling;
@@ -21549,7 +49709,7 @@ function text_contiguousTextNodes(node, self = false) {
                         return { done: true, value: null };
                     }
                     else {
-                        const result = { done: false, value: currentNode };
+                        var result = { done: false, value: currentNode };
                         if (util_1.Guard.isTextNode(currentNode._nextSibling)) {
                             currentNode = currentNode._nextSibling;
                         }
@@ -21560,30 +49720,33 @@ function text_contiguousTextNodes(node, self = false) {
                     }
                 }
             };
-        }
-    };
+        },
+        _a;
 }
+exports.text_contiguousTextNodes = text_contiguousTextNodes;
 /**
  * Returns node with its adjacent text node siblings.
  *
  * @param node - a node
  * @param self - whether to include node itself
  */
-function text_contiguousExclusiveTextNodes(node, self = false) {
+function text_contiguousExclusiveTextNodes(node, self) {
+    var _a;
+    if (self === void 0) { self = false; }
     /**
      * The contiguous exclusive Text nodes of a node node are node, node’s
      * previous sibling exclusive Text node, if any, and its contiguous
      * exclusive Text nodes, and node’s next sibling exclusive Text node,
      * if any, and its contiguous exclusive Text nodes, avoiding any duplicates.
      */
-    return {
-        [Symbol.iterator]() {
-            let currentNode = node;
+    return _a = {},
+        _a[Symbol.iterator] = function () {
+            var currentNode = node;
             while (currentNode && util_1.Guard.isExclusiveTextNode(currentNode._previousSibling)) {
                 currentNode = currentNode._previousSibling;
             }
             return {
-                next() {
+                next: function () {
                     if (currentNode && (!self && currentNode === node)) {
                         if (util_1.Guard.isExclusiveTextNode(currentNode._nextSibling)) {
                             currentNode = currentNode._nextSibling;
@@ -21596,7 +49759,7 @@ function text_contiguousExclusiveTextNodes(node, self = false) {
                         return { done: true, value: null };
                     }
                     else {
-                        const result = { done: false, value: currentNode };
+                        var result = { done: false, value: currentNode };
                         if (util_1.Guard.isExclusiveTextNode(currentNode._nextSibling)) {
                             currentNode = currentNode._nextSibling;
                         }
@@ -21607,9 +49770,10 @@ function text_contiguousExclusiveTextNodes(node, self = false) {
                     }
                 }
             };
-        }
-    };
+        },
+        _a;
 }
+exports.text_contiguousExclusiveTextNodes = text_contiguousExclusiveTextNodes;
 /**
  * Returns the concatenation of the data of all the Text node descendants of
  * node, in tree order.
@@ -21621,14 +49785,15 @@ function text_descendantTextContent(node) {
      * The descendant text content of a node node is the concatenation of the
      * data of all the Text node descendants of node, in tree order.
      */
-    let contents = '';
-    let text = (0, TreeAlgorithm_1.tree_getFirstDescendantNode)(node, false, false, (e) => util_1.Guard.isTextNode(e));
+    var contents = '';
+    var text = TreeAlgorithm_1.tree_getFirstDescendantNode(node, false, false, function (e) { return util_1.Guard.isTextNode(e); });
     while (text !== null) {
         contents += text._data;
-        text = (0, TreeAlgorithm_1.tree_getNextDescendantNode)(node, text, false, false, (e) => util_1.Guard.isTextNode(e));
+        text = TreeAlgorithm_1.tree_getNextDescendantNode(node, text, false, false, function (e) { return util_1.Guard.isTextNode(e); });
     }
     return contents;
 }
+exports.text_descendantTextContent = text_descendantTextContent;
 /**
  * Splits data at the given offset and returns the remainder as a text
  * node.
@@ -21637,12 +49802,13 @@ function text_descendantTextContent(node) {
  * @param offset - the offset at which to split the nodes.
  */
 function text_split(node, offset) {
+    var e_1, _a;
     /**
      * 1. Let length be node’s length.
      * 2. If offset is greater than length, then throw an "IndexSizeError"
      * DOMException.
      */
-    const length = node._data.length;
+    var length = node._data.length;
     if (offset > length) {
         throw new DOMException_1.IndexSizeError();
     }
@@ -21655,43 +49821,53 @@ function text_split(node, offset) {
      * 6. Let parent be node’s parent.
      * 7. If parent is not null, then:
      */
-    const count = length - offset;
-    const newData = (0, CharacterDataAlgorithm_1.characterData_substringData)(node, offset, count);
-    const newNode = (0, CreateAlgorithm_1.create_text)(node._nodeDocument, newData);
-    const parent = node._parent;
+    var count = length - offset;
+    var newData = CharacterDataAlgorithm_1.characterData_substringData(node, offset, count);
+    var newNode = CreateAlgorithm_1.create_text(node._nodeDocument, newData);
+    var parent = node._parent;
     if (parent !== null) {
         /**
          * 7.1. Insert new node into parent before node’s next sibling.
          */
-        (0, MutationAlgorithm_1.mutation_insert)(newNode, parent, node._nextSibling);
-        /**
-         * 7.2. For each live range whose start node is node and start offset is
-         * greater than offset, set its start node to new node and decrease its
-         * start offset by offset.
-         * 7.3. For each live range whose end node is node and end offset is greater
-         * than offset, set its end node to new node and decrease its end offset
-         * by offset.
-         * 7.4. For each live range whose start node is parent and start offset is
-         * equal to the index of node plus 1, increase its start offset by 1.
-         * 7.5. For each live range whose end node is parent and end offset is equal
-         * to the index of node plus 1, increase its end offset by 1.
-         */
-        for (const range of DOMImpl_1.dom.rangeList) {
-            if (range._start[0] === node && range._start[1] > offset) {
-                range._start[0] = newNode;
-                range._start[1] -= offset;
+        MutationAlgorithm_1.mutation_insert(newNode, parent, node._nextSibling);
+        try {
+            /**
+             * 7.2. For each live range whose start node is node and start offset is
+             * greater than offset, set its start node to new node and decrease its
+             * start offset by offset.
+             * 7.3. For each live range whose end node is node and end offset is greater
+             * than offset, set its end node to new node and decrease its end offset
+             * by offset.
+             * 7.4. For each live range whose start node is parent and start offset is
+             * equal to the index of node plus 1, increase its start offset by 1.
+             * 7.5. For each live range whose end node is parent and end offset is equal
+             * to the index of node plus 1, increase its end offset by 1.
+             */
+            for (var _b = __values(DOMImpl_1.dom.rangeList), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var range = _c.value;
+                if (range._start[0] === node && range._start[1] > offset) {
+                    range._start[0] = newNode;
+                    range._start[1] -= offset;
+                }
+                if (range._end[0] === node && range._end[1] > offset) {
+                    range._end[0] = newNode;
+                    range._end[1] -= offset;
+                }
+                var index = TreeAlgorithm_1.tree_index(node);
+                if (range._start[0] === parent && range._start[1] === index + 1) {
+                    range._start[1]++;
+                }
+                if (range._end[0] === parent && range._end[1] === index + 1) {
+                    range._end[1]++;
+                }
             }
-            if (range._end[0] === node && range._end[1] > offset) {
-                range._end[0] = newNode;
-                range._end[1] -= offset;
-            }
-            const index = (0, TreeAlgorithm_1.tree_index)(node);
-            if (range._start[0] === parent && range._start[1] === index + 1) {
-                range._start[1]++;
-            }
-            if (range._end[0] === parent && range._end[1] === index + 1) {
-                range._end[1]++;
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
+            finally { if (e_1) throw e_1.error; }
         }
     }
     /**
@@ -21699,9 +49875,10 @@ function text_split(node, offset) {
      * the empty string.
      * 9. Return new node.
      */
-    (0, CharacterDataAlgorithm_1.characterData_replaceData)(node, offset, count, '');
+    CharacterDataAlgorithm_1.characterData_replaceData(node, offset, count, '');
     return newNode;
 }
+exports.text_split = text_split;
 //# sourceMappingURL=TextAlgorithm.js.map
 
 /***/ }),
@@ -21712,9 +49889,8 @@ function text_split(node, offset) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.traversal_filter = traversal_filter;
-const interfaces_1 = __nccwpck_require__(27305);
-const DOMException_1 = __nccwpck_require__(13166);
+var interfaces_1 = __nccwpck_require__(27305);
+var DOMException_1 = __nccwpck_require__(13166);
 /**
  * Applies the filter to the given node and returns the result.
  *
@@ -21732,12 +49908,12 @@ function traversal_filter(traverser, node) {
     /**
      * 2. Let n be node’s nodeType attribute value − 1.
      */
-    const n = node._nodeType - 1;
+    var n = node._nodeType - 1;
     /**
      * 3. If the nth bit (where 0 is the least significant bit) of traverser’s
      * whatToShow is not set, then return FILTER_SKIP.
      */
-    const mask = 1 << n;
+    var mask = 1 << n;
     if ((traverser.whatToShow & mask) === 0) {
         return interfaces_1.FilterResult.Skip;
     }
@@ -21756,7 +49932,7 @@ function traversal_filter(traverser, node) {
      * traverser’s filter, "acceptNode", and « node ». If this throws an
      * exception, then unset traverser’s active flag and rethrow the exception.
      */
-    let result = interfaces_1.FilterResult.Reject;
+    var result = interfaces_1.FilterResult.Reject;
     try {
         result = traverser.filter.acceptNode(node);
     }
@@ -21771,48 +49947,30 @@ function traversal_filter(traverser, node) {
     traverser._activeFlag = false;
     return result;
 }
+exports.traversal_filter = traversal_filter;
 //# sourceMappingURL=TraversalAlgorithm.js.map
 
 /***/ }),
 
 /***/ 16620:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.tree_getFirstDescendantNode = tree_getFirstDescendantNode;
-exports.tree_getNextDescendantNode = tree_getNextDescendantNode;
-exports.tree_getDescendantNodes = tree_getDescendantNodes;
-exports.tree_getDescendantElements = tree_getDescendantElements;
-exports.tree_getSiblingNodes = tree_getSiblingNodes;
-exports.tree_getFirstAncestorNode = tree_getFirstAncestorNode;
-exports.tree_getNextAncestorNode = tree_getNextAncestorNode;
-exports.tree_getAncestorNodes = tree_getAncestorNodes;
-exports.tree_getCommonAncestor = tree_getCommonAncestor;
-exports.tree_getFollowingNode = tree_getFollowingNode;
-exports.tree_getPrecedingNode = tree_getPrecedingNode;
-exports.tree_isConstrained = tree_isConstrained;
-exports.tree_nodeLength = tree_nodeLength;
-exports.tree_isEmpty = tree_isEmpty;
-exports.tree_rootNode = tree_rootNode;
-exports.tree_isDescendantOf = tree_isDescendantOf;
-exports.tree_isAncestorOf = tree_isAncestorOf;
-exports.tree_isHostIncludingAncestorOf = tree_isHostIncludingAncestorOf;
-exports.tree_isSiblingOf = tree_isSiblingOf;
-exports.tree_isPreceding = tree_isPreceding;
-exports.tree_isFollowing = tree_isFollowing;
-exports.tree_isParentOf = tree_isParentOf;
-exports.tree_isChildOf = tree_isChildOf;
-exports.tree_previousSibling = tree_previousSibling;
-exports.tree_nextSibling = tree_nextSibling;
-exports.tree_firstChild = tree_firstChild;
-exports.tree_lastChild = tree_lastChild;
-exports.tree_treePosition = tree_treePosition;
-exports.tree_index = tree_index;
-exports.tree_retarget = tree_retarget;
-const util_1 = __nccwpck_require__(65282);
-const interfaces_1 = __nccwpck_require__(27305);
+var util_1 = __nccwpck_require__(65282);
+var interfaces_1 = __nccwpck_require__(27305);
 /**
  * Gets the next descendant of the given node of the tree rooted at `root`
  * in depth-first pre-order.
@@ -21821,7 +49979,8 @@ const interfaces_1 = __nccwpck_require__(27305);
  * @param node - a node
  * @param shadow - whether to visit shadow tree nodes
  */
-function _getNextDescendantNode(root, node, shadow = false) {
+function _getNextDescendantNode(root, node, shadow) {
+    if (shadow === void 0) { shadow = false; }
     // traverse shadow tree
     if (shadow && util_1.Guard.isElementNode(node) && util_1.Guard.isShadowRoot(node.shadowRoot)) {
         if (node.shadowRoot._firstChild)
@@ -21836,7 +49995,7 @@ function _getNextDescendantNode(root, node, shadow = false) {
     if (node._nextSibling)
         return node._nextSibling;
     // traverse parent's next sibling
-    let parent = node._parent;
+    var parent = node._parent;
     while (parent && parent !== root) {
         if (parent._nextSibling)
             return parent._nextSibling;
@@ -21845,15 +50004,16 @@ function _getNextDescendantNode(root, node, shadow = false) {
     return null;
 }
 function _emptyIterator() {
-    return {
-        [Symbol.iterator]: () => {
+    var _a;
+    return _a = {},
+        _a[Symbol.iterator] = function () {
             return {
-                next: () => {
+                next: function () {
                     return { done: true, value: null };
                 }
             };
-        }
-    };
+        },
+        _a;
 }
 /**
  * Returns the first descendant node of the tree rooted at `node` in
@@ -21864,13 +50024,16 @@ function _emptyIterator() {
  * @param shadow - whether to visit shadow tree nodes
  * @param filter - a function to filter nodes
  */
-function tree_getFirstDescendantNode(node, self = false, shadow = false, filter) {
-    let firstNode = (self ? node : _getNextDescendantNode(node, node, shadow));
+function tree_getFirstDescendantNode(node, self, shadow, filter) {
+    if (self === void 0) { self = false; }
+    if (shadow === void 0) { shadow = false; }
+    var firstNode = (self ? node : _getNextDescendantNode(node, node, shadow));
     while (firstNode && filter && !filter(firstNode)) {
         firstNode = _getNextDescendantNode(node, firstNode, shadow);
     }
     return firstNode;
 }
+exports.tree_getFirstDescendantNode = tree_getFirstDescendantNode;
 /**
  * Returns the next descendant node of the tree rooted at `node` in
  * depth-first pre-order.
@@ -21881,13 +50044,16 @@ function tree_getFirstDescendantNode(node, self = false, shadow = false, filter)
  * @param shadow - whether to visit shadow tree nodes
  * @param filter - a function to filter nodes
  */
-function tree_getNextDescendantNode(node, currentNode, self = false, shadow = false, filter) {
-    let nextNode = _getNextDescendantNode(node, currentNode, shadow);
+function tree_getNextDescendantNode(node, currentNode, self, shadow, filter) {
+    if (self === void 0) { self = false; }
+    if (shadow === void 0) { shadow = false; }
+    var nextNode = _getNextDescendantNode(node, currentNode, shadow);
     while (nextNode && filter && !filter(nextNode)) {
         nextNode = _getNextDescendantNode(node, nextNode, shadow);
     }
     return nextNode;
 }
+exports.tree_getNextDescendantNode = tree_getNextDescendantNode;
 /**
  * Traverses through all descendant nodes of the tree rooted at
  * `node` in depth-first pre-order.
@@ -21897,15 +50063,18 @@ function tree_getNextDescendantNode(node, currentNode, self = false, shadow = fa
  * @param shadow - whether to visit shadow tree nodes
  * @param filter - a function to filter nodes
  */
-function tree_getDescendantNodes(node, self = false, shadow = false, filter) {
+function tree_getDescendantNodes(node, self, shadow, filter) {
+    var _a;
+    if (self === void 0) { self = false; }
+    if (shadow === void 0) { shadow = false; }
     if (!self && node._children.size === 0) {
         return _emptyIterator();
     }
-    return {
-        [Symbol.iterator]: () => {
-            let currentNode = (self ? node : _getNextDescendantNode(node, node, shadow));
+    return _a = {},
+        _a[Symbol.iterator] = function () {
+            var currentNode = (self ? node : _getNextDescendantNode(node, node, shadow));
             return {
-                next: () => {
+                next: function () {
                     while (currentNode && filter && !filter(currentNode)) {
                         currentNode = _getNextDescendantNode(node, currentNode, shadow);
                     }
@@ -21913,15 +50082,16 @@ function tree_getDescendantNodes(node, self = false, shadow = false, filter) {
                         return { done: true, value: null };
                     }
                     else {
-                        const result = { done: false, value: currentNode };
+                        var result = { done: false, value: currentNode };
                         currentNode = _getNextDescendantNode(node, currentNode, shadow);
                         return result;
                     }
                 }
             };
-        }
-    };
+        },
+        _a;
 }
+exports.tree_getDescendantNodes = tree_getDescendantNodes;
 /**
  * Traverses through all descendant element nodes of the tree rooted at
  * `node` in depth-first preorder.
@@ -21931,16 +50101,19 @@ function tree_getDescendantNodes(node, self = false, shadow = false, filter) {
  * @param shadow - whether to visit shadow tree nodes
  * @param filter - a function to filter nodes
  */
-function tree_getDescendantElements(node, self = false, shadow = false, filter) {
+function tree_getDescendantElements(node, self, shadow, filter) {
+    var _a;
+    if (self === void 0) { self = false; }
+    if (shadow === void 0) { shadow = false; }
     if (!self && node._children.size === 0) {
         return _emptyIterator();
     }
-    return {
-        [Symbol.iterator]: () => {
-            const it = tree_getDescendantNodes(node, self, shadow, (e) => util_1.Guard.isElementNode(e))[Symbol.iterator]();
-            let currentNode = it.next().value;
+    return _a = {},
+        _a[Symbol.iterator] = function () {
+            var it = tree_getDescendantNodes(node, self, shadow, function (e) { return util_1.Guard.isElementNode(e); })[Symbol.iterator]();
+            var currentNode = it.next().value;
             return {
-                next() {
+                next: function () {
                     while (currentNode && filter && !filter(currentNode)) {
                         currentNode = it.next().value;
                     }
@@ -21948,15 +50121,16 @@ function tree_getDescendantElements(node, self = false, shadow = false, filter)
                         return { done: true, value: null };
                     }
                     else {
-                        const result = { done: false, value: currentNode };
+                        var result = { done: false, value: currentNode };
                         currentNode = it.next().value;
                         return result;
                     }
                 }
             };
-        }
-    };
+        },
+        _a;
 }
+exports.tree_getDescendantElements = tree_getDescendantElements;
 /**
  * Traverses through all sibling nodes of `node`.
  *
@@ -21964,15 +50138,17 @@ function tree_getDescendantElements(node, self = false, shadow = false, filter)
  * @param self - whether to include `node` in traversal
  * @param filter - a function to filter nodes
  */
-function tree_getSiblingNodes(node, self = false, filter) {
+function tree_getSiblingNodes(node, self, filter) {
+    var _a;
+    if (self === void 0) { self = false; }
     if (!node._parent || node._parent._children.size === 0) {
         return _emptyIterator();
     }
-    return {
-        [Symbol.iterator]() {
-            let currentNode = node._parent ? node._parent._firstChild : null;
+    return _a = {},
+        _a[Symbol.iterator] = function () {
+            var currentNode = node._parent ? node._parent._firstChild : null;
             return {
-                next() {
+                next: function () {
                     while (currentNode && (filter && !filter(currentNode) || (!self && currentNode === node))) {
                         currentNode = currentNode._nextSibling;
                     }
@@ -21980,15 +50156,16 @@ function tree_getSiblingNodes(node, self = false, filter) {
                         return { done: true, value: null };
                     }
                     else {
-                        const result = { done: false, value: currentNode };
+                        var result = { done: false, value: currentNode };
                         currentNode = currentNode._nextSibling;
                         return result;
                     }
                 }
             };
-        }
-    };
+        },
+        _a;
 }
+exports.tree_getSiblingNodes = tree_getSiblingNodes;
 /**
  * Gets the first ancestor of `node` in reverse tree order.
  *
@@ -21996,13 +50173,15 @@ function tree_getSiblingNodes(node, self = false, filter) {
  * @param self - whether to include `node` in traversal
  * @param filter - a function to filter nodes
  */
-function tree_getFirstAncestorNode(node, self = false, filter) {
-    let firstNode = self ? node : node._parent;
+function tree_getFirstAncestorNode(node, self, filter) {
+    if (self === void 0) { self = false; }
+    var firstNode = self ? node : node._parent;
     while (firstNode && filter && !filter(firstNode)) {
         firstNode = firstNode._parent;
     }
     return firstNode;
 }
+exports.tree_getFirstAncestorNode = tree_getFirstAncestorNode;
 /**
  * Gets the first ancestor of `node` in reverse tree order.
  *
@@ -22010,13 +50189,15 @@ function tree_getFirstAncestorNode(node, self = false, filter) {
  * @param self - whether to include `node` in traversal
  * @param filter - a function to filter nodes
  */
-function tree_getNextAncestorNode(node, currentNode, self = false, filter) {
-    let nextNode = currentNode._parent;
+function tree_getNextAncestorNode(node, currentNode, self, filter) {
+    if (self === void 0) { self = false; }
+    var nextNode = currentNode._parent;
     while (nextNode && filter && !filter(nextNode)) {
         nextNode = nextNode._parent;
     }
     return nextNode;
 }
+exports.tree_getNextAncestorNode = tree_getNextAncestorNode;
 /**
  * Traverses through all ancestor nodes `node` in reverse tree order.
  *
@@ -22024,28 +50205,31 @@ function tree_getNextAncestorNode(node, currentNode, self = false, filter) {
  * @param self - whether to include `node` in traversal
  * @param filter - a function to filter nodes
  */
-function tree_getAncestorNodes(node, self = false, filter) {
+function tree_getAncestorNodes(node, self, filter) {
+    var _a;
+    if (self === void 0) { self = false; }
     if (!self && !node._parent) {
         return _emptyIterator();
     }
-    return {
-        [Symbol.iterator]() {
-            let currentNode = tree_getFirstAncestorNode(node, self, filter);
+    return _a = {},
+        _a[Symbol.iterator] = function () {
+            var currentNode = tree_getFirstAncestorNode(node, self, filter);
             return {
-                next() {
+                next: function () {
                     if (currentNode === null) {
                         return { done: true, value: null };
                     }
                     else {
-                        const result = { done: false, value: currentNode };
+                        var result = { done: false, value: currentNode };
                         currentNode = tree_getNextAncestorNode(node, currentNode, self, filter);
                         return result;
                     }
                 }
             };
-        }
-    };
+        },
+        _a;
 }
+exports.tree_getAncestorNodes = tree_getAncestorNodes;
 /**
  * Returns the common ancestor of the given nodes.
  *
@@ -22057,25 +50241,25 @@ function tree_getCommonAncestor(nodeA, nodeB) {
         return nodeA._parent;
     }
     // lists of parent nodes
-    const parentsA = [];
-    const parentsB = [];
-    let pA = tree_getFirstAncestorNode(nodeA, true);
+    var parentsA = [];
+    var parentsB = [];
+    var pA = tree_getFirstAncestorNode(nodeA, true);
     while (pA !== null) {
         parentsA.push(pA);
         pA = tree_getNextAncestorNode(nodeA, pA, true);
     }
-    let pB = tree_getFirstAncestorNode(nodeB, true);
+    var pB = tree_getFirstAncestorNode(nodeB, true);
     while (pB !== null) {
         parentsB.push(pB);
         pB = tree_getNextAncestorNode(nodeB, pB, true);
     }
     // walk through parents backwards until they differ
-    let pos1 = parentsA.length;
-    let pos2 = parentsB.length;
-    let parent = null;
-    for (let i = Math.min(pos1, pos2); i > 0; i--) {
-        const parent1 = parentsA[--pos1];
-        const parent2 = parentsB[--pos2];
+    var pos1 = parentsA.length;
+    var pos2 = parentsB.length;
+    var parent = null;
+    for (var i = Math.min(pos1, pos2); i > 0; i--) {
+        var parent1 = parentsA[--pos1];
+        var parent2 = parentsB[--pos2];
         if (parent1 !== parent2) {
             break;
         }
@@ -22083,6 +50267,7 @@ function tree_getCommonAncestor(nodeA, nodeB) {
     }
     return parent;
 }
+exports.tree_getCommonAncestor = tree_getCommonAncestor;
 /**
  * Returns the node following `node` in depth-first preorder.
  *
@@ -22098,7 +50283,7 @@ function tree_getFollowingNode(root, node) {
     }
     else {
         while (true) {
-            const parent = node._parent;
+            var parent = node._parent;
             if (parent === null || parent === root) {
                 return null;
             }
@@ -22111,6 +50296,7 @@ function tree_getFollowingNode(root, node) {
         }
     }
 }
+exports.tree_getFollowingNode = tree_getFollowingNode;
 /**
  * Returns the node preceding `node` in depth-first preorder.
  *
@@ -22134,6 +50320,7 @@ function tree_getPrecedingNode(root, node) {
         return node._parent;
     }
 }
+exports.tree_getPrecedingNode = tree_getPrecedingNode;
 /**
  * Determines if the node tree is constrained. A node tree is
  * constrained as follows, expressed as a relationship between the
@@ -22156,44 +50343,65 @@ function tree_getPrecedingNode(root, node) {
  * @param node - the root of the tree
  */
 function tree_isConstrained(node) {
+    var e_1, _a, e_2, _b, e_3, _c;
     switch (node._nodeType) {
         case interfaces_1.NodeType.Document:
-            let hasDocType = false;
-            let hasElement = false;
-            for (const childNode of node._children) {
-                switch (childNode._nodeType) {
-                    case interfaces_1.NodeType.ProcessingInstruction:
-                    case interfaces_1.NodeType.Comment:
-                        break;
-                    case interfaces_1.NodeType.DocumentType:
-                        if (hasDocType || hasElement)
+            var hasDocType = false;
+            var hasElement = false;
+            try {
+                for (var _d = __values(node._children), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var childNode = _e.value;
+                    switch (childNode._nodeType) {
+                        case interfaces_1.NodeType.ProcessingInstruction:
+                        case interfaces_1.NodeType.Comment:
+                            break;
+                        case interfaces_1.NodeType.DocumentType:
+                            if (hasDocType || hasElement)
+                                return false;
+                            hasDocType = true;
+                            break;
+                        case interfaces_1.NodeType.Element:
+                            if (hasElement)
+                                return false;
+                            hasElement = true;
+                            break;
+                        default:
                             return false;
-                        hasDocType = true;
-                        break;
-                    case interfaces_1.NodeType.Element:
-                        if (hasElement)
-                            return false;
-                        hasElement = true;
-                        break;
-                    default:
-                        return false;
+                    }
                 }
             }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
             break;
         case interfaces_1.NodeType.DocumentFragment:
         case interfaces_1.NodeType.Element:
-            for (const childNode of node._children) {
-                switch (childNode._nodeType) {
-                    case interfaces_1.NodeType.Element:
-                    case interfaces_1.NodeType.Text:
-                    case interfaces_1.NodeType.ProcessingInstruction:
-                    case interfaces_1.NodeType.CData:
-                    case interfaces_1.NodeType.Comment:
-                        break;
-                    default:
-                        return false;
+            try {
+                for (var _f = __values(node._children), _g = _f.next(); !_g.done; _g = _f.next()) {
+                    var childNode = _g.value;
+                    switch (childNode._nodeType) {
+                        case interfaces_1.NodeType.Element:
+                        case interfaces_1.NodeType.Text:
+                        case interfaces_1.NodeType.ProcessingInstruction:
+                        case interfaces_1.NodeType.CData:
+                        case interfaces_1.NodeType.Comment:
+                            break;
+                        default:
+                            return false;
+                    }
                 }
             }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
             break;
         case interfaces_1.NodeType.DocumentType:
         case interfaces_1.NodeType.Text:
@@ -22202,13 +50410,24 @@ function tree_isConstrained(node) {
         case interfaces_1.NodeType.Comment:
             return (!node.hasChildNodes());
     }
-    for (const childNode of node._children) {
-        // recursively check child nodes
-        if (!tree_isConstrained(childNode))
-            return false;
+    try {
+        for (var _h = __values(node._children), _j = _h.next(); !_j.done; _j = _h.next()) {
+            var childNode = _j.value;
+            // recursively check child nodes
+            if (!tree_isConstrained(childNode))
+                return false;
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_j && !_j.done && (_c = _h.return)) _c.call(_h);
+        }
+        finally { if (e_3) throw e_3.error; }
     }
     return true;
 }
+exports.tree_isConstrained = tree_isConstrained;
 /**
  * Returns the length of a node.
  *
@@ -22236,6 +50455,7 @@ function tree_nodeLength(node) {
         return node._children.size;
     }
 }
+exports.tree_nodeLength = tree_nodeLength;
 /**
  * Determines if a node is empty.
  *
@@ -22247,6 +50467,7 @@ function tree_isEmpty(node) {
         */
     return (tree_nodeLength(node) === 0);
 }
+exports.tree_isEmpty = tree_isEmpty;
 /**
  * Returns the root node of a tree. The root of an object is itself,
  * if its parent is `null`, or else it is the root of its parent.
@@ -22257,14 +50478,15 @@ function tree_isEmpty(node) {
  * @param shadow - `true` to return shadow-including root, otherwise
  * `false`
  */
-function tree_rootNode(node, shadow = false) {
+function tree_rootNode(node, shadow) {
+    if (shadow === void 0) { shadow = false; }
     /**
         * The root of an object is itself, if its parent is null, or else it is the
         * root of its parent. The root of a tree is any object participating in
         * that tree whose parent is null.
         */
     if (shadow) {
-        const root = tree_rootNode(node, false);
+        var root = tree_rootNode(node, false);
         if (util_1.Guard.isShadowRoot(root))
             return tree_rootNode(root._host, true);
         else
@@ -22277,6 +50499,7 @@ function tree_rootNode(node, shadow = false) {
             return tree_rootNode(node._parent);
     }
 }
+exports.tree_rootNode = tree_rootNode;
 /**
  * Determines whether `other` is a descendant of `node`. An object
  * A is called a descendant of an object B, if either A is a child
@@ -22288,14 +50511,16 @@ function tree_rootNode(node, shadow = false) {
  * @param shadow - if `true`, traversal includes the
  * node's and its descendant's shadow trees as well.
  */
-function tree_isDescendantOf(node, other, self = false, shadow = false) {
+function tree_isDescendantOf(node, other, self, shadow) {
+    if (self === void 0) { self = false; }
+    if (shadow === void 0) { shadow = false; }
     /**
         * An object A is called a descendant of an object B, if either A is a
         * child of B or A is a child of an object C that is a descendant of B.
         *
         * An inclusive descendant is an object or one of its descendants.
     */
-    let child = tree_getFirstDescendantNode(node, self, shadow);
+    var child = tree_getFirstDescendantNode(node, self, shadow);
     while (child !== null) {
         if (child === other) {
             return true;
@@ -22304,6 +50529,7 @@ function tree_isDescendantOf(node, other, self = false, shadow = false) {
     }
     return false;
 }
+exports.tree_isDescendantOf = tree_isDescendantOf;
 /**
  * Determines whether `other` is an ancestor of `node`. An object A
  * is called an ancestor of an object B if and only if B is a
@@ -22315,8 +50541,10 @@ function tree_isDescendantOf(node, other, self = false, shadow = false) {
  * @param shadow - if `true`, traversal includes the
  * node's and its descendant's shadow trees as well.
  */
-function tree_isAncestorOf(node, other, self = false, shadow = false) {
-    let ancestor = self ? node : shadow && util_1.Guard.isShadowRoot(node) ?
+function tree_isAncestorOf(node, other, self, shadow) {
+    if (self === void 0) { self = false; }
+    if (shadow === void 0) { shadow = false; }
+    var ancestor = self ? node : shadow && util_1.Guard.isShadowRoot(node) ?
         node._host : node._parent;
     while (ancestor !== null) {
         if (ancestor === other)
@@ -22326,6 +50554,7 @@ function tree_isAncestorOf(node, other, self = false, shadow = false) {
     }
     return false;
 }
+exports.tree_isAncestorOf = tree_isAncestorOf;
 /**
  * Determines whether `other` is a host-including ancestor of `node`. An
  * object A is a host-including inclusive ancestor of an object B, if either
@@ -22336,15 +50565,17 @@ function tree_isAncestorOf(node, other, self = false, shadow = false) {
  * @param other - the node to check
  * @param self - if `true`, traversal includes `node` itself
  */
-function tree_isHostIncludingAncestorOf(node, other, self = false) {
+function tree_isHostIncludingAncestorOf(node, other, self) {
+    if (self === void 0) { self = false; }
     if (tree_isAncestorOf(node, other, self))
         return true;
-    const root = tree_rootNode(node);
+    var root = tree_rootNode(node);
     if (util_1.Guard.isDocumentFragmentNode(root) && root._host !== null &&
         tree_isHostIncludingAncestorOf(root._host, other, self))
         return true;
     return false;
 }
+exports.tree_isHostIncludingAncestorOf = tree_isHostIncludingAncestorOf;
 /**
  * Determines whether `other` is a sibling of `node`. An object A is
  * called a sibling of an object B, if and only if B and A share
@@ -22354,7 +50585,8 @@ function tree_isHostIncludingAncestorOf(node, other, self = false) {
  * @param other - the node to check
  * @param self - if `true`, traversal includes `node` itself
  */
-function tree_isSiblingOf(node, other, self = false) {
+function tree_isSiblingOf(node, other, self) {
+    if (self === void 0) { self = false; }
     /**
         * An object A is called a sibling of an object B, if and only if B and A
         * share the same non-null parent.
@@ -22370,6 +50602,7 @@ function tree_isSiblingOf(node, other, self = false) {
     }
     return false;
 }
+exports.tree_isSiblingOf = tree_isSiblingOf;
 /**
  * Determines whether `other` is preceding `node`. An object A is
  * preceding an object B if A and B are in the same tree and A comes
@@ -22383,8 +50616,8 @@ function tree_isPreceding(node, other) {
         * An object A is preceding an object B if A and B are in the same tree and
         * A comes before B in tree order.
         */
-    const nodePos = tree_treePosition(node);
-    const otherPos = tree_treePosition(other);
+    var nodePos = tree_treePosition(node);
+    var otherPos = tree_treePosition(other);
     if (nodePos === -1 || otherPos === -1)
         return false;
     else if (tree_rootNode(node) !== tree_rootNode(other))
@@ -22392,6 +50625,7 @@ function tree_isPreceding(node, other) {
     else
         return otherPos < nodePos;
 }
+exports.tree_isPreceding = tree_isPreceding;
 /**
  * Determines whether `other` is following `node`. An object A is
  * following an object B if A and B are in the same tree and A comes
@@ -22405,8 +50639,8 @@ function tree_isFollowing(node, other) {
         * An object A is following an object B if A and B are in the same tree and
         * A comes after B in tree order.
         */
-    const nodePos = tree_treePosition(node);
-    const otherPos = tree_treePosition(other);
+    var nodePos = tree_treePosition(node);
+    var otherPos = tree_treePosition(other);
     if (nodePos === -1 || otherPos === -1)
         return false;
     else if (tree_rootNode(node) !== tree_rootNode(other))
@@ -22414,6 +50648,7 @@ function tree_isFollowing(node, other) {
     else
         return otherPos > nodePos;
 }
+exports.tree_isFollowing = tree_isFollowing;
 /**
  * Determines whether `other` is the parent node of `node`.
  *
@@ -22428,6 +50663,7 @@ function tree_isParentOf(node, other) {
         */
     return (node._parent === other);
 }
+exports.tree_isParentOf = tree_isParentOf;
 /**
  * Determines whether `other` is a child node of `node`.
  *
@@ -22442,6 +50678,7 @@ function tree_isChildOf(node, other) {
         */
     return (other._parent === node);
 }
+exports.tree_isChildOf = tree_isChildOf;
 /**
  * Returns the previous sibling node of `node` or null if it has no
  * preceding sibling.
@@ -22455,6 +50692,7 @@ function tree_previousSibling(node) {
         */
     return node._previousSibling;
 }
+exports.tree_previousSibling = tree_previousSibling;
 /**
  * Returns the next sibling node of `node` or null if it has no
  * following sibling.
@@ -22468,6 +50706,7 @@ function tree_nextSibling(node) {
         */
     return node._nextSibling;
 }
+exports.tree_nextSibling = tree_nextSibling;
 /**
  * Returns the first child node of `node` or null if it has no
  * children.
@@ -22481,6 +50720,7 @@ function tree_firstChild(node) {
         */
     return node._firstChild;
 }
+exports.tree_firstChild = tree_firstChild;
 /**
  * Returns the last child node of `node` or null if it has no
  * children.
@@ -22494,6 +50734,7 @@ function tree_lastChild(node) {
         */
     return node._lastChild;
 }
+exports.tree_lastChild = tree_lastChild;
 /**
  * Returns the zero-based index of `node` when counted preorder in
  * the tree rooted at `root`. Returns `-1` if `node` is not in
@@ -22502,9 +50743,9 @@ function tree_lastChild(node) {
  * @param node - the node to get the index of
  */
 function tree_treePosition(node) {
-    const root = tree_rootNode(node);
-    let pos = 0;
-    let childNode = tree_getFirstDescendantNode(root);
+    var root = tree_rootNode(node);
+    var pos = 0;
+    var childNode = tree_getFirstDescendantNode(root);
     while (childNode !== null) {
         pos++;
         if (childNode === node)
@@ -22513,6 +50754,7 @@ function tree_treePosition(node) {
     }
     return -1;
 }
+exports.tree_treePosition = tree_treePosition;
 /**
  * Determines the index of `node`. The index of an object is its number of
  * preceding siblings, or 0 if it has none.
@@ -22525,13 +50767,14 @@ function tree_index(node) {
         * The index of an object is its number of preceding siblings, or 0 if it
         * has none.
         */
-    let n = 0;
+    var n = 0;
     while (node._previousSibling !== null) {
         n++;
         node = node._previousSibling;
     }
     return n;
 }
+exports.tree_index = tree_index;
 /**
  * Retargets an object against another object.
  *
@@ -22554,7 +50797,7 @@ function tree_retarget(a, b) {
         if (!a || !util_1.Guard.isNode(a)) {
             return a;
         }
-        const rootOfA = tree_rootNode(a);
+        var rootOfA = tree_rootNode(a);
         if (!util_1.Guard.isShadowRoot(rootOfA)) {
             return a;
         }
@@ -22564,6 +50807,7 @@ function tree_retarget(a, b) {
         a = rootOfA.host;
     }
 }
+exports.tree_retarget = tree_retarget;
 //# sourceMappingURL=TreeAlgorithm.js.map
 
 /***/ }),
@@ -22574,10 +50818,8 @@ function tree_retarget(a, b) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.treeWalker_traverseChildren = treeWalker_traverseChildren;
-exports.treeWalker_traverseSiblings = treeWalker_traverseSiblings;
-const interfaces_1 = __nccwpck_require__(27305);
-const TraversalAlgorithm_1 = __nccwpck_require__(80998);
+var interfaces_1 = __nccwpck_require__(27305);
+var TraversalAlgorithm_1 = __nccwpck_require__(80998);
 /**
  * Returns the first or last child node, or `null` if there are none.
  *
@@ -22592,12 +50834,12 @@ function treeWalker_traverseChildren(walker, first) {
      * if type is last.
      * 3. While node is non-null:
      */
-    let node = (first ? walker._current._firstChild : walker._current._lastChild);
+    var node = (first ? walker._current._firstChild : walker._current._lastChild);
     while (node !== null) {
         /**
          * 3.1. Let result be the result of filtering node within walker.
          */
-        const result = (0, TraversalAlgorithm_1.traversal_filter)(walker, node);
+        var result = TraversalAlgorithm_1.traversal_filter(walker, node);
         if (result === interfaces_1.FilterResult.Accept) {
             /**
              * 3.2. If result is FILTER_ACCEPT, then set walker’s current to node and
@@ -22613,7 +50855,7 @@ function treeWalker_traverseChildren(walker, first) {
              * last child if type is last.
              * 3.3.2. If child is non-null, then set node to child and continue.
              */
-            const child = (first ? node._firstChild : node._lastChild);
+            var child = (first ? node._firstChild : node._lastChild);
             if (child !== null) {
                 node = child;
                 continue;
@@ -22628,7 +50870,7 @@ function treeWalker_traverseChildren(walker, first) {
              * node’s previous sibling if type is last.
              * 3.4.2. If sibling is non-null, then set node to sibling and break.
              */
-            const sibling = (first ? node._nextSibling : node._previousSibling);
+            var sibling = (first ? node._nextSibling : node._previousSibling);
             if (sibling !== null) {
                 node = sibling;
                 break;
@@ -22638,7 +50880,7 @@ function treeWalker_traverseChildren(walker, first) {
              * 3.4.4. If parent is null, walker’s root, or walker’s current, then
              * return null.
              */
-            const parent = node._parent;
+            var parent = node._parent;
             if (parent === null || parent === walker._root || parent === walker._current) {
                 return null;
             }
@@ -22653,6 +50895,7 @@ function treeWalker_traverseChildren(walker, first) {
      */
     return null;
 }
+exports.treeWalker_traverseChildren = treeWalker_traverseChildren;
 /**
  * Returns the next or previous sibling node, or `null` if there are none.
  *
@@ -22666,7 +50909,7 @@ function treeWalker_traverseSiblings(walker, next) {
      * 2. If node is root, then return null.
      * 3. While node is non-null:
      */
-    let node = walker._current;
+    var node = walker._current;
     if (node === walker._root)
         return null;
     while (true) {
@@ -22675,7 +50918,7 @@ function treeWalker_traverseSiblings(walker, next) {
          * previous sibling if type is previous.
          * 3.2. While sibling is non-null:
          */
-        let sibling = (next ? node._nextSibling : node._previousSibling);
+        var sibling = (next ? node._nextSibling : node._previousSibling);
         while (sibling !== null) {
             /**
              * 3.2.1. Set node to sibling.
@@ -22684,7 +50927,7 @@ function treeWalker_traverseSiblings(walker, next) {
              * and return node.
              */
             node = sibling;
-            const result = (0, TraversalAlgorithm_1.traversal_filter)(walker, node);
+            var result = TraversalAlgorithm_1.traversal_filter(walker, node);
             if (result === interfaces_1.FilterResult.Accept) {
                 walker._current = node;
                 return node;
@@ -22713,11 +50956,12 @@ function treeWalker_traverseSiblings(walker, next) {
          * 3.5. If the return value of filtering node within walker is FILTER_ACCEPT,
          * then return null.
          */
-        if ((0, TraversalAlgorithm_1.traversal_filter)(walker, node) === interfaces_1.FilterResult.Accept) {
+        if (TraversalAlgorithm_1.traversal_filter(walker, node) === interfaces_1.FilterResult.Accept) {
             return null;
         }
     }
 }
+exports.treeWalker_traverseSiblings = treeWalker_traverseSiblings;
 //# sourceMappingURL=TreeWalkerAlgorithm.js.map
 
 /***/ }),
@@ -22728,7 +50972,6 @@ function treeWalker_traverseSiblings(walker, next) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.idl_defineConst = idl_defineConst;
 /**
  * Defines a WebIDL `Const` property on the given object.
  *
@@ -22739,6 +50982,7 @@ exports.idl_defineConst = idl_defineConst;
 function idl_defineConst(o, name, value) {
     Object.defineProperty(o, name, { writable: false, enumerable: true, configurable: false, value: value });
 }
+exports.idl_defineConst = idl_defineConst;
 //# sourceMappingURL=WebIDLAlgorithm.js.map
 
 /***/ }),
@@ -22749,18 +50993,14 @@ function idl_defineConst(o, name, value) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.xml_isName = xml_isName;
-exports.xml_isQName = xml_isQName;
-exports.xml_isLegalChar = xml_isLegalChar;
-exports.xml_isPubidChar = xml_isPubidChar;
 /**
  * Determines if the given string is valid for a `"Name"` construct.
  *
  * @param name - name string to test
  */
 function xml_isName(name) {
-    for (let i = 0; i < name.length; i++) {
-        let n = name.charCodeAt(i);
+    for (var i = 0; i < name.length; i++) {
+        var n = name.charCodeAt(i);
         // NameStartChar
         if ((n >= 97 && n <= 122) || // [a-z]
             (n >= 65 && n <= 90) || // [A-Z]
@@ -22787,7 +51027,7 @@ function xml_isName(name) {
             continue;
         }
         if (n >= 0xD800 && n <= 0xDBFF && i < name.length - 1) {
-            const n2 = name.charCodeAt(i + 1);
+            var n2 = name.charCodeAt(i + 1);
             if (n2 >= 0xDC00 && n2 <= 0xDFFF) {
                 n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000;
                 i++;
@@ -22800,15 +51040,16 @@ function xml_isName(name) {
     }
     return true;
 }
+exports.xml_isName = xml_isName;
 /**
  * Determines if the given string is valid for a `"QName"` construct.
  *
  * @param name - name string to test
  */
 function xml_isQName(name) {
-    let colonFound = false;
-    for (let i = 0; i < name.length; i++) {
-        let n = name.charCodeAt(i);
+    var colonFound = false;
+    for (var i = 0; i < name.length; i++) {
+        var n = name.charCodeAt(i);
         // NameStartChar
         if ((n >= 97 && n <= 122) || // [a-z]
             (n >= 65 && n <= 90) || // [A-Z]
@@ -22843,7 +51084,7 @@ function xml_isQName(name) {
             continue;
         }
         if (n >= 0xD800 && n <= 0xDBFF && i < name.length - 1) {
-            const n2 = name.charCodeAt(i + 1);
+            var n2 = name.charCodeAt(i + 1);
             if (n2 >= 0xDC00 && n2 <= 0xDFFF) {
                 n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000;
                 i++;
@@ -22856,14 +51097,15 @@ function xml_isQName(name) {
     }
     return true;
 }
+exports.xml_isQName = xml_isQName;
 /**
  * Determines if the given string contains legal characters.
  *
  * @param chars - sequence of characters to test
  */
 function xml_isLegalChar(chars) {
-    for (let i = 0; i < chars.length; i++) {
-        let n = chars.charCodeAt(i);
+    for (var i = 0; i < chars.length; i++) {
+        var n = chars.charCodeAt(i);
         // #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
         if (n === 0x9 || n === 0xA || n === 0xD ||
             (n >= 0x20 && n <= 0xD7FF) ||
@@ -22871,7 +51113,7 @@ function xml_isLegalChar(chars) {
             continue;
         }
         if (n >= 0xD800 && n <= 0xDBFF && i < chars.length - 1) {
-            const n2 = chars.charCodeAt(i + 1);
+            var n2 = chars.charCodeAt(i + 1);
             if (n2 >= 0xDC00 && n2 <= 0xDFFF) {
                 n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000;
                 i++;
@@ -22884,6 +51126,7 @@ function xml_isLegalChar(chars) {
     }
     return true;
 }
+exports.xml_isLegalChar = xml_isLegalChar;
 /**
  * Determines if the given string contains legal characters for a public
  * identifier.
@@ -22891,9 +51134,9 @@ function xml_isLegalChar(chars) {
  * @param chars - sequence of characters to test
  */
 function xml_isPubidChar(chars) {
-    for (let i = 0; i < chars.length; i++) {
+    for (var i = 0; i < chars.length; i++) {
         // PubId chars are all in the ASCII range, no need to check surrogates
-        const n = chars.charCodeAt(i);
+        var n = chars.charCodeAt(i);
         // #x20 | #xD | #xA | [a-zA-Z0-9] | [-'()+,./:=?;!*#@$_%]
         if ((n >= 97 && n <= 122) || // [a-z]
             (n >= 65 && n <= 90) || // [A-Z]
@@ -22910,58 +51153,48 @@ function xml_isPubidChar(chars) {
     }
     return true;
 }
+exports.xml_isPubidChar = xml_isPubidChar;
 //# sourceMappingURL=XMLAlgorithm.js.map
 
 /***/ }),
 
 /***/ 61:
-/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
 
 "use strict";
 
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-__exportStar(__nccwpck_require__(32206), exports);
-__exportStar(__nccwpck_require__(84309), exports);
-__exportStar(__nccwpck_require__(81054), exports);
-__exportStar(__nccwpck_require__(19461), exports);
-__exportStar(__nccwpck_require__(57339), exports);
-__exportStar(__nccwpck_require__(35648), exports);
-__exportStar(__nccwpck_require__(12793), exports);
-__exportStar(__nccwpck_require__(9628), exports);
-__exportStar(__nccwpck_require__(93261), exports);
-__exportStar(__nccwpck_require__(51849), exports);
-__exportStar(__nccwpck_require__(28217), exports);
-__exportStar(__nccwpck_require__(21312), exports);
-__exportStar(__nccwpck_require__(45463), exports);
-__exportStar(__nccwpck_require__(78157), exports);
-__exportStar(__nccwpck_require__(35856), exports);
-__exportStar(__nccwpck_require__(74924), exports);
-__exportStar(__nccwpck_require__(3973), exports);
-__exportStar(__nccwpck_require__(53670), exports);
-__exportStar(__nccwpck_require__(2328), exports);
-__exportStar(__nccwpck_require__(30457), exports);
-__exportStar(__nccwpck_require__(41853), exports);
-__exportStar(__nccwpck_require__(68733), exports);
-__exportStar(__nccwpck_require__(13512), exports);
-__exportStar(__nccwpck_require__(80998), exports);
-__exportStar(__nccwpck_require__(16620), exports);
-__exportStar(__nccwpck_require__(94962), exports);
-__exportStar(__nccwpck_require__(45457), exports);
-__exportStar(__nccwpck_require__(57030), exports);
+__export(__nccwpck_require__(32206));
+__export(__nccwpck_require__(84309));
+__export(__nccwpck_require__(81054));
+__export(__nccwpck_require__(19461));
+__export(__nccwpck_require__(57339));
+__export(__nccwpck_require__(35648));
+__export(__nccwpck_require__(12793));
+__export(__nccwpck_require__(9628));
+__export(__nccwpck_require__(93261));
+__export(__nccwpck_require__(51849));
+__export(__nccwpck_require__(28217));
+__export(__nccwpck_require__(21312));
+__export(__nccwpck_require__(45463));
+__export(__nccwpck_require__(78157));
+__export(__nccwpck_require__(35856));
+__export(__nccwpck_require__(74924));
+__export(__nccwpck_require__(3973));
+__export(__nccwpck_require__(53670));
+__export(__nccwpck_require__(2328));
+__export(__nccwpck_require__(30457));
+__export(__nccwpck_require__(41853));
+__export(__nccwpck_require__(68733));
+__export(__nccwpck_require__(13512));
+__export(__nccwpck_require__(80998));
+__export(__nccwpck_require__(16620));
+__export(__nccwpck_require__(94962));
+__export(__nccwpck_require__(45457));
+__export(__nccwpck_require__(57030));
 //# sourceMappingURL=index.js.map
 
 /***/ }),
@@ -22972,74 +51205,100 @@ __exportStar(__nccwpck_require__(57030), exports);
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.AbortControllerImpl = void 0;
-const algorithm_1 = __nccwpck_require__(61);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents a controller that allows to abort DOM requests.
  */
-class AbortControllerImpl {
-    _signal;
+var AbortControllerImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `AbortController`.
      */
-    constructor() {
+    function AbortControllerImpl() {
         /**
          * 1. Let signal be a new AbortSignal object.
          * 2. Let controller be a new AbortController object whose signal is signal.
          * 3. Return controller.
          */
-        this._signal = (0, algorithm_1.create_abortSignal)();
+        this._signal = algorithm_1.create_abortSignal();
     }
+    Object.defineProperty(AbortControllerImpl.prototype, "signal", {
+        /** @inheritdoc */
+        get: function () { return this._signal; },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get signal() { return this._signal; }
-    /** @inheritdoc */
-    abort() {
-        (0, algorithm_1.abort_signalAbort)(this._signal);
-    }
-}
+    AbortControllerImpl.prototype.abort = function () {
+        algorithm_1.abort_signalAbort(this._signal);
+    };
+    return AbortControllerImpl;
+}());
 exports.AbortControllerImpl = AbortControllerImpl;
 //# sourceMappingURL=AbortControllerImpl.js.map
 
 /***/ }),
 
 /***/ 10022:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.AbortSignalImpl = void 0;
-const EventTargetImpl_1 = __nccwpck_require__(69968);
-const algorithm_1 = __nccwpck_require__(61);
+var EventTargetImpl_1 = __nccwpck_require__(69968);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents a signal object that communicates with a DOM request and abort
  * it through an AbortController.
  */
-class AbortSignalImpl extends EventTargetImpl_1.EventTargetImpl {
-    _abortedFlag = false;
-    _abortAlgorithms = new Set();
+var AbortSignalImpl = /** @class */ (function (_super) {
+    __extends(AbortSignalImpl, _super);
     /**
      * Initializes a new instance of `AbortSignal`.
      */
-    constructor() {
-        super();
-    }
-    /** @inheritdoc */
-    get aborted() { return this._abortedFlag; }
-    /** @inheritdoc */
-    get onabort() {
-        return (0, algorithm_1.event_getterEventHandlerIDLAttribute)(this, "onabort");
-    }
-    set onabort(val) {
-        (0, algorithm_1.event_setterEventHandlerIDLAttribute)(this, "onabort", val);
+    function AbortSignalImpl() {
+        var _this = _super.call(this) || this;
+        _this._abortedFlag = false;
+        _this._abortAlgorithms = new Set();
+        return _this;
     }
+    Object.defineProperty(AbortSignalImpl.prototype, "aborted", {
+        /** @inheritdoc */
+        get: function () { return this._abortedFlag; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbortSignalImpl.prototype, "onabort", {
+        /** @inheritdoc */
+        get: function () {
+            return algorithm_1.event_getterEventHandlerIDLAttribute(this, "onabort");
+        },
+        set: function (val) {
+            algorithm_1.event_setterEventHandlerIDLAttribute(this, "onabort", val);
+        },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Creates a new `AbortSignal`.
      */
-    static _create() {
+    AbortSignalImpl._create = function () {
         return new AbortSignalImpl();
-    }
-}
+    };
+    return AbortSignalImpl;
+}(EventTargetImpl_1.EventTargetImpl));
 exports.AbortSignalImpl = AbortSignalImpl;
 //# sourceMappingURL=AbortSignalImpl.js.map
 
@@ -23051,143 +51310,236 @@ exports.AbortSignalImpl = AbortSignalImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.AbstractRangeImpl = void 0;
 /**
  * Represents an abstract range with a start and end boundary point.
  */
-class AbstractRangeImpl {
-    get _startNode() { return this._start[0]; }
-    get _startOffset() { return this._start[1]; }
-    get _endNode() { return this._end[0]; }
-    get _endOffset() { return this._end[1]; }
-    get _collapsed() {
-        return (this._start[0] === this._end[0] &&
-            this._start[1] === this._end[1]);
+var AbstractRangeImpl = /** @class */ (function () {
+    function AbstractRangeImpl() {
     }
-    /** @inheritdoc */
-    get startContainer() { return this._startNode; }
-    /** @inheritdoc */
-    get startOffset() { return this._startOffset; }
-    /** @inheritdoc */
-    get endContainer() { return this._endNode; }
-    /** @inheritdoc */
-    get endOffset() { return this._endOffset; }
-    /** @inheritdoc */
-    get collapsed() { return this._collapsed; }
-}
+    Object.defineProperty(AbstractRangeImpl.prototype, "_startNode", {
+        get: function () { return this._start[0]; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbstractRangeImpl.prototype, "_startOffset", {
+        get: function () { return this._start[1]; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbstractRangeImpl.prototype, "_endNode", {
+        get: function () { return this._end[0]; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbstractRangeImpl.prototype, "_endOffset", {
+        get: function () { return this._end[1]; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbstractRangeImpl.prototype, "_collapsed", {
+        get: function () {
+            return (this._start[0] === this._end[0] &&
+                this._start[1] === this._end[1]);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbstractRangeImpl.prototype, "startContainer", {
+        /** @inheritdoc */
+        get: function () { return this._startNode; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbstractRangeImpl.prototype, "startOffset", {
+        /** @inheritdoc */
+        get: function () { return this._startOffset; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbstractRangeImpl.prototype, "endContainer", {
+        /** @inheritdoc */
+        get: function () { return this._endNode; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbstractRangeImpl.prototype, "endOffset", {
+        /** @inheritdoc */
+        get: function () { return this._endOffset; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AbstractRangeImpl.prototype, "collapsed", {
+        /** @inheritdoc */
+        get: function () { return this._collapsed; },
+        enumerable: true,
+        configurable: true
+    });
+    return AbstractRangeImpl;
+}());
 exports.AbstractRangeImpl = AbstractRangeImpl;
 //# sourceMappingURL=AbstractRangeImpl.js.map
 
 /***/ }),
 
 /***/ 13717:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.AttrImpl = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
-const NodeImpl_1 = __nccwpck_require__(91745);
-const algorithm_1 = __nccwpck_require__(61);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var interfaces_1 = __nccwpck_require__(27305);
+var NodeImpl_1 = __nccwpck_require__(91745);
+var algorithm_1 = __nccwpck_require__(61);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents an attribute of an element node.
  */
-class AttrImpl extends NodeImpl_1.NodeImpl {
-    _nodeType = interfaces_1.NodeType.Attribute;
-    _localName;
-    _namespace = null;
-    _namespacePrefix = null;
-    _element = null;
-    _value = '';
+var AttrImpl = /** @class */ (function (_super) {
+    __extends(AttrImpl, _super);
     /**
      * Initializes a new instance of `Attr`.
      *
      * @param localName - local name
      */
-    constructor(localName) {
-        super();
-        this._localName = localName;
+    function AttrImpl(localName) {
+        var _this = _super.call(this) || this;
+        _this._namespace = null;
+        _this._namespacePrefix = null;
+        _this._element = null;
+        _this._value = '';
+        _this._localName = localName;
+        return _this;
     }
-    /** @inheritdoc */
-    specified;
-    /** @inheritdoc */
-    get ownerElement() { return this._element; }
-    /** @inheritdoc */
-    get namespaceURI() { return this._namespace; }
-    /** @inheritdoc */
-    get prefix() { return this._namespacePrefix; }
-    /** @inheritdoc */
-    get localName() { return this._localName; }
-    /** @inheritdoc */
-    get name() { return this._qualifiedName; }
-    /** @inheritdoc */
-    get value() { return this._value; }
-    set value(value) {
+    Object.defineProperty(AttrImpl.prototype, "ownerElement", {
+        /** @inheritdoc */
+        get: function () { return this._element; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AttrImpl.prototype, "namespaceURI", {
+        /** @inheritdoc */
+        get: function () { return this._namespace; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AttrImpl.prototype, "prefix", {
+        /** @inheritdoc */
+        get: function () { return this._namespacePrefix; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AttrImpl.prototype, "localName", {
+        /** @inheritdoc */
+        get: function () { return this._localName; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AttrImpl.prototype, "name", {
+        /** @inheritdoc */
+        get: function () { return this._qualifiedName; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AttrImpl.prototype, "value", {
+        /** @inheritdoc */
+        get: function () { return this._value; },
+        set: function (value) {
+            /**
+             * The value attribute’s setter must set an existing attribute value with
+             * context object and the given value.
+             */
+            algorithm_1.attr_setAnExistingAttributeValue(this, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(AttrImpl.prototype, "_qualifiedName", {
         /**
-         * The value attribute’s setter must set an existing attribute value with
-         * context object and the given value.
+         * Returns the qualified name.
          */
-        (0, algorithm_1.attr_setAnExistingAttributeValue)(this, value);
-    }
-    /**
-     * Returns the qualified name.
-     */
-    get _qualifiedName() {
-        /**
-         * An attribute’s qualified name is its local name if its namespace prefix
-         * is null, and its namespace prefix, followed by ":", followed by its
-         * local name, otherwise.
-         */
-        return (this._namespacePrefix !== null ?
-            this._namespacePrefix + ':' + this._localName :
-            this._localName);
-    }
+        get: function () {
+            /**
+             * An attribute’s qualified name is its local name if its namespace prefix
+             * is null, and its namespace prefix, followed by ":", followed by its
+             * local name, otherwise.
+             */
+            return (this._namespacePrefix !== null ?
+                this._namespacePrefix + ':' + this._localName :
+                this._localName);
+        },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Creates an `Attr`.
      *
      * @param document - owner document
      * @param localName - local name
      */
-    static _create(document, localName) {
-        const node = new AttrImpl(localName);
+    AttrImpl._create = function (document, localName) {
+        var node = new AttrImpl(localName);
         node._nodeDocument = document;
         return node;
-    }
-}
+    };
+    return AttrImpl;
+}(NodeImpl_1.NodeImpl));
 exports.AttrImpl = AttrImpl;
 /**
  * Initialize prototype properties
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(AttrImpl.prototype, "_nodeType", interfaces_1.NodeType.Attribute);
-(0, WebIDLAlgorithm_1.idl_defineConst)(AttrImpl.prototype, "specified", true);
+WebIDLAlgorithm_1.idl_defineConst(AttrImpl.prototype, "_nodeType", interfaces_1.NodeType.Attribute);
+WebIDLAlgorithm_1.idl_defineConst(AttrImpl.prototype, "specified", true);
 //# sourceMappingURL=AttrImpl.js.map
 
 /***/ }),
 
 /***/ 23977:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.CDATASectionImpl = void 0;
-const TextImpl_1 = __nccwpck_require__(42191);
-const interfaces_1 = __nccwpck_require__(27305);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var TextImpl_1 = __nccwpck_require__(42191);
+var interfaces_1 = __nccwpck_require__(27305);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents a CDATA node.
  */
-class CDATASectionImpl extends TextImpl_1.TextImpl {
-    _nodeType = interfaces_1.NodeType.CData;
+var CDATASectionImpl = /** @class */ (function (_super) {
+    __extends(CDATASectionImpl, _super);
     /**
      * Initializes a new instance of `CDATASection`.
      *
      * @param data - node contents
      */
-    constructor(data) {
-        super(data);
+    function CDATASectionImpl(data) {
+        return _super.call(this, data) || this;
     }
     /**
      * Creates a new `CDATASection`.
@@ -23195,107 +51547,157 @@ class CDATASectionImpl extends TextImpl_1.TextImpl {
      * @param document - owner document
      * @param data - node contents
      */
-    static _create(document, data = '') {
-        const node = new CDATASectionImpl(data);
+    CDATASectionImpl._create = function (document, data) {
+        if (data === void 0) { data = ''; }
+        var node = new CDATASectionImpl(data);
         node._nodeDocument = document;
         return node;
-    }
-}
+    };
+    return CDATASectionImpl;
+}(TextImpl_1.TextImpl));
 exports.CDATASectionImpl = CDATASectionImpl;
 /**
  * Initialize prototype properties
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(CDATASectionImpl.prototype, "_nodeType", interfaces_1.NodeType.CData);
+WebIDLAlgorithm_1.idl_defineConst(CDATASectionImpl.prototype, "_nodeType", interfaces_1.NodeType.CData);
 //# sourceMappingURL=CDATASectionImpl.js.map
 
 /***/ }),
 
 /***/ 65330:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.CharacterDataImpl = void 0;
-const NodeImpl_1 = __nccwpck_require__(91745);
-const algorithm_1 = __nccwpck_require__(61);
+var NodeImpl_1 = __nccwpck_require__(91745);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents a generic text node.
  */
-class CharacterDataImpl extends NodeImpl_1.NodeImpl {
-    _data;
+var CharacterDataImpl = /** @class */ (function (_super) {
+    __extends(CharacterDataImpl, _super);
     /**
      * Initializes a new instance of `CharacterData`.
      *
      * @param data - the text content
      */
-    constructor(data) {
-        super();
-        this._data = data;
+    function CharacterDataImpl(data) {
+        var _this = _super.call(this) || this;
+        _this._data = data;
+        return _this;
     }
+    Object.defineProperty(CharacterDataImpl.prototype, "data", {
+        /** @inheritdoc */
+        get: function () { return this._data; },
+        set: function (value) {
+            algorithm_1.characterData_replaceData(this, 0, this._data.length, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterDataImpl.prototype, "length", {
+        /** @inheritdoc */
+        get: function () { return this._data.length; },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get data() { return this._data; }
-    set data(value) {
-        (0, algorithm_1.characterData_replaceData)(this, 0, this._data.length, value);
-    }
-    /** @inheritdoc */
-    get length() { return this._data.length; }
-    /** @inheritdoc */
-    substringData(offset, count) {
+    CharacterDataImpl.prototype.substringData = function (offset, count) {
         /**
          * The substringData(offset, count) method, when invoked, must return the
          * result of running substring data with node context object, offset offset, and count count.
          */
-        return (0, algorithm_1.characterData_substringData)(this, offset, count);
-    }
+        return algorithm_1.characterData_substringData(this, offset, count);
+    };
     /** @inheritdoc */
-    appendData(data) {
+    CharacterDataImpl.prototype.appendData = function (data) {
         /**
          * The appendData(data) method, when invoked, must replace data with node
          * context object, offset context object’s length, count 0, and data data.
          */
-        return (0, algorithm_1.characterData_replaceData)(this, this._data.length, 0, data);
-    }
+        return algorithm_1.characterData_replaceData(this, this._data.length, 0, data);
+    };
     /** @inheritdoc */
-    insertData(offset, data) {
+    CharacterDataImpl.prototype.insertData = function (offset, data) {
         /**
          * The insertData(offset, data) method, when invoked, must replace data with
          * node context object, offset offset, count 0, and data data.
          */
-        (0, algorithm_1.characterData_replaceData)(this, offset, 0, data);
-    }
+        algorithm_1.characterData_replaceData(this, offset, 0, data);
+    };
     /** @inheritdoc */
-    deleteData(offset, count) {
+    CharacterDataImpl.prototype.deleteData = function (offset, count) {
         /**
          * The deleteData(offset, count) method, when invoked, must replace data
          * with node context object, offset offset, count count, and data the
          * empty string.
          */
-        (0, algorithm_1.characterData_replaceData)(this, offset, count, '');
-    }
+        algorithm_1.characterData_replaceData(this, offset, count, '');
+    };
     /** @inheritdoc */
-    replaceData(offset, count, data) {
+    CharacterDataImpl.prototype.replaceData = function (offset, count, data) {
         /**
          * The replaceData(offset, count, data) method, when invoked, must replace
          * data with node context object, offset offset, count count, and data data.
          */
-        (0, algorithm_1.characterData_replaceData)(this, offset, count, data);
-    }
-    // MIXIN: NonDocumentTypeChildNode
-    /* istanbul ignore next */
-    get previousElementSibling() { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); }
-    /* istanbul ignore next */
-    get nextElementSibling() { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); }
+        algorithm_1.characterData_replaceData(this, offset, count, data);
+    };
+    Object.defineProperty(CharacterDataImpl.prototype, "previousElementSibling", {
+        // MIXIN: NonDocumentTypeChildNode
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(CharacterDataImpl.prototype, "nextElementSibling", {
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
     // MIXIN: ChildNode
     /* istanbul ignore next */
-    before(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
+    CharacterDataImpl.prototype.before = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ChildNode not implemented.");
+    };
     /* istanbul ignore next */
-    after(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
+    CharacterDataImpl.prototype.after = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ChildNode not implemented.");
+    };
     /* istanbul ignore next */
-    replaceWith(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
+    CharacterDataImpl.prototype.replaceWith = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ChildNode not implemented.");
+    };
     /* istanbul ignore next */
-    remove() { throw new Error("Mixin: ChildNode not implemented."); }
-}
+    CharacterDataImpl.prototype.remove = function () { throw new Error("Mixin: ChildNode not implemented."); };
+    return CharacterDataImpl;
+}(NodeImpl_1.NodeImpl));
 exports.CharacterDataImpl = CharacterDataImpl;
 //# sourceMappingURL=CharacterDataImpl.js.map
 
@@ -23307,35 +51709,40 @@ exports.CharacterDataImpl = CharacterDataImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ChildNodeImpl = void 0;
-const util_1 = __nccwpck_require__(65282);
-const algorithm_1 = __nccwpck_require__(61);
+var util_1 = __nccwpck_require__(65282);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents a mixin that extends child nodes that can have siblings
  * including doctypes. This mixin is implemented by {@link Element},
  * {@link CharacterData} and {@link DocumentType}.
  */
-class ChildNodeImpl {
+var ChildNodeImpl = /** @class */ (function () {
+    function ChildNodeImpl() {
+    }
     /** @inheritdoc */
-    before(...nodes) {
+    ChildNodeImpl.prototype.before = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
         /**
          * 1. Let parent be context object’s parent.
          * 2. If parent is null, then return.
          */
-        const context = util_1.Cast.asNode(this);
-        const parent = context._parent;
+        var context = util_1.Cast.asNode(this);
+        var parent = context._parent;
         if (parent === null)
             return;
         /**
          * 3. Let viablePreviousSibling be context object’s first preceding
          * sibling not in nodes, and null otherwise.
          */
-        let viablePreviousSibling = context._previousSibling;
-        let flag = true;
+        var viablePreviousSibling = context._previousSibling;
+        var flag = true;
         while (flag && viablePreviousSibling) {
             flag = false;
-            for (let i = 0; i < nodes.length; i++) {
-                const child = nodes[i];
+            for (var i = 0; i < nodes.length; i++) {
+                var child = nodes[i];
                 if (child === viablePreviousSibling) {
                     viablePreviousSibling = viablePreviousSibling._previousSibling;
                     flag = true;
@@ -23347,7 +51754,7 @@ class ChildNodeImpl {
          * 4. Let node be the result of converting nodes into a node, given nodes
          * and context object’s node document.
          */
-        const node = (0, algorithm_1.parentNode_convertNodesIntoANode)(nodes, context._nodeDocument);
+        var node = algorithm_1.parentNode_convertNodesIntoANode(nodes, context._nodeDocument);
         /**
          * 5. If viablePreviousSibling is null, set it to parent’s first child,
          * and to viablePreviousSibling’s next sibling otherwise.
@@ -23359,28 +51766,32 @@ class ChildNodeImpl {
         /**
          * 6. Pre-insert node into parent before viablePreviousSibling.
          */
-        (0, algorithm_1.mutation_preInsert)(node, parent, viablePreviousSibling);
-    }
+        algorithm_1.mutation_preInsert(node, parent, viablePreviousSibling);
+    };
     /** @inheritdoc */
-    after(...nodes) {
+    ChildNodeImpl.prototype.after = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
         /**
          * 1. Let parent be context object’s parent.
          * 2. If parent is null, then return.
          */
-        const context = util_1.Cast.asNode(this);
-        const parent = context._parent;
+        var context = util_1.Cast.asNode(this);
+        var parent = context._parent;
         if (!parent)
             return;
         /**
          * 3. Let viableNextSibling be context object’s first following sibling not
          * in nodes, and null otherwise.
          */
-        let viableNextSibling = context._nextSibling;
-        let flag = true;
+        var viableNextSibling = context._nextSibling;
+        var flag = true;
         while (flag && viableNextSibling) {
             flag = false;
-            for (let i = 0; i < nodes.length; i++) {
-                const child = nodes[i];
+            for (var i = 0; i < nodes.length; i++) {
+                var child = nodes[i];
                 if (child === viableNextSibling) {
                     viableNextSibling = viableNextSibling._nextSibling;
                     flag = true;
@@ -23392,32 +51803,36 @@ class ChildNodeImpl {
          * 4. Let node be the result of converting nodes into a node, given nodes
          * and context object’s node document.
          */
-        const node = (0, algorithm_1.parentNode_convertNodesIntoANode)(nodes, context._nodeDocument);
+        var node = algorithm_1.parentNode_convertNodesIntoANode(nodes, context._nodeDocument);
         /**
          * 5. Pre-insert node into parent before viableNextSibling.
          */
-        (0, algorithm_1.mutation_preInsert)(node, parent, viableNextSibling);
-    }
+        algorithm_1.mutation_preInsert(node, parent, viableNextSibling);
+    };
     /** @inheritdoc */
-    replaceWith(...nodes) {
+    ChildNodeImpl.prototype.replaceWith = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
         /**
          * 1. Let parent be context object’s parent.
          * 2. If parent is null, then return.
          */
-        const context = util_1.Cast.asNode(this);
-        const parent = context._parent;
+        var context = util_1.Cast.asNode(this);
+        var parent = context._parent;
         if (!parent)
             return;
         /**
          * 3. Let viableNextSibling be context object’s first following sibling not
          * in nodes, and null otherwise.
          */
-        let viableNextSibling = context._nextSibling;
-        let flag = true;
+        var viableNextSibling = context._nextSibling;
+        var flag = true;
         while (flag && viableNextSibling) {
             flag = false;
-            for (let i = 0; i < nodes.length; i++) {
-                const child = nodes[i];
+            for (var i = 0; i < nodes.length; i++) {
+                var child = nodes[i];
                 if (child === viableNextSibling) {
                     viableNextSibling = viableNextSibling._nextSibling;
                     flag = true;
@@ -23429,7 +51844,7 @@ class ChildNodeImpl {
          * 4. Let node be the result of converting nodes into a node, given nodes
          * and context object’s node document.
          */
-        const node = (0, algorithm_1.parentNode_convertNodesIntoANode)(nodes, context._nodeDocument);
+        var node = algorithm_1.parentNode_convertNodesIntoANode(nodes, context._nodeDocument);
         /**
          * 5. If context object’s parent is parent, replace the context object with
          * node within parent.
@@ -23437,50 +51852,64 @@ class ChildNodeImpl {
          * 6. Otherwise, pre-insert node into parent before viableNextSibling.
          */
         if (context._parent === parent)
-            (0, algorithm_1.mutation_replace)(context, node, parent);
+            algorithm_1.mutation_replace(context, node, parent);
         else
-            (0, algorithm_1.mutation_preInsert)(node, parent, viableNextSibling);
-    }
+            algorithm_1.mutation_preInsert(node, parent, viableNextSibling);
+    };
     /** @inheritdoc */
-    remove() {
+    ChildNodeImpl.prototype.remove = function () {
         /**
          * 1. If context object’s parent is null, then return.
          * 2. Remove the context object from context object’s parent.
          */
-        const context = util_1.Cast.asNode(this);
-        const parent = context._parent;
+        var context = util_1.Cast.asNode(this);
+        var parent = context._parent;
         if (!parent)
             return;
-        (0, algorithm_1.mutation_remove)(context, parent);
-    }
-}
+        algorithm_1.mutation_remove(context, parent);
+    };
+    return ChildNodeImpl;
+}());
 exports.ChildNodeImpl = ChildNodeImpl;
 //# sourceMappingURL=ChildNodeImpl.js.map
 
 /***/ }),
 
 /***/ 20930:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.CommentImpl = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
-const CharacterDataImpl_1 = __nccwpck_require__(65330);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var interfaces_1 = __nccwpck_require__(27305);
+var CharacterDataImpl_1 = __nccwpck_require__(65330);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents a comment node.
  */
-class CommentImpl extends CharacterDataImpl_1.CharacterDataImpl {
-    _nodeType = interfaces_1.NodeType.Comment;
+var CommentImpl = /** @class */ (function (_super) {
+    __extends(CommentImpl, _super);
     /**
      * Initializes a new instance of `Comment`.
      *
      * @param data - the text content
      */
-    constructor(data = '') {
-        super(data);
+    function CommentImpl(data) {
+        if (data === void 0) { data = ''; }
+        return _super.call(this, data) || this;
     }
     /**
      * Creates a new `Comment`.
@@ -23488,46 +51917,69 @@ class CommentImpl extends CharacterDataImpl_1.CharacterDataImpl {
      * @param document - owner document
      * @param data - node contents
      */
-    static _create(document, data = '') {
-        const node = new CommentImpl(data);
+    CommentImpl._create = function (document, data) {
+        if (data === void 0) { data = ''; }
+        var node = new CommentImpl(data);
         node._nodeDocument = document;
         return node;
-    }
-}
+    };
+    return CommentImpl;
+}(CharacterDataImpl_1.CharacterDataImpl));
 exports.CommentImpl = CommentImpl;
 /**
  * Initialize prototype properties
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(CommentImpl.prototype, "_nodeType", interfaces_1.NodeType.Comment);
+WebIDLAlgorithm_1.idl_defineConst(CommentImpl.prototype, "_nodeType", interfaces_1.NodeType.Comment);
 //# sourceMappingURL=CommentImpl.js.map
 
 /***/ }),
 
 /***/ 59857:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.CustomEventImpl = void 0;
-const EventImpl_1 = __nccwpck_require__(38245);
-const algorithm_1 = __nccwpck_require__(61);
+var EventImpl_1 = __nccwpck_require__(38245);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents and event that carries custom data.
  */
-class CustomEventImpl extends EventImpl_1.EventImpl {
-    _detail = null;
+var CustomEventImpl = /** @class */ (function (_super) {
+    __extends(CustomEventImpl, _super);
     /**
      * Initializes a new instance of `CustomEvent`.
      */
-    constructor(type, eventInit) {
-        super(type, eventInit);
-        this._detail = (eventInit && eventInit.detail) || null;
+    function CustomEventImpl(type, eventInit) {
+        var _this = _super.call(this, type, eventInit) || this;
+        _this._detail = null;
+        _this._detail = (eventInit && eventInit.detail) || null;
+        return _this;
     }
+    Object.defineProperty(CustomEventImpl.prototype, "detail", {
+        /** @inheritdoc */
+        get: function () { return this._detail; },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get detail() { return this._detail; }
-    /** @inheritdoc */
-    initCustomEvent(type, bubbles = false, cancelable = false, detail = null) {
+    CustomEventImpl.prototype.initCustomEvent = function (type, bubbles, cancelable, detail) {
+        if (bubbles === void 0) { bubbles = false; }
+        if (cancelable === void 0) { cancelable = false; }
+        if (detail === void 0) { detail = null; }
         /**
          * 1. If the context object’s dispatch flag is set, then return.
          */
@@ -23536,277 +51988,368 @@ class CustomEventImpl extends EventImpl_1.EventImpl {
         /**
          * 2. Initialize the context object with type, bubbles, and cancelable.
          */
-        (0, algorithm_1.event_initialize)(this, type, bubbles, cancelable);
+        algorithm_1.event_initialize(this, type, bubbles, cancelable);
         /**
          * 3. Set the context object’s detail attribute to detail.
          */
         this._detail = detail;
-    }
-}
+    };
+    return CustomEventImpl;
+}(EventImpl_1.EventImpl));
 exports.CustomEventImpl = CustomEventImpl;
 //# sourceMappingURL=CustomEventImpl.js.map
 
 /***/ }),
 
 /***/ 13166:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.InvalidCharacterError = exports.SyntaxError = exports.IndexSizeError = exports.NotFoundError = exports.HierarchyRequestError = exports.NotImplementedError = exports.DataCloneError = exports.InvalidNodeTypeError = exports.TimeoutError = exports.QuotaExceededError = exports.URLMismatchError = exports.AbortError = exports.NetworkError = exports.SecurityError = exports.TypeMismatchError = exports.ValidationError = exports.InvalidAccessError = exports.NamespaceError = exports.InvalidModificationError = exports.InvalidStateError = exports.InUseAttributeError = exports.NotSupportedError = exports.NoModificationAllowedError = exports.NoDataAllowedError = exports.WrongDocumentError = exports.DOMStringSizeError = exports.DOMException = void 0;
 /**
  * Represents the base class of `Error` objects used by this module.
  */
-class DOMException extends Error {
-    /**
-     * Returns the name of the error message.
-     */
-    name;
+var DOMException = /** @class */ (function (_super) {
+    __extends(DOMException, _super);
     /**
      *
      * @param name - message name
      * @param message - error message
      */
-    constructor(name, message = "") {
-        super(message);
-        this.name = name;
+    function DOMException(name, message) {
+        if (message === void 0) { message = ""; }
+        var _this = _super.call(this, message) || this;
+        _this.name = name;
+        return _this;
     }
-}
+    return DOMException;
+}(Error));
 exports.DOMException = DOMException;
-class DOMStringSizeError extends DOMException {
+var DOMStringSizeError = /** @class */ (function (_super) {
+    __extends(DOMStringSizeError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("DOMStringSizeError", message);
+    function DOMStringSizeError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "DOMStringSizeError", message) || this;
     }
-}
+    return DOMStringSizeError;
+}(DOMException));
 exports.DOMStringSizeError = DOMStringSizeError;
-class WrongDocumentError extends DOMException {
+var WrongDocumentError = /** @class */ (function (_super) {
+    __extends(WrongDocumentError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("WrongDocumentError", "The object is in the wrong document. " + message);
+    function WrongDocumentError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "WrongDocumentError", "The object is in the wrong document. " + message) || this;
     }
-}
+    return WrongDocumentError;
+}(DOMException));
 exports.WrongDocumentError = WrongDocumentError;
-class NoDataAllowedError extends DOMException {
+var NoDataAllowedError = /** @class */ (function (_super) {
+    __extends(NoDataAllowedError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("NoDataAllowedError", message);
+    function NoDataAllowedError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "NoDataAllowedError", message) || this;
     }
-}
+    return NoDataAllowedError;
+}(DOMException));
 exports.NoDataAllowedError = NoDataAllowedError;
-class NoModificationAllowedError extends DOMException {
+var NoModificationAllowedError = /** @class */ (function (_super) {
+    __extends(NoModificationAllowedError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("NoModificationAllowedError", "The object can not be modified. " + message);
+    function NoModificationAllowedError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "NoModificationAllowedError", "The object can not be modified. " + message) || this;
     }
-}
+    return NoModificationAllowedError;
+}(DOMException));
 exports.NoModificationAllowedError = NoModificationAllowedError;
-class NotSupportedError extends DOMException {
+var NotSupportedError = /** @class */ (function (_super) {
+    __extends(NotSupportedError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("NotSupportedError", "The operation is not supported. " + message);
+    function NotSupportedError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "NotSupportedError", "The operation is not supported. " + message) || this;
     }
-}
+    return NotSupportedError;
+}(DOMException));
 exports.NotSupportedError = NotSupportedError;
-class InUseAttributeError extends DOMException {
+var InUseAttributeError = /** @class */ (function (_super) {
+    __extends(InUseAttributeError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("InUseAttributeError", message);
+    function InUseAttributeError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "InUseAttributeError", message) || this;
     }
-}
+    return InUseAttributeError;
+}(DOMException));
 exports.InUseAttributeError = InUseAttributeError;
-class InvalidStateError extends DOMException {
+var InvalidStateError = /** @class */ (function (_super) {
+    __extends(InvalidStateError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("InvalidStateError", "The object is in an invalid state. " + message);
+    function InvalidStateError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "InvalidStateError", "The object is in an invalid state. " + message) || this;
     }
-}
+    return InvalidStateError;
+}(DOMException));
 exports.InvalidStateError = InvalidStateError;
-class InvalidModificationError extends DOMException {
+var InvalidModificationError = /** @class */ (function (_super) {
+    __extends(InvalidModificationError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("InvalidModificationError", "The object can not be modified in this way. " + message);
+    function InvalidModificationError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "InvalidModificationError", "The object can not be modified in this way. " + message) || this;
     }
-}
+    return InvalidModificationError;
+}(DOMException));
 exports.InvalidModificationError = InvalidModificationError;
-class NamespaceError extends DOMException {
+var NamespaceError = /** @class */ (function (_super) {
+    __extends(NamespaceError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("NamespaceError", "The operation is not allowed by Namespaces in XML. [XMLNS] " + message);
+    function NamespaceError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "NamespaceError", "The operation is not allowed by Namespaces in XML. [XMLNS] " + message) || this;
     }
-}
+    return NamespaceError;
+}(DOMException));
 exports.NamespaceError = NamespaceError;
-class InvalidAccessError extends DOMException {
+var InvalidAccessError = /** @class */ (function (_super) {
+    __extends(InvalidAccessError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("InvalidAccessError", "The object does not support the operation or argument. " + message);
+    function InvalidAccessError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "InvalidAccessError", "The object does not support the operation or argument. " + message) || this;
     }
-}
+    return InvalidAccessError;
+}(DOMException));
 exports.InvalidAccessError = InvalidAccessError;
-class ValidationError extends DOMException {
+var ValidationError = /** @class */ (function (_super) {
+    __extends(ValidationError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("ValidationError", message);
+    function ValidationError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "ValidationError", message) || this;
     }
-}
+    return ValidationError;
+}(DOMException));
 exports.ValidationError = ValidationError;
-class TypeMismatchError extends DOMException {
+var TypeMismatchError = /** @class */ (function (_super) {
+    __extends(TypeMismatchError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("TypeMismatchError", message);
+    function TypeMismatchError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "TypeMismatchError", message) || this;
     }
-}
+    return TypeMismatchError;
+}(DOMException));
 exports.TypeMismatchError = TypeMismatchError;
-class SecurityError extends DOMException {
+var SecurityError = /** @class */ (function (_super) {
+    __extends(SecurityError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("SecurityError", "The operation is insecure. " + message);
+    function SecurityError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "SecurityError", "The operation is insecure. " + message) || this;
     }
-}
+    return SecurityError;
+}(DOMException));
 exports.SecurityError = SecurityError;
-class NetworkError extends DOMException {
+var NetworkError = /** @class */ (function (_super) {
+    __extends(NetworkError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("NetworkError", "A network error occurred. " + message);
+    function NetworkError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "NetworkError", "A network error occurred. " + message) || this;
     }
-}
+    return NetworkError;
+}(DOMException));
 exports.NetworkError = NetworkError;
-class AbortError extends DOMException {
+var AbortError = /** @class */ (function (_super) {
+    __extends(AbortError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("AbortError", "The operation was aborted. " + message);
+    function AbortError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "AbortError", "The operation was aborted. " + message) || this;
     }
-}
+    return AbortError;
+}(DOMException));
 exports.AbortError = AbortError;
-class URLMismatchError extends DOMException {
+var URLMismatchError = /** @class */ (function (_super) {
+    __extends(URLMismatchError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("URLMismatchError", "The given URL does not match another URL. " + message);
+    function URLMismatchError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "URLMismatchError", "The given URL does not match another URL. " + message) || this;
     }
-}
+    return URLMismatchError;
+}(DOMException));
 exports.URLMismatchError = URLMismatchError;
-class QuotaExceededError extends DOMException {
+var QuotaExceededError = /** @class */ (function (_super) {
+    __extends(QuotaExceededError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("QuotaExceededError", "The quota has been exceeded. " + message);
+    function QuotaExceededError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "QuotaExceededError", "The quota has been exceeded. " + message) || this;
     }
-}
+    return QuotaExceededError;
+}(DOMException));
 exports.QuotaExceededError = QuotaExceededError;
-class TimeoutError extends DOMException {
+var TimeoutError = /** @class */ (function (_super) {
+    __extends(TimeoutError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("TimeoutError", "The operation timed out. " + message);
+    function TimeoutError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "TimeoutError", "The operation timed out. " + message) || this;
     }
-}
+    return TimeoutError;
+}(DOMException));
 exports.TimeoutError = TimeoutError;
-class InvalidNodeTypeError extends DOMException {
+var InvalidNodeTypeError = /** @class */ (function (_super) {
+    __extends(InvalidNodeTypeError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("InvalidNodeTypeError", "The supplied node is incorrect or has an incorrect ancestor for this operation. " + message);
+    function InvalidNodeTypeError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "InvalidNodeTypeError", "The supplied node is incorrect or has an incorrect ancestor for this operation. " + message) || this;
     }
-}
+    return InvalidNodeTypeError;
+}(DOMException));
 exports.InvalidNodeTypeError = InvalidNodeTypeError;
-class DataCloneError extends DOMException {
+var DataCloneError = /** @class */ (function (_super) {
+    __extends(DataCloneError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("DataCloneError", "The object can not be cloned. " + message);
+    function DataCloneError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "DataCloneError", "The object can not be cloned. " + message) || this;
     }
-}
+    return DataCloneError;
+}(DOMException));
 exports.DataCloneError = DataCloneError;
-class NotImplementedError extends DOMException {
+var NotImplementedError = /** @class */ (function (_super) {
+    __extends(NotImplementedError, _super);
     /**
     * @param message - error message
     */
-    constructor(message = "") {
-        super("NotImplementedError", "The DOM method is not implemented by this module. " + message);
+    function NotImplementedError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "NotImplementedError", "The DOM method is not implemented by this module. " + message) || this;
     }
-}
+    return NotImplementedError;
+}(DOMException));
 exports.NotImplementedError = NotImplementedError;
-class HierarchyRequestError extends DOMException {
+var HierarchyRequestError = /** @class */ (function (_super) {
+    __extends(HierarchyRequestError, _super);
     /**
      * @param message - error message
      */
-    constructor(message = "") {
-        super("HierarchyRequestError", "The operation would yield an incorrect node tree. " + message);
+    function HierarchyRequestError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "HierarchyRequestError", "The operation would yield an incorrect node tree. " + message) || this;
     }
-}
+    return HierarchyRequestError;
+}(DOMException));
 exports.HierarchyRequestError = HierarchyRequestError;
-class NotFoundError extends DOMException {
+var NotFoundError = /** @class */ (function (_super) {
+    __extends(NotFoundError, _super);
     /**
      * @param message - error message
      */
-    constructor(message = "") {
-        super("NotFoundError", "The object can not be found here. " + message);
+    function NotFoundError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "NotFoundError", "The object can not be found here. " + message) || this;
     }
-}
+    return NotFoundError;
+}(DOMException));
 exports.NotFoundError = NotFoundError;
-class IndexSizeError extends DOMException {
+var IndexSizeError = /** @class */ (function (_super) {
+    __extends(IndexSizeError, _super);
     /**
      * @param message - error message
      */
-    constructor(message = "") {
-        super("IndexSizeError", "The index is not in the allowed range. " + message);
+    function IndexSizeError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "IndexSizeError", "The index is not in the allowed range. " + message) || this;
     }
-}
+    return IndexSizeError;
+}(DOMException));
 exports.IndexSizeError = IndexSizeError;
-class SyntaxError extends DOMException {
+var SyntaxError = /** @class */ (function (_super) {
+    __extends(SyntaxError, _super);
     /**
      * @param message - error message
      */
-    constructor(message = "") {
-        super("SyntaxError", "The string did not match the expected pattern. " + message);
+    function SyntaxError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "SyntaxError", "The string did not match the expected pattern. " + message) || this;
     }
-}
+    return SyntaxError;
+}(DOMException));
 exports.SyntaxError = SyntaxError;
-class InvalidCharacterError extends DOMException {
+var InvalidCharacterError = /** @class */ (function (_super) {
+    __extends(InvalidCharacterError, _super);
     /**
      * @param message - error message
      */
-    constructor(message = "") {
-        super("InvalidCharacterError", "The string contains invalid characters. " + message);
+    function InvalidCharacterError(message) {
+        if (message === void 0) { message = ""; }
+        return _super.call(this, "InvalidCharacterError", "The string contains invalid characters. " + message) || this;
     }
-}
+    return InvalidCharacterError;
+}(DOMException));
 exports.InvalidCharacterError = InvalidCharacterError;
 //# sourceMappingURL=DOMException.js.map
 
@@ -23818,27 +52361,23 @@ exports.InvalidCharacterError = InvalidCharacterError;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.dom = void 0;
-const util_1 = __nccwpck_require__(76195);
-const CreateAlgorithm_1 = __nccwpck_require__(57339);
+var util_1 = __nccwpck_require__(76195);
+var CreateAlgorithm_1 = __nccwpck_require__(57339);
 /**
  * Represents an object implementing DOM algorithms.
  */
-class DOMImpl {
-    static _instance;
-    _features = {
-        mutationObservers: true,
-        customElements: true,
-        slots: true,
-        steps: true
-    };
-    _window = null;
-    _compareCache;
-    _rangeList;
+var DOMImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `DOM`.
      */
-    constructor() {
+    function DOMImpl() {
+        this._features = {
+            mutationObservers: true,
+            customElements: true,
+            slots: true,
+            steps: true
+        };
+        this._window = null;
         this._compareCache = new util_1.CompareCache();
         this._rangeList = new util_1.FixedSizeSet();
     }
@@ -23848,52 +52387,73 @@ class DOMImpl {
      * @param features - DOM features supported by algorithms. All features are
      * enabled by default unless explicity disabled.
      */
-    setFeatures(features) {
+    DOMImpl.prototype.setFeatures = function (features) {
         if (features === undefined)
             features = true;
-        if ((0, util_1.isObject)(features)) {
-            for (const key in features) {
+        if (util_1.isObject(features)) {
+            for (var key in features) {
                 this._features[key] = features[key] || false;
             }
         }
         else {
             // enable/disable all features
-            for (const key in this._features) {
+            for (var key in this._features) {
                 this._features[key] = features;
             }
         }
-    }
-    /**
-     * Gets DOM algorithm features.
-     */
-    get features() { return this._features; }
-    /**
-     * Gets the DOM window.
-     */
-    get window() {
-        if (this._window === null) {
-            this._window = (0, CreateAlgorithm_1.create_window)();
-        }
-        return this._window;
-    }
-    /**
-     * Gets the global node compare cache.
-     */
-    get compareCache() { return this._compareCache; }
-    /**
-     * Gets the global range list.
-     */
-    get rangeList() { return this._rangeList; }
-    /**
-     * Returns the instance of `DOM`.
-     */
-    static get instance() {
-        if (!DOMImpl._instance) {
-            DOMImpl._instance = new DOMImpl();
-        }
-        return DOMImpl._instance;
-    }
-}
+    };
+    Object.defineProperty(DOMImpl.prototype, "features", {
+        /**
+         * Gets DOM algorithm features.
+         */
+        get: function () { return this._features; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DOMImpl.prototype, "window", {
+        /**
+         * Gets the DOM window.
+         */
+        get: function () {
+            if (this._window === null) {
+                this._window = CreateAlgorithm_1.create_window();
+            }
+            return this._window;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DOMImpl.prototype, "compareCache", {
+        /**
+         * Gets the global node compare cache.
+         */
+        get: function () { return this._compareCache; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DOMImpl.prototype, "rangeList", {
+        /**
+         * Gets the global range list.
+         */
+        get: function () { return this._rangeList; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DOMImpl, "instance", {
+        /**
+         * Returns the instance of `DOM`.
+         */
+        get: function () {
+            if (!DOMImpl._instance) {
+                DOMImpl._instance = new DOMImpl();
+            }
+            return DOMImpl._instance;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return DOMImpl;
+}());
 /**
  * Represents an object implementing DOM algorithms.
  */
@@ -23908,52 +52468,50 @@ exports.dom = DOMImpl.instance;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DOMImplementationImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const infra_1 = __nccwpck_require__(84251);
-const algorithm_1 = __nccwpck_require__(61);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var infra_1 = __nccwpck_require__(84251);
+var algorithm_1 = __nccwpck_require__(61);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents an object providing methods which are not dependent on
  * any particular document.
  */
-class DOMImplementationImpl {
-    _ID = "@oozcitak/dom";
-    _associatedDocument;
+var DOMImplementationImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `DOMImplementation`.
      *
      * @param document - the associated document
      */
-    constructor(document) {
+    function DOMImplementationImpl(document) {
         this._associatedDocument = document || DOMImpl_1.dom.window.document;
     }
     /** @inheritdoc */
-    createDocumentType(qualifiedName, publicId, systemId) {
+    DOMImplementationImpl.prototype.createDocumentType = function (qualifiedName, publicId, systemId) {
         /**
          * 1. Validate qualifiedName.
          * 2. Return a new doctype, with qualifiedName as its name, publicId as its
          * public ID, and systemId as its system ID, and with its node document set
          * to the associated document of the context object.
          */
-        (0, algorithm_1.namespace_validate)(qualifiedName);
-        return (0, algorithm_1.create_documentType)(this._associatedDocument, qualifiedName, publicId, systemId);
-    }
+        algorithm_1.namespace_validate(qualifiedName);
+        return algorithm_1.create_documentType(this._associatedDocument, qualifiedName, publicId, systemId);
+    };
     /** @inheritdoc */
-    createDocument(namespace, qualifiedName, doctype = null) {
+    DOMImplementationImpl.prototype.createDocument = function (namespace, qualifiedName, doctype) {
+        if (doctype === void 0) { doctype = null; }
         /**
          * 1. Let document be a new XMLDocument.
          */
-        const document = (0, algorithm_1.create_xmlDocument)();
+        var document = algorithm_1.create_xmlDocument();
         /**
          * 2. Let element be null.
          * 3. If qualifiedName is not the empty string, then set element to
          * the result of running the internal createElementNS steps, given document,
          * namespace, qualifiedName, and an empty dictionary.
          */
-        let element = null;
+        var element = null;
         if (qualifiedName) {
-            element = (0, algorithm_1.document_internalCreateElementNS)(document, namespace, qualifiedName);
+            element = algorithm_1.document_internalCreateElementNS(document, namespace, qualifiedName);
         }
         /**
          * 4. If doctype is non-null, append doctype to document.
@@ -23986,32 +52544,32 @@ class DOMImplementationImpl {
          * 8. Return document.
          */
         return document;
-    }
+    };
     /** @inheritdoc */
-    createHTMLDocument(title) {
+    DOMImplementationImpl.prototype.createHTMLDocument = function (title) {
         /**
          * 1. Let doc be a new document that is an HTML document.
          * 2. Set doc’s content type to "text/html".
          */
-        const doc = (0, algorithm_1.create_document)();
+        var doc = algorithm_1.create_document();
         doc._type = "html";
         doc._contentType = "text/html";
         /**
          * 3. Append a new doctype, with "html" as its name and with its node
          * document set to doc, to doc.
          */
-        doc.appendChild((0, algorithm_1.create_documentType)(doc, "html", "", ""));
+        doc.appendChild(algorithm_1.create_documentType(doc, "html", "", ""));
         /**
          * 4. Append the result of creating an element given doc, html, and the
          * HTML namespace, to doc.
          */
-        const htmlElement = (0, algorithm_1.element_createAnElement)(doc, "html", infra_1.namespace.HTML);
+        var htmlElement = algorithm_1.element_createAnElement(doc, "html", infra_1.namespace.HTML);
         doc.appendChild(htmlElement);
         /**
          * 5. Append the result of creating an element given doc, head, and the
          * HTML namespace, to the html element created earlier.
          */
-        const headElement = (0, algorithm_1.element_createAnElement)(doc, "head", infra_1.namespace.HTML);
+        var headElement = algorithm_1.element_createAnElement(doc, "head", infra_1.namespace.HTML);
         htmlElement.appendChild(headElement);
         /**
          * 6. If title is given:
@@ -24022,16 +52580,16 @@ class DOMImplementationImpl {
          * element created earlier.
          */
         if (title !== undefined) {
-            const titleElement = (0, algorithm_1.element_createAnElement)(doc, "title", infra_1.namespace.HTML);
+            var titleElement = algorithm_1.element_createAnElement(doc, "title", infra_1.namespace.HTML);
             headElement.appendChild(titleElement);
-            const textElement = (0, algorithm_1.create_text)(doc, title);
+            var textElement = algorithm_1.create_text(doc, title);
             titleElement.appendChild(textElement);
         }
         /**
          * 7. Append the result of creating an element given doc, body, and the
          * HTML namespace, to the html element created earlier.
          */
-        const bodyElement = (0, algorithm_1.element_createAnElement)(doc, "body", infra_1.namespace.HTML);
+        var bodyElement = algorithm_1.element_createAnElement(doc, "body", infra_1.namespace.HTML);
         htmlElement.appendChild(bodyElement);
         /**
          * 8. doc’s origin is context object’s associated document’s origin.
@@ -24041,49 +52599,57 @@ class DOMImplementationImpl {
          * 9. Return doc.
          */
         return doc;
-    }
+    };
     /** @inheritdoc */
-    hasFeature() { return true; }
+    DOMImplementationImpl.prototype.hasFeature = function () { return true; };
     /**
      * Creates a new `DOMImplementation`.
      *
      * @param document - owner document
      */
-    static _create(document) {
+    DOMImplementationImpl._create = function (document) {
         return new DOMImplementationImpl(document);
-    }
-}
+    };
+    return DOMImplementationImpl;
+}());
 exports.DOMImplementationImpl = DOMImplementationImpl;
-(0, WebIDLAlgorithm_1.idl_defineConst)(DOMImplementationImpl.prototype, "_ID", "@oozcitak/dom");
+WebIDLAlgorithm_1.idl_defineConst(DOMImplementationImpl.prototype, "_ID", "@oozcitak/dom");
 //# sourceMappingURL=DOMImplementationImpl.js.map
 
 /***/ }),
 
 /***/ 65096:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DOMTokenListImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const DOMException_1 = __nccwpck_require__(13166);
-const infra_1 = __nccwpck_require__(84251);
-const algorithm_1 = __nccwpck_require__(61);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var DOMException_1 = __nccwpck_require__(13166);
+var infra_1 = __nccwpck_require__(84251);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents a token set.
  */
-class DOMTokenListImpl {
-    _element;
-    _attribute;
-    _tokenSet;
+var DOMTokenListImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `DOMTokenList`.
      *
      * @param element - associated element
      * @param attribute - associated attribute
      */
-    constructor(element, attribute) {
+    function DOMTokenListImpl(element, attribute) {
         /**
          * 1. Let element be associated element.
          * 2. Let localName be associated attribute’s local name.
@@ -24095,10 +52661,10 @@ class DOMTokenListImpl {
         this._element = element;
         this._attribute = attribute;
         this._tokenSet = new Set();
-        const localName = attribute._localName;
-        const value = (0, algorithm_1.element_getAnAttributeValue)(element, localName);
+        var localName = attribute._localName;
+        var value = algorithm_1.element_getAnAttributeValue(element, localName);
         // define a closure to be called when the associated attribute's value changes
-        const thisObj = this;
+        var thisObj = this;
         function updateTokenSet(element, localName, oldValue, value, namespace) {
             /**
              * 1. If localName is associated attribute’s local name, namespace is null,
@@ -24110,96 +52676,142 @@ class DOMTokenListImpl {
                 if (!value)
                     thisObj._tokenSet.clear();
                 else
-                    thisObj._tokenSet = (0, algorithm_1.orderedSet_parse)(value);
+                    thisObj._tokenSet = algorithm_1.orderedSet_parse(value);
             }
         }
         // add the closure to the associated element's attribute change steps
         this._element._attributeChangeSteps.push(updateTokenSet);
         if (DOMImpl_1.dom.features.steps) {
-            (0, algorithm_1.dom_runAttributeChangeSteps)(element, localName, value, value, null);
+            algorithm_1.dom_runAttributeChangeSteps(element, localName, value, value, null);
         }
     }
+    Object.defineProperty(DOMTokenListImpl.prototype, "length", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The length attribute' getter must return context object’s token set’s
+             * size.
+             */
+            return this._tokenSet.size;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get length() {
-        /**
-         * The length attribute' getter must return context object’s token set’s
-         * size.
-         */
-        return this._tokenSet.size;
-    }
-    /** @inheritdoc */
-    item(index) {
+    DOMTokenListImpl.prototype.item = function (index) {
+        var e_1, _a;
         /**
          * 1. If index is equal to or greater than context object’s token set’s
          * size, then return null.
          * 2. Return context object’s token set[index].
          */
-        let i = 0;
-        for (const token of this._tokenSet) {
-            if (i === index)
-                return token;
-            i++;
+        var i = 0;
+        try {
+            for (var _b = __values(this._tokenSet), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var token = _c.value;
+                if (i === index)
+                    return token;
+                i++;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
         return null;
-    }
+    };
     /** @inheritdoc */
-    contains(token) {
+    DOMTokenListImpl.prototype.contains = function (token) {
         /**
          * The contains(token) method, when invoked, must return true if context
          * object’s token set[token] exists, and false otherwise.
          */
         return this._tokenSet.has(token);
-    }
+    };
     /** @inheritdoc */
-    add(...tokens) {
-        /**
-         * 1. For each token in tokens:
-         * 1.1. If token is the empty string, then throw a "SyntaxError"
-         * DOMException.
-         * 1.2. If token contains any ASCII whitespace, then throw an
-         * "InvalidCharacterError" DOMException.
-         * 2. For each token in tokens, append token to context object’s token set.
-         * 3. Run the update steps.
-         */
-        for (const token of tokens) {
-            if (token === '') {
-                throw new DOMException_1.SyntaxError("Cannot add an empty token.");
-            }
-            else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) {
-                throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace.");
-            }
-            else {
-                this._tokenSet.add(token);
+    DOMTokenListImpl.prototype.add = function () {
+        var e_2, _a;
+        var tokens = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            tokens[_i] = arguments[_i];
+        }
+        try {
+            /**
+             * 1. For each token in tokens:
+             * 1.1. If token is the empty string, then throw a "SyntaxError"
+             * DOMException.
+             * 1.2. If token contains any ASCII whitespace, then throw an
+             * "InvalidCharacterError" DOMException.
+             * 2. For each token in tokens, append token to context object’s token set.
+             * 3. Run the update steps.
+             */
+            for (var tokens_1 = __values(tokens), tokens_1_1 = tokens_1.next(); !tokens_1_1.done; tokens_1_1 = tokens_1.next()) {
+                var token = tokens_1_1.value;
+                if (token === '') {
+                    throw new DOMException_1.SyntaxError("Cannot add an empty token.");
+                }
+                else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) {
+                    throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace.");
+                }
+                else {
+                    this._tokenSet.add(token);
+                }
             }
         }
-        (0, algorithm_1.tokenList_updateSteps)(this);
-    }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (tokens_1_1 && !tokens_1_1.done && (_a = tokens_1.return)) _a.call(tokens_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        algorithm_1.tokenList_updateSteps(this);
+    };
     /** @inheritdoc */
-    remove(...tokens) {
-        /**
-         * 1. For each token in tokens:
-         * 1.1. If token is the empty string, then throw a "SyntaxError"
-         * DOMException.
-         * 1.2. If token contains any ASCII whitespace, then throw an
-         * "InvalidCharacterError" DOMException.
-         * 2. For each token in tokens, remove token from context object’s token set.
-         * 3. Run the update steps.
-         */
-        for (const token of tokens) {
-            if (token === '') {
-                throw new DOMException_1.SyntaxError("Cannot remove an empty token.");
-            }
-            else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) {
-                throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace.");
-            }
-            else {
-                this._tokenSet.delete(token);
+    DOMTokenListImpl.prototype.remove = function () {
+        var e_3, _a;
+        var tokens = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            tokens[_i] = arguments[_i];
+        }
+        try {
+            /**
+             * 1. For each token in tokens:
+             * 1.1. If token is the empty string, then throw a "SyntaxError"
+             * DOMException.
+             * 1.2. If token contains any ASCII whitespace, then throw an
+             * "InvalidCharacterError" DOMException.
+             * 2. For each token in tokens, remove token from context object’s token set.
+             * 3. Run the update steps.
+             */
+            for (var tokens_2 = __values(tokens), tokens_2_1 = tokens_2.next(); !tokens_2_1.done; tokens_2_1 = tokens_2.next()) {
+                var token = tokens_2_1.value;
+                if (token === '') {
+                    throw new DOMException_1.SyntaxError("Cannot remove an empty token.");
+                }
+                else if (infra_1.codePoint.ASCIIWhiteSpace.test(token)) {
+                    throw new DOMException_1.InvalidCharacterError("Token cannot contain whitespace.");
+                }
+                else {
+                    this._tokenSet.delete(token);
+                }
             }
         }
-        (0, algorithm_1.tokenList_updateSteps)(this);
-    }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (tokens_2_1 && !tokens_2_1.done && (_a = tokens_2.return)) _a.call(tokens_2);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        algorithm_1.tokenList_updateSteps(this);
+    };
     /** @inheritdoc */
-    toggle(token, force = undefined) {
+    DOMTokenListImpl.prototype.toggle = function (token, force) {
+        if (force === void 0) { force = undefined; }
         /**
          * 1. If token is the empty string, then throw a "SyntaxError" DOMException.
          * 2. If token contains any ASCII whitespace, then throw an
@@ -24222,7 +52834,7 @@ class DOMTokenListImpl {
              */
             if (force === undefined || force === false) {
                 this._tokenSet.delete(token);
-                (0, algorithm_1.tokenList_updateSteps)(this);
+                algorithm_1.tokenList_updateSteps(this);
                 return false;
             }
             return true;
@@ -24233,16 +52845,16 @@ class DOMTokenListImpl {
          */
         if (force === undefined || force === true) {
             this._tokenSet.add(token);
-            (0, algorithm_1.tokenList_updateSteps)(this);
+            algorithm_1.tokenList_updateSteps(this);
             return true;
         }
         /**
          * 5. Return false.
          */
         return false;
-    }
+    };
     /** @inheritdoc */
-    replace(token, newToken) {
+    DOMTokenListImpl.prototype.replace = function (token, newToken) {
         /**
          * 1. If either token or newToken is the empty string, then throw a
          * "SyntaxError" DOMException.
@@ -24267,278 +52879,424 @@ class DOMTokenListImpl {
          * 6. Return true.
          */
         infra_1.set.replace(this._tokenSet, token, newToken);
-        (0, algorithm_1.tokenList_updateSteps)(this);
+        algorithm_1.tokenList_updateSteps(this);
         return true;
-    }
+    };
     /** @inheritdoc */
-    supports(token) {
+    DOMTokenListImpl.prototype.supports = function (token) {
         /**
          * 1. Let result be the return value of validation steps called with token.
          * 2. Return result.
          */
-        return (0, algorithm_1.tokenList_validationSteps)(this, token);
-    }
-    /** @inheritdoc */
-    get value() {
-        /**
-         * The value attribute must return the result of running context object’s
-         * serialize steps.
-         */
-        return (0, algorithm_1.tokenList_serializeSteps)(this);
-    }
-    set value(value) {
-        /**
-         * Setting the value attribute must set an attribute value for the
-         * associated element using associated attribute’s local name and the given
-         * value.
-         */
-        (0, algorithm_1.element_setAnAttributeValue)(this._element, this._attribute._localName, value);
-    }
+        return algorithm_1.tokenList_validationSteps(this, token);
+    };
+    Object.defineProperty(DOMTokenListImpl.prototype, "value", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The value attribute must return the result of running context object’s
+             * serialize steps.
+             */
+            return algorithm_1.tokenList_serializeSteps(this);
+        },
+        set: function (value) {
+            /**
+             * Setting the value attribute must set an attribute value for the
+             * associated element using associated attribute’s local name and the given
+             * value.
+             */
+            algorithm_1.element_setAnAttributeValue(this._element, this._attribute._localName, value);
+        },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Returns an iterator for the token set.
      */
-    [Symbol.iterator]() {
-        const it = this._tokenSet[Symbol.iterator]();
+    DOMTokenListImpl.prototype[Symbol.iterator] = function () {
+        var it = this._tokenSet[Symbol.iterator]();
         return {
-            next() {
+            next: function () {
                 return it.next();
             }
         };
-    }
+    };
     /**
      * Creates a new `DOMTokenList`.
      *
      * @param element - associated element
      * @param attribute - associated attribute
      */
-    static _create(element, attribute) {
+    DOMTokenListImpl._create = function (element, attribute) {
         return new DOMTokenListImpl(element, attribute);
-    }
-}
+    };
+    return DOMTokenListImpl;
+}());
 exports.DOMTokenListImpl = DOMTokenListImpl;
 //# sourceMappingURL=DOMTokenListImpl.js.map
 
 /***/ }),
 
 /***/ 12585:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DocumentFragmentImpl = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
-const NodeImpl_1 = __nccwpck_require__(91745);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var interfaces_1 = __nccwpck_require__(27305);
+var NodeImpl_1 = __nccwpck_require__(91745);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents a document fragment in the XML tree.
  */
-class DocumentFragmentImpl extends NodeImpl_1.NodeImpl {
-    _nodeType = interfaces_1.NodeType.DocumentFragment;
-    _children = new Set();
-    _host;
+var DocumentFragmentImpl = /** @class */ (function (_super) {
+    __extends(DocumentFragmentImpl, _super);
     /**
      * Initializes a new instance of `DocumentFragment`.
      *
      * @param host - shadow root's host element
      */
-    constructor(host = null) {
-        super();
-        this._host = host;
+    function DocumentFragmentImpl(host) {
+        if (host === void 0) { host = null; }
+        var _this = _super.call(this) || this;
+        _this._children = new Set();
+        _this._host = host;
+        return _this;
     }
     // MIXIN: NonElementParentNode
     /* istanbul ignore next */
-    getElementById(elementId) { throw new Error("Mixin: NonElementParentNode not implemented."); }
-    // MIXIN: ParentNode
+    DocumentFragmentImpl.prototype.getElementById = function (elementId) { throw new Error("Mixin: NonElementParentNode not implemented."); };
+    Object.defineProperty(DocumentFragmentImpl.prototype, "children", {
+        // MIXIN: ParentNode
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: ParentNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentFragmentImpl.prototype, "firstElementChild", {
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: ParentNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentFragmentImpl.prototype, "lastElementChild", {
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: ParentNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentFragmentImpl.prototype, "childElementCount", {
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: ParentNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
     /* istanbul ignore next */
-    get children() { throw new Error("Mixin: ParentNode not implemented."); }
+    DocumentFragmentImpl.prototype.prepend = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ParentNode not implemented.");
+    };
     /* istanbul ignore next */
-    get firstElementChild() { throw new Error("Mixin: ParentNode not implemented."); }
+    DocumentFragmentImpl.prototype.append = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ParentNode not implemented.");
+    };
     /* istanbul ignore next */
-    get lastElementChild() { throw new Error("Mixin: ParentNode not implemented."); }
+    DocumentFragmentImpl.prototype.querySelector = function (selectors) { throw new Error("Mixin: ParentNode not implemented."); };
     /* istanbul ignore next */
-    get childElementCount() { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    prepend(...nodes) { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    append(...nodes) { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    querySelector(selectors) { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    querySelectorAll(selectors) { throw new Error("Mixin: ParentNode not implemented."); }
+    DocumentFragmentImpl.prototype.querySelectorAll = function (selectors) { throw new Error("Mixin: ParentNode not implemented."); };
     /**
      * Creates a new `DocumentFragment`.
      *
      * @param document - owner document
      * @param host - shadow root's host element
      */
-    static _create(document, host = null) {
-        const node = new DocumentFragmentImpl(host);
+    DocumentFragmentImpl._create = function (document, host) {
+        if (host === void 0) { host = null; }
+        var node = new DocumentFragmentImpl(host);
         node._nodeDocument = document;
         return node;
-    }
-}
+    };
+    return DocumentFragmentImpl;
+}(NodeImpl_1.NodeImpl));
 exports.DocumentFragmentImpl = DocumentFragmentImpl;
 /**
  * Initialize prototype properties
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(DocumentFragmentImpl.prototype, "_nodeType", interfaces_1.NodeType.DocumentFragment);
+WebIDLAlgorithm_1.idl_defineConst(DocumentFragmentImpl.prototype, "_nodeType", interfaces_1.NodeType.DocumentFragment);
 //# sourceMappingURL=DocumentFragmentImpl.js.map
 
 /***/ }),
 
 /***/ 14333:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DocumentImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const interfaces_1 = __nccwpck_require__(27305);
-const DOMException_1 = __nccwpck_require__(13166);
-const NodeImpl_1 = __nccwpck_require__(91745);
-const util_1 = __nccwpck_require__(65282);
-const util_2 = __nccwpck_require__(76195);
-const infra_1 = __nccwpck_require__(84251);
-const URLAlgorithm_1 = __nccwpck_require__(53568);
-const algorithm_1 = __nccwpck_require__(61);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var interfaces_1 = __nccwpck_require__(27305);
+var DOMException_1 = __nccwpck_require__(13166);
+var NodeImpl_1 = __nccwpck_require__(91745);
+var util_1 = __nccwpck_require__(65282);
+var util_2 = __nccwpck_require__(76195);
+var infra_1 = __nccwpck_require__(84251);
+var URLAlgorithm_1 = __nccwpck_require__(53568);
+var algorithm_1 = __nccwpck_require__(61);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents a document node.
  */
-class DocumentImpl extends NodeImpl_1.NodeImpl {
-    _nodeType = interfaces_1.NodeType.Document;
-    _children = new Set();
-    _encoding = {
-        name: "UTF-8",
-        labels: ["unicode-1-1-utf-8", "utf-8", "utf8"]
-    };
-    _contentType = 'application/xml';
-    _URL = {
-        scheme: "about",
-        username: "",
-        password: "",
-        host: null,
-        port: null,
-        path: ["blank"],
-        query: null,
-        fragment: null,
-        _cannotBeABaseURLFlag: true,
-        _blobURLEntry: null
-    };
-    _origin = null;
-    _type = "xml";
-    _mode = "no-quirks";
-    _implementation;
-    _documentElement = null;
-    _hasNamespaces = false;
-    _nodeDocumentOverwrite = null;
-    get _nodeDocument() { return this._nodeDocumentOverwrite || this; }
-    set _nodeDocument(val) { this._nodeDocumentOverwrite = val; }
+var DocumentImpl = /** @class */ (function (_super) {
+    __extends(DocumentImpl, _super);
     /**
      * Initializes a new instance of `Document`.
      */
-    constructor() {
-        super();
+    function DocumentImpl() {
+        var _this = _super.call(this) || this;
+        _this._children = new Set();
+        _this._encoding = {
+            name: "UTF-8",
+            labels: ["unicode-1-1-utf-8", "utf-8", "utf8"]
+        };
+        _this._contentType = 'application/xml';
+        _this._URL = {
+            scheme: "about",
+            username: "",
+            password: "",
+            host: null,
+            port: null,
+            path: ["blank"],
+            query: null,
+            fragment: null,
+            _cannotBeABaseURLFlag: true,
+            _blobURLEntry: null
+        };
+        _this._origin = null;
+        _this._type = "xml";
+        _this._mode = "no-quirks";
+        _this._documentElement = null;
+        _this._hasNamespaces = false;
+        _this._nodeDocumentOverwrite = null;
+        return _this;
     }
+    Object.defineProperty(DocumentImpl.prototype, "_nodeDocument", {
+        get: function () { return this._nodeDocumentOverwrite || this; },
+        set: function (val) { this._nodeDocumentOverwrite = val; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "implementation", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The implementation attribute’s getter must return the DOMImplementation
+             * object that is associated with the document.
+             */
+            return this._implementation || (this._implementation = algorithm_1.create_domImplementation(this));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "URL", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The URL attribute’s getter and documentURI attribute’s getter must return
+             * the URL, serialized.
+             * See: https://url.spec.whatwg.org/#concept-url-serializer
+             */
+            return URLAlgorithm_1.urlSerializer(this._URL);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "documentURI", {
+        /** @inheritdoc */
+        get: function () { return this.URL; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "origin", {
+        /** @inheritdoc */
+        get: function () {
+            return "null";
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "compatMode", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The compatMode attribute’s getter must return "BackCompat" if context
+             * object’s mode is "quirks", and "CSS1Compat" otherwise.
+             */
+            return this._mode === "quirks" ? "BackCompat" : "CSS1Compat";
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "characterSet", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The characterSet attribute’s getter, charset attribute’s getter, and
+             * inputEncoding attribute’s getter, must return context object’s
+             * encoding’s name.
+             */
+            return this._encoding.name;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "charset", {
+        /** @inheritdoc */
+        get: function () { return this._encoding.name; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "inputEncoding", {
+        /** @inheritdoc */
+        get: function () { return this._encoding.name; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "contentType", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The contentType attribute’s getter must return the content type.
+             */
+            return this._contentType;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "doctype", {
+        /** @inheritdoc */
+        get: function () {
+            var e_1, _a;
+            try {
+                /**
+                 * The doctype attribute’s getter must return the child of the document
+                 * that is a doctype, and null otherwise.
+                 */
+                for (var _b = __values(this._children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var child = _c.value;
+                    if (util_1.Guard.isDocumentTypeNode(child))
+                        return child;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return null;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "documentElement", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The documentElement attribute’s getter must return the document element.
+             */
+            return this._documentElement;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get implementation() {
-        /**
-         * The implementation attribute’s getter must return the DOMImplementation
-         * object that is associated with the document.
-         */
-        return this._implementation || (this._implementation = (0, algorithm_1.create_domImplementation)(this));
-    }
-    /** @inheritdoc */
-    get URL() {
-        /**
-         * The URL attribute’s getter and documentURI attribute’s getter must return
-         * the URL, serialized.
-         * See: https://url.spec.whatwg.org/#concept-url-serializer
-         */
-        return (0, URLAlgorithm_1.urlSerializer)(this._URL);
-    }
-    /** @inheritdoc */
-    get documentURI() { return this.URL; }
-    /** @inheritdoc */
-    get origin() {
-        return "null";
-    }
-    /** @inheritdoc */
-    get compatMode() {
-        /**
-         * The compatMode attribute’s getter must return "BackCompat" if context
-         * object’s mode is "quirks", and "CSS1Compat" otherwise.
-         */
-        return this._mode === "quirks" ? "BackCompat" : "CSS1Compat";
-    }
-    /** @inheritdoc */
-    get characterSet() {
-        /**
-         * The characterSet attribute’s getter, charset attribute’s getter, and
-         * inputEncoding attribute’s getter, must return context object’s
-         * encoding’s name.
-         */
-        return this._encoding.name;
-    }
-    /** @inheritdoc */
-    get charset() { return this._encoding.name; }
-    /** @inheritdoc */
-    get inputEncoding() { return this._encoding.name; }
-    /** @inheritdoc */
-    get contentType() {
-        /**
-         * The contentType attribute’s getter must return the content type.
-         */
-        return this._contentType;
-    }
-    /** @inheritdoc */
-    get doctype() {
-        /**
-         * The doctype attribute’s getter must return the child of the document
-         * that is a doctype, and null otherwise.
-         */
-        for (const child of this._children) {
-            if (util_1.Guard.isDocumentTypeNode(child))
-                return child;
-        }
-        return null;
-    }
-    /** @inheritdoc */
-    get documentElement() {
-        /**
-         * The documentElement attribute’s getter must return the document element.
-         */
-        return this._documentElement;
-    }
-    /** @inheritdoc */
-    getElementsByTagName(qualifiedName) {
+    DocumentImpl.prototype.getElementsByTagName = function (qualifiedName) {
         /**
          * The getElementsByTagName(qualifiedName) method, when invoked, must return
          * the list of elements with qualified name qualifiedName for the context object.
          */
-        return (0, algorithm_1.node_listOfElementsWithQualifiedName)(qualifiedName, this);
-    }
+        return algorithm_1.node_listOfElementsWithQualifiedName(qualifiedName, this);
+    };
     /** @inheritdoc */
-    getElementsByTagNameNS(namespace, localName) {
+    DocumentImpl.prototype.getElementsByTagNameNS = function (namespace, localName) {
         /**
          * The getElementsByTagNameNS(namespace, localName) method, when invoked,
          * must return the list of elements with namespace namespace and local name
          * localName for the context object.
          */
-        return (0, algorithm_1.node_listOfElementsWithNamespace)(namespace, localName, this);
-    }
+        return algorithm_1.node_listOfElementsWithNamespace(namespace, localName, this);
+    };
     /** @inheritdoc */
-    getElementsByClassName(classNames) {
+    DocumentImpl.prototype.getElementsByClassName = function (classNames) {
         /**
          * The getElementsByClassName(classNames) method, when invoked, must return
          * the list of elements with class names classNames for the context object.
          */
-        return (0, algorithm_1.node_listOfElementsWithClassNames)(classNames, this);
-    }
+        return algorithm_1.node_listOfElementsWithClassNames(classNames, this);
+    };
     /** @inheritdoc */
-    createElement(localName, options) {
+    DocumentImpl.prototype.createElement = function (localName, options) {
         /**
          * 1. If localName does not match the Name production, then throw an
          * "InvalidCharacterError" DOMException.
@@ -24554,50 +53312,50 @@ class DocumentImpl extends NodeImpl_1.NodeImpl {
          * localName, namespace, null, is, and with the synchronous custom elements
          * flag set.
          */
-        if (!(0, algorithm_1.xml_isName)(localName))
+        if (!algorithm_1.xml_isName(localName))
             throw new DOMException_1.InvalidCharacterError();
         if (this._type === "html")
             localName = localName.toLowerCase();
-        let is = null;
+        var is = null;
         if (options !== undefined) {
-            if ((0, util_2.isString)(options)) {
+            if (util_2.isString(options)) {
                 is = options;
             }
             else {
                 is = options.is;
             }
         }
-        const namespace = (this._type === "html" || this._contentType === "application/xhtml+xml") ?
+        var namespace = (this._type === "html" || this._contentType === "application/xhtml+xml") ?
             infra_1.namespace.HTML : null;
-        return (0, algorithm_1.element_createAnElement)(this, localName, namespace, null, is, true);
-    }
+        return algorithm_1.element_createAnElement(this, localName, namespace, null, is, true);
+    };
     /** @inheritdoc */
-    createElementNS(namespace, qualifiedName, options) {
+    DocumentImpl.prototype.createElementNS = function (namespace, qualifiedName, options) {
         /**
          * The createElementNS(namespace, qualifiedName, options) method, when
          * invoked, must return the result of running the internal createElementNS
          * steps, given context object, namespace, qualifiedName, and options.
          */
-        return (0, algorithm_1.document_internalCreateElementNS)(this, namespace, qualifiedName, options);
-    }
+        return algorithm_1.document_internalCreateElementNS(this, namespace, qualifiedName, options);
+    };
     /** @inheritdoc */
-    createDocumentFragment() {
+    DocumentImpl.prototype.createDocumentFragment = function () {
         /**
          * The createDocumentFragment() method, when invoked, must return a new
          * DocumentFragment node with its node document set to the context object.
          */
-        return (0, algorithm_1.create_documentFragment)(this);
-    }
+        return algorithm_1.create_documentFragment(this);
+    };
     /** @inheritdoc */
-    createTextNode(data) {
+    DocumentImpl.prototype.createTextNode = function (data) {
         /**
          * The createTextNode(data) method, when invoked, must return a new Text
          * node with its data set to data and node document set to the context object.
          */
-        return (0, algorithm_1.create_text)(this, data);
-    }
+        return algorithm_1.create_text(this, data);
+    };
     /** @inheritdoc */
-    createCDATASection(data) {
+    DocumentImpl.prototype.createCDATASection = function (data) {
         /**
          * 1. If context object is an HTML document, then throw a
          * "NotSupportedError" DOMException.
@@ -24610,18 +53368,18 @@ class DocumentImpl extends NodeImpl_1.NodeImpl {
             throw new DOMException_1.NotSupportedError();
         if (data.indexOf(']]>') !== -1)
             throw new DOMException_1.InvalidCharacterError();
-        return (0, algorithm_1.create_cdataSection)(this, data);
-    }
+        return algorithm_1.create_cdataSection(this, data);
+    };
     /** @inheritdoc */
-    createComment(data) {
+    DocumentImpl.prototype.createComment = function (data) {
         /**
          * The createComment(data) method, when invoked, must return a new Comment
          * node with its data set to data and node document set to the context object.
          */
-        return (0, algorithm_1.create_comment)(this, data);
-    }
+        return algorithm_1.create_comment(this, data);
+    };
     /** @inheritdoc */
-    createProcessingInstruction(target, data) {
+    DocumentImpl.prototype.createProcessingInstruction = function (target, data) {
         /**
          * 1. If target does not match the Name production, then throw an
          * "InvalidCharacterError" DOMException.
@@ -24630,14 +53388,15 @@ class DocumentImpl extends NodeImpl_1.NodeImpl {
          * 3. Return a new ProcessingInstruction node, with target set to target,
          * data set to data, and node document set to the context object.
          */
-        if (!(0, algorithm_1.xml_isName)(target))
+        if (!algorithm_1.xml_isName(target))
             throw new DOMException_1.InvalidCharacterError();
         if (data.indexOf("?>") !== -1)
             throw new DOMException_1.InvalidCharacterError();
-        return (0, algorithm_1.create_processingInstruction)(this, target, data);
-    }
+        return algorithm_1.create_processingInstruction(this, target, data);
+    };
     /** @inheritdoc */
-    importNode(node, deep = false) {
+    DocumentImpl.prototype.importNode = function (node, deep) {
+        if (deep === void 0) { deep = false; }
         /**
          * 1. If node is a document or shadow root, then throw a "NotSupportedError" DOMException.
          */
@@ -24646,10 +53405,10 @@ class DocumentImpl extends NodeImpl_1.NodeImpl {
         /**
          * 2. Return a clone of node, with context object and the clone children flag set if deep is true.
          */
-        return (0, algorithm_1.node_clone)(node, this, deep);
-    }
+        return algorithm_1.node_clone(node, this, deep);
+    };
     /** @inheritdoc */
-    adoptNode(node) {
+    DocumentImpl.prototype.adoptNode = function (node) {
         /**
          * 1. If node is a document, then throw a "NotSupportedError" DOMException.
          */
@@ -24664,11 +53423,11 @@ class DocumentImpl extends NodeImpl_1.NodeImpl {
          * 3. Adopt node into the context object.
          * 4. Return node.
          */
-        (0, algorithm_1.document_adopt)(node, this);
+        algorithm_1.document_adopt(node, this);
         return node;
-    }
+    };
     /** @inheritdoc */
-    createAttribute(localName) {
+    DocumentImpl.prototype.createAttribute = function (localName) {
         /**
          * 1. If localName does not match the Name production in XML, then throw
          * an "InvalidCharacterError" DOMException.
@@ -24677,45 +53436,47 @@ class DocumentImpl extends NodeImpl_1.NodeImpl {
          * 3. Return a new attribute whose local name is localName and node document
          * is context object.
          */
-        if (!(0, algorithm_1.xml_isName)(localName))
+        if (!algorithm_1.xml_isName(localName))
             throw new DOMException_1.InvalidCharacterError();
         if (this._type === "html") {
             localName = localName.toLowerCase();
         }
-        const attr = (0, algorithm_1.create_attr)(this, localName);
+        var attr = algorithm_1.create_attr(this, localName);
         return attr;
-    }
+    };
     /** @inheritdoc */
-    createAttributeNS(namespace, qualifiedName) {
+    DocumentImpl.prototype.createAttributeNS = function (namespace, qualifiedName) {
         /**
          * 1. Let namespace, prefix, and localName be the result of passing
          * namespace and qualifiedName to validate and extract.
          * 2. Return a new attribute whose namespace is namespace, namespace prefix
          * is prefix, local name is localName, and node document is context object.
          */
-        const [ns, prefix, localName] = (0, algorithm_1.namespace_validateAndExtract)(namespace, qualifiedName);
-        const attr = (0, algorithm_1.create_attr)(this, localName);
+        var _a = __read(algorithm_1.namespace_validateAndExtract(namespace, qualifiedName), 3), ns = _a[0], prefix = _a[1], localName = _a[2];
+        var attr = algorithm_1.create_attr(this, localName);
         attr._namespace = ns;
         attr._namespacePrefix = prefix;
         return attr;
-    }
+    };
     /** @inheritdoc */
-    createEvent(eventInterface) {
-        return (0, algorithm_1.event_createLegacyEvent)(eventInterface);
-    }
+    DocumentImpl.prototype.createEvent = function (eventInterface) {
+        return algorithm_1.event_createLegacyEvent(eventInterface);
+    };
     /** @inheritdoc */
-    createRange() {
+    DocumentImpl.prototype.createRange = function () {
         /**
          * The createRange() method, when invoked, must return a new live range
          * with (context object, 0) as its start and end.
          */
-        const range = (0, algorithm_1.create_range)();
+        var range = algorithm_1.create_range();
         range._start = [this, 0];
         range._end = [this, 0];
         return range;
-    }
+    };
     /** @inheritdoc */
-    createNodeIterator(root, whatToShow = interfaces_1.WhatToShow.All, filter = null) {
+    DocumentImpl.prototype.createNodeIterator = function (root, whatToShow, filter) {
+        if (whatToShow === void 0) { whatToShow = interfaces_1.WhatToShow.All; }
+        if (filter === void 0) { filter = null; }
         /**
          * 1. Let iterator be a new NodeIterator object.
          * 2. Set iterator’s root and iterator’s reference to root.
@@ -24724,20 +53485,22 @@ class DocumentImpl extends NodeImpl_1.NodeImpl {
          * 5. Set iterator’s filter to filter.
          * 6. Return iterator.
          */
-        const iterator = (0, algorithm_1.create_nodeIterator)(root, root, true);
+        var iterator = algorithm_1.create_nodeIterator(root, root, true);
         iterator._whatToShow = whatToShow;
-        iterator._iteratorCollection = (0, algorithm_1.create_nodeList)(root);
-        if ((0, util_2.isFunction)(filter)) {
-            iterator._filter = (0, algorithm_1.create_nodeFilter)();
+        iterator._iteratorCollection = algorithm_1.create_nodeList(root);
+        if (util_2.isFunction(filter)) {
+            iterator._filter = algorithm_1.create_nodeFilter();
             iterator._filter.acceptNode = filter;
         }
         else {
             iterator._filter = filter;
         }
         return iterator;
-    }
+    };
     /** @inheritdoc */
-    createTreeWalker(root, whatToShow = interfaces_1.WhatToShow.All, filter = null) {
+    DocumentImpl.prototype.createTreeWalker = function (root, whatToShow, filter) {
+        if (whatToShow === void 0) { whatToShow = interfaces_1.WhatToShow.All; }
+        if (filter === void 0) { filter = null; }
         /**
          * 1. Let walker be a new TreeWalker object.
          * 2. Set walker’s root and walker’s current to root.
@@ -24745,23 +53508,23 @@ class DocumentImpl extends NodeImpl_1.NodeImpl {
          * 4. Set walker’s filter to filter.
          * 5. Return walker.
          */
-        const walker = (0, algorithm_1.create_treeWalker)(root, root);
+        var walker = algorithm_1.create_treeWalker(root, root);
         walker._whatToShow = whatToShow;
-        if ((0, util_2.isFunction)(filter)) {
-            walker._filter = (0, algorithm_1.create_nodeFilter)();
+        if (util_2.isFunction(filter)) {
+            walker._filter = algorithm_1.create_nodeFilter();
             walker._filter.acceptNode = filter;
         }
         else {
             walker._filter = filter;
         }
         return walker;
-    }
+    };
     /**
      * Gets the parent event target for the given event.
      *
      * @param event - an event
      */
-    _getTheParent(event) {
+    DocumentImpl.prototype._getTheParent = function (event) {
         /**
          * TODO: Implement realms
          * A document’s get the parent algorithm, given an event, returns null if
@@ -24774,35 +53537,64 @@ class DocumentImpl extends NodeImpl_1.NodeImpl {
         else {
             return DOMImpl_1.dom.window;
         }
-    }
+    };
     // MIXIN: NonElementParentNode
     /* istanbul ignore next */
-    getElementById(elementId) { throw new Error("Mixin: NonElementParentNode not implemented."); }
-    // MIXIN: DocumentOrShadowRoot
-    // No elements
-    // MIXIN: ParentNode
+    DocumentImpl.prototype.getElementById = function (elementId) { throw new Error("Mixin: NonElementParentNode not implemented."); };
+    Object.defineProperty(DocumentImpl.prototype, "children", {
+        // MIXIN: DocumentOrShadowRoot
+        // No elements
+        // MIXIN: ParentNode
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: ParentNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "firstElementChild", {
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: ParentNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "lastElementChild", {
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: ParentNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentImpl.prototype, "childElementCount", {
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: ParentNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
     /* istanbul ignore next */
-    get children() { throw new Error("Mixin: ParentNode not implemented."); }
+    DocumentImpl.prototype.prepend = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ParentNode not implemented.");
+    };
     /* istanbul ignore next */
-    get firstElementChild() { throw new Error("Mixin: ParentNode not implemented."); }
+    DocumentImpl.prototype.append = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ParentNode not implemented.");
+    };
     /* istanbul ignore next */
-    get lastElementChild() { throw new Error("Mixin: ParentNode not implemented."); }
+    DocumentImpl.prototype.querySelector = function (selectors) { throw new Error("Mixin: ParentNode not implemented."); };
     /* istanbul ignore next */
-    get childElementCount() { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    prepend(...nodes) { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    append(...nodes) { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    querySelector(selectors) { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    querySelectorAll(selectors) { throw new Error("Mixin: ParentNode not implemented."); }
-}
+    DocumentImpl.prototype.querySelectorAll = function (selectors) { throw new Error("Mixin: ParentNode not implemented."); };
+    return DocumentImpl;
+}(NodeImpl_1.NodeImpl));
 exports.DocumentImpl = DocumentImpl;
 /**
  * Initialize prototype properties
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(DocumentImpl.prototype, "_nodeType", interfaces_1.NodeType.Document);
+WebIDLAlgorithm_1.idl_defineConst(DocumentImpl.prototype, "_nodeType", interfaces_1.NodeType.Document);
 //# sourceMappingURL=DocumentImpl.js.map
 
 /***/ }),
@@ -24813,7 +53605,6 @@ exports.DocumentImpl = DocumentImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DocumentOrShadowRootImpl = void 0;
 /**
  * Represents a mixin for an interface to be used to share APIs between
  * documents and shadow roots. This mixin is implemented by
@@ -24822,32 +53613,44 @@ exports.DocumentOrShadowRootImpl = void 0;
  * _Note:_ The DocumentOrShadowRoot mixin is expected to be used by other
  * standards that want to define APIs shared between documents and shadow roots.
  */
-class DocumentOrShadowRootImpl {
-}
+var DocumentOrShadowRootImpl = /** @class */ (function () {
+    function DocumentOrShadowRootImpl() {
+    }
+    return DocumentOrShadowRootImpl;
+}());
 exports.DocumentOrShadowRootImpl = DocumentOrShadowRootImpl;
 //# sourceMappingURL=DocumentOrShadowRootImpl.js.map
 
 /***/ }),
 
 /***/ 3173:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DocumentTypeImpl = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
-const NodeImpl_1 = __nccwpck_require__(91745);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var interfaces_1 = __nccwpck_require__(27305);
+var NodeImpl_1 = __nccwpck_require__(91745);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents an object providing methods which are not dependent on
  * any particular document
  */
-class DocumentTypeImpl extends NodeImpl_1.NodeImpl {
-    _nodeType = interfaces_1.NodeType.DocumentType;
-    _name = '';
-    _publicId = '';
-    _systemId = '';
+var DocumentTypeImpl = /** @class */ (function (_super) {
+    __extends(DocumentTypeImpl, _super);
     /**
      * Initializes a new instance of `DocumentType`.
      *
@@ -24855,27 +53658,61 @@ class DocumentTypeImpl extends NodeImpl_1.NodeImpl {
      * @param publicId - `PUBLIC` identifier
      * @param systemId - `SYSTEM` identifier
      */
-    constructor(name, publicId, systemId) {
-        super();
-        this._name = name;
-        this._publicId = publicId;
-        this._systemId = systemId;
+    function DocumentTypeImpl(name, publicId, systemId) {
+        var _this = _super.call(this) || this;
+        _this._name = '';
+        _this._publicId = '';
+        _this._systemId = '';
+        _this._name = name;
+        _this._publicId = publicId;
+        _this._systemId = systemId;
+        return _this;
     }
-    /** @inheritdoc */
-    get name() { return this._name; }
-    /** @inheritdoc */
-    get publicId() { return this._publicId; }
-    /** @inheritdoc */
-    get systemId() { return this._systemId; }
+    Object.defineProperty(DocumentTypeImpl.prototype, "name", {
+        /** @inheritdoc */
+        get: function () { return this._name; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentTypeImpl.prototype, "publicId", {
+        /** @inheritdoc */
+        get: function () { return this._publicId; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(DocumentTypeImpl.prototype, "systemId", {
+        /** @inheritdoc */
+        get: function () { return this._systemId; },
+        enumerable: true,
+        configurable: true
+    });
     // MIXIN: ChildNode
     /* istanbul ignore next */
-    before(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
+    DocumentTypeImpl.prototype.before = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ChildNode not implemented.");
+    };
     /* istanbul ignore next */
-    after(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
+    DocumentTypeImpl.prototype.after = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ChildNode not implemented.");
+    };
     /* istanbul ignore next */
-    replaceWith(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
+    DocumentTypeImpl.prototype.replaceWith = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ChildNode not implemented.");
+    };
     /* istanbul ignore next */
-    remove() { throw new Error("Mixin: ChildNode not implemented."); }
+    DocumentTypeImpl.prototype.remove = function () { throw new Error("Mixin: ChildNode not implemented."); };
     /**
      * Creates a new `DocumentType`.
      *
@@ -24884,143 +53721,232 @@ class DocumentTypeImpl extends NodeImpl_1.NodeImpl {
      * @param publicId - `PUBLIC` identifier
      * @param systemId - `SYSTEM` identifier
      */
-    static _create(document, name, publicId = '', systemId = '') {
-        const node = new DocumentTypeImpl(name, publicId, systemId);
+    DocumentTypeImpl._create = function (document, name, publicId, systemId) {
+        if (publicId === void 0) { publicId = ''; }
+        if (systemId === void 0) { systemId = ''; }
+        var node = new DocumentTypeImpl(name, publicId, systemId);
         node._nodeDocument = document;
         return node;
-    }
-}
+    };
+    return DocumentTypeImpl;
+}(NodeImpl_1.NodeImpl));
 exports.DocumentTypeImpl = DocumentTypeImpl;
 /**
  * Initialize prototype properties
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(DocumentTypeImpl.prototype, "_nodeType", interfaces_1.NodeType.DocumentType);
+WebIDLAlgorithm_1.idl_defineConst(DocumentTypeImpl.prototype, "_nodeType", interfaces_1.NodeType.DocumentType);
 //# sourceMappingURL=DocumentTypeImpl.js.map
 
 /***/ }),
 
 /***/ 35975:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ElementImpl = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
-const NodeImpl_1 = __nccwpck_require__(91745);
-const DOMException_1 = __nccwpck_require__(13166);
-const infra_1 = __nccwpck_require__(84251);
-const algorithm_1 = __nccwpck_require__(61);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var interfaces_1 = __nccwpck_require__(27305);
+var NodeImpl_1 = __nccwpck_require__(91745);
+var DOMException_1 = __nccwpck_require__(13166);
+var infra_1 = __nccwpck_require__(84251);
+var algorithm_1 = __nccwpck_require__(61);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents an element node.
  */
-class ElementImpl extends NodeImpl_1.NodeImpl {
-    _nodeType = interfaces_1.NodeType.Element;
-    _children = new Set();
-    _namespace = null;
-    _namespacePrefix = null;
-    _localName = "";
-    _customElementState = "undefined";
-    _customElementDefinition = null;
-    _is = null;
-    _shadowRoot = null;
-    _attributeList = (0, algorithm_1.create_namedNodeMap)(this);
-    _uniqueIdentifier;
-    _attributeChangeSteps = [];
-    _name = '';
-    _assignedSlot = null;
+var ElementImpl = /** @class */ (function (_super) {
+    __extends(ElementImpl, _super);
     /**
      * Initializes a new instance of `Element`.
      */
-    constructor() {
-        super();
+    function ElementImpl() {
+        var _this = _super.call(this) || this;
+        _this._children = new Set();
+        _this._namespace = null;
+        _this._namespacePrefix = null;
+        _this._localName = "";
+        _this._customElementState = "undefined";
+        _this._customElementDefinition = null;
+        _this._is = null;
+        _this._shadowRoot = null;
+        _this._attributeList = algorithm_1.create_namedNodeMap(_this);
+        _this._attributeChangeSteps = [];
+        _this._name = '';
+        _this._assignedSlot = null;
+        return _this;
     }
+    Object.defineProperty(ElementImpl.prototype, "namespaceURI", {
+        /** @inheritdoc */
+        get: function () { return this._namespace; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "prefix", {
+        /** @inheritdoc */
+        get: function () { return this._namespacePrefix; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "localName", {
+        /** @inheritdoc */
+        get: function () { return this._localName; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "tagName", {
+        /** @inheritdoc */
+        get: function () { return this._htmlUppercasedQualifiedName; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "id", {
+        /** @inheritdoc */
+        get: function () {
+            return algorithm_1.element_getAnAttributeValue(this, "id");
+        },
+        set: function (value) {
+            algorithm_1.element_setAnAttributeValue(this, "id", value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "className", {
+        /** @inheritdoc */
+        get: function () {
+            return algorithm_1.element_getAnAttributeValue(this, "class");
+        },
+        set: function (value) {
+            algorithm_1.element_setAnAttributeValue(this, "class", value);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "classList", {
+        /** @inheritdoc */
+        get: function () {
+            var attr = algorithm_1.element_getAnAttributeByName("class", this);
+            if (attr === null) {
+                attr = algorithm_1.create_attr(this._nodeDocument, "class");
+            }
+            return algorithm_1.create_domTokenList(this, attr);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "slot", {
+        /** @inheritdoc */
+        get: function () {
+            return algorithm_1.element_getAnAttributeValue(this, "slot");
+        },
+        set: function (value) {
+            algorithm_1.element_setAnAttributeValue(this, "slot", value);
+        },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get namespaceURI() { return this._namespace; }
-    /** @inheritdoc */
-    get prefix() { return this._namespacePrefix; }
-    /** @inheritdoc */
-    get localName() { return this._localName; }
-    /** @inheritdoc */
-    get tagName() { return this._htmlUppercasedQualifiedName; }
-    /** @inheritdoc */
-    get id() {
-        return (0, algorithm_1.element_getAnAttributeValue)(this, "id");
-    }
-    set id(value) {
-        (0, algorithm_1.element_setAnAttributeValue)(this, "id", value);
-    }
-    /** @inheritdoc */
-    get className() {
-        return (0, algorithm_1.element_getAnAttributeValue)(this, "class");
-    }
-    set className(value) {
-        (0, algorithm_1.element_setAnAttributeValue)(this, "class", value);
-    }
-    /** @inheritdoc */
-    get classList() {
-        let attr = (0, algorithm_1.element_getAnAttributeByName)("class", this);
-        if (attr === null) {
-            attr = (0, algorithm_1.create_attr)(this._nodeDocument, "class");
-        }
-        return (0, algorithm_1.create_domTokenList)(this, attr);
-    }
-    /** @inheritdoc */
-    get slot() {
-        return (0, algorithm_1.element_getAnAttributeValue)(this, "slot");
-    }
-    set slot(value) {
-        (0, algorithm_1.element_setAnAttributeValue)(this, "slot", value);
-    }
-    /** @inheritdoc */
-    hasAttributes() {
+    ElementImpl.prototype.hasAttributes = function () {
         return this._attributeList.length !== 0;
-    }
+    };
+    Object.defineProperty(ElementImpl.prototype, "attributes", {
+        /** @inheritdoc */
+        get: function () { return this._attributeList; },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get attributes() { return this._attributeList; }
-    /** @inheritdoc */
-    getAttributeNames() {
+    ElementImpl.prototype.getAttributeNames = function () {
+        var e_1, _a;
         /**
          * The getAttributeNames() method, when invoked, must return the qualified
          * names of the attributes in context object’s attribute list, in order,
          * and a new list otherwise.
          */
-        const names = [];
-        for (const attr of this._attributeList) {
-            names.push(attr._qualifiedName);
+        var names = [];
+        try {
+            for (var _b = __values(this._attributeList), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var attr = _c.value;
+                names.push(attr._qualifiedName);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
         return names;
-    }
+    };
     /** @inheritdoc */
-    getAttribute(qualifiedName) {
+    ElementImpl.prototype.getAttribute = function (qualifiedName) {
         /**
          * 1. Let attr be the result of getting an attribute given qualifiedName
          * and the context object.
          * 2. If attr is null, return null.
          * 3. Return attr’s value.
          */
-        const attr = (0, algorithm_1.element_getAnAttributeByName)(qualifiedName, this);
+        var attr = algorithm_1.element_getAnAttributeByName(qualifiedName, this);
         return (attr ? attr._value : null);
-    }
+    };
     /** @inheritdoc */
-    getAttributeNS(namespace, localName) {
+    ElementImpl.prototype.getAttributeNS = function (namespace, localName) {
         /**
          * 1. Let attr be the result of getting an attribute given namespace,
          * localName, and the context object.
          * 2. If attr is null, return null.
          * 3. Return attr’s value.
          */
-        const attr = (0, algorithm_1.element_getAnAttributeByNamespaceAndLocalName)(namespace, localName, this);
+        var attr = algorithm_1.element_getAnAttributeByNamespaceAndLocalName(namespace, localName, this);
         return (attr ? attr._value : null);
-    }
+    };
     /** @inheritdoc */
-    setAttribute(qualifiedName, value) {
+    ElementImpl.prototype.setAttribute = function (qualifiedName, value) {
         /**
          * 1. If qualifiedName does not match the Name production in XML, then
          * throw an "InvalidCharacterError" DOMException.
          */
-        if (!(0, algorithm_1.xml_isName)(qualifiedName))
+        if (!algorithm_1.xml_isName(qualifiedName))
             throw new DOMException_1.InvalidCharacterError();
         /**
          * 2. If the context object is in the HTML namespace and its node document
@@ -25034,9 +53960,9 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
          * 3. Let attribute be the first attribute in context object’s attribute
          * list whose qualified name is qualifiedName, and null otherwise.
          */
-        let attribute = null;
-        for (let i = 0; i < this._attributeList.length; i++) {
-            const attr = this._attributeList[i];
+        var attribute = null;
+        for (var i = 0; i < this._attributeList.length; i++) {
+            var attr = this._attributeList[i];
             if (attr._qualifiedName === qualifiedName) {
                 attribute = attr;
                 break;
@@ -25049,47 +53975,47 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
          * then return.
          */
         if (attribute === null) {
-            attribute = (0, algorithm_1.create_attr)(this._nodeDocument, qualifiedName);
+            attribute = algorithm_1.create_attr(this._nodeDocument, qualifiedName);
             attribute._value = value;
-            (0, algorithm_1.element_append)(attribute, this);
+            algorithm_1.element_append(attribute, this);
             return;
         }
         /**
          * 5. Change attribute from context object to value.
          */
-        (0, algorithm_1.element_change)(attribute, this, value);
-    }
+        algorithm_1.element_change(attribute, this, value);
+    };
     /** @inheritdoc */
-    setAttributeNS(namespace, qualifiedName, value) {
+    ElementImpl.prototype.setAttributeNS = function (namespace, qualifiedName, value) {
         /**
          * 1. Let namespace, prefix, and localName be the result of passing
          * namespace and qualifiedName to validate and extract.
          * 2. Set an attribute value for the context object using localName, value,
          * and also prefix and namespace.
          */
-        const [ns, prefix, localName] = (0, algorithm_1.namespace_validateAndExtract)(namespace, qualifiedName);
-        (0, algorithm_1.element_setAnAttributeValue)(this, localName, value, prefix, ns);
-    }
+        var _a = __read(algorithm_1.namespace_validateAndExtract(namespace, qualifiedName), 3), ns = _a[0], prefix = _a[1], localName = _a[2];
+        algorithm_1.element_setAnAttributeValue(this, localName, value, prefix, ns);
+    };
     /** @inheritdoc */
-    removeAttribute(qualifiedName) {
+    ElementImpl.prototype.removeAttribute = function (qualifiedName) {
         /**
          * The removeAttribute(qualifiedName) method, when invoked, must remove an
          * attribute given qualifiedName and the context object, and then return
          * undefined.
          */
-        (0, algorithm_1.element_removeAnAttributeByName)(qualifiedName, this);
-    }
+        algorithm_1.element_removeAnAttributeByName(qualifiedName, this);
+    };
     /** @inheritdoc */
-    removeAttributeNS(namespace, localName) {
+    ElementImpl.prototype.removeAttributeNS = function (namespace, localName) {
         /**
          * The removeAttributeNS(namespace, localName) method, when invoked, must
          * remove an attribute given namespace, localName, and context object, and
          * then return undefined.
          */
-        (0, algorithm_1.element_removeAnAttributeByNamespaceAndLocalName)(namespace, localName, this);
-    }
+        algorithm_1.element_removeAnAttributeByNamespaceAndLocalName(namespace, localName, this);
+    };
     /** @inheritdoc */
-    hasAttribute(qualifiedName) {
+    ElementImpl.prototype.hasAttribute = function (qualifiedName) {
         /**
          * 1. If the context object is in the HTML namespace and its node document
          * is an HTML document, then set qualifiedName to qualifiedName in ASCII
@@ -25100,21 +54026,21 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
         if (this._namespace === infra_1.namespace.HTML && this._nodeDocument._type === "html") {
             qualifiedName = qualifiedName.toLowerCase();
         }
-        for (let i = 0; i < this._attributeList.length; i++) {
-            const attr = this._attributeList[i];
+        for (var i = 0; i < this._attributeList.length; i++) {
+            var attr = this._attributeList[i];
             if (attr._qualifiedName === qualifiedName) {
                 return true;
             }
         }
         return false;
-    }
+    };
     /** @inheritdoc */
-    toggleAttribute(qualifiedName, force) {
+    ElementImpl.prototype.toggleAttribute = function (qualifiedName, force) {
         /**
          * 1. If qualifiedName does not match the Name production in XML, then
          * throw an "InvalidCharacterError" DOMException.
          */
-        if (!(0, algorithm_1.xml_isName)(qualifiedName))
+        if (!algorithm_1.xml_isName(qualifiedName))
             throw new DOMException_1.InvalidCharacterError();
         /**
          * 2. If the context object is in the HTML namespace and its node document
@@ -25128,9 +54054,9 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
          * 3. Let attribute be the first attribute in the context object’s attribute
          * list whose qualified name is qualifiedName, and null otherwise.
          */
-        let attribute = null;
-        for (let i = 0; i < this._attributeList.length; i++) {
-            const attr = this._attributeList[i];
+        var attribute = null;
+        for (var i = 0; i < this._attributeList.length; i++) {
+            var attr = this._attributeList[i];
             if (attr._qualifiedName === qualifiedName) {
                 attribute = attr;
                 break;
@@ -25146,9 +54072,9 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
              * 4.2. Return false.
              */
             if (force === undefined || force === true) {
-                attribute = (0, algorithm_1.create_attr)(this._nodeDocument, qualifiedName);
+                attribute = algorithm_1.create_attr(this._nodeDocument, qualifiedName);
                 attribute._value = '';
-                (0, algorithm_1.element_append)(attribute, this);
+                algorithm_1.element_append(attribute, this);
                 return true;
             }
             return false;
@@ -25158,71 +54084,71 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
              * 5. Otherwise, if force is not given or is false, remove an attribute
              * given qualifiedName and the context object, and then return false.
              */
-            (0, algorithm_1.element_removeAnAttributeByName)(qualifiedName, this);
+            algorithm_1.element_removeAnAttributeByName(qualifiedName, this);
             return false;
         }
         /**
          * 6. Return true.
          */
         return true;
-    }
+    };
     /** @inheritdoc */
-    hasAttributeNS(namespace, localName) {
+    ElementImpl.prototype.hasAttributeNS = function (namespace, localName) {
         /**
          * 1. If namespace is the empty string, set it to null.
          * 2. Return true if the context object has an attribute whose namespace is
          * namespace and local name is localName, and false otherwise.
          */
-        const ns = namespace || null;
-        for (let i = 0; i < this._attributeList.length; i++) {
-            const attr = this._attributeList[i];
+        var ns = namespace || null;
+        for (var i = 0; i < this._attributeList.length; i++) {
+            var attr = this._attributeList[i];
             if (attr._namespace === ns && attr._localName === localName) {
                 return true;
             }
         }
         return false;
-    }
+    };
     /** @inheritdoc */
-    getAttributeNode(qualifiedName) {
+    ElementImpl.prototype.getAttributeNode = function (qualifiedName) {
         /**
          * The getAttributeNode(qualifiedName) method, when invoked, must return the
          * result of getting an attribute given qualifiedName and context object.
          */
-        return (0, algorithm_1.element_getAnAttributeByName)(qualifiedName, this);
-    }
+        return algorithm_1.element_getAnAttributeByName(qualifiedName, this);
+    };
     /** @inheritdoc */
-    getAttributeNodeNS(namespace, localName) {
+    ElementImpl.prototype.getAttributeNodeNS = function (namespace, localName) {
         /**
          * The getAttributeNodeNS(namespace, localName) method, when invoked, must
          * return the result of getting an attribute given namespace, localName, and
          * the context object.
          */
-        return (0, algorithm_1.element_getAnAttributeByNamespaceAndLocalName)(namespace, localName, this);
-    }
+        return algorithm_1.element_getAnAttributeByNamespaceAndLocalName(namespace, localName, this);
+    };
     /** @inheritdoc */
-    setAttributeNode(attr) {
+    ElementImpl.prototype.setAttributeNode = function (attr) {
         /**
          * The setAttributeNode(attr) and setAttributeNodeNS(attr) methods, when
          * invoked, must return the result of setting an attribute given attr and
          * the context object.
          */
-        return (0, algorithm_1.element_setAnAttribute)(attr, this);
-    }
+        return algorithm_1.element_setAnAttribute(attr, this);
+    };
     /** @inheritdoc */
-    setAttributeNodeNS(attr) {
-        return (0, algorithm_1.element_setAnAttribute)(attr, this);
-    }
+    ElementImpl.prototype.setAttributeNodeNS = function (attr) {
+        return algorithm_1.element_setAnAttribute(attr, this);
+    };
     /** @inheritdoc */
-    removeAttributeNode(attr) {
+    ElementImpl.prototype.removeAttributeNode = function (attr) {
         /**
          * 1. If context object’s attribute list does not contain attr, then throw
          * a "NotFoundError" DOMException.
          * 2. Remove attr from context object.
          * 3. Return attr.
          */
-        let found = false;
-        for (let i = 0; i < this._attributeList.length; i++) {
-            const attribute = this._attributeList[i];
+        var found = false;
+        for (var i = 0; i < this._attributeList.length; i++) {
+            var attribute = this._attributeList[i];
             if (attribute === attr) {
                 found = true;
                 break;
@@ -25230,11 +54156,11 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
         }
         if (!found)
             throw new DOMException_1.NotFoundError();
-        (0, algorithm_1.element_remove)(attr, this);
+        algorithm_1.element_remove(attr, this);
         return attr;
-    }
+    };
     /** @inheritdoc */
-    attachShadow(init) {
+    ElementImpl.prototype.attachShadow = function (init) {
         /**
          * 1. If context object’s namespace is not the HTML namespace, then throw a
          * "NotSupportedError" DOMException.
@@ -25247,8 +54173,8 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
          * "h3", "h4", "h5", "h6", "header", "main" "nav", "p", "section",
          * or "span", then throw a "NotSupportedError" DOMException.
          */
-        if (!(0, algorithm_1.customElement_isValidCustomElementName)(this._localName) &&
-            !(0, algorithm_1.customElement_isValidShadowHostName)(this._localName))
+        if (!algorithm_1.customElement_isValidCustomElementName(this._localName) &&
+            !algorithm_1.customElement_isValidShadowHostName(this._localName))
             throw new DOMException_1.NotSupportedError();
         /**
          * 3. If context object’s local name is a valid custom element name,
@@ -25259,8 +54185,8 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
          * 3.2. If definition is not null and definition’s disable shadow is true,
          *  then throw a "NotSupportedError" DOMException.
          */
-        if ((0, algorithm_1.customElement_isValidCustomElementName)(this._localName) || this._is !== null) {
-            const definition = (0, algorithm_1.customElement_lookUpACustomElementDefinition)(this._nodeDocument, this._namespace, this._localName, this._is);
+        if (algorithm_1.customElement_isValidCustomElementName(this._localName) || this._is !== null) {
+            var definition = algorithm_1.customElement_lookUpACustomElementDefinition(this._nodeDocument, this._namespace, this._localName, this._is);
             if (definition !== null && definition.disableShadow === true) {
                 throw new DOMException_1.NotSupportedError();
             }
@@ -25277,26 +54203,30 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
          * 6. Set context object’s shadow root to shadow.
          * 7. Return shadow.
          */
-        const shadow = (0, algorithm_1.create_shadowRoot)(this._nodeDocument, this);
+        var shadow = algorithm_1.create_shadowRoot(this._nodeDocument, this);
         shadow._mode = init.mode;
         this._shadowRoot = shadow;
         return shadow;
-    }
+    };
+    Object.defineProperty(ElementImpl.prototype, "shadowRoot", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * 1. Let shadow be context object’s shadow root.
+             * 2. If shadow is null or its mode is "closed", then return null.
+             * 3. Return shadow.
+             */
+            var shadow = this._shadowRoot;
+            if (shadow === null || shadow.mode === "closed")
+                return null;
+            else
+                return shadow;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get shadowRoot() {
-        /**
-         * 1. Let shadow be context object’s shadow root.
-         * 2. If shadow is null or its mode is "closed", then return null.
-         * 3. Return shadow.
-         */
-        const shadow = this._shadowRoot;
-        if (shadow === null || shadow.mode === "closed")
-            return null;
-        else
-            return shadow;
-    }
-    /** @inheritdoc */
-    closest(selectors) {
+    ElementImpl.prototype.closest = function (selectors) {
         /**
          * TODO: Selectors
          * 1. Let s be the result of parse a selector from selectors. [SELECTORS4]
@@ -25309,9 +54239,9 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
          * 5. Return null.
          */
         throw new DOMException_1.NotImplementedError();
-    }
+    };
     /** @inheritdoc */
-    matches(selectors) {
+    ElementImpl.prototype.matches = function (selectors) {
         /**
          * TODO: Selectors
          * 1. Let s be the result of parse a selector from selectors. [SELECTORS4]
@@ -25321,120 +54251,186 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
          * and false otherwise. [SELECTORS4]
          */
         throw new DOMException_1.NotImplementedError();
-    }
+    };
     /** @inheritdoc */
-    webkitMatchesSelector(selectors) {
+    ElementImpl.prototype.webkitMatchesSelector = function (selectors) {
         return this.matches(selectors);
-    }
+    };
     /** @inheritdoc */
-    getElementsByTagName(qualifiedName) {
+    ElementImpl.prototype.getElementsByTagName = function (qualifiedName) {
         /**
          * The getElementsByTagName(qualifiedName) method, when invoked, must return
          * the list of elements with qualified name qualifiedName for context
          * object.
          */
-        return (0, algorithm_1.node_listOfElementsWithQualifiedName)(qualifiedName, this);
-    }
+        return algorithm_1.node_listOfElementsWithQualifiedName(qualifiedName, this);
+    };
     /** @inheritdoc */
-    getElementsByTagNameNS(namespace, localName) {
+    ElementImpl.prototype.getElementsByTagNameNS = function (namespace, localName) {
         /**
          * The getElementsByTagNameNS(namespace, localName) method, when invoked,
          * must return the list of elements with namespace namespace and local name
          * localName for context object.
          */
-        return (0, algorithm_1.node_listOfElementsWithNamespace)(namespace, localName, this);
-    }
+        return algorithm_1.node_listOfElementsWithNamespace(namespace, localName, this);
+    };
     /** @inheritdoc */
-    getElementsByClassName(classNames) {
+    ElementImpl.prototype.getElementsByClassName = function (classNames) {
         /**
          * The getElementsByClassName(classNames) method, when invoked, must return
          * the list of elements with class names classNames for context object.
          */
-        return (0, algorithm_1.node_listOfElementsWithClassNames)(classNames, this);
-    }
+        return algorithm_1.node_listOfElementsWithClassNames(classNames, this);
+    };
     /** @inheritdoc */
-    insertAdjacentElement(where, element) {
+    ElementImpl.prototype.insertAdjacentElement = function (where, element) {
         /**
          * The insertAdjacentElement(where, element) method, when invoked, must
          * return the result of running insert adjacent, given context object,
          *  where, and element.
          */
-        return (0, algorithm_1.element_insertAdjacent)(this, where, element);
-    }
+        return algorithm_1.element_insertAdjacent(this, where, element);
+    };
     /** @inheritdoc */
-    insertAdjacentText(where, data) {
+    ElementImpl.prototype.insertAdjacentText = function (where, data) {
         /**
          * 1. Let text be a new Text node whose data is data and node document is
          * context object’s node document.
          * 2. Run insert adjacent, given context object, where, and text.
          */
-        const text = (0, algorithm_1.create_text)(this._nodeDocument, data);
-        (0, algorithm_1.element_insertAdjacent)(this, where, text);
-    }
-    /**
-     * Returns the qualified name.
-     */
-    get _qualifiedName() {
+        var text = algorithm_1.create_text(this._nodeDocument, data);
+        algorithm_1.element_insertAdjacent(this, where, text);
+    };
+    Object.defineProperty(ElementImpl.prototype, "_qualifiedName", {
         /**
-         * An element’s qualified name is its local name if its namespace prefix is
-         * null, and its namespace prefix, followed by ":", followed by its
-         * local name, otherwise.
+         * Returns the qualified name.
          */
-        return (this._namespacePrefix ?
-            this._namespacePrefix + ':' + this._localName :
-            this._localName);
-    }
-    /**
-     * Returns the upper-cased qualified name for a html element.
-     */
-    get _htmlUppercasedQualifiedName() {
+        get: function () {
+            /**
+             * An element’s qualified name is its local name if its namespace prefix is
+             * null, and its namespace prefix, followed by ":", followed by its
+             * local name, otherwise.
+             */
+            return (this._namespacePrefix ?
+                this._namespacePrefix + ':' + this._localName :
+                this._localName);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "_htmlUppercasedQualifiedName", {
         /**
-         * 1. Let qualifiedName be context object’s qualified name.
-         * 2. If the context object is in the HTML namespace and its node document
-         * is an HTML document, then set qualifiedName to qualifiedName in ASCII
-         * uppercase.
-         * 3. Return qualifiedName.
+         * Returns the upper-cased qualified name for a html element.
          */
-        let qualifiedName = this._qualifiedName;
-        if (this._namespace === infra_1.namespace.HTML && this._nodeDocument._type === "html") {
-            qualifiedName = qualifiedName.toUpperCase();
+        get: function () {
+            /**
+             * 1. Let qualifiedName be context object’s qualified name.
+             * 2. If the context object is in the HTML namespace and its node document
+             * is an HTML document, then set qualifiedName to qualifiedName in ASCII
+             * uppercase.
+             * 3. Return qualifiedName.
+             */
+            var qualifiedName = this._qualifiedName;
+            if (this._namespace === infra_1.namespace.HTML && this._nodeDocument._type === "html") {
+                qualifiedName = qualifiedName.toUpperCase();
+            }
+            return qualifiedName;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "children", {
+        // MIXIN: ParentNode
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: ParentNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "firstElementChild", {
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: ParentNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "lastElementChild", {
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: ParentNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "childElementCount", {
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: ParentNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
+    /* istanbul ignore next */
+    ElementImpl.prototype.prepend = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
         }
-        return qualifiedName;
-    }
-    // MIXIN: ParentNode
+        throw new Error("Mixin: ParentNode not implemented.");
+    };
     /* istanbul ignore next */
-    get children() { throw new Error("Mixin: ParentNode not implemented."); }
+    ElementImpl.prototype.append = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ParentNode not implemented.");
+    };
     /* istanbul ignore next */
-    get firstElementChild() { throw new Error("Mixin: ParentNode not implemented."); }
+    ElementImpl.prototype.querySelector = function (selectors) { throw new Error("Mixin: ParentNode not implemented."); };
     /* istanbul ignore next */
-    get lastElementChild() { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    get childElementCount() { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    prepend(...nodes) { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    append(...nodes) { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    querySelector(selectors) { throw new Error("Mixin: ParentNode not implemented."); }
-    /* istanbul ignore next */
-    querySelectorAll(selectors) { throw new Error("Mixin: ParentNode not implemented."); }
-    // MIXIN: NonDocumentTypeChildNode
-    /* istanbul ignore next */
-    get previousElementSibling() { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); }
-    /* istanbul ignore next */
-    get nextElementSibling() { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); }
+    ElementImpl.prototype.querySelectorAll = function (selectors) { throw new Error("Mixin: ParentNode not implemented."); };
+    Object.defineProperty(ElementImpl.prototype, "previousElementSibling", {
+        // MIXIN: NonDocumentTypeChildNode
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ElementImpl.prototype, "nextElementSibling", {
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: NonDocumentTypeChildNode not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
     // MIXIN: ChildNode
     /* istanbul ignore next */
-    before(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
+    ElementImpl.prototype.before = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ChildNode not implemented.");
+    };
     /* istanbul ignore next */
-    after(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
+    ElementImpl.prototype.after = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ChildNode not implemented.");
+    };
     /* istanbul ignore next */
-    replaceWith(...nodes) { throw new Error("Mixin: ChildNode not implemented."); }
+    ElementImpl.prototype.replaceWith = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
+        throw new Error("Mixin: ChildNode not implemented.");
+    };
     /* istanbul ignore next */
-    remove() { throw new Error("Mixin: ChildNode not implemented."); }
-    // MIXIN: Slotable
-    /* istanbul ignore next */
-    get assignedSlot() { throw new Error("Mixin: Slotable not implemented."); }
+    ElementImpl.prototype.remove = function () { throw new Error("Mixin: ChildNode not implemented."); };
+    Object.defineProperty(ElementImpl.prototype, "assignedSlot", {
+        // MIXIN: Slotable
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: Slotable not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Creates a new `Element`.
      *
@@ -25443,20 +54439,23 @@ class ElementImpl extends NodeImpl_1.NodeImpl {
      * @param namespace - namespace
      * @param prefix - namespace prefix
      */
-    static _create(document, localName, namespace = null, namespacePrefix = null) {
-        const node = new ElementImpl();
+    ElementImpl._create = function (document, localName, namespace, namespacePrefix) {
+        if (namespace === void 0) { namespace = null; }
+        if (namespacePrefix === void 0) { namespacePrefix = null; }
+        var node = new ElementImpl();
         node._localName = localName;
         node._namespace = namespace;
         node._namespacePrefix = namespacePrefix;
         node._nodeDocument = document;
         return node;
-    }
-}
+    };
+    return ElementImpl;
+}(NodeImpl_1.NodeImpl));
 exports.ElementImpl = ElementImpl;
 /**
  * Initialize prototype properties
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(ElementImpl.prototype, "_nodeType", interfaces_1.NodeType.Element);
+WebIDLAlgorithm_1.idl_defineConst(ElementImpl.prototype, "_nodeType", interfaces_1.NodeType.Element);
 //# sourceMappingURL=ElementImpl.js.map
 
 /***/ }),
@@ -25467,44 +54466,33 @@ exports.ElementImpl = ElementImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.EventImpl = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
-const algorithm_1 = __nccwpck_require__(61);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var interfaces_1 = __nccwpck_require__(27305);
+var algorithm_1 = __nccwpck_require__(61);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents a DOM event.
  */
-class EventImpl {
-    static NONE = 0;
-    static CAPTURING_PHASE = 1;
-    static AT_TARGET = 2;
-    static BUBBLING_PHASE = 3;
-    NONE = 0;
-    CAPTURING_PHASE = 1;
-    AT_TARGET = 2;
-    BUBBLING_PHASE = 3;
-    _target = null;
-    _relatedTarget = null;
-    _touchTargetList = [];
-    _path = [];
-    _currentTarget = null;
-    _eventPhase = interfaces_1.EventPhase.None;
-    _stopPropagationFlag = false;
-    _stopImmediatePropagationFlag = false;
-    _canceledFlag = false;
-    _inPassiveListenerFlag = false;
-    _composedFlag = false;
-    _initializedFlag = false;
-    _dispatchFlag = false;
-    _isTrusted = false;
-    _type;
-    _bubbles = false;
-    _cancelable = false;
-    _timeStamp;
+var EventImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `Event`.
      */
-    constructor(type, eventInit) {
+    function EventImpl(type, eventInit) {
+        this._target = null;
+        this._relatedTarget = null;
+        this._touchTargetList = [];
+        this._path = [];
+        this._currentTarget = null;
+        this._eventPhase = interfaces_1.EventPhase.None;
+        this._stopPropagationFlag = false;
+        this._stopImmediatePropagationFlag = false;
+        this._canceledFlag = false;
+        this._inPassiveListenerFlag = false;
+        this._composedFlag = false;
+        this._initializedFlag = false;
+        this._dispatchFlag = false;
+        this._isTrusted = false;
+        this._bubbles = false;
+        this._cancelable = false;
         /**
          * When a constructor of the Event interface, or of an interface that
          * inherits from the Event interface, is invoked, these steps must be run,
@@ -25523,16 +54511,32 @@ class EventImpl {
         this._initializedFlag = true;
         this._timeStamp = new Date().getTime();
     }
+    Object.defineProperty(EventImpl.prototype, "type", {
+        /** @inheritdoc */
+        get: function () { return this._type; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "target", {
+        /** @inheritdoc */
+        get: function () { return this._target; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "srcElement", {
+        /** @inheritdoc */
+        get: function () { return this._target; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "currentTarget", {
+        /** @inheritdoc */
+        get: function () { return this._currentTarget; },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get type() { return this._type; }
-    /** @inheritdoc */
-    get target() { return this._target; }
-    /** @inheritdoc */
-    get srcElement() { return this._target; }
-    /** @inheritdoc */
-    get currentTarget() { return this._currentTarget; }
-    /** @inheritdoc */
-    composedPath() {
+    EventImpl.prototype.composedPath = function () {
         /**
          * 1. Let composedPath be an empty list.
          * 2. Let path be the context object’s path.
@@ -25543,22 +54547,22 @@ class EventImpl {
          * 6. Let currentTargetIndex be 0.
          * 7. Let currentTargetHiddenSubtreeLevel be 0.
          */
-        const composedPath = [];
-        const path = this._path;
+        var composedPath = [];
+        var path = this._path;
         if (path.length === 0)
             return composedPath;
-        const currentTarget = this._currentTarget;
+        var currentTarget = this._currentTarget;
         if (currentTarget === null) {
             throw new Error("Event currentTarget is null.");
         }
         composedPath.push(currentTarget);
-        let currentTargetIndex = 0;
-        let currentTargetHiddenSubtreeLevel = 0;
+        var currentTargetIndex = 0;
+        var currentTargetHiddenSubtreeLevel = 0;
         /**
          * 8. Let index be path’s size − 1.
          * 9. While index is greater than or equal to 0:
          */
-        let index = path.length - 1;
+        var index = path.length - 1;
         while (index >= 0) {
             /**
              * 9.1. If path[index]'s root-of-closed-tree is true, then increase
@@ -25585,8 +54589,8 @@ class EventImpl {
          * 10. Let currentHiddenLevel and maxHiddenLevel be
          * currentTargetHiddenSubtreeLevel.
          */
-        let currentHiddenLevel = currentTargetHiddenSubtreeLevel;
-        let maxHiddenLevel = currentTargetHiddenSubtreeLevel;
+        var currentHiddenLevel = currentTargetHiddenSubtreeLevel;
+        var maxHiddenLevel = currentTargetHiddenSubtreeLevel;
         /**
          * 11. Set index to currentTargetIndex − 1.
          * 12. While index is greater than or equal to 0:
@@ -25671,45 +54675,83 @@ class EventImpl {
          * 16. Return composedPath.
          */
         return composedPath;
-    }
+    };
+    Object.defineProperty(EventImpl.prototype, "eventPhase", {
+        /** @inheritdoc */
+        get: function () { return this._eventPhase; },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get eventPhase() { return this._eventPhase; }
+    EventImpl.prototype.stopPropagation = function () { this._stopPropagationFlag = true; };
+    Object.defineProperty(EventImpl.prototype, "cancelBubble", {
+        /** @inheritdoc */
+        get: function () { return this._stopPropagationFlag; },
+        set: function (value) { if (value)
+            this.stopPropagation(); },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    stopPropagation() { this._stopPropagationFlag = true; }
-    /** @inheritdoc */
-    get cancelBubble() { return this._stopPropagationFlag; }
-    set cancelBubble(value) { if (value)
-        this.stopPropagation(); }
-    /** @inheritdoc */
-    stopImmediatePropagation() {
+    EventImpl.prototype.stopImmediatePropagation = function () {
         this._stopPropagationFlag = true;
         this._stopImmediatePropagationFlag = true;
-    }
+    };
+    Object.defineProperty(EventImpl.prototype, "bubbles", {
+        /** @inheritdoc */
+        get: function () { return this._bubbles; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "cancelable", {
+        /** @inheritdoc */
+        get: function () { return this._cancelable; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "returnValue", {
+        /** @inheritdoc */
+        get: function () { return !this._canceledFlag; },
+        set: function (value) {
+            if (!value) {
+                algorithm_1.event_setTheCanceledFlag(this);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get bubbles() { return this._bubbles; }
+    EventImpl.prototype.preventDefault = function () {
+        algorithm_1.event_setTheCanceledFlag(this);
+    };
+    Object.defineProperty(EventImpl.prototype, "defaultPrevented", {
+        /** @inheritdoc */
+        get: function () { return this._canceledFlag; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "composed", {
+        /** @inheritdoc */
+        get: function () { return this._composedFlag; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "isTrusted", {
+        /** @inheritdoc */
+        get: function () { return this._isTrusted; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EventImpl.prototype, "timeStamp", {
+        /** @inheritdoc */
+        get: function () { return this._timeStamp; },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get cancelable() { return this._cancelable; }
-    /** @inheritdoc */
-    get returnValue() { return !this._canceledFlag; }
-    set returnValue(value) {
-        if (!value) {
-            (0, algorithm_1.event_setTheCanceledFlag)(this);
-        }
-    }
-    /** @inheritdoc */
-    preventDefault() {
-        (0, algorithm_1.event_setTheCanceledFlag)(this);
-    }
-    /** @inheritdoc */
-    get defaultPrevented() { return this._canceledFlag; }
-    /** @inheritdoc */
-    get composed() { return this._composedFlag; }
-    /** @inheritdoc */
-    get isTrusted() { return this._isTrusted; }
-    /** @inheritdoc */
-    get timeStamp() { return this._timeStamp; }
-    /** @inheritdoc */
-    initEvent(type, bubbles = false, cancelable = false) {
+    EventImpl.prototype.initEvent = function (type, bubbles, cancelable) {
+        if (bubbles === void 0) { bubbles = false; }
+        if (cancelable === void 0) { cancelable = false; }
         /**
          * 1. If the context object’s dispatch flag is set, then return.
          */
@@ -25718,55 +54760,83 @@ class EventImpl {
         /**
          * 2. Initialize the context object with type, bubbles, and cancelable.
          */
-        (0, algorithm_1.event_initialize)(this, type, bubbles, cancelable);
-    }
-}
+        algorithm_1.event_initialize(this, type, bubbles, cancelable);
+    };
+    EventImpl.NONE = 0;
+    EventImpl.CAPTURING_PHASE = 1;
+    EventImpl.AT_TARGET = 2;
+    EventImpl.BUBBLING_PHASE = 3;
+    return EventImpl;
+}());
 exports.EventImpl = EventImpl;
 /**
  * Define constants on prototype.
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(EventImpl.prototype, "NONE", 0);
-(0, WebIDLAlgorithm_1.idl_defineConst)(EventImpl.prototype, "CAPTURING_PHASE", 1);
-(0, WebIDLAlgorithm_1.idl_defineConst)(EventImpl.prototype, "AT_TARGET", 2);
-(0, WebIDLAlgorithm_1.idl_defineConst)(EventImpl.prototype, "BUBBLING_PHASE", 3);
+WebIDLAlgorithm_1.idl_defineConst(EventImpl.prototype, "NONE", 0);
+WebIDLAlgorithm_1.idl_defineConst(EventImpl.prototype, "CAPTURING_PHASE", 1);
+WebIDLAlgorithm_1.idl_defineConst(EventImpl.prototype, "AT_TARGET", 2);
+WebIDLAlgorithm_1.idl_defineConst(EventImpl.prototype, "BUBBLING_PHASE", 3);
 //# sourceMappingURL=EventImpl.js.map
 
 /***/ }),
 
 /***/ 69968:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.EventTargetImpl = void 0;
-const DOMException_1 = __nccwpck_require__(13166);
-const util_1 = __nccwpck_require__(65282);
-const algorithm_1 = __nccwpck_require__(61);
+var DOMException_1 = __nccwpck_require__(13166);
+var util_1 = __nccwpck_require__(65282);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents a target to which an event can be dispatched.
  */
-class EventTargetImpl {
-    __eventListenerList;
-    get _eventListenerList() {
-        return this.__eventListenerList || (this.__eventListenerList = []);
-    }
-    __eventHandlerMap;
-    get _eventHandlerMap() {
-        return this.__eventHandlerMap || (this.__eventHandlerMap = {});
-    }
+var EventTargetImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `EventTarget`.
      */
-    constructor() { }
+    function EventTargetImpl() {
+    }
+    Object.defineProperty(EventTargetImpl.prototype, "_eventListenerList", {
+        get: function () {
+            return this.__eventListenerList || (this.__eventListenerList = []);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(EventTargetImpl.prototype, "_eventHandlerMap", {
+        get: function () {
+            return this.__eventHandlerMap || (this.__eventHandlerMap = {});
+        },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    addEventListener(type, callback, options = { passive: false, once: false, capture: false }) {
+    EventTargetImpl.prototype.addEventListener = function (type, callback, options) {
+        if (options === void 0) { options = { passive: false, once: false, capture: false }; }
         /**
          * 1. Let capture, passive, and once be the result of flattening more options.
          */
-        const [capture, passive, once] = (0, algorithm_1.eventTarget_flattenMore)(options);
+        var _a = __read(algorithm_1.eventTarget_flattenMore(options), 3), capture = _a[0], passive = _a[1], once = _a[2];
         // convert callback function to EventListener, return if null
-        let listenerCallback;
+        var listenerCallback;
         if (!callback) {
             return;
         }
@@ -25781,7 +54851,7 @@ class EventTargetImpl {
          * whose type is type, callback is callback, capture is capture, passive is
          * passive, and once is once.
          */
-        (0, algorithm_1.eventTarget_addEventListener)(this, {
+        algorithm_1.eventTarget_addEventListener(this, {
             type: type,
             callback: listenerCallback,
             capture: capture,
@@ -25789,9 +54859,9 @@ class EventTargetImpl {
             once: once,
             removed: false
         });
-    }
+    };
     /** @inheritdoc */
-    removeEventListener(type, callback, options = { capture: false }) {
+    EventTargetImpl.prototype.removeEventListener = function (type, callback, options) {
         /**
          * TODO: Implement realms
          * 1. If the context object’s relevant global object is a
@@ -25799,10 +54869,11 @@ class EventTargetImpl {
          * script resource’s has ever been evaluated flag is set, then throw
          * a TypeError. [SERVICE-WORKERS]
          */
+        if (options === void 0) { options = { capture: false }; }
         /**
          * 2. Let capture be the result of flattening options.
          */
-        const capture = (0, algorithm_1.eventTarget_flatten)(options);
+        var capture = algorithm_1.eventTarget_flatten(options);
         if (!callback)
             return;
         /**
@@ -25810,22 +54881,22 @@ class EventTargetImpl {
          * whose type is type, callback is callback, and capture is capture, then
          * remove an event listener with the context object and that event listener.
          */
-        for (let i = 0; i < this._eventListenerList.length; i++) {
-            const entry = this._eventListenerList[i];
+        for (var i = 0; i < this._eventListenerList.length; i++) {
+            var entry = this._eventListenerList[i];
             if (entry.type !== type || entry.capture !== capture)
                 continue;
             if (util_1.Guard.isEventListener(callback) && entry.callback === callback) {
-                (0, algorithm_1.eventTarget_removeEventListener)(this, entry, i);
+                algorithm_1.eventTarget_removeEventListener(this, entry, i);
                 break;
             }
             else if (callback && entry.callback.handleEvent === callback) {
-                (0, algorithm_1.eventTarget_removeEventListener)(this, entry, i);
+                algorithm_1.eventTarget_removeEventListener(this, entry, i);
                 break;
             }
         }
-    }
+    };
     /** @inheritdoc */
-    dispatchEvent(event) {
+    EventTargetImpl.prototype.dispatchEvent = function (event) {
         /**
          * 1. If event’s dispatch flag is set, or if its initialized flag is not
          * set, then throw an "InvalidStateError" DOMException.
@@ -25836,13 +54907,14 @@ class EventTargetImpl {
             throw new DOMException_1.InvalidStateError();
         }
         event._isTrusted = false;
-        return (0, algorithm_1.event_dispatch)(event, this);
-    }
+        return algorithm_1.event_dispatch(event, this);
+    };
     /** @inheritdoc */
-    _getTheParent(event) {
+    EventTargetImpl.prototype._getTheParent = function (event) {
         return null;
-    }
-}
+    };
+    return EventTargetImpl;
+}());
 exports.EventTargetImpl = EventTargetImpl;
 //# sourceMappingURL=EventTargetImpl.js.map
 
@@ -25854,65 +54926,67 @@ exports.EventTargetImpl = EventTargetImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.HTMLCollectionImpl = void 0;
-const infra_1 = __nccwpck_require__(84251);
-const algorithm_1 = __nccwpck_require__(61);
-const util_1 = __nccwpck_require__(65282);
-const util_2 = __nccwpck_require__(76195);
+var infra_1 = __nccwpck_require__(84251);
+var algorithm_1 = __nccwpck_require__(61);
+var util_1 = __nccwpck_require__(65282);
+var util_2 = __nccwpck_require__(76195);
 /**
  * Represents a collection of elements.
  */
-class HTMLCollectionImpl {
-    _live = true;
-    _root;
-    _filter;
-    static reservedNames = ['_root', '_live', '_filter', 'length',
-        'item', 'namedItem', 'get', 'set'];
+var HTMLCollectionImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `HTMLCollection`.
      *
      * @param root - root node
      * @param filter - node filter
      */
-    constructor(root, filter) {
+    function HTMLCollectionImpl(root, filter) {
+        this._live = true;
         this._root = root;
         this._filter = filter;
         return new Proxy(this, this);
     }
+    Object.defineProperty(HTMLCollectionImpl.prototype, "length", {
+        /** @inheritdoc */
+        get: function () {
+            var _this = this;
+            /**
+             * The length attribute’s getter must return the number of nodes
+             * represented by the collection.
+             */
+            var count = 0;
+            var node = algorithm_1.tree_getFirstDescendantNode(this._root, false, false, function (e) { return util_1.Guard.isElementNode(e) && _this._filter(e); });
+            while (node !== null) {
+                count++;
+                node = algorithm_1.tree_getNextDescendantNode(this._root, node, false, false, function (e) { return util_1.Guard.isElementNode(e) && _this._filter(e); });
+            }
+            return count;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get length() {
-        /**
-         * The length attribute’s getter must return the number of nodes
-         * represented by the collection.
-         */
-        let count = 0;
-        let node = (0, algorithm_1.tree_getFirstDescendantNode)(this._root, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e));
-        while (node !== null) {
-            count++;
-            node = (0, algorithm_1.tree_getNextDescendantNode)(this._root, node, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e));
-        }
-        return count;
-    }
-    /** @inheritdoc */
-    item(index) {
+    HTMLCollectionImpl.prototype.item = function (index) {
+        var _this = this;
         /**
          * The item(index) method, when invoked, must return the indexth element
          * in the collection. If there is no indexth element in the collection,
          * then the method must return null.
          */
-        let i = 0;
-        let node = (0, algorithm_1.tree_getFirstDescendantNode)(this._root, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e));
+        var i = 0;
+        var node = algorithm_1.tree_getFirstDescendantNode(this._root, false, false, function (e) { return util_1.Guard.isElementNode(e) && _this._filter(e); });
         while (node !== null) {
             if (i === index)
                 return node;
             else
                 i++;
-            node = (0, algorithm_1.tree_getNextDescendantNode)(this._root, node, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e));
+            node = algorithm_1.tree_getNextDescendantNode(this._root, node, false, false, function (e) { return util_1.Guard.isElementNode(e) && _this._filter(e); });
         }
         return null;
-    }
+    };
     /** @inheritdoc */
-    namedItem(key) {
+    HTMLCollectionImpl.prototype.namedItem = function (key) {
+        var _this = this;
         /**
          * 1. If key is the empty string, return null.
          * 2. Return the first element in the collection for which at least one of
@@ -25923,124 +54997,138 @@ class HTMLCollectionImpl {
          */
         if (key === '')
             return null;
-        let ele = (0, algorithm_1.tree_getFirstDescendantNode)(this._root, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e));
+        var ele = algorithm_1.tree_getFirstDescendantNode(this._root, false, false, function (e) { return util_1.Guard.isElementNode(e) && _this._filter(e); });
         while (ele != null) {
             if (ele._uniqueIdentifier === key) {
                 return ele;
             }
             else if (ele._namespace === infra_1.namespace.HTML) {
-                for (let i = 0; i < ele._attributeList.length; i++) {
-                    const attr = ele._attributeList[i];
+                for (var i = 0; i < ele._attributeList.length; i++) {
+                    var attr = ele._attributeList[i];
                     if (attr._localName === "name" && attr._namespace === null &&
                         attr._namespacePrefix === null && attr._value === key)
                         return ele;
                 }
             }
-            ele = (0, algorithm_1.tree_getNextDescendantNode)(this._root, ele, false, false, (e) => util_1.Guard.isElementNode(e) && this._filter(e));
+            ele = algorithm_1.tree_getNextDescendantNode(this._root, ele, false, false, function (e) { return util_1.Guard.isElementNode(e) && _this._filter(e); });
         }
         return null;
-    }
+    };
     /** @inheritdoc */
-    [Symbol.iterator]() {
-        const root = this._root;
-        const filter = this._filter;
-        let currentNode = (0, algorithm_1.tree_getFirstDescendantNode)(root, false, false, (e) => util_1.Guard.isElementNode(e) && filter(e));
+    HTMLCollectionImpl.prototype[Symbol.iterator] = function () {
+        var root = this._root;
+        var filter = this._filter;
+        var currentNode = algorithm_1.tree_getFirstDescendantNode(root, false, false, function (e) { return util_1.Guard.isElementNode(e) && filter(e); });
         return {
-            next() {
+            next: function () {
                 if (currentNode === null) {
                     return { done: true, value: null };
                 }
                 else {
-                    const result = { done: false, value: currentNode };
-                    currentNode = (0, algorithm_1.tree_getNextDescendantNode)(root, currentNode, false, false, (e) => util_1.Guard.isElementNode(e) && filter(e));
+                    var result = { done: false, value: currentNode };
+                    currentNode = algorithm_1.tree_getNextDescendantNode(root, currentNode, false, false, function (e) { return util_1.Guard.isElementNode(e) && filter(e); });
                     return result;
                 }
             }
         };
-    }
+    };
     /**
      * Implements a proxy get trap to provide array-like access.
      */
-    get(target, key, receiver) {
-        if (!(0, util_2.isString)(key) || HTMLCollectionImpl.reservedNames.indexOf(key) !== -1) {
+    HTMLCollectionImpl.prototype.get = function (target, key, receiver) {
+        if (!util_2.isString(key) || HTMLCollectionImpl.reservedNames.indexOf(key) !== -1) {
             return Reflect.get(target, key, receiver);
         }
-        const index = Number(key);
+        var index = Number(key);
         if (isNaN(index)) {
             return target.namedItem(key) || undefined;
         }
         else {
             return target.item(index) || undefined;
         }
-    }
+    };
     /**
      * Implements a proxy set trap to provide array-like access.
      */
-    set(target, key, value, receiver) {
-        if (!(0, util_2.isString)(key) || HTMLCollectionImpl.reservedNames.indexOf(key) !== -1) {
+    HTMLCollectionImpl.prototype.set = function (target, key, value, receiver) {
+        if (!util_2.isString(key) || HTMLCollectionImpl.reservedNames.indexOf(key) !== -1) {
             return Reflect.set(target, key, value, receiver);
         }
-        const index = Number(key);
-        const node = isNaN(index) ?
+        var index = Number(key);
+        var node = isNaN(index) ?
             target.namedItem(key) || undefined : target.item(index) || undefined;
         if (node && node._parent) {
-            (0, algorithm_1.mutation_replace)(node, value, node._parent);
+            algorithm_1.mutation_replace(node, value, node._parent);
             return true;
         }
         else {
             return false;
         }
-    }
+    };
     /**
      * Creates a new `HTMLCollection`.
      *
      * @param root - root node
      * @param filter - node filter
      */
-    static _create(root, filter = (() => true)) {
+    HTMLCollectionImpl._create = function (root, filter) {
+        if (filter === void 0) { filter = (function () { return true; }); }
         return new HTMLCollectionImpl(root, filter);
-    }
-}
+    };
+    HTMLCollectionImpl.reservedNames = ['_root', '_live', '_filter', 'length',
+        'item', 'namedItem', 'get', 'set'];
+    return HTMLCollectionImpl;
+}());
 exports.HTMLCollectionImpl = HTMLCollectionImpl;
 //# sourceMappingURL=HTMLCollectionImpl.js.map
 
 /***/ }),
 
 /***/ 89616:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.MutationObserverImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const util_1 = __nccwpck_require__(65282);
-const infra_1 = __nccwpck_require__(84251);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var util_1 = __nccwpck_require__(65282);
+var infra_1 = __nccwpck_require__(84251);
 /**
  * Represents an object that can be used to observe mutations to the tree of
  * nodes.
  */
-class MutationObserverImpl {
-    _callback;
-    _nodeList = [];
-    _recordQueue = [];
+var MutationObserverImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `MutationObserver`.
      *
      * @param callback - the callback function
      */
-    constructor(callback) {
+    function MutationObserverImpl(callback) {
+        this._nodeList = [];
+        this._recordQueue = [];
         /**
          * 1. Let mo be a new MutationObserver object whose callback is callback.
          * 2. Append mo to mo’s relevant agent’s mutation observers.
          * 3. Return mo.
          */
         this._callback = callback;
-        const window = DOMImpl_1.dom.window;
+        var window = DOMImpl_1.dom.window;
         infra_1.set.append(window._mutationObservers, this);
     }
     /** @inheritdoc */
-    observe(target, options) {
+    MutationObserverImpl.prototype.observe = function (target, options) {
+        var e_1, _a;
         options = options || {
             childList: false,
             subtree: false
@@ -26083,24 +55171,51 @@ class MutationObserverImpl {
          * 7. For each registered of target’s registered observer list, if
          * registered’s observer is the context object:
          */
-        let isRegistered = false;
-        const coptions = options;
-        for (const registered of target._registeredObserverList) {
-            if (registered.observer === this) {
+        var isRegistered = false;
+        var coptions = options;
+        var _loop_1 = function (registered) {
+            var e_2, _a;
+            if (registered.observer === this_1) {
                 isRegistered = true;
-                /**
-                 * 7.1. For each node of the context object’s node list, remove all
-                 * transient registered observers whose source is registered from node’s
-                 * registered observer list.
-                 */
-                for (const node of this._nodeList) {
-                    infra_1.list.remove(node._registeredObserverList, (ob) => util_1.Guard.isTransientRegisteredObserver(ob) && ob.source === registered);
+                try {
+                    /**
+                     * 7.1. For each node of the context object’s node list, remove all
+                     * transient registered observers whose source is registered from node’s
+                     * registered observer list.
+                     */
+                    for (var _b = (e_2 = void 0, __values(this_1._nodeList)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                        var node = _c.value;
+                        infra_1.list.remove(node._registeredObserverList, function (ob) {
+                            return util_1.Guard.isTransientRegisteredObserver(ob) && ob.source === registered;
+                        });
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                    }
+                    finally { if (e_2) throw e_2.error; }
                 }
                 /**
                  * 7.2. Set registered’s options to options.
                  */
                 registered.options = coptions;
             }
+        };
+        var this_1 = this;
+        try {
+            for (var _b = __values(target._registeredObserverList), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var registered = _c.value;
+                _loop_1(registered);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
         /**
          * 8. Otherwise:
@@ -26112,34 +55227,49 @@ class MutationObserverImpl {
             target._registeredObserverList.push({ observer: this, options: options });
             this._nodeList.push(target);
         }
-    }
+    };
     /** @inheritdoc */
-    disconnect() {
-        /**
-         * 1. For each node of the context object’s node list, remove any
-         * registered observer from node’s registered observer list for which the
-         * context object is the observer.
-         */
-        for (const node of this._nodeList) {
-            infra_1.list.remove((node)._registeredObserverList, (ob) => ob.observer === this);
+    MutationObserverImpl.prototype.disconnect = function () {
+        var e_3, _a;
+        var _this = this;
+        try {
+            /**
+             * 1. For each node of the context object’s node list, remove any
+             * registered observer from node’s registered observer list for which the
+             * context object is the observer.
+             */
+            for (var _b = __values(this._nodeList), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var node = _c.value;
+                infra_1.list.remove((node)._registeredObserverList, function (ob) {
+                    return ob.observer === _this;
+                });
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
         }
         /**
          * 2. Empty the context object’s record queue.
          */
         this._recordQueue = [];
-    }
+    };
     /** @inheritdoc */
-    takeRecords() {
+    MutationObserverImpl.prototype.takeRecords = function () {
         /**
          * 1. Let records be a clone of the context object’s record queue.
          * 2. Empty the context object’s record queue.
          * 3. Return records.
          */
-        const records = this._recordQueue;
+        var records = this._recordQueue;
         this._recordQueue = [];
         return records;
-    }
-}
+    };
+    return MutationObserverImpl;
+}());
 exports.MutationObserverImpl = MutationObserverImpl;
 //# sourceMappingURL=MutationObserverImpl.js.map
 
@@ -26151,20 +55281,10 @@ exports.MutationObserverImpl = MutationObserverImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.MutationRecordImpl = void 0;
 /**
  * Represents a mutation record.
  */
-class MutationRecordImpl {
-    _type;
-    _target;
-    _addedNodes;
-    _removedNodes;
-    _previousSibling;
-    _nextSibling;
-    _attributeName;
-    _attributeNamespace;
-    _oldValue;
+var MutationRecordImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `MutationRecord`.
      *
@@ -26184,7 +55304,7 @@ class MutationRecordImpl {
      * mutation, node `data` for a mutation to a CharacterData node and `null`
      * for a mutation to the tree of nodes.
      */
-    constructor(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue) {
+    function MutationRecordImpl(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue) {
         this._type = type;
         this._target = target;
         this._addedNodes = addedNodes;
@@ -26195,24 +55315,60 @@ class MutationRecordImpl {
         this._attributeNamespace = attributeNamespace;
         this._oldValue = oldValue;
     }
-    /** @inheritdoc */
-    get type() { return this._type; }
-    /** @inheritdoc */
-    get target() { return this._target; }
-    /** @inheritdoc */
-    get addedNodes() { return this._addedNodes; }
-    /** @inheritdoc */
-    get removedNodes() { return this._removedNodes; }
-    /** @inheritdoc */
-    get previousSibling() { return this._previousSibling; }
-    /** @inheritdoc */
-    get nextSibling() { return this._nextSibling; }
-    /** @inheritdoc */
-    get attributeName() { return this._attributeName; }
-    /** @inheritdoc */
-    get attributeNamespace() { return this._attributeNamespace; }
-    /** @inheritdoc */
-    get oldValue() { return this._oldValue; }
+    Object.defineProperty(MutationRecordImpl.prototype, "type", {
+        /** @inheritdoc */
+        get: function () { return this._type; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MutationRecordImpl.prototype, "target", {
+        /** @inheritdoc */
+        get: function () { return this._target; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MutationRecordImpl.prototype, "addedNodes", {
+        /** @inheritdoc */
+        get: function () { return this._addedNodes; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MutationRecordImpl.prototype, "removedNodes", {
+        /** @inheritdoc */
+        get: function () { return this._removedNodes; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MutationRecordImpl.prototype, "previousSibling", {
+        /** @inheritdoc */
+        get: function () { return this._previousSibling; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MutationRecordImpl.prototype, "nextSibling", {
+        /** @inheritdoc */
+        get: function () { return this._nextSibling; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MutationRecordImpl.prototype, "attributeName", {
+        /** @inheritdoc */
+        get: function () { return this._attributeName; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MutationRecordImpl.prototype, "attributeNamespace", {
+        /** @inheritdoc */
+        get: function () { return this._attributeNamespace; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(MutationRecordImpl.prototype, "oldValue", {
+        /** @inheritdoc */
+        get: function () { return this._oldValue; },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Creates a new `MutationRecord`.
      *
@@ -26232,43 +55388,57 @@ class MutationRecordImpl {
      * mutation, node `data` for a mutation to a CharacterData node and `null`
      * for a mutation to the tree of nodes.
      */
-    static _create(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue) {
+    MutationRecordImpl._create = function (type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue) {
         return new MutationRecordImpl(type, target, addedNodes, removedNodes, previousSibling, nextSibling, attributeName, attributeNamespace, oldValue);
-    }
-}
+    };
+    return MutationRecordImpl;
+}());
 exports.MutationRecordImpl = MutationRecordImpl;
 //# sourceMappingURL=MutationRecordImpl.js.map
 
 /***/ }),
 
 /***/ 57206:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NamedNodeMapImpl = void 0;
-const DOMException_1 = __nccwpck_require__(13166);
-const algorithm_1 = __nccwpck_require__(61);
+var DOMException_1 = __nccwpck_require__(13166);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents a collection of attributes.
  */
-class NamedNodeMapImpl extends Array {
-    _element;
+var NamedNodeMapImpl = /** @class */ (function (_super) {
+    __extends(NamedNodeMapImpl, _super);
     /**
      * Initializes a new instance of `NamedNodeMap`.
      *
      * @param element - parent element
      */
-    constructor(element) {
-        super();
-        this._element = element;
+    function NamedNodeMapImpl(element) {
+        var _this = _super.call(this) || this;
+        _this._element = element;
         // TODO: This workaround is needed to extend Array in ES5
-        Object.setPrototypeOf(this, NamedNodeMapImpl.prototype);
+        Object.setPrototypeOf(_this, NamedNodeMapImpl.prototype);
+        return _this;
     }
-    _asArray() { return this; }
+    NamedNodeMapImpl.prototype._asArray = function () { return this; };
     /** @inheritdoc */
-    item(index) {
+    NamedNodeMapImpl.prototype.item = function (index) {
         /**
          * 1. If index is equal to or greater than context object’s attribute list’s
          * size, then return null.
@@ -26276,71 +55446,72 @@ class NamedNodeMapImpl extends Array {
          *
          */
         return this[index] || null;
-    }
+    };
     /** @inheritdoc */
-    getNamedItem(qualifiedName) {
+    NamedNodeMapImpl.prototype.getNamedItem = function (qualifiedName) {
         /**
          * The getNamedItem(qualifiedName) method, when invoked, must return the
          * result of getting an attribute given qualifiedName and element.
          */
-        return (0, algorithm_1.element_getAnAttributeByName)(qualifiedName, this._element);
-    }
+        return algorithm_1.element_getAnAttributeByName(qualifiedName, this._element);
+    };
     /** @inheritdoc */
-    getNamedItemNS(namespace, localName) {
+    NamedNodeMapImpl.prototype.getNamedItemNS = function (namespace, localName) {
         /**
          * The getNamedItemNS(namespace, localName) method, when invoked, must
          * return the result of getting an attribute given namespace, localName,
          * and element.
          */
-        return (0, algorithm_1.element_getAnAttributeByNamespaceAndLocalName)(namespace || '', localName, this._element);
-    }
+        return algorithm_1.element_getAnAttributeByNamespaceAndLocalName(namespace || '', localName, this._element);
+    };
     /** @inheritdoc */
-    setNamedItem(attr) {
+    NamedNodeMapImpl.prototype.setNamedItem = function (attr) {
         /**
          * The setNamedItem(attr) and setNamedItemNS(attr) methods, when invoked,
          * must return the result of setting an attribute given attr and element.
          */
-        return (0, algorithm_1.element_setAnAttribute)(attr, this._element);
-    }
+        return algorithm_1.element_setAnAttribute(attr, this._element);
+    };
     /** @inheritdoc */
-    setNamedItemNS(attr) {
-        return (0, algorithm_1.element_setAnAttribute)(attr, this._element);
-    }
+    NamedNodeMapImpl.prototype.setNamedItemNS = function (attr) {
+        return algorithm_1.element_setAnAttribute(attr, this._element);
+    };
     /** @inheritdoc */
-    removeNamedItem(qualifiedName) {
+    NamedNodeMapImpl.prototype.removeNamedItem = function (qualifiedName) {
         /**
          * 1. Let attr be the result of removing an attribute given qualifiedName
          * and element.
          * 2. If attr is null, then throw a "NotFoundError" DOMException.
          * 3. Return attr.
          */
-        const attr = (0, algorithm_1.element_removeAnAttributeByName)(qualifiedName, this._element);
+        var attr = algorithm_1.element_removeAnAttributeByName(qualifiedName, this._element);
         if (attr === null)
             throw new DOMException_1.NotFoundError();
         return attr;
-    }
+    };
     /** @inheritdoc */
-    removeNamedItemNS(namespace, localName) {
+    NamedNodeMapImpl.prototype.removeNamedItemNS = function (namespace, localName) {
         /**
          * 1. Let attr be the result of removing an attribute given namespace,
          * localName, and element.
          * 2. If attr is null, then throw a "NotFoundError" DOMException.
          * 3. Return attr.
          */
-        const attr = (0, algorithm_1.element_removeAnAttributeByNamespaceAndLocalName)(namespace || '', localName, this._element);
+        var attr = algorithm_1.element_removeAnAttributeByNamespaceAndLocalName(namespace || '', localName, this._element);
         if (attr === null)
             throw new DOMException_1.NotFoundError();
         return attr;
-    }
+    };
     /**
      * Creates a new `NamedNodeMap`.
      *
      * @param element - parent element
      */
-    static _create(element) {
+    NamedNodeMapImpl._create = function (element) {
         return new NamedNodeMapImpl(element);
-    }
-}
+    };
+    return NamedNodeMapImpl;
+}(Array));
 exports.NamedNodeMapImpl = NamedNodeMapImpl;
 //# sourceMappingURL=NamedNodeMapImpl.js.map
 
@@ -26352,239 +55523,240 @@ exports.NamedNodeMapImpl = NamedNodeMapImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NodeFilterImpl = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var interfaces_1 = __nccwpck_require__(27305);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents a node filter.
  */
-class NodeFilterImpl {
-    static FILTER_ACCEPT = 1;
-    static FILTER_REJECT = 2;
-    static FILTER_SKIP = 3;
-    static SHOW_ALL = 0xffffffff;
-    static SHOW_ELEMENT = 0x1;
-    static SHOW_ATTRIBUTE = 0x2;
-    static SHOW_TEXT = 0x4;
-    static SHOW_CDATA_SECTION = 0x8;
-    static SHOW_ENTITY_REFERENCE = 0x10;
-    static SHOW_ENTITY = 0x20;
-    static SHOW_PROCESSING_INSTRUCTION = 0x40;
-    static SHOW_COMMENT = 0x80;
-    static SHOW_DOCUMENT = 0x100;
-    static SHOW_DOCUMENT_TYPE = 0x200;
-    static SHOW_DOCUMENT_FRAGMENT = 0x400;
-    static SHOW_NOTATION = 0x800;
-    FILTER_ACCEPT = 1;
-    FILTER_REJECT = 2;
-    FILTER_SKIP = 3;
-    SHOW_ALL = 0xffffffff;
-    SHOW_ELEMENT = 0x1;
-    SHOW_ATTRIBUTE = 0x2;
-    SHOW_TEXT = 0x4;
-    SHOW_CDATA_SECTION = 0x8;
-    SHOW_ENTITY_REFERENCE = 0x10;
-    SHOW_ENTITY = 0x20;
-    SHOW_PROCESSING_INSTRUCTION = 0x40;
-    SHOW_COMMENT = 0x80;
-    SHOW_DOCUMENT = 0x100;
-    SHOW_DOCUMENT_TYPE = 0x200;
-    SHOW_DOCUMENT_FRAGMENT = 0x400;
-    SHOW_NOTATION = 0x800;
+var NodeFilterImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `NodeFilter`.
      */
-    constructor() {
+    function NodeFilterImpl() {
     }
     /**
      * Callback function.
      */
-    acceptNode(node) {
+    NodeFilterImpl.prototype.acceptNode = function (node) {
         return interfaces_1.FilterResult.Accept;
-    }
+    };
     /**
      * Creates a new `NodeFilter`.
      */
-    static _create() {
+    NodeFilterImpl._create = function () {
         return new NodeFilterImpl();
-    }
-}
+    };
+    NodeFilterImpl.FILTER_ACCEPT = 1;
+    NodeFilterImpl.FILTER_REJECT = 2;
+    NodeFilterImpl.FILTER_SKIP = 3;
+    NodeFilterImpl.SHOW_ALL = 0xffffffff;
+    NodeFilterImpl.SHOW_ELEMENT = 0x1;
+    NodeFilterImpl.SHOW_ATTRIBUTE = 0x2;
+    NodeFilterImpl.SHOW_TEXT = 0x4;
+    NodeFilterImpl.SHOW_CDATA_SECTION = 0x8;
+    NodeFilterImpl.SHOW_ENTITY_REFERENCE = 0x10;
+    NodeFilterImpl.SHOW_ENTITY = 0x20;
+    NodeFilterImpl.SHOW_PROCESSING_INSTRUCTION = 0x40;
+    NodeFilterImpl.SHOW_COMMENT = 0x80;
+    NodeFilterImpl.SHOW_DOCUMENT = 0x100;
+    NodeFilterImpl.SHOW_DOCUMENT_TYPE = 0x200;
+    NodeFilterImpl.SHOW_DOCUMENT_FRAGMENT = 0x400;
+    NodeFilterImpl.SHOW_NOTATION = 0x800;
+    return NodeFilterImpl;
+}());
 exports.NodeFilterImpl = NodeFilterImpl;
 /**
  * Define constants on prototype.
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "FILTER_ACCEPT", 1);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "FILTER_REJECT", 2);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "FILTER_SKIP", 3);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_ALL", 0xffffffff);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_ELEMENT", 0x1);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_ATTRIBUTE", 0x2);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_TEXT", 0x4);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_CDATA_SECTION", 0x8);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_ENTITY_REFERENCE", 0x10);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_ENTITY", 0x20);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_PROCESSING_INSTRUCTION", 0x40);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_COMMENT", 0x80);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_DOCUMENT", 0x100);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_DOCUMENT_TYPE", 0x200);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_DOCUMENT_FRAGMENT", 0x400);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeFilterImpl.prototype, "SHOW_NOTATION", 0x800);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "FILTER_ACCEPT", 1);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "FILTER_REJECT", 2);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "FILTER_SKIP", 3);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_ALL", 0xffffffff);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_ELEMENT", 0x1);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_ATTRIBUTE", 0x2);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_TEXT", 0x4);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_CDATA_SECTION", 0x8);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_ENTITY_REFERENCE", 0x10);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_ENTITY", 0x20);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_PROCESSING_INSTRUCTION", 0x40);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_COMMENT", 0x80);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_DOCUMENT", 0x100);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_DOCUMENT_TYPE", 0x200);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_DOCUMENT_FRAGMENT", 0x400);
+WebIDLAlgorithm_1.idl_defineConst(NodeFilterImpl.prototype, "SHOW_NOTATION", 0x800);
 //# sourceMappingURL=NodeFilterImpl.js.map
 
 /***/ }),
 
 /***/ 91745:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NodeImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const interfaces_1 = __nccwpck_require__(27305);
-const EventTargetImpl_1 = __nccwpck_require__(69968);
-const util_1 = __nccwpck_require__(65282);
-const DOMException_1 = __nccwpck_require__(13166);
-const algorithm_1 = __nccwpck_require__(61);
-const URLAlgorithm_1 = __nccwpck_require__(53568);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var interfaces_1 = __nccwpck_require__(27305);
+var EventTargetImpl_1 = __nccwpck_require__(69968);
+var util_1 = __nccwpck_require__(65282);
+var DOMException_1 = __nccwpck_require__(13166);
+var algorithm_1 = __nccwpck_require__(61);
+var URLAlgorithm_1 = __nccwpck_require__(53568);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents a generic XML node.
  */
-class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
-    static ELEMENT_NODE = 1;
-    static ATTRIBUTE_NODE = 2;
-    static TEXT_NODE = 3;
-    static CDATA_SECTION_NODE = 4;
-    static ENTITY_REFERENCE_NODE = 5;
-    static ENTITY_NODE = 6;
-    static PROCESSING_INSTRUCTION_NODE = 7;
-    static COMMENT_NODE = 8;
-    static DOCUMENT_NODE = 9;
-    static DOCUMENT_TYPE_NODE = 10;
-    static DOCUMENT_FRAGMENT_NODE = 11;
-    static NOTATION_NODE = 12;
-    static DOCUMENT_POSITION_DISCONNECTED = 0x01;
-    static DOCUMENT_POSITION_PRECEDING = 0x02;
-    static DOCUMENT_POSITION_FOLLOWING = 0x04;
-    static DOCUMENT_POSITION_CONTAINS = 0x08;
-    static DOCUMENT_POSITION_CONTAINED_BY = 0x10;
-    static DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20;
-    ELEMENT_NODE = 1;
-    ATTRIBUTE_NODE = 2;
-    TEXT_NODE = 3;
-    CDATA_SECTION_NODE = 4;
-    ENTITY_REFERENCE_NODE = 5;
-    ENTITY_NODE = 6;
-    PROCESSING_INSTRUCTION_NODE = 7;
-    COMMENT_NODE = 8;
-    DOCUMENT_NODE = 9;
-    DOCUMENT_TYPE_NODE = 10;
-    DOCUMENT_FRAGMENT_NODE = 11;
-    NOTATION_NODE = 12;
-    DOCUMENT_POSITION_DISCONNECTED = 0x01;
-    DOCUMENT_POSITION_PRECEDING = 0x02;
-    DOCUMENT_POSITION_FOLLOWING = 0x04;
-    DOCUMENT_POSITION_CONTAINS = 0x08;
-    DOCUMENT_POSITION_CONTAINED_BY = 0x10;
-    DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20;
-    __childNodes;
-    get _childNodes() {
-        return this.__childNodes || (this.__childNodes = (0, algorithm_1.create_nodeList)(this));
-    }
-    _nodeDocumentOverride;
-    get _nodeDocument() { return this._nodeDocumentOverride || DOMImpl_1.dom.window._associatedDocument; }
-    set _nodeDocument(val) { this._nodeDocumentOverride = val; }
-    __registeredObserverList;
-    get _registeredObserverList() {
-        return this.__registeredObserverList || (this.__registeredObserverList = []);
-    }
-    _parent = null;
-    _children = new util_1.EmptySet;
-    _firstChild = null;
-    _lastChild = null;
-    _previousSibling = null;
-    _nextSibling = null;
+var NodeImpl = /** @class */ (function (_super) {
+    __extends(NodeImpl, _super);
     /**
      * Initializes a new instance of `Node`.
      */
-    constructor() {
-        super();
+    function NodeImpl() {
+        var _this = _super.call(this) || this;
+        _this._parent = null;
+        _this._firstChild = null;
+        _this._lastChild = null;
+        _this._previousSibling = null;
+        _this._nextSibling = null;
+        return _this;
     }
-    /** @inheritdoc */
-    get nodeType() { return this._nodeType; }
-    /**
-     * Returns a string appropriate for the type of node.
-     */
-    get nodeName() {
-        if (util_1.Guard.isElementNode(this)) {
-            return this._htmlUppercasedQualifiedName;
-        }
-        else if (util_1.Guard.isAttrNode(this)) {
-            return this._qualifiedName;
-        }
-        else if (util_1.Guard.isExclusiveTextNode(this)) {
-            return "#text";
-        }
-        else if (util_1.Guard.isCDATASectionNode(this)) {
-            return "#cdata-section";
-        }
-        else if (util_1.Guard.isProcessingInstructionNode(this)) {
-            return this._target;
-        }
-        else if (util_1.Guard.isCommentNode(this)) {
-            return "#comment";
-        }
-        else if (util_1.Guard.isDocumentNode(this)) {
-            return "#document";
-        }
-        else if (util_1.Guard.isDocumentTypeNode(this)) {
-            return this._name;
-        }
-        else if (util_1.Guard.isDocumentFragmentNode(this)) {
-            return "#document-fragment";
-        }
-        else {
-            return "";
-        }
-    }
-    /**
-     * Gets the absolute base URL of the node.
-     */
-    get baseURI() {
+    Object.defineProperty(NodeImpl.prototype, "_childNodes", {
+        get: function () {
+            return this.__childNodes || (this.__childNodes = algorithm_1.create_nodeList(this));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "_nodeDocument", {
+        get: function () { return this._nodeDocumentOverride || DOMImpl_1.dom.window._associatedDocument; },
+        set: function (val) { this._nodeDocumentOverride = val; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "_registeredObserverList", {
+        get: function () {
+            return this.__registeredObserverList || (this.__registeredObserverList = []);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "nodeType", {
+        /** @inheritdoc */
+        get: function () { return this._nodeType; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "nodeName", {
         /**
-         * The baseURI attribute’s getter must return node document’s document
-         * base URL, serialized.
-         * TODO: Implement in HTML DOM
-         * https://html.spec.whatwg.org/multipage/urls-and-fetching.html#document-base-url
+         * Returns a string appropriate for the type of node.
          */
-        return (0, URLAlgorithm_1.urlSerializer)(this._nodeDocument._URL);
-    }
-    /**
-     * Returns whether the node is rooted to a document node.
-     */
-    get isConnected() {
+        get: function () {
+            if (util_1.Guard.isElementNode(this)) {
+                return this._htmlUppercasedQualifiedName;
+            }
+            else if (util_1.Guard.isAttrNode(this)) {
+                return this._qualifiedName;
+            }
+            else if (util_1.Guard.isExclusiveTextNode(this)) {
+                return "#text";
+            }
+            else if (util_1.Guard.isCDATASectionNode(this)) {
+                return "#cdata-section";
+            }
+            else if (util_1.Guard.isProcessingInstructionNode(this)) {
+                return this._target;
+            }
+            else if (util_1.Guard.isCommentNode(this)) {
+                return "#comment";
+            }
+            else if (util_1.Guard.isDocumentNode(this)) {
+                return "#document";
+            }
+            else if (util_1.Guard.isDocumentTypeNode(this)) {
+                return this._name;
+            }
+            else if (util_1.Guard.isDocumentFragmentNode(this)) {
+                return "#document-fragment";
+            }
+            else {
+                return "";
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "baseURI", {
         /**
-         * The isConnected attribute’s getter must return true, if context object
-         * is connected, and false otherwise.
+         * Gets the absolute base URL of the node.
          */
-        return util_1.Guard.isElementNode(this) && (0, algorithm_1.shadowTree_isConnected)(this);
-    }
-    /**
-     * Returns the parent document.
-     */
-    get ownerDocument() {
+        get: function () {
+            /**
+             * The baseURI attribute’s getter must return node document’s document
+             * base URL, serialized.
+             * TODO: Implement in HTML DOM
+             * https://html.spec.whatwg.org/multipage/urls-and-fetching.html#document-base-url
+             */
+            return URLAlgorithm_1.urlSerializer(this._nodeDocument._URL);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "isConnected", {
         /**
-         * The ownerDocument attribute’s getter must return null, if the context
-         * object is a document, and the context object’s node document otherwise.
-         * _Note:_ The node document of a document is that document itself. All
-         * nodes have a node document at all times.
+         * Returns whether the node is rooted to a document node.
          */
-        if (this._nodeType === interfaces_1.NodeType.Document)
-            return null;
-        else
-            return this._nodeDocument;
-    }
+        get: function () {
+            /**
+             * The isConnected attribute’s getter must return true, if context object
+             * is connected, and false otherwise.
+             */
+            return util_1.Guard.isElementNode(this) && algorithm_1.shadowTree_isConnected(this);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "ownerDocument", {
+        /**
+         * Returns the parent document.
+         */
+        get: function () {
+            /**
+             * The ownerDocument attribute’s getter must return null, if the context
+             * object is a document, and the context object’s node document otherwise.
+             * _Note:_ The node document of a document is that document itself. All
+             * nodes have a node document at all times.
+             */
+            if (this._nodeType === interfaces_1.NodeType.Document)
+                return null;
+            else
+                return this._nodeDocument;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Returns the root node.
      *
@@ -26592,164 +55764,200 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
      * returns the node's shadow-including root, otherwise it returns
      * the node's root node.
      */
-    getRootNode(options) {
+    NodeImpl.prototype.getRootNode = function (options) {
         /**
          * The getRootNode(options) method, when invoked, must return context
          * object’s shadow-including root if options’s composed is true,
          * and context object’s root otherwise.
          */
-        return (0, algorithm_1.tree_rootNode)(this, !!options && options.composed);
-    }
-    /**
-     * Returns the parent node.
-     */
-    get parentNode() {
+        return algorithm_1.tree_rootNode(this, !!options && options.composed);
+    };
+    Object.defineProperty(NodeImpl.prototype, "parentNode", {
         /**
-         * The parentNode attribute’s getter must return the context object’s parent.
-         * _Note:_ An Attr node has no parent.
+         * Returns the parent node.
          */
-        if (this._nodeType === interfaces_1.NodeType.Attribute) {
-            return null;
-        }
-        else {
-            return this._parent;
-        }
-    }
-    /**
-     * Returns the parent element.
-     */
-    get parentElement() {
+        get: function () {
+            /**
+             * The parentNode attribute’s getter must return the context object’s parent.
+             * _Note:_ An Attr node has no parent.
+             */
+            if (this._nodeType === interfaces_1.NodeType.Attribute) {
+                return null;
+            }
+            else {
+                return this._parent;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "parentElement", {
         /**
-         * The parentElement attribute’s getter must return the context object’s
-         * parent element.
+         * Returns the parent element.
          */
-        if (this._parent && util_1.Guard.isElementNode(this._parent)) {
-            return this._parent;
-        }
-        else {
-            return null;
-        }
-    }
+        get: function () {
+            /**
+             * The parentElement attribute’s getter must return the context object’s
+             * parent element.
+             */
+            if (this._parent && util_1.Guard.isElementNode(this._parent)) {
+                return this._parent;
+            }
+            else {
+                return null;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Determines whether a node has any children.
      */
-    hasChildNodes() {
+    NodeImpl.prototype.hasChildNodes = function () {
         /**
          * The hasChildNodes() method, when invoked, must return true if the context
          * object has children, and false otherwise.
          */
         return (this._firstChild !== null);
-    }
-    /**
-     * Returns a {@link NodeList} of child nodes.
-     */
-    get childNodes() {
+    };
+    Object.defineProperty(NodeImpl.prototype, "childNodes", {
         /**
-         * The childNodes attribute’s getter must return a NodeList rooted at the
-         * context object matching only children.
+         * Returns a {@link NodeList} of child nodes.
          */
-        return this._childNodes;
-    }
-    /**
-     * Returns the first child node.
-     */
-    get firstChild() {
+        get: function () {
+            /**
+             * The childNodes attribute’s getter must return a NodeList rooted at the
+             * context object matching only children.
+             */
+            return this._childNodes;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "firstChild", {
         /**
-         * The firstChild attribute’s getter must return the context object’s first
-         * child.
+         * Returns the first child node.
          */
-        return this._firstChild;
-    }
-    /**
-     * Returns the last child node.
-     */
-    get lastChild() {
+        get: function () {
+            /**
+             * The firstChild attribute’s getter must return the context object’s first
+             * child.
+             */
+            return this._firstChild;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "lastChild", {
         /**
-         * The lastChild attribute’s getter must return the context object’s last
-         * child.
+         * Returns the last child node.
          */
-        return this._lastChild;
-    }
-    /**
-     * Returns the previous sibling node.
-     */
-    get previousSibling() {
+        get: function () {
+            /**
+             * The lastChild attribute’s getter must return the context object’s last
+             * child.
+             */
+            return this._lastChild;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "previousSibling", {
         /**
-         * The previousSibling attribute’s getter must return the context object’s
-         * previous sibling.
-         * _Note:_ An Attr node has no siblings.
+         * Returns the previous sibling node.
          */
-        return this._previousSibling;
-    }
-    /**
-     * Returns the next sibling node.
-     */
-    get nextSibling() {
+        get: function () {
+            /**
+             * The previousSibling attribute’s getter must return the context object’s
+             * previous sibling.
+             * _Note:_ An Attr node has no siblings.
+             */
+            return this._previousSibling;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "nextSibling", {
         /**
-         * The nextSibling attribute’s getter must return the context object’s
-         * next sibling.
+         * Returns the next sibling node.
          */
-        return this._nextSibling;
-    }
-    /**
-     * Gets or sets the data associated with a {@link CharacterData} node or the
-     * value of an {@link @Attr} node. For other node types returns `null`.
-     */
-    get nodeValue() {
-        if (util_1.Guard.isAttrNode(this)) {
-            return this._value;
-        }
-        else if (util_1.Guard.isCharacterDataNode(this)) {
-            return this._data;
-        }
-        else {
-            return null;
-        }
-    }
-    set nodeValue(value) {
-        if (value === null) {
-            value = '';
-        }
-        if (util_1.Guard.isAttrNode(this)) {
-            (0, algorithm_1.attr_setAnExistingAttributeValue)(this, value);
-        }
-        else if (util_1.Guard.isCharacterDataNode(this)) {
-            (0, algorithm_1.characterData_replaceData)(this, 0, this._data.length, value);
-        }
-    }
-    /**
-     * Returns the concatenation of data of all the {@link Text}
-     * node descendants in tree order. When set, replaces the text
-     * contents of the node with the given value.
-     */
-    get textContent() {
-        if (util_1.Guard.isDocumentFragmentNode(this) || util_1.Guard.isElementNode(this)) {
-            return (0, algorithm_1.text_descendantTextContent)(this);
-        }
-        else if (util_1.Guard.isAttrNode(this)) {
-            return this._value;
-        }
-        else if (util_1.Guard.isCharacterDataNode(this)) {
-            return this._data;
-        }
-        else {
-            return null;
-        }
-    }
-    set textContent(value) {
-        if (value === null) {
-            value = '';
-        }
-        if (util_1.Guard.isDocumentFragmentNode(this) || util_1.Guard.isElementNode(this)) {
-            (0, algorithm_1.node_stringReplaceAll)(value, this);
-        }
-        else if (util_1.Guard.isAttrNode(this)) {
-            (0, algorithm_1.attr_setAnExistingAttributeValue)(this, value);
-        }
-        else if (util_1.Guard.isCharacterDataNode(this)) {
-            (0, algorithm_1.characterData_replaceData)(this, 0, (0, algorithm_1.tree_nodeLength)(this), value);
-        }
-    }
+        get: function () {
+            /**
+             * The nextSibling attribute’s getter must return the context object’s
+             * next sibling.
+             */
+            return this._nextSibling;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "nodeValue", {
+        /**
+         * Gets or sets the data associated with a {@link CharacterData} node or the
+         * value of an {@link @Attr} node. For other node types returns `null`.
+         */
+        get: function () {
+            if (util_1.Guard.isAttrNode(this)) {
+                return this._value;
+            }
+            else if (util_1.Guard.isCharacterDataNode(this)) {
+                return this._data;
+            }
+            else {
+                return null;
+            }
+        },
+        set: function (value) {
+            if (value === null) {
+                value = '';
+            }
+            if (util_1.Guard.isAttrNode(this)) {
+                algorithm_1.attr_setAnExistingAttributeValue(this, value);
+            }
+            else if (util_1.Guard.isCharacterDataNode(this)) {
+                algorithm_1.characterData_replaceData(this, 0, this._data.length, value);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeImpl.prototype, "textContent", {
+        /**
+         * Returns the concatenation of data of all the {@link Text}
+         * node descendants in tree order. When set, replaces the text
+         * contents of the node with the given value.
+         */
+        get: function () {
+            if (util_1.Guard.isDocumentFragmentNode(this) || util_1.Guard.isElementNode(this)) {
+                return algorithm_1.text_descendantTextContent(this);
+            }
+            else if (util_1.Guard.isAttrNode(this)) {
+                return this._value;
+            }
+            else if (util_1.Guard.isCharacterDataNode(this)) {
+                return this._data;
+            }
+            else {
+                return null;
+            }
+        },
+        set: function (value) {
+            if (value === null) {
+                value = '';
+            }
+            if (util_1.Guard.isDocumentFragmentNode(this) || util_1.Guard.isElementNode(this)) {
+                algorithm_1.node_stringReplaceAll(value, this);
+            }
+            else if (util_1.Guard.isAttrNode(this)) {
+                algorithm_1.attr_setAnExistingAttributeValue(this, value);
+            }
+            else if (util_1.Guard.isCharacterDataNode(this)) {
+                algorithm_1.characterData_replaceData(this, 0, algorithm_1.tree_nodeLength(this), value);
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Puts all {@link Text} nodes in the full depth of the sub-tree
      * underneath this node into a "normal" form where only markup
@@ -26757,51 +55965,62 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
      * and entity references) separates {@link Text} nodes, i.e., there
      * are no adjacent Text nodes.
      */
-    normalize() {
+    NodeImpl.prototype.normalize = function () {
+        var e_1, _a, e_2, _b;
         /**
          * The normalize() method, when invoked, must run these steps for each
          * descendant exclusive Text node node of context object:
          */
-        const descendantNodes = [];
-        let node = (0, algorithm_1.tree_getFirstDescendantNode)(this, false, false, (e) => util_1.Guard.isExclusiveTextNode(e));
+        var descendantNodes = [];
+        var node = algorithm_1.tree_getFirstDescendantNode(this, false, false, function (e) { return util_1.Guard.isExclusiveTextNode(e); });
         while (node !== null) {
             descendantNodes.push(node);
-            node = (0, algorithm_1.tree_getNextDescendantNode)(this, node, false, false, (e) => util_1.Guard.isExclusiveTextNode(e));
+            node = algorithm_1.tree_getNextDescendantNode(this, node, false, false, function (e) { return util_1.Guard.isExclusiveTextNode(e); });
         }
-        for (let i = 0; i < descendantNodes.length; i++) {
-            const node = descendantNodes[i];
-            if (node._parent === null)
+        for (var i = 0; i < descendantNodes.length; i++) {
+            var node_1 = descendantNodes[i];
+            if (node_1._parent === null)
                 continue;
             /**
              * 1. Let length be node’s length.
              * 2. If length is zero, then remove node and continue with the next
              * exclusive Text node, if any.
              */
-            let length = (0, algorithm_1.tree_nodeLength)(node);
+            var length = algorithm_1.tree_nodeLength(node_1);
             if (length === 0) {
-                (0, algorithm_1.mutation_remove)(node, node._parent);
+                algorithm_1.mutation_remove(node_1, node_1._parent);
                 continue;
             }
             /**
              * 3. Let data be the concatenation of the data of node’s contiguous
              * exclusive Text nodes (excluding itself), in tree order.
              */
-            const textSiblings = [];
-            let data = '';
-            for (const sibling of (0, algorithm_1.text_contiguousExclusiveTextNodes)(node)) {
-                textSiblings.push(sibling);
-                data += sibling._data;
+            var textSiblings = [];
+            var data = '';
+            try {
+                for (var _c = (e_1 = void 0, __values(algorithm_1.text_contiguousExclusiveTextNodes(node_1))), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var sibling = _d.value;
+                    textSiblings.push(sibling);
+                    data += sibling._data;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
             }
             /**
              * 4. Replace data with node node, offset length, count 0, and data data.
              */
-            (0, algorithm_1.characterData_replaceData)(node, length, 0, data);
+            algorithm_1.characterData_replaceData(node_1, length, 0, data);
             /**
              * 5. Let currentNode be node’s next sibling.
              * 6. While currentNode is an exclusive Text node:
              */
             if (DOMImpl_1.dom.rangeList.size !== 0) {
-                let currentNode = node._nextSibling;
+                var currentNode = node_1._nextSibling;
                 while (currentNode !== null && util_1.Guard.isExclusiveTextNode(currentNode)) {
                     /**
                      * 6.1. For each live range whose start node is currentNode, add length
@@ -26815,31 +56034,41 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
                      * end offset is currentNode’s index, set its end node to node and its
                      * end offset to length.
                      */
-                    const cn = currentNode;
-                    const index = (0, algorithm_1.tree_index)(cn);
-                    for (const range of DOMImpl_1.dom.rangeList) {
-                        if (range._start[0] === cn) {
-                            range._start[0] = node;
-                            range._start[1] += length;
+                    var cn = currentNode;
+                    var index = algorithm_1.tree_index(cn);
+                    try {
+                        for (var _e = (e_2 = void 0, __values(DOMImpl_1.dom.rangeList)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                            var range = _f.value;
+                            if (range._start[0] === cn) {
+                                range._start[0] = node_1;
+                                range._start[1] += length;
+                            }
+                            if (range._end[0] === cn) {
+                                range._end[0] = node_1;
+                                range._end[1] += length;
+                            }
+                            if (range._start[0] === cn._parent && range._start[1] === index) {
+                                range._start[0] = node_1;
+                                range._start[1] = length;
+                            }
+                            if (range._end[0] === cn._parent && range._end[1] === index) {
+                                range._end[0] = node_1;
+                                range._end[1] = length;
+                            }
                         }
-                        if (range._end[0] === cn) {
-                            range._end[0] = node;
-                            range._end[1] += length;
-                        }
-                        if (range._start[0] === cn._parent && range._start[1] === index) {
-                            range._start[0] = node;
-                            range._start[1] = length;
-                        }
-                        if (range._end[0] === cn._parent && range._end[1] === index) {
-                            range._end[0] = node;
-                            range._end[1] = length;
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
                         }
+                        finally { if (e_2) throw e_2.error; }
                     }
                     /**
                      * 6.5. Add currentNode’s length to length.
                      * 6.6. Set currentNode to its next sibling.
                      */
-                    length += (0, algorithm_1.tree_nodeLength)(currentNode);
+                    length += algorithm_1.tree_nodeLength(currentNode);
                     currentNode = currentNode._nextSibling;
                 }
             }
@@ -26847,14 +56076,14 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
              * 7. Remove node’s contiguous exclusive Text nodes (excluding itself),
              * in tree order.
              */
-            for (let i = 0; i < textSiblings.length; i++) {
-                const sibling = textSiblings[i];
+            for (var i_1 = 0; i_1 < textSiblings.length; i_1++) {
+                var sibling = textSiblings[i_1];
                 if (sibling._parent === null)
                     continue;
-                (0, algorithm_1.mutation_remove)(sibling, sibling._parent);
+                algorithm_1.mutation_remove(sibling, sibling._parent);
             }
         }
-    }
+    };
     /**
      * Returns a duplicate of this node, i.e., serves as a generic copy
      * constructor for nodes. The duplicate node has no parent
@@ -26864,7 +56093,8 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
      * specified node. If `false`, clone only the node itself (and its
      * attributes, if it is an {@link Element}).
      */
-    cloneNode(deep = false) {
+    NodeImpl.prototype.cloneNode = function (deep) {
+        if (deep === void 0) { deep = false; }
         /**
          * 1. If context object is a shadow root, then throw a "NotSupportedError"
          * DOMException.
@@ -26873,38 +56103,40 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
          */
         if (util_1.Guard.isShadowRoot(this))
             throw new DOMException_1.NotSupportedError();
-        return (0, algorithm_1.node_clone)(this, null, deep);
-    }
+        return algorithm_1.node_clone(this, null, deep);
+    };
     /**
      * Determines if the given node is equal to this one.
      *
      * @param node - the node to compare with
      */
-    isEqualNode(node = null) {
+    NodeImpl.prototype.isEqualNode = function (node) {
+        if (node === void 0) { node = null; }
         /**
          * The isEqualNode(otherNode) method, when invoked, must return true if
          * otherNode is non-null and context object equals otherNode, and false
          * otherwise.
          */
-        return (node !== null && (0, algorithm_1.node_equals)(this, node));
-    }
+        return (node !== null && algorithm_1.node_equals(this, node));
+    };
     /**
      * Determines if the given node is reference equal to this one.
      *
      * @param node - the node to compare with
      */
-    isSameNode(node = null) {
+    NodeImpl.prototype.isSameNode = function (node) {
+        if (node === void 0) { node = null; }
         /**
          * The isSameNode(otherNode) method, when invoked, must return true if
          * otherNode is context object, and false otherwise.
          */
         return (this === node);
-    }
+    };
     /**
      * Returns a bitmask indicating the position of the given `node`
      * relative to this node.
      */
-    compareDocumentPosition(other) {
+    NodeImpl.prototype.compareDocumentPosition = function (other) {
         /**
          * 1. If context object is other, then return zero.
          * 2. Let node1 be other and node2 be context object.
@@ -26912,11 +56144,11 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
          * attr1’s element.
          */
         if (other === this)
-            return interfaces_1.Position.SameNode;
-        let node1 = other;
-        let node2 = this;
-        let attr1 = null;
-        let attr2 = null;
+            return 0;
+        var node1 = other;
+        var node2 = this;
+        var attr1 = null;
+        var attr2 = null;
         /**
          * 4. If node1 is an attribute, then set attr1 to node1 and node1 to
          * attr1’s element.
@@ -26941,8 +56173,8 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
                 /**
                  * 5.2. For each attr in node2’s attribute list:
                  */
-                for (let i = 0; i < node2._attributeList.length; i++) {
-                    const attr = node2._attributeList[i];
+                for (var i = 0; i < node2._attributeList.length; i++) {
+                    var attr = node2._attributeList[i];
                     /**
                      * 5.2.1. If attr equals attr1, then return the result of adding
                      * DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC and
@@ -26951,10 +56183,10 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
                      * DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC and
                      * DOCUMENT_POSITION_FOLLOWING.
                      */
-                    if ((0, algorithm_1.node_equals)(attr, attr1)) {
+                    if (algorithm_1.node_equals(attr, attr1)) {
                         return interfaces_1.Position.ImplementationSpecific | interfaces_1.Position.Preceding;
                     }
-                    else if ((0, algorithm_1.node_equals)(attr, attr2)) {
+                    else if (algorithm_1.node_equals(attr, attr2)) {
                         return interfaces_1.Position.ImplementationSpecific | interfaces_1.Position.Following;
                     }
                 }
@@ -26968,7 +56200,7 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
          * with the constraint that this is to be consistent, together.
          */
         if (node1 === null || node2 === null ||
-            (0, algorithm_1.tree_rootNode)(node1) !== (0, algorithm_1.tree_rootNode)(node2)) {
+            algorithm_1.tree_rootNode(node1) !== algorithm_1.tree_rootNode(node2)) {
             // nodes are disconnected
             // return a random result but cache the value for consistency
             return interfaces_1.Position.Disconnected | interfaces_1.Position.ImplementationSpecific |
@@ -26979,7 +56211,7 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
          * and attr2 is non-null, then return the result of adding
          * DOCUMENT_POSITION_CONTAINS to DOCUMENT_POSITION_PRECEDING.
          */
-        if ((!attr1 && (0, algorithm_1.tree_isAncestorOf)(node2, node1)) ||
+        if ((!attr1 && algorithm_1.tree_isAncestorOf(node2, node1)) ||
             (attr2 && (node1 === node2))) {
             return interfaces_1.Position.Contains | interfaces_1.Position.Preceding;
         }
@@ -26988,27 +56220,27 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
          * and attr1 is non-null, then return the result of adding
          * DOCUMENT_POSITION_CONTAINED_BY to DOCUMENT_POSITION_FOLLOWING.
          */
-        if ((!attr2 && (0, algorithm_1.tree_isDescendantOf)(node2, node1)) ||
+        if ((!attr2 && algorithm_1.tree_isDescendantOf(node2, node1)) ||
             (attr1 && (node1 === node2))) {
             return interfaces_1.Position.ContainedBy | interfaces_1.Position.Following;
         }
         /**
          * 9. If node1 is preceding node2, then return DOCUMENT_POSITION_PRECEDING.
          */
-        if ((0, algorithm_1.tree_isPreceding)(node2, node1))
+        if (algorithm_1.tree_isPreceding(node2, node1))
             return interfaces_1.Position.Preceding;
         /**
          * 10. Return DOCUMENT_POSITION_FOLLOWING.
          */
         return interfaces_1.Position.Following;
-    }
+    };
     /**
      * Returns `true` if given node is an inclusive descendant of this
      * node, and `false` otherwise (including when other node is `null`).
      *
      * @param other - the node to check
      */
-    contains(other) {
+    NodeImpl.prototype.contains = function (other) {
         /**
          * The contains(other) method, when invoked, must return true if other is an
          * inclusive descendant of context object, and false otherwise (including
@@ -27016,15 +56248,15 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
          */
         if (other === null)
             return false;
-        return (0, algorithm_1.tree_isDescendantOf)(this, other, true);
-    }
+        return algorithm_1.tree_isDescendantOf(this, other, true);
+    };
     /**
      * Returns the prefix for a given namespace URI, if present, and
      * `null` if not.
      *
      * @param namespace - the namespace to search
      */
-    lookupPrefix(namespace) {
+    NodeImpl.prototype.lookupPrefix = function (namespace) {
         /**
          * 1. If namespace is null or the empty string, then return null.
          * 2. Switch on the context object:
@@ -27036,7 +56268,7 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
              * Return the result of locating a namespace prefix for it using
              * namespace.
              */
-            return (0, algorithm_1.node_locateANamespacePrefix)(this, namespace);
+            return algorithm_1.node_locateANamespacePrefix(this, namespace);
         }
         else if (util_1.Guard.isDocumentNode(this)) {
             /**
@@ -27047,7 +56279,7 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
                 return null;
             }
             else {
-                return (0, algorithm_1.node_locateANamespacePrefix)(this.documentElement, namespace);
+                return algorithm_1.node_locateANamespacePrefix(this.documentElement, namespace);
             }
         }
         else if (util_1.Guard.isDocumentTypeNode(this) || util_1.Guard.isDocumentFragmentNode(this)) {
@@ -27062,7 +56294,7 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
                 return null;
             }
             else {
-                return (0, algorithm_1.node_locateANamespacePrefix)(this._element, namespace);
+                return algorithm_1.node_locateANamespacePrefix(this._element, namespace);
             }
         }
         else {
@@ -27071,34 +56303,34 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
              * element, if its parent element is non-null, and null otherwise.
              */
             if (this._parent !== null && util_1.Guard.isElementNode(this._parent)) {
-                return (0, algorithm_1.node_locateANamespacePrefix)(this._parent, namespace);
+                return algorithm_1.node_locateANamespacePrefix(this._parent, namespace);
             }
             else {
                 return null;
             }
         }
-    }
+    };
     /**
      * Returns the namespace URI for a given prefix if present, and `null`
      * if not.
      *
      * @param prefix - the prefix to search
      */
-    lookupNamespaceURI(prefix) {
+    NodeImpl.prototype.lookupNamespaceURI = function (prefix) {
         /**
          * 1. If prefix is the empty string, then set it to null.
          * 2. Return the result of running locate a namespace for the context object
          * using prefix.
          */
-        return (0, algorithm_1.node_locateANamespace)(this, prefix || null);
-    }
+        return algorithm_1.node_locateANamespace(this, prefix || null);
+    };
     /**
      * Returns `true` if the namespace is the default namespace on this
      * node or `false` if not.
      *
      * @param namespace - the namespace to check
      */
-    isDefaultNamespace(namespace) {
+    NodeImpl.prototype.isDefaultNamespace = function (namespace) {
         /**
          * 1. If namespace is the empty string, then set it to null.
          * 2. Let defaultNamespace be the result of running locate a namespace for
@@ -27107,9 +56339,9 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
          */
         if (!namespace)
             namespace = null;
-        const defaultNamespace = (0, algorithm_1.node_locateANamespace)(this, null);
+        var defaultNamespace = algorithm_1.node_locateANamespace(this, null);
         return (defaultNamespace === namespace);
-    }
+    };
     /**
      * Inserts the node `newChild` before the existing child node
      * `refChild`. If `refChild` is `null`, inserts `newChild` at the end
@@ -27126,13 +56358,13 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
      *
      * @returns the newly inserted child node
      */
-    insertBefore(newChild, refChild) {
+    NodeImpl.prototype.insertBefore = function (newChild, refChild) {
         /**
          * The insertBefore(node, child) method, when invoked, must return the
          * result of pre-inserting node into context object before child.
          */
-        return (0, algorithm_1.mutation_preInsert)(newChild, this, refChild);
-    }
+        return algorithm_1.mutation_preInsert(newChild, this, refChild);
+    };
     /**
      * Adds the node `newChild` to the end of the list of children of this
      * node, and returns it. If `newChild` is already in the tree, it is
@@ -27146,13 +56378,13 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
      *
      * @returns the newly inserted child node
      */
-    appendChild(newChild) {
+    NodeImpl.prototype.appendChild = function (newChild) {
         /**
          * The appendChild(node) method, when invoked, must return the result of
          * appending node to context object.
          */
-        return (0, algorithm_1.mutation_append)(newChild, this);
-    }
+        return algorithm_1.mutation_append(newChild, this);
+    };
     /**
      * Replaces the child node `oldChild` with `newChild` in the list of
      * children, and returns the `oldChild` node. If `newChild` is already
@@ -27163,13 +56395,13 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
      *
      * @returns the removed child node
      */
-    replaceChild(newChild, oldChild) {
+    NodeImpl.prototype.replaceChild = function (newChild, oldChild) {
         /**
          * The replaceChild(node, child) method, when invoked, must return the
          * result of replacing child with node within context object.
          */
-        return (0, algorithm_1.mutation_replace)(oldChild, newChild, this);
-    }
+        return algorithm_1.mutation_replace(oldChild, newChild, this);
+    };
     /**
     * Removes the child node indicated by `oldChild` from the list of
     * children, and returns it.
@@ -27178,31 +56410,50 @@ class NodeImpl extends EventTargetImpl_1.EventTargetImpl {
     *
     * @returns the removed child node
     */
-    removeChild(oldChild) {
+    NodeImpl.prototype.removeChild = function (oldChild) {
         /**
          * The removeChild(child) method, when invoked, must return the result of
          * pre-removing child from context object.
          */
-        return (0, algorithm_1.mutation_preRemove)(oldChild, this);
-    }
+        return algorithm_1.mutation_preRemove(oldChild, this);
+    };
     /**
      * Gets the parent event target for the given event.
      *
      * @param event - an event
      */
-    _getTheParent(event) {
+    NodeImpl.prototype._getTheParent = function (event) {
         /**
          * A node’s get the parent algorithm, given an event, returns the node’s
          * assigned slot, if node is assigned, and node’s parent otherwise.
          */
-        if (util_1.Guard.isSlotable(this) && (0, algorithm_1.shadowTree_isAssigned)(this)) {
+        if (util_1.Guard.isSlotable(this) && algorithm_1.shadowTree_isAssigned(this)) {
             return this._assignedSlot;
         }
         else {
             return this._parent;
         }
-    }
-}
+    };
+    NodeImpl.ELEMENT_NODE = 1;
+    NodeImpl.ATTRIBUTE_NODE = 2;
+    NodeImpl.TEXT_NODE = 3;
+    NodeImpl.CDATA_SECTION_NODE = 4;
+    NodeImpl.ENTITY_REFERENCE_NODE = 5;
+    NodeImpl.ENTITY_NODE = 6;
+    NodeImpl.PROCESSING_INSTRUCTION_NODE = 7;
+    NodeImpl.COMMENT_NODE = 8;
+    NodeImpl.DOCUMENT_NODE = 9;
+    NodeImpl.DOCUMENT_TYPE_NODE = 10;
+    NodeImpl.DOCUMENT_FRAGMENT_NODE = 11;
+    NodeImpl.NOTATION_NODE = 12;
+    NodeImpl.DOCUMENT_POSITION_DISCONNECTED = 0x01;
+    NodeImpl.DOCUMENT_POSITION_PRECEDING = 0x02;
+    NodeImpl.DOCUMENT_POSITION_FOLLOWING = 0x04;
+    NodeImpl.DOCUMENT_POSITION_CONTAINS = 0x08;
+    NodeImpl.DOCUMENT_POSITION_CONTAINED_BY = 0x10;
+    NodeImpl.DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20;
+    return NodeImpl;
+}(EventTargetImpl_1.EventTargetImpl));
 exports.NodeImpl = NodeImpl;
 /**
  * A performance tweak to share an empty set between all node classes. This will
@@ -27213,84 +56464,103 @@ NodeImpl.prototype._children = new util_1.EmptySet();
 /**
  * Define constants on prototype.
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "ELEMENT_NODE", 1);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "ATTRIBUTE_NODE", 2);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "TEXT_NODE", 3);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "CDATA_SECTION_NODE", 4);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "ENTITY_REFERENCE_NODE", 5);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "ENTITY_NODE", 6);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "PROCESSING_INSTRUCTION_NODE", 7);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "COMMENT_NODE", 8);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_NODE", 9);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_TYPE_NODE", 10);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_FRAGMENT_NODE", 11);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "NOTATION_NODE", 12);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_POSITION_DISCONNECTED", 0x01);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_POSITION_PRECEDING", 0x02);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_POSITION_FOLLOWING", 0x04);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_POSITION_CONTAINS", 0x08);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_POSITION_CONTAINED_BY", 0x10);
-(0, WebIDLAlgorithm_1.idl_defineConst)(NodeImpl.prototype, "DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC", 0x20);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "ELEMENT_NODE", 1);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "ATTRIBUTE_NODE", 2);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "TEXT_NODE", 3);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "CDATA_SECTION_NODE", 4);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "ENTITY_REFERENCE_NODE", 5);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "ENTITY_NODE", 6);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "PROCESSING_INSTRUCTION_NODE", 7);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "COMMENT_NODE", 8);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "DOCUMENT_NODE", 9);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "DOCUMENT_TYPE_NODE", 10);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "DOCUMENT_FRAGMENT_NODE", 11);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "NOTATION_NODE", 12);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "DOCUMENT_POSITION_DISCONNECTED", 0x01);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "DOCUMENT_POSITION_PRECEDING", 0x02);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "DOCUMENT_POSITION_FOLLOWING", 0x04);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "DOCUMENT_POSITION_CONTAINS", 0x08);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "DOCUMENT_POSITION_CONTAINED_BY", 0x10);
+WebIDLAlgorithm_1.idl_defineConst(NodeImpl.prototype, "DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC", 0x20);
 //# sourceMappingURL=NodeImpl.js.map
 
 /***/ }),
 
 /***/ 61997:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NodeIteratorImpl = void 0;
-const TraverserImpl_1 = __nccwpck_require__(39782);
-const algorithm_1 = __nccwpck_require__(61);
+var TraverserImpl_1 = __nccwpck_require__(39782);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents an object which can be used to iterate through the nodes
  * of a subtree.
  */
-class NodeIteratorImpl extends TraverserImpl_1.TraverserImpl {
-    _iteratorCollection;
-    _reference;
-    _pointerBeforeReference;
+var NodeIteratorImpl = /** @class */ (function (_super) {
+    __extends(NodeIteratorImpl, _super);
     /**
      * Initializes a new instance of `NodeIterator`.
      */
-    constructor(root, reference, pointerBeforeReference) {
-        super(root);
-        this._iteratorCollection = undefined;
-        this._reference = reference;
-        this._pointerBeforeReference = pointerBeforeReference;
-        (0, algorithm_1.nodeIterator_iteratorList)().add(this);
+    function NodeIteratorImpl(root, reference, pointerBeforeReference) {
+        var _this = _super.call(this, root) || this;
+        _this._iteratorCollection = undefined;
+        _this._reference = reference;
+        _this._pointerBeforeReference = pointerBeforeReference;
+        algorithm_1.nodeIterator_iteratorList().add(_this);
+        return _this;
     }
+    Object.defineProperty(NodeIteratorImpl.prototype, "referenceNode", {
+        /** @inheritdoc */
+        get: function () { return this._reference; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NodeIteratorImpl.prototype, "pointerBeforeReferenceNode", {
+        /** @inheritdoc */
+        get: function () { return this._pointerBeforeReference; },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get referenceNode() { return this._reference; }
-    /** @inheritdoc */
-    get pointerBeforeReferenceNode() { return this._pointerBeforeReference; }
-    /** @inheritdoc */
-    nextNode() {
+    NodeIteratorImpl.prototype.nextNode = function () {
         /**
          * The nextNode() method, when invoked, must return the result of
          * traversing with the context object and next.
          */
-        return (0, algorithm_1.nodeIterator_traverse)(this, true);
-    }
+        return algorithm_1.nodeIterator_traverse(this, true);
+    };
     /** @inheritdoc */
-    previousNode() {
+    NodeIteratorImpl.prototype.previousNode = function () {
         /**
          * The previousNode() method, when invoked, must return the result of
          * traversing with the context object and previous.
          */
-        return (0, algorithm_1.nodeIterator_traverse)(this, false);
-    }
+        return algorithm_1.nodeIterator_traverse(this, false);
+    };
     /** @inheritdoc */
-    detach() {
+    NodeIteratorImpl.prototype.detach = function () {
         /**
          * The detach() method, when invoked, must do nothing.
          *
          * since JS lacks weak references, we still use detach
          */
-        (0, algorithm_1.nodeIterator_iteratorList)().delete(this);
-    }
+        algorithm_1.nodeIterator_iteratorList().delete(this);
+    };
     /**
      * Creates a new `NodeIterator`.
      *
@@ -27299,52 +56569,66 @@ class NodeIteratorImpl extends TraverserImpl_1.TraverserImpl {
      * @param pointerBeforeReference - whether the iterator is before or after the
      * reference node
      */
-    static _create(root, reference, pointerBeforeReference) {
+    NodeIteratorImpl._create = function (root, reference, pointerBeforeReference) {
         return new NodeIteratorImpl(root, reference, pointerBeforeReference);
-    }
-}
+    };
+    return NodeIteratorImpl;
+}(TraverserImpl_1.TraverserImpl));
 exports.NodeIteratorImpl = NodeIteratorImpl;
 //# sourceMappingURL=NodeIteratorImpl.js.map
 
 /***/ }),
 
 /***/ 43728:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NodeListImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const util_1 = __nccwpck_require__(76195);
-const algorithm_1 = __nccwpck_require__(61);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var util_1 = __nccwpck_require__(76195);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents an ordered set of nodes.
  */
-class NodeListImpl {
-    _live = true;
-    _root;
-    _filter = null;
-    _length = 0;
+var NodeListImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `NodeList`.
      *
      * @param root - root node
      */
-    constructor(root) {
+    function NodeListImpl(root) {
+        this._live = true;
+        this._filter = null;
+        this._length = 0;
         this._root = root;
         return new Proxy(this, this);
     }
+    Object.defineProperty(NodeListImpl.prototype, "length", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The length attribute must return the number of nodes represented
+             * by the collection.
+             */
+            return this._root._children.size;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get length() {
-        /**
-         * The length attribute must return the number of nodes represented
-         * by the collection.
-         */
-        return this._root._children.size;
-    }
-    /** @inheritdoc */
-    item(index) {
+    NodeListImpl.prototype.item = function (index) {
         /**
          * The item(index) method must return the indexth node in the collection.
          * If there is no indexth node in the collection, then the method must
@@ -27353,8 +56637,8 @@ class NodeListImpl {
         if (index < 0 || index > this.length - 1)
             return null;
         if (index < this.length / 2) {
-            let i = 0;
-            let node = this._root._firstChild;
+            var i = 0;
+            var node = this._root._firstChild;
             while (node !== null && i !== index) {
                 node = node._nextSibling;
                 i++;
@@ -27362,20 +56646,21 @@ class NodeListImpl {
             return node;
         }
         else {
-            let i = this.length - 1;
-            let node = this._root._lastChild;
+            var i = this.length - 1;
+            var node = this._root._lastChild;
             while (node !== null && i !== index) {
                 node = node._previousSibling;
                 i--;
             }
             return node;
         }
-    }
+    };
     /** @inheritdoc */
-    keys() {
-        return {
-            [Symbol.iterator]: function () {
-                let index = 0;
+    NodeListImpl.prototype.keys = function () {
+        var _a;
+        return _a = {},
+            _a[Symbol.iterator] = function () {
+                var index = 0;
                 return {
                     next: function () {
                         if (index === this.length) {
@@ -27386,31 +56671,33 @@ class NodeListImpl {
                         }
                     }.bind(this)
                 };
-            }.bind(this)
-        };
-    }
+            }.bind(this),
+            _a;
+    };
     /** @inheritdoc */
-    values() {
-        return {
-            [Symbol.iterator]: function () {
-                const it = this[Symbol.iterator]();
+    NodeListImpl.prototype.values = function () {
+        var _a;
+        return _a = {},
+            _a[Symbol.iterator] = function () {
+                var it = this[Symbol.iterator]();
                 return {
-                    next() {
+                    next: function () {
                         return it.next();
                     }
                 };
-            }.bind(this)
-        };
-    }
+            }.bind(this),
+            _a;
+    };
     /** @inheritdoc */
-    entries() {
-        return {
-            [Symbol.iterator]: function () {
-                const it = this[Symbol.iterator]();
-                let index = 0;
+    NodeListImpl.prototype.entries = function () {
+        var _a;
+        return _a = {},
+            _a[Symbol.iterator] = function () {
+                var it = this[Symbol.iterator]();
+                var index = 0;
                 return {
-                    next() {
-                        const itResult = it.next();
+                    next: function () {
+                        var itResult = it.next();
                         if (itResult.done) {
                             return { done: true, value: null };
                         }
@@ -27419,112 +56706,136 @@ class NodeListImpl {
                         }
                     }
                 };
-            }.bind(this)
-        };
-    }
+            }.bind(this),
+            _a;
+    };
     /** @inheritdoc */
-    [Symbol.iterator]() {
+    NodeListImpl.prototype[Symbol.iterator] = function () {
         return this._root._children[Symbol.iterator]();
-    }
+    };
     /** @inheritdoc */
-    forEach(callback, thisArg) {
+    NodeListImpl.prototype.forEach = function (callback, thisArg) {
+        var e_1, _a;
         if (thisArg === undefined) {
             thisArg = DOMImpl_1.dom.window;
         }
-        let index = 0;
-        for (const node of this._root._children) {
-            callback.call(thisArg, node, index++, this);
+        var index = 0;
+        try {
+            for (var _b = __values(this._root._children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var node = _c.value;
+                callback.call(thisArg, node, index++, this);
+            }
         }
-    }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
     /**
      * Implements a proxy get trap to provide array-like access.
      */
-    get(target, key, receiver) {
-        if (!(0, util_1.isString)(key)) {
+    NodeListImpl.prototype.get = function (target, key, receiver) {
+        if (!util_1.isString(key)) {
             return Reflect.get(target, key, receiver);
         }
-        const index = Number(key);
+        var index = Number(key);
         if (isNaN(index)) {
             return Reflect.get(target, key, receiver);
         }
         return target.item(index) || undefined;
-    }
+    };
     /**
      * Implements a proxy set trap to provide array-like access.
      */
-    set(target, key, value, receiver) {
-        if (!(0, util_1.isString)(key)) {
+    NodeListImpl.prototype.set = function (target, key, value, receiver) {
+        if (!util_1.isString(key)) {
             return Reflect.set(target, key, value, receiver);
         }
-        const index = Number(key);
+        var index = Number(key);
         if (isNaN(index)) {
             return Reflect.set(target, key, value, receiver);
         }
-        const node = target.item(index) || undefined;
+        var node = target.item(index) || undefined;
         if (!node)
             return false;
         if (node._parent) {
-            (0, algorithm_1.mutation_replace)(node, value, node._parent);
+            algorithm_1.mutation_replace(node, value, node._parent);
             return true;
         }
         else {
             return false;
         }
-    }
+    };
     /**
      * Creates a new `NodeList`.
      *
      * @param root - root node
      */
-    static _create(root) {
+    NodeListImpl._create = function (root) {
         return new NodeListImpl(root);
-    }
-}
+    };
+    return NodeListImpl;
+}());
 exports.NodeListImpl = NodeListImpl;
 //# sourceMappingURL=NodeListImpl.js.map
 
 /***/ }),
 
 /***/ 65306:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NodeListStaticImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const util_1 = __nccwpck_require__(76195);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var util_1 = __nccwpck_require__(76195);
 /**
  * Represents an ordered list of nodes.
  * This is a static implementation of `NodeList`.
  */
-class NodeListStaticImpl {
-    _live = false;
-    _root;
-    _filter;
-    _items = [];
-    _length = 0;
+var NodeListStaticImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `NodeList`.
      *
      * @param root - root node
      */
-    constructor(root) {
+    function NodeListStaticImpl(root) {
+        this._live = false;
+        this._items = [];
+        this._length = 0;
         this._root = root;
         this._items = [];
         this._filter = function (node) { return true; };
         return new Proxy(this, this);
     }
+    Object.defineProperty(NodeListStaticImpl.prototype, "length", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The length attribute must return the number of nodes represented by
+             * the collection.
+             */
+            return this._items.length;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get length() {
-        /**
-         * The length attribute must return the number of nodes represented by
-         * the collection.
-         */
-        return this._items.length;
-    }
-    /** @inheritdoc */
-    item(index) {
+    NodeListStaticImpl.prototype.item = function (index) {
         /**
          * The item(index) method must return the indexth node in the collection.
          * If there is no indexth node in the collection, then the method must
@@ -27533,12 +56844,13 @@ class NodeListStaticImpl {
         if (index < 0 || index > this.length - 1)
             return null;
         return this._items[index];
-    }
+    };
     /** @inheritdoc */
-    keys() {
-        return {
-            [Symbol.iterator]: function () {
-                let index = 0;
+    NodeListStaticImpl.prototype.keys = function () {
+        var _a;
+        return _a = {},
+            _a[Symbol.iterator] = function () {
+                var index = 0;
                 return {
                     next: function () {
                         if (index === this.length) {
@@ -27549,31 +56861,33 @@ class NodeListStaticImpl {
                         }
                     }.bind(this)
                 };
-            }.bind(this)
-        };
-    }
+            }.bind(this),
+            _a;
+    };
     /** @inheritdoc */
-    values() {
-        return {
-            [Symbol.iterator]: function () {
-                const it = this[Symbol.iterator]();
+    NodeListStaticImpl.prototype.values = function () {
+        var _a;
+        return _a = {},
+            _a[Symbol.iterator] = function () {
+                var it = this[Symbol.iterator]();
                 return {
-                    next() {
+                    next: function () {
                         return it.next();
                     }
                 };
-            }.bind(this)
-        };
-    }
+            }.bind(this),
+            _a;
+    };
     /** @inheritdoc */
-    entries() {
-        return {
-            [Symbol.iterator]: function () {
-                const it = this[Symbol.iterator]();
-                let index = 0;
+    NodeListStaticImpl.prototype.entries = function () {
+        var _a;
+        return _a = {},
+            _a[Symbol.iterator] = function () {
+                var it = this[Symbol.iterator]();
+                var index = 0;
                 return {
-                    next() {
-                        const itResult = it.next();
+                    next: function () {
+                        var itResult = it.next();
                         if (itResult.done) {
                             return { done: true, value: null };
                         }
@@ -27582,49 +56896,60 @@ class NodeListStaticImpl {
                         }
                     }
                 };
-            }.bind(this)
-        };
-    }
+            }.bind(this),
+            _a;
+    };
     /** @inheritdoc */
-    [Symbol.iterator]() {
-        const it = this._items[Symbol.iterator]();
+    NodeListStaticImpl.prototype[Symbol.iterator] = function () {
+        var it = this._items[Symbol.iterator]();
         return {
-            next() {
+            next: function () {
                 return it.next();
             }
         };
-    }
+    };
     /** @inheritdoc */
-    forEach(callback, thisArg) {
+    NodeListStaticImpl.prototype.forEach = function (callback, thisArg) {
+        var e_1, _a;
         if (thisArg === undefined) {
             thisArg = DOMImpl_1.dom.window;
         }
-        let index = 0;
-        for (const node of this._items) {
-            callback.call(thisArg, node, index++, this);
+        var index = 0;
+        try {
+            for (var _b = __values(this._items), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var node = _c.value;
+                callback.call(thisArg, node, index++, this);
+            }
         }
-    }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
     /**
      * Implements a proxy get trap to provide array-like access.
      */
-    get(target, key, receiver) {
-        if (!(0, util_1.isString)(key)) {
+    NodeListStaticImpl.prototype.get = function (target, key, receiver) {
+        if (!util_1.isString(key)) {
             return Reflect.get(target, key, receiver);
         }
-        const index = Number(key);
+        var index = Number(key);
         if (isNaN(index)) {
             return Reflect.get(target, key, receiver);
         }
         return target._items[index] || undefined;
-    }
+    };
     /**
      * Implements a proxy set trap to provide array-like access.
      */
-    set(target, key, value, receiver) {
-        if (!(0, util_1.isString)(key)) {
+    NodeListStaticImpl.prototype.set = function (target, key, value, receiver) {
+        if (!util_1.isString(key)) {
             return Reflect.set(target, key, value, receiver);
         }
-        const index = Number(key);
+        var index = Number(key);
         if (isNaN(index)) {
             return Reflect.set(target, key, value, receiver);
         }
@@ -27635,19 +56960,20 @@ class NodeListStaticImpl {
         else {
             return false;
         }
-    }
+    };
     /**
      * Creates a new `NodeList`.
      *
      * @param root - root node
      * @param items - a list of items to initialize the list
      */
-    static _create(root, items) {
-        const list = new NodeListStaticImpl(root);
+    NodeListStaticImpl._create = function (root, items) {
+        var list = new NodeListStaticImpl(root);
         list._items = items;
         return list;
-    }
-}
+    };
+    return NodeListStaticImpl;
+}());
 exports.NodeListStaticImpl = NodeListStaticImpl;
 //# sourceMappingURL=NodeListStaticImpl.js.map
 
@@ -27659,45 +56985,55 @@ exports.NodeListStaticImpl = NodeListStaticImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NonDocumentTypeChildNodeImpl = void 0;
-const util_1 = __nccwpck_require__(65282);
+var util_1 = __nccwpck_require__(65282);
 /**
  * Represents a mixin that extends child nodes that can have siblings
  * other than doctypes. This mixin is implemented by {@link Element} and
  * {@link CharacterData}.
  */
-class NonDocumentTypeChildNodeImpl {
-    /** @inheritdoc */
-    get previousElementSibling() {
-        /**
-         * The previousElementSibling attribute’s getter must return the first
-         * preceding sibling that is an element, and null otherwise.
-         */
-        let node = util_1.Cast.asNode(this)._previousSibling;
-        while (node) {
-            if (util_1.Guard.isElementNode(node))
-                return node;
-            else
-                node = node._previousSibling;
-        }
-        return null;
+var NonDocumentTypeChildNodeImpl = /** @class */ (function () {
+    function NonDocumentTypeChildNodeImpl() {
     }
-    /** @inheritdoc */
-    get nextElementSibling() {
-        /**
-         * The nextElementSibling attribute’s getter must return the first
-         * following sibling that is an element, and null otherwise.
-         */
-        let node = util_1.Cast.asNode(this)._nextSibling;
-        while (node) {
-            if (util_1.Guard.isElementNode(node))
-                return node;
-            else
-                node = node._nextSibling;
-        }
-        return null;
-    }
-}
+    Object.defineProperty(NonDocumentTypeChildNodeImpl.prototype, "previousElementSibling", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The previousElementSibling attribute’s getter must return the first
+             * preceding sibling that is an element, and null otherwise.
+             */
+            var node = util_1.Cast.asNode(this)._previousSibling;
+            while (node) {
+                if (util_1.Guard.isElementNode(node))
+                    return node;
+                else
+                    node = node._previousSibling;
+            }
+            return null;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(NonDocumentTypeChildNodeImpl.prototype, "nextElementSibling", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The nextElementSibling attribute’s getter must return the first
+             * following sibling that is an element, and null otherwise.
+             */
+            var node = util_1.Cast.asNode(this)._nextSibling;
+            while (node) {
+                if (util_1.Guard.isElementNode(node))
+                    return node;
+                else
+                    node = node._nextSibling;
+            }
+            return null;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return NonDocumentTypeChildNodeImpl;
+}());
 exports.NonDocumentTypeChildNodeImpl = NonDocumentTypeChildNodeImpl;
 //# sourceMappingURL=NonDocumentTypeChildNodeImpl.js.map
 
@@ -27709,180 +57045,246 @@ exports.NonDocumentTypeChildNodeImpl = NonDocumentTypeChildNodeImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NonElementParentNodeImpl = void 0;
-const util_1 = __nccwpck_require__(65282);
-const algorithm_1 = __nccwpck_require__(61);
+var util_1 = __nccwpck_require__(65282);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents a mixin that extends non-element parent nodes. This mixin
  * is implemented by {@link Document} and {@link DocumentFragment}.
  */
-class NonElementParentNodeImpl {
+var NonElementParentNodeImpl = /** @class */ (function () {
+    function NonElementParentNodeImpl() {
+    }
     /** @inheritdoc */
-    getElementById(id) {
+    NonElementParentNodeImpl.prototype.getElementById = function (id) {
         /**
          * The getElementById(elementId) method, when invoked, must return the first
          * element, in tree order, within the context object’s descendants,
          * whose ID is elementId, and null if there is no such element otherwise.
          */
-        let ele = (0, algorithm_1.tree_getFirstDescendantNode)(util_1.Cast.asNode(this), false, false, (e) => util_1.Guard.isElementNode(e));
+        var ele = algorithm_1.tree_getFirstDescendantNode(util_1.Cast.asNode(this), false, false, function (e) { return util_1.Guard.isElementNode(e); });
         while (ele !== null) {
             if (ele._uniqueIdentifier === id) {
                 return ele;
             }
-            ele = (0, algorithm_1.tree_getNextDescendantNode)(util_1.Cast.asNode(this), ele, false, false, (e) => util_1.Guard.isElementNode(e));
+            ele = algorithm_1.tree_getNextDescendantNode(util_1.Cast.asNode(this), ele, false, false, function (e) { return util_1.Guard.isElementNode(e); });
         }
         return null;
-    }
-}
+    };
+    return NonElementParentNodeImpl;
+}());
 exports.NonElementParentNodeImpl = NonElementParentNodeImpl;
 //# sourceMappingURL=NonElementParentNodeImpl.js.map
 
 /***/ }),
 
 /***/ 85988:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ParentNodeImpl = void 0;
-const util_1 = __nccwpck_require__(65282);
-const algorithm_1 = __nccwpck_require__(61);
+var util_1 = __nccwpck_require__(65282);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents a mixin that extends parent nodes that can have children.
  * This mixin is implemented by {@link Element}, {@link Document} and
  * {@link DocumentFragment}.
  */
-class ParentNodeImpl {
-    /** @inheritdoc */
-    get children() {
-        /**
-         * The children attribute’s getter must return an HTMLCollection collection
-         * rooted at context object matching only element children.
-         */
-        return (0, algorithm_1.create_htmlCollection)(util_1.Cast.asNode(this));
+var ParentNodeImpl = /** @class */ (function () {
+    function ParentNodeImpl() {
     }
+    Object.defineProperty(ParentNodeImpl.prototype, "children", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The children attribute’s getter must return an HTMLCollection collection
+             * rooted at context object matching only element children.
+             */
+            return algorithm_1.create_htmlCollection(util_1.Cast.asNode(this));
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParentNodeImpl.prototype, "firstElementChild", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The firstElementChild attribute’s getter must return the first child
+             * that is an element, and null otherwise.
+             */
+            var node = util_1.Cast.asNode(this)._firstChild;
+            while (node) {
+                if (util_1.Guard.isElementNode(node))
+                    return node;
+                else
+                    node = node._nextSibling;
+            }
+            return null;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParentNodeImpl.prototype, "lastElementChild", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * The lastElementChild attribute’s getter must return the last child that
+             * is an element, and null otherwise.
+             */
+            var node = util_1.Cast.asNode(this)._lastChild;
+            while (node) {
+                if (util_1.Guard.isElementNode(node))
+                    return node;
+                else
+                    node = node._previousSibling;
+            }
+            return null;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ParentNodeImpl.prototype, "childElementCount", {
+        /** @inheritdoc */
+        get: function () {
+            var e_1, _a;
+            /**
+             * The childElementCount attribute’s getter must return the number of
+             * children of context object that are elements.
+             */
+            var count = 0;
+            try {
+                for (var _b = __values(util_1.Cast.asNode(this)._children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var childNode = _c.value;
+                    if (util_1.Guard.isElementNode(childNode))
+                        count++;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return count;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get firstElementChild() {
-        /**
-         * The firstElementChild attribute’s getter must return the first child
-         * that is an element, and null otherwise.
-         */
-        let node = util_1.Cast.asNode(this)._firstChild;
-        while (node) {
-            if (util_1.Guard.isElementNode(node))
-                return node;
-            else
-                node = node._nextSibling;
+    ParentNodeImpl.prototype.prepend = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
         }
-        return null;
-    }
-    /** @inheritdoc */
-    get lastElementChild() {
-        /**
-         * The lastElementChild attribute’s getter must return the last child that
-         * is an element, and null otherwise.
-         */
-        let node = util_1.Cast.asNode(this)._lastChild;
-        while (node) {
-            if (util_1.Guard.isElementNode(node))
-                return node;
-            else
-                node = node._previousSibling;
-        }
-        return null;
-    }
-    /** @inheritdoc */
-    get childElementCount() {
-        /**
-         * The childElementCount attribute’s getter must return the number of
-         * children of context object that are elements.
-         */
-        let count = 0;
-        for (const childNode of util_1.Cast.asNode(this)._children) {
-            if (util_1.Guard.isElementNode(childNode))
-                count++;
-        }
-        return count;
-    }
-    /** @inheritdoc */
-    prepend(...nodes) {
         /**
          * 1. Let node be the result of converting nodes into a node given nodes
          * and context object’s node document.
          * 2. Pre-insert node into context object before the context object’s first
          * child.
          */
-        const node = util_1.Cast.asNode(this);
-        const childNode = (0, algorithm_1.parentNode_convertNodesIntoANode)(nodes, node._nodeDocument);
-        (0, algorithm_1.mutation_preInsert)(childNode, node, node._firstChild);
-    }
+        var node = util_1.Cast.asNode(this);
+        var childNode = algorithm_1.parentNode_convertNodesIntoANode(nodes, node._nodeDocument);
+        algorithm_1.mutation_preInsert(childNode, node, node._firstChild);
+    };
     /** @inheritdoc */
-    append(...nodes) {
+    ParentNodeImpl.prototype.append = function () {
+        var nodes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            nodes[_i] = arguments[_i];
+        }
         /**
          * 1. Let node be the result of converting nodes into a node given nodes
          * and context object’s node document.
          * 2. Append node to context object.
          */
-        const node = util_1.Cast.asNode(this);
-        const childNode = (0, algorithm_1.parentNode_convertNodesIntoANode)(nodes, node._nodeDocument);
-        (0, algorithm_1.mutation_append)(childNode, node);
-    }
+        var node = util_1.Cast.asNode(this);
+        var childNode = algorithm_1.parentNode_convertNodesIntoANode(nodes, node._nodeDocument);
+        algorithm_1.mutation_append(childNode, node);
+    };
     /** @inheritdoc */
-    querySelector(selectors) {
+    ParentNodeImpl.prototype.querySelector = function (selectors) {
         /**
          * The querySelector(selectors) method, when invoked, must return the first
          * result of running scope-match a selectors string selectors against
          * context object, if the result is not an empty list, and null otherwise.
          */
-        const node = util_1.Cast.asNode(this);
-        const result = (0, algorithm_1.selectors_scopeMatchASelectorsString)(selectors, node);
+        var node = util_1.Cast.asNode(this);
+        var result = algorithm_1.selectors_scopeMatchASelectorsString(selectors, node);
         return (result.length === 0 ? null : result[0]);
-    }
+    };
     /** @inheritdoc */
-    querySelectorAll(selectors) {
+    ParentNodeImpl.prototype.querySelectorAll = function (selectors) {
         /**
          * The querySelectorAll(selectors) method, when invoked, must return the
          * static result of running scope-match a selectors string selectors against
          * context object.
          */
-        const node = util_1.Cast.asNode(this);
-        const result = (0, algorithm_1.selectors_scopeMatchASelectorsString)(selectors, node);
-        return (0, algorithm_1.create_nodeListStatic)(node, result);
-    }
-}
+        var node = util_1.Cast.asNode(this);
+        var result = algorithm_1.selectors_scopeMatchASelectorsString(selectors, node);
+        return algorithm_1.create_nodeListStatic(node, result);
+    };
+    return ParentNodeImpl;
+}());
 exports.ParentNodeImpl = ParentNodeImpl;
 //# sourceMappingURL=ParentNodeImpl.js.map
 
 /***/ }),
 
 /***/ 99430:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ProcessingInstructionImpl = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
-const CharacterDataImpl_1 = __nccwpck_require__(65330);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var interfaces_1 = __nccwpck_require__(27305);
+var CharacterDataImpl_1 = __nccwpck_require__(65330);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents a processing instruction node.
  */
-class ProcessingInstructionImpl extends CharacterDataImpl_1.CharacterDataImpl {
-    _nodeType = interfaces_1.NodeType.ProcessingInstruction;
-    _target;
+var ProcessingInstructionImpl = /** @class */ (function (_super) {
+    __extends(ProcessingInstructionImpl, _super);
     /**
      * Initializes a new instance of `ProcessingInstruction`.
      */
-    constructor(target, data) {
-        super(data);
-        this._target = target;
+    function ProcessingInstructionImpl(target, data) {
+        var _this = _super.call(this, data) || this;
+        _this._target = target;
+        return _this;
     }
-    /**
-     * Gets the target of the {@link ProcessingInstruction} node.
-     */
-    get target() { return this._target; }
+    Object.defineProperty(ProcessingInstructionImpl.prototype, "target", {
+        /**
+         * Gets the target of the {@link ProcessingInstruction} node.
+         */
+        get: function () { return this._target; },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Creates a new `ProcessingInstruction`.
      *
@@ -27890,150 +57292,170 @@ class ProcessingInstructionImpl extends CharacterDataImpl_1.CharacterDataImpl {
      * @param target - instruction target
      * @param data - node contents
      */
-    static _create(document, target, data) {
-        const node = new ProcessingInstructionImpl(target, data);
+    ProcessingInstructionImpl._create = function (document, target, data) {
+        var node = new ProcessingInstructionImpl(target, data);
         node._nodeDocument = document;
         return node;
-    }
-}
+    };
+    return ProcessingInstructionImpl;
+}(CharacterDataImpl_1.CharacterDataImpl));
 exports.ProcessingInstructionImpl = ProcessingInstructionImpl;
 /**
  * Initialize prototype properties
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(ProcessingInstructionImpl.prototype, "_nodeType", interfaces_1.NodeType.ProcessingInstruction);
+WebIDLAlgorithm_1.idl_defineConst(ProcessingInstructionImpl.prototype, "_nodeType", interfaces_1.NodeType.ProcessingInstruction);
 //# sourceMappingURL=ProcessingInstructionImpl.js.map
 
 /***/ }),
 
 /***/ 50166:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.RangeImpl = void 0;
-const DOMImpl_1 = __nccwpck_require__(14177);
-const interfaces_1 = __nccwpck_require__(27305);
-const AbstractRangeImpl_1 = __nccwpck_require__(57126);
-const DOMException_1 = __nccwpck_require__(13166);
-const algorithm_1 = __nccwpck_require__(61);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
-const util_1 = __nccwpck_require__(65282);
+var DOMImpl_1 = __nccwpck_require__(14177);
+var interfaces_1 = __nccwpck_require__(27305);
+var AbstractRangeImpl_1 = __nccwpck_require__(57126);
+var DOMException_1 = __nccwpck_require__(13166);
+var algorithm_1 = __nccwpck_require__(61);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var util_1 = __nccwpck_require__(65282);
 /**
  * Represents a live range.
  */
-class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
-    static START_TO_START = 0;
-    static START_TO_END = 1;
-    static END_TO_END = 2;
-    static END_TO_START = 3;
-    START_TO_START = 0;
-    START_TO_END = 1;
-    END_TO_END = 2;
-    END_TO_START = 3;
-    _start;
-    _end;
+var RangeImpl = /** @class */ (function (_super) {
+    __extends(RangeImpl, _super);
     /**
      * Initializes a new instance of `Range`.
      */
-    constructor() {
-        super();
+    function RangeImpl() {
+        var _this = _super.call(this) || this;
         /**
          * The Range() constructor, when invoked, must return a new live range with
          * (current global object’s associated Document, 0) as its start and end.
          */
-        const doc = DOMImpl_1.dom.window._associatedDocument;
-        this._start = [doc, 0];
-        this._end = [doc, 0];
-        DOMImpl_1.dom.rangeList.add(this);
+        var doc = DOMImpl_1.dom.window._associatedDocument;
+        _this._start = [doc, 0];
+        _this._end = [doc, 0];
+        DOMImpl_1.dom.rangeList.add(_this);
+        return _this;
     }
-    /** @inheritdoc */
-    get commonAncestorContainer() {
-        /**
-         * 1. Let container be start node.
-         * 2. While container is not an inclusive ancestor of end node, let
-         * container be container’s parent.
-         * 3. Return container.
-         */
-        let container = this._start[0];
-        while (!(0, algorithm_1.tree_isAncestorOf)(this._end[0], container, true)) {
-            if (container._parent === null) {
-                throw new Error("Parent node  is null.");
+    Object.defineProperty(RangeImpl.prototype, "commonAncestorContainer", {
+        /** @inheritdoc */
+        get: function () {
+            /**
+             * 1. Let container be start node.
+             * 2. While container is not an inclusive ancestor of end node, let
+             * container be container’s parent.
+             * 3. Return container.
+             */
+            var container = this._start[0];
+            while (!algorithm_1.tree_isAncestorOf(this._end[0], container, true)) {
+                if (container._parent === null) {
+                    throw new Error("Parent node  is null.");
+                }
+                container = container._parent;
             }
-            container = container._parent;
-        }
-        return container;
-    }
+            return container;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    setStart(node, offset) {
+    RangeImpl.prototype.setStart = function (node, offset) {
         /**
          * The setStart(node, offset) method, when invoked, must set the start of
          * context object to boundary point (node, offset).
          */
-        (0, algorithm_1.range_setTheStart)(this, node, offset);
-    }
+        algorithm_1.range_setTheStart(this, node, offset);
+    };
     /** @inheritdoc */
-    setEnd(node, offset) {
+    RangeImpl.prototype.setEnd = function (node, offset) {
         /**
          * The setEnd(node, offset) method, when invoked, must set the end of
          * context object to boundary point (node, offset).
          */
-        (0, algorithm_1.range_setTheEnd)(this, node, offset);
-    }
+        algorithm_1.range_setTheEnd(this, node, offset);
+    };
     /** @inheritdoc */
-    setStartBefore(node) {
+    RangeImpl.prototype.setStartBefore = function (node) {
         /**
          * 1. Let parent be node’s parent.
          * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException.
          * 3. Set the start of the context object to boundary point
          * (parent, node’s index).
          */
-        let parent = node._parent;
+        var parent = node._parent;
         if (parent === null)
             throw new DOMException_1.InvalidNodeTypeError();
-        (0, algorithm_1.range_setTheStart)(this, parent, (0, algorithm_1.tree_index)(node));
-    }
+        algorithm_1.range_setTheStart(this, parent, algorithm_1.tree_index(node));
+    };
     /** @inheritdoc */
-    setStartAfter(node) {
+    RangeImpl.prototype.setStartAfter = function (node) {
         /**
          * 1. Let parent be node’s parent.
          * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException.
          * 3. Set the start of the context object to boundary point
          * (parent, node’s index plus 1).
          */
-        let parent = node._parent;
+        var parent = node._parent;
         if (parent === null)
             throw new DOMException_1.InvalidNodeTypeError();
-        (0, algorithm_1.range_setTheStart)(this, parent, (0, algorithm_1.tree_index)(node) + 1);
-    }
+        algorithm_1.range_setTheStart(this, parent, algorithm_1.tree_index(node) + 1);
+    };
     /** @inheritdoc */
-    setEndBefore(node) {
+    RangeImpl.prototype.setEndBefore = function (node) {
         /**
          * 1. Let parent be node’s parent.
          * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException.
          * 3. Set the end of the context object to boundary point
          * (parent, node’s index).
          */
-        let parent = node._parent;
+        var parent = node._parent;
         if (parent === null)
             throw new DOMException_1.InvalidNodeTypeError();
-        (0, algorithm_1.range_setTheEnd)(this, parent, (0, algorithm_1.tree_index)(node));
-    }
+        algorithm_1.range_setTheEnd(this, parent, algorithm_1.tree_index(node));
+    };
     /** @inheritdoc */
-    setEndAfter(node) {
+    RangeImpl.prototype.setEndAfter = function (node) {
         /**
          * 1. Let parent be node’s parent.
          * 2. If parent is null, then throw an "InvalidNodeTypeError" DOMException.
          * 3. Set the end of the context object to boundary point
          * (parent, node’s index plus 1).
          */
-        let parent = node._parent;
+        var parent = node._parent;
         if (parent === null)
             throw new DOMException_1.InvalidNodeTypeError();
-        (0, algorithm_1.range_setTheEnd)(this, parent, (0, algorithm_1.tree_index)(node) + 1);
-    }
+        algorithm_1.range_setTheEnd(this, parent, algorithm_1.tree_index(node) + 1);
+    };
     /** @inheritdoc */
-    collapse(toStart) {
+    RangeImpl.prototype.collapse = function (toStart) {
         /**
          * The collapse(toStart) method, when invoked, must if toStart is true,
          * set end to start, and set start to end otherwise.
@@ -28044,17 +57466,17 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
         else {
             this._start = this._end;
         }
-    }
+    };
     /** @inheritdoc */
-    selectNode(node) {
+    RangeImpl.prototype.selectNode = function (node) {
         /**
          * The selectNode(node) method, when invoked, must select node within
          * context object.
          */
-        (0, algorithm_1.range_select)(node, this);
-    }
+        algorithm_1.range_select(node, this);
+    };
     /** @inheritdoc */
-    selectNodeContents(node) {
+    RangeImpl.prototype.selectNodeContents = function (node) {
         /**
          * 1. If node is a doctype, throw an "InvalidNodeTypeError" DOMException.
          * 2. Let length be the length of node.
@@ -28063,12 +57485,12 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
          */
         if (util_1.Guard.isDocumentTypeNode(node))
             throw new DOMException_1.InvalidNodeTypeError();
-        const length = (0, algorithm_1.tree_nodeLength)(node);
+        var length = algorithm_1.tree_nodeLength(node);
         this._start = [node, 0];
         this._end = [node, length];
-    }
+    };
     /** @inheritdoc */
-    compareBoundaryPoints(how, sourceRange) {
+    RangeImpl.prototype.compareBoundaryPoints = function (how, sourceRange) {
         /**
          * 1. If how is not one of
          * - START_TO_START,
@@ -28084,7 +57506,7 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
          * 2. If context object’s root is not the same as sourceRange’s root,
          * then throw a "WrongDocumentError" DOMException.
          */
-        if ((0, algorithm_1.range_root)(this) !== (0, algorithm_1.range_root)(sourceRange))
+        if (algorithm_1.range_root(this) !== algorithm_1.range_root(sourceRange))
             throw new DOMException_1.WrongDocumentError();
         /**
          * 3. If how is:
@@ -28101,8 +57523,8 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
          * Let this point be the context object’s start. Let other point be
          * sourceRange’s end.
          */
-        let thisPoint;
-        let otherPoint;
+        var thisPoint;
+        var otherPoint;
         switch (how) {
             case interfaces_1.HowToCompare.StartToStart:
                 thisPoint = this._start;
@@ -28133,7 +57555,7 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
          * - after
          * Return 1.
          */
-        const position = (0, algorithm_1.boundaryPoint_position)(thisPoint, otherPoint);
+        var position = algorithm_1.boundaryPoint_position(thisPoint, otherPoint);
         if (position === interfaces_1.BoundaryPosition.Before) {
             return -1;
         }
@@ -28143,21 +57565,22 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
         else {
             return 0;
         }
-    }
+    };
     /** @inheritdoc */
-    deleteContents() {
+    RangeImpl.prototype.deleteContents = function () {
+        var e_1, _a, e_2, _b;
         /**
          * 1. If the context object is collapsed, then return.
          * 2. Let original start node, original start offset, original end node,
          * and original end offset be the context object’s start node,
          * start offset, end node, and end offset, respectively.
          */
-        if ((0, algorithm_1.range_collapsed)(this))
+        if (algorithm_1.range_collapsed(this))
             return;
-        const originalStartNode = this._startNode;
-        const originalStartOffset = this._startOffset;
-        const originalEndNode = this._endNode;
-        const originalEndOffset = this._endOffset;
+        var originalStartNode = this._startNode;
+        var originalStartOffset = this._startOffset;
+        var originalEndNode = this._endNode;
+        var originalEndOffset = this._endOffset;
         /**
          * 3. If original start node and original end node are the same, and they
          * are a Text, ProcessingInstruction, or Comment node, replace data with
@@ -28167,7 +57590,7 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
          */
         if (originalStartNode === originalEndNode &&
             util_1.Guard.isCharacterDataNode(originalStartNode)) {
-            (0, algorithm_1.characterData_replaceData)(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset, '');
+            algorithm_1.characterData_replaceData(originalStartNode, originalStartOffset, originalEndOffset - originalStartOffset, '');
             return;
         }
         /**
@@ -28175,17 +57598,27 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
          * the context object, in tree order, omitting any node whose parent is also
          * contained in the context object.
          */
-        const nodesToRemove = [];
-        for (const node of (0, algorithm_1.range_getContainedNodes)(this)) {
-            const parent = node._parent;
-            if (parent !== null && (0, algorithm_1.range_isContained)(parent, this)) {
-                continue;
+        var nodesToRemove = [];
+        try {
+            for (var _c = __values(algorithm_1.range_getContainedNodes(this)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var node = _d.value;
+                var parent = node._parent;
+                if (parent !== null && algorithm_1.range_isContained(parent, this)) {
+                    continue;
+                }
+                nodesToRemove.push(node);
             }
-            nodesToRemove.push(node);
         }
-        let newNode;
-        let newOffset;
-        if ((0, algorithm_1.tree_isAncestorOf)(originalEndNode, originalStartNode, true)) {
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var newNode;
+        var newOffset;
+        if (algorithm_1.tree_isAncestorOf(originalEndNode, originalStartNode, true)) {
             /**
              * 5. If original start node is an inclusive ancestor of original end
              * node, set new node to original start node and new offset to original
@@ -28203,9 +57636,9 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
              * 6.3. Set new node to the parent of reference node, and new offset to
              * one plus the index of reference node.
              */
-            let referenceNode = originalStartNode;
+            var referenceNode = originalStartNode;
             while (referenceNode._parent !== null &&
-                !(0, algorithm_1.tree_isAncestorOf)(originalEndNode, referenceNode._parent, true)) {
+                !algorithm_1.tree_isAncestorOf(originalEndNode, referenceNode._parent, true)) {
                 referenceNode = referenceNode._parent;
             }
             /* istanbul ignore next */
@@ -28213,7 +57646,7 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
                 throw new Error("Parent node is null.");
             }
             newNode = referenceNode._parent;
-            newOffset = (0, algorithm_1.tree_index)(referenceNode) + 1;
+            newOffset = algorithm_1.tree_index(referenceNode) + 1;
         }
         /**
          * 7. If original start node is a Text, ProcessingInstruction, or Comment
@@ -28222,67 +57655,88 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
          * data the empty string.
          */
         if (util_1.Guard.isCharacterDataNode(originalStartNode)) {
-            (0, algorithm_1.characterData_replaceData)(originalStartNode, originalStartOffset, (0, algorithm_1.tree_nodeLength)(originalStartNode) - originalStartOffset, '');
+            algorithm_1.characterData_replaceData(originalStartNode, originalStartOffset, algorithm_1.tree_nodeLength(originalStartNode) - originalStartOffset, '');
         }
-        /**
-         * 8. For each node in nodes to remove, in tree order, remove node from its
-         * parent.
-         */
-        for (const node of nodesToRemove) {
-            /* istanbul ignore else */
-            if (node._parent) {
-                (0, algorithm_1.mutation_remove)(node, node._parent);
+        try {
+            /**
+             * 8. For each node in nodes to remove, in tree order, remove node from its
+             * parent.
+             */
+            for (var nodesToRemove_1 = __values(nodesToRemove), nodesToRemove_1_1 = nodesToRemove_1.next(); !nodesToRemove_1_1.done; nodesToRemove_1_1 = nodesToRemove_1.next()) {
+                var node = nodesToRemove_1_1.value;
+                /* istanbul ignore else */
+                if (node._parent) {
+                    algorithm_1.mutation_remove(node, node._parent);
+                }
             }
         }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (nodesToRemove_1_1 && !nodesToRemove_1_1.done && (_b = nodesToRemove_1.return)) _b.call(nodesToRemove_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
         /**
          * 9. If original end node is a Text, ProcessingInstruction, or Comment
          * node, replace data with node original end node, offset 0, count original
          * end offset and data the empty string.
          */
         if (util_1.Guard.isCharacterDataNode(originalEndNode)) {
-            (0, algorithm_1.characterData_replaceData)(originalEndNode, 0, originalEndOffset, '');
+            algorithm_1.characterData_replaceData(originalEndNode, 0, originalEndOffset, '');
         }
         /**
          * 10. Set start and end to (new node, new offset).
          */
         this._start = [newNode, newOffset];
         this._end = [newNode, newOffset];
-    }
+    };
     /** @inheritdoc */
-    extractContents() {
+    RangeImpl.prototype.extractContents = function () {
         /**
          * The extractContents() method, when invoked, must return the result of
          * extracting the context object.
          */
-        return (0, algorithm_1.range_extract)(this);
-    }
+        return algorithm_1.range_extract(this);
+    };
     /** @inheritdoc */
-    cloneContents() {
+    RangeImpl.prototype.cloneContents = function () {
         /**
          * The cloneContents() method, when invoked, must return the result of
          * cloning the contents of the context object.
          */
-        return (0, algorithm_1.range_cloneTheContents)(this);
-    }
+        return algorithm_1.range_cloneTheContents(this);
+    };
     /** @inheritdoc */
-    insertNode(node) {
+    RangeImpl.prototype.insertNode = function (node) {
         /**
          * The insertNode(node) method, when invoked, must insert node into the
          * context object.
          */
-        return (0, algorithm_1.range_insert)(node, this);
-    }
+        return algorithm_1.range_insert(node, this);
+    };
     /** @inheritdoc */
-    surroundContents(newParent) {
-        /**
-         * 1. If a non-Text node is partially contained in the context object, then
-         * throw an "InvalidStateError" DOMException.
-         */
-        for (const node of (0, algorithm_1.range_getPartiallyContainedNodes)(this)) {
-            if (!util_1.Guard.isTextNode(node)) {
-                throw new DOMException_1.InvalidStateError();
+    RangeImpl.prototype.surroundContents = function (newParent) {
+        var e_3, _a;
+        try {
+            /**
+             * 1. If a non-Text node is partially contained in the context object, then
+             * throw an "InvalidStateError" DOMException.
+             */
+            for (var _b = __values(algorithm_1.range_getPartiallyContainedNodes(this)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var node = _c.value;
+                if (!util_1.Guard.isTextNode(node)) {
+                    throw new DOMException_1.InvalidStateError();
+                }
             }
         }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
         /**
          * 2. If newParent is a Document, DocumentType, or DocumentFragment node,
          * then throw an "InvalidNodeTypeError" DOMException.
@@ -28295,47 +57749,47 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
         /**
          * 3. Let fragment be the result of extracting the context object.
          */
-        const fragment = (0, algorithm_1.range_extract)(this);
+        var fragment = algorithm_1.range_extract(this);
         /**
          * 4. If newParent has children, then replace all with null within newParent.
          */
         if ((newParent)._children.size !== 0) {
-            (0, algorithm_1.mutation_replaceAll)(null, newParent);
+            algorithm_1.mutation_replaceAll(null, newParent);
         }
         /**
          * 5. Insert newParent into the context object.
          * 6. Append fragment to newParent.
          */
-        (0, algorithm_1.range_insert)(newParent, this);
-        (0, algorithm_1.mutation_append)(fragment, newParent);
+        algorithm_1.range_insert(newParent, this);
+        algorithm_1.mutation_append(fragment, newParent);
         /**
          * 7. Select newParent within the context object.
          */
-        (0, algorithm_1.range_select)(newParent, this);
-    }
+        algorithm_1.range_select(newParent, this);
+    };
     /** @inheritdoc */
-    cloneRange() {
+    RangeImpl.prototype.cloneRange = function () {
         /**
          * The cloneRange() method, when invoked, must return a new live range with
          * the same start and end as the context object.
          */
-        return (0, algorithm_1.create_range)(this._start, this._end);
-    }
+        return algorithm_1.create_range(this._start, this._end);
+    };
     /** @inheritdoc */
-    detach() {
+    RangeImpl.prototype.detach = function () {
         /**
          * The detach() method, when invoked, must do nothing.
          *
          * since JS lacks weak references, we still use detach
          */
         DOMImpl_1.dom.rangeList.delete(this);
-    }
+    };
     /** @inheritdoc */
-    isPointInRange(node, offset) {
+    RangeImpl.prototype.isPointInRange = function (node, offset) {
         /**
          * 1. If node’s root is different from the context object’s root, return false.
          */
-        if ((0, algorithm_1.tree_rootNode)(node) !== (0, algorithm_1.range_root)(this)) {
+        if (algorithm_1.tree_rootNode(node) !== algorithm_1.range_root(this)) {
             return false;
         }
         /**
@@ -28345,23 +57799,23 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
          */
         if (util_1.Guard.isDocumentTypeNode(node))
             throw new DOMException_1.InvalidNodeTypeError();
-        if (offset > (0, algorithm_1.tree_nodeLength)(node))
+        if (offset > algorithm_1.tree_nodeLength(node))
             throw new DOMException_1.IndexSizeError();
         /**
          * 4. If (node, offset) is before start or after end, return false.
          */
-        const bp = [node, offset];
-        if ((0, algorithm_1.boundaryPoint_position)(bp, this._start) === interfaces_1.BoundaryPosition.Before ||
-            (0, algorithm_1.boundaryPoint_position)(bp, this._end) === interfaces_1.BoundaryPosition.After) {
+        var bp = [node, offset];
+        if (algorithm_1.boundaryPoint_position(bp, this._start) === interfaces_1.BoundaryPosition.Before ||
+            algorithm_1.boundaryPoint_position(bp, this._end) === interfaces_1.BoundaryPosition.After) {
             return false;
         }
         /**
          * 5. Return true.
          */
         return true;
-    }
+    };
     /** @inheritdoc */
-    comparePoint(node, offset) {
+    RangeImpl.prototype.comparePoint = function (node, offset) {
         /**
          * 1. If node’s root is different from the context object’s root, then throw
          * a "WrongDocumentError" DOMException.
@@ -28369,65 +57823,66 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
          * 3. If offset is greater than node’s length, then throw an
          * "IndexSizeError" DOMException.
          */
-        if ((0, algorithm_1.tree_rootNode)(node) !== (0, algorithm_1.range_root)(this))
+        if (algorithm_1.tree_rootNode(node) !== algorithm_1.range_root(this))
             throw new DOMException_1.WrongDocumentError();
         if (util_1.Guard.isDocumentTypeNode(node))
             throw new DOMException_1.InvalidNodeTypeError();
-        if (offset > (0, algorithm_1.tree_nodeLength)(node))
+        if (offset > algorithm_1.tree_nodeLength(node))
             throw new DOMException_1.IndexSizeError();
         /**
          * 4. If (node, offset) is before start, return −1.
          * 5. If (node, offset) is after end, return 1.
          * 6. Return 0.
          */
-        const bp = [node, offset];
-        if ((0, algorithm_1.boundaryPoint_position)(bp, this._start) === interfaces_1.BoundaryPosition.Before) {
+        var bp = [node, offset];
+        if (algorithm_1.boundaryPoint_position(bp, this._start) === interfaces_1.BoundaryPosition.Before) {
             return -1;
         }
-        else if ((0, algorithm_1.boundaryPoint_position)(bp, this._end) === interfaces_1.BoundaryPosition.After) {
+        else if (algorithm_1.boundaryPoint_position(bp, this._end) === interfaces_1.BoundaryPosition.After) {
             return 1;
         }
         else {
             return 0;
         }
-    }
+    };
     /** @inheritdoc */
-    intersectsNode(node) {
+    RangeImpl.prototype.intersectsNode = function (node) {
         /**
          * 1. If node’s root is different from the context object’s root, return false.
          */
-        if ((0, algorithm_1.tree_rootNode)(node) !== (0, algorithm_1.range_root)(this)) {
+        if (algorithm_1.tree_rootNode(node) !== algorithm_1.range_root(this)) {
             return false;
         }
         /**
          * 2. Let parent be node’s parent.
          * 3. If parent is null, return true.
          */
-        const parent = node._parent;
+        var parent = node._parent;
         if (parent === null)
             return true;
         /**
          * 4. Let offset be node’s index.
          */
-        const offset = (0, algorithm_1.tree_index)(node);
+        var offset = algorithm_1.tree_index(node);
         /**
          * 5. If (parent, offset) is before end and (parent, offset plus 1) is
          * after start, return true.
          */
-        if ((0, algorithm_1.boundaryPoint_position)([parent, offset], this._end) === interfaces_1.BoundaryPosition.Before &&
-            (0, algorithm_1.boundaryPoint_position)([parent, offset + 1], this._start) === interfaces_1.BoundaryPosition.After) {
+        if (algorithm_1.boundaryPoint_position([parent, offset], this._end) === interfaces_1.BoundaryPosition.Before &&
+            algorithm_1.boundaryPoint_position([parent, offset + 1], this._start) === interfaces_1.BoundaryPosition.After) {
             return true;
         }
         /**
          * 6. Return false.
          */
         return false;
-    }
-    toString() {
+    };
+    RangeImpl.prototype.toString = function () {
+        var e_4, _a;
         /**
          * 1. Let s be the empty string.
          */
-        let s = '';
+        var s = '';
         /**
          * 2. If the context object’s start node is the context object’s end node
          * and it is a Text node, then return the substring of that Text node’s data
@@ -28445,15 +57900,25 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
         if (util_1.Guard.isTextNode(this._startNode)) {
             s += this._startNode._data.substring(this._startOffset);
         }
-        /**
-         * 4. Append the concatenation of the data of all Text nodes that are
-         * contained in the context object, in tree order, to s.
-         */
-        for (const child of (0, algorithm_1.range_getContainedNodes)(this)) {
-            if (util_1.Guard.isTextNode(child)) {
-                s += child._data;
+        try {
+            /**
+             * 4. Append the concatenation of the data of all Text nodes that are
+             * contained in the context object, in tree order, to s.
+             */
+            for (var _b = __values(algorithm_1.range_getContainedNodes(this)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var child = _c.value;
+                if (util_1.Guard.isTextNode(child)) {
+                    s += child._data;
+                }
             }
         }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
         /**
          * 5. If the context object’s end node is a Text node, then append the
          * substring of that node’s data from its start until the context object’s
@@ -28466,85 +57931,110 @@ class RangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
          * 6. Return s.
          */
         return s;
-    }
+    };
     /**
      * Creates a new `Range`.
      *
      * @param start - start point
      * @param end - end point
      */
-    static _create(start, end) {
-        const range = new RangeImpl();
+    RangeImpl._create = function (start, end) {
+        var range = new RangeImpl();
         if (start)
             range._start = start;
         if (end)
             range._end = end;
         return range;
-    }
-}
+    };
+    RangeImpl.START_TO_START = 0;
+    RangeImpl.START_TO_END = 1;
+    RangeImpl.END_TO_END = 2;
+    RangeImpl.END_TO_START = 3;
+    return RangeImpl;
+}(AbstractRangeImpl_1.AbstractRangeImpl));
 exports.RangeImpl = RangeImpl;
 /**
  * Define constants on prototype.
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(RangeImpl.prototype, "START_TO_START", 0);
-(0, WebIDLAlgorithm_1.idl_defineConst)(RangeImpl.prototype, "START_TO_END", 1);
-(0, WebIDLAlgorithm_1.idl_defineConst)(RangeImpl.prototype, "END_TO_END", 2);
-(0, WebIDLAlgorithm_1.idl_defineConst)(RangeImpl.prototype, "END_TO_START", 3);
+WebIDLAlgorithm_1.idl_defineConst(RangeImpl.prototype, "START_TO_START", 0);
+WebIDLAlgorithm_1.idl_defineConst(RangeImpl.prototype, "START_TO_END", 1);
+WebIDLAlgorithm_1.idl_defineConst(RangeImpl.prototype, "END_TO_END", 2);
+WebIDLAlgorithm_1.idl_defineConst(RangeImpl.prototype, "END_TO_START", 3);
 //# sourceMappingURL=RangeImpl.js.map
 
 /***/ }),
 
 /***/ 61911:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ShadowRootImpl = void 0;
-const DocumentFragmentImpl_1 = __nccwpck_require__(12585);
-const util_1 = __nccwpck_require__(76195);
-const algorithm_1 = __nccwpck_require__(61);
+var DocumentFragmentImpl_1 = __nccwpck_require__(12585);
+var util_1 = __nccwpck_require__(76195);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents a shadow root.
  */
-class ShadowRootImpl extends DocumentFragmentImpl_1.DocumentFragmentImpl {
-    _host;
-    _mode;
+var ShadowRootImpl = /** @class */ (function (_super) {
+    __extends(ShadowRootImpl, _super);
     /**
      * Initializes a new instance of `ShadowRoot`.
      *
      * @param host - shadow root's host element
      * @param mode - shadow root's mode
      */
-    constructor(host, mode) {
-        super();
-        this._host = host;
-        this._mode = mode;
+    function ShadowRootImpl(host, mode) {
+        var _this = _super.call(this) || this;
+        _this._host = host;
+        _this._mode = mode;
+        return _this;
     }
-    /** @inheritdoc */
-    get mode() { return this._mode; }
-    /** @inheritdoc */
-    get host() { return this._host; }
+    Object.defineProperty(ShadowRootImpl.prototype, "mode", {
+        /** @inheritdoc */
+        get: function () { return this._mode; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(ShadowRootImpl.prototype, "host", {
+        /** @inheritdoc */
+        get: function () { return this._host; },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Gets the parent event target for the given event.
      *
      * @param event - an event
      */
-    _getTheParent(event) {
+    ShadowRootImpl.prototype._getTheParent = function (event) {
         /**
          * A shadow root’s get the parent algorithm, given an event, returns null
          * if event’s composed flag is unset and shadow root is the root of
          * event’s path’s first struct’s invocation target, and shadow root’s host
          * otherwise.
          */
-        if (!event._composedFlag && !(0, util_1.isEmpty)(event._path) &&
-            (0, algorithm_1.tree_rootNode)(event._path[0].invocationTarget) === this) {
+        if (!event._composedFlag && !util_1.isEmpty(event._path) &&
+            algorithm_1.tree_rootNode(event._path[0].invocationTarget) === this) {
             return null;
         }
         else {
             return this._host;
         }
-    }
+    };
     // MIXIN: DocumentOrShadowRoot
     // No elements
     /**
@@ -28553,10 +58043,11 @@ class ShadowRootImpl extends DocumentFragmentImpl_1.DocumentFragmentImpl {
      * @param document - owner document
      * @param host - shadow root's host element
      */
-    static _create(document, host) {
+    ShadowRootImpl._create = function (document, host) {
         return new ShadowRootImpl(host, "closed");
-    }
-}
+    };
+    return ShadowRootImpl;
+}(DocumentFragmentImpl_1.DocumentFragmentImpl));
 exports.ShadowRootImpl = ShadowRootImpl;
 //# sourceMappingURL=ShadowRootImpl.js.map
 
@@ -28568,51 +58059,74 @@ exports.ShadowRootImpl = ShadowRootImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.SlotableImpl = void 0;
-const algorithm_1 = __nccwpck_require__(61);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents a mixin that allows nodes to become the contents of
  * a <slot> element. This mixin is implemented by {@link Element} and
  * {@link Text}.
  */
-class SlotableImpl {
-    __name;
-    __assignedSlot;
-    get _name() { return this.__name || ''; }
-    set _name(val) { this.__name = val; }
-    get _assignedSlot() { return this.__assignedSlot || null; }
-    set _assignedSlot(val) { this.__assignedSlot = val; }
-    /** @inheritdoc */
-    get assignedSlot() {
-        return (0, algorithm_1.shadowTree_findASlot)(this, true);
+var SlotableImpl = /** @class */ (function () {
+    function SlotableImpl() {
     }
-}
+    Object.defineProperty(SlotableImpl.prototype, "_name", {
+        get: function () { return this.__name || ''; },
+        set: function (val) { this.__name = val; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(SlotableImpl.prototype, "_assignedSlot", {
+        get: function () { return this.__assignedSlot || null; },
+        set: function (val) { this.__assignedSlot = val; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(SlotableImpl.prototype, "assignedSlot", {
+        /** @inheritdoc */
+        get: function () {
+            return algorithm_1.shadowTree_findASlot(this, true);
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return SlotableImpl;
+}());
 exports.SlotableImpl = SlotableImpl;
 //# sourceMappingURL=SlotableImpl.js.map
 
 /***/ }),
 
 /***/ 86357:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.StaticRangeImpl = void 0;
-const AbstractRangeImpl_1 = __nccwpck_require__(57126);
-const DOMException_1 = __nccwpck_require__(13166);
-const util_1 = __nccwpck_require__(65282);
+var AbstractRangeImpl_1 = __nccwpck_require__(57126);
+var DOMException_1 = __nccwpck_require__(13166);
+var util_1 = __nccwpck_require__(65282);
 /**
  * Represents a static range.
  */
-class StaticRangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
-    _start;
-    _end;
+var StaticRangeImpl = /** @class */ (function (_super) {
+    __extends(StaticRangeImpl, _super);
     /**
      * Initializes a new instance of `StaticRange`.
      */
-    constructor(init) {
-        super();
+    function StaticRangeImpl(init) {
+        var _this = _super.call(this) || this;
         /**
          * 1. If init’s startContainer or endContainer is a DocumentType or Attr
          * node, then throw an "InvalidNodeTypeError" DOMException.
@@ -28625,81 +58139,129 @@ class StaticRangeImpl extends AbstractRangeImpl_1.AbstractRangeImpl {
             util_1.Guard.isDocumentTypeNode(init.endContainer) || util_1.Guard.isAttrNode(init.endContainer)) {
             throw new DOMException_1.InvalidNodeTypeError();
         }
-        this._start = [init.startContainer, init.startOffset];
-        this._end = [init.endContainer, init.endOffset];
+        _this._start = [init.startContainer, init.startOffset];
+        _this._end = [init.endContainer, init.endOffset];
+        return _this;
     }
-}
+    return StaticRangeImpl;
+}(AbstractRangeImpl_1.AbstractRangeImpl));
 exports.StaticRangeImpl = StaticRangeImpl;
 //# sourceMappingURL=StaticRangeImpl.js.map
 
 /***/ }),
 
 /***/ 42191:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.TextImpl = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
-const CharacterDataImpl_1 = __nccwpck_require__(65330);
-const algorithm_1 = __nccwpck_require__(61);
-const WebIDLAlgorithm_1 = __nccwpck_require__(45457);
+var interfaces_1 = __nccwpck_require__(27305);
+var CharacterDataImpl_1 = __nccwpck_require__(65330);
+var algorithm_1 = __nccwpck_require__(61);
+var WebIDLAlgorithm_1 = __nccwpck_require__(45457);
 /**
  * Represents a text node.
  */
-class TextImpl extends CharacterDataImpl_1.CharacterDataImpl {
-    _nodeType = interfaces_1.NodeType.Text;
-    _name = '';
-    _assignedSlot = null;
+var TextImpl = /** @class */ (function (_super) {
+    __extends(TextImpl, _super);
     /**
      * Initializes a new instance of `Text`.
      *
      * @param data - the text content
      */
-    constructor(data = '') {
-        super(data);
+    function TextImpl(data) {
+        if (data === void 0) { data = ''; }
+        var _this = _super.call(this, data) || this;
+        _this._name = '';
+        _this._assignedSlot = null;
+        return _this;
     }
+    Object.defineProperty(TextImpl.prototype, "wholeText", {
+        /** @inheritdoc */
+        get: function () {
+            var e_1, _a;
+            /**
+             * The wholeText attribute’s getter must return the concatenation of the
+             * data of the contiguous Text nodes of the context object, in tree order.
+             */
+            var text = '';
+            try {
+                for (var _b = __values(algorithm_1.text_contiguousTextNodes(this, true)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var node = _c.value;
+                    text = text + node._data;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return text;
+        },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get wholeText() {
-        /**
-         * The wholeText attribute’s getter must return the concatenation of the
-         * data of the contiguous Text nodes of the context object, in tree order.
-         */
-        let text = '';
-        for (const node of (0, algorithm_1.text_contiguousTextNodes)(this, true)) {
-            text = text + node._data;
-        }
-        return text;
-    }
-    /** @inheritdoc */
-    splitText(offset) {
+    TextImpl.prototype.splitText = function (offset) {
         /**
          * The splitText(offset) method, when invoked, must split context object
          * with offset offset.
          */
-        return (0, algorithm_1.text_split)(this, offset);
-    }
-    // MIXIN: Slotable
-    /* istanbul ignore next */
-    get assignedSlot() { throw new Error("Mixin: Slotable not implemented."); }
+        return algorithm_1.text_split(this, offset);
+    };
+    Object.defineProperty(TextImpl.prototype, "assignedSlot", {
+        // MIXIN: Slotable
+        /* istanbul ignore next */
+        get: function () { throw new Error("Mixin: Slotable not implemented."); },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Creates a `Text`.
      *
      * @param document - owner document
      * @param data - the text content
      */
-    static _create(document, data = '') {
-        const node = new TextImpl(data);
+    TextImpl._create = function (document, data) {
+        if (data === void 0) { data = ''; }
+        var node = new TextImpl(data);
         node._nodeDocument = document;
         return node;
-    }
-}
+    };
+    return TextImpl;
+}(CharacterDataImpl_1.CharacterDataImpl));
 exports.TextImpl = TextImpl;
 /**
  * Initialize prototype properties
  */
-(0, WebIDLAlgorithm_1.idl_defineConst)(TextImpl.prototype, "_nodeType", interfaces_1.NodeType.Text);
+WebIDLAlgorithm_1.idl_defineConst(TextImpl.prototype, "_nodeType", interfaces_1.NodeType.Text);
 //# sourceMappingURL=TextImpl.js.map
 
 /***/ }),
@@ -28710,72 +58272,97 @@ exports.TextImpl = TextImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.TraverserImpl = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
+var interfaces_1 = __nccwpck_require__(27305);
 /**
  * Represents an object which can be used to iterate through the nodes
  * of a subtree.
  */
-class TraverserImpl {
-    _activeFlag;
-    _root;
-    _whatToShow;
-    _filter;
+var TraverserImpl = /** @class */ (function () {
     /**
      * Initializes a new instance of `Traverser`.
      *
      * @param root - root node
      */
-    constructor(root) {
+    function TraverserImpl(root) {
         this._activeFlag = false;
         this._root = root;
         this._whatToShow = interfaces_1.WhatToShow.All;
         this._filter = null;
     }
-    /** @inheritdoc */
-    get root() { return this._root; }
-    /** @inheritdoc */
-    get whatToShow() { return this._whatToShow; }
-    /** @inheritdoc */
-    get filter() { return this._filter; }
-}
+    Object.defineProperty(TraverserImpl.prototype, "root", {
+        /** @inheritdoc */
+        get: function () { return this._root; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TraverserImpl.prototype, "whatToShow", {
+        /** @inheritdoc */
+        get: function () { return this._whatToShow; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(TraverserImpl.prototype, "filter", {
+        /** @inheritdoc */
+        get: function () { return this._filter; },
+        enumerable: true,
+        configurable: true
+    });
+    return TraverserImpl;
+}());
 exports.TraverserImpl = TraverserImpl;
 //# sourceMappingURL=TraverserImpl.js.map
 
 /***/ }),
 
 /***/ 89261:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.TreeWalkerImpl = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
-const TraverserImpl_1 = __nccwpck_require__(39782);
-const algorithm_1 = __nccwpck_require__(61);
+var interfaces_1 = __nccwpck_require__(27305);
+var TraverserImpl_1 = __nccwpck_require__(39782);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents the nodes of a subtree and a position within them.
  */
-class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl {
-    _current;
+var TreeWalkerImpl = /** @class */ (function (_super) {
+    __extends(TreeWalkerImpl, _super);
     /**
      * Initializes a new instance of `TreeWalker`.
      */
-    constructor(root, current) {
-        super(root);
-        this._current = current;
+    function TreeWalkerImpl(root, current) {
+        var _this = _super.call(this, root) || this;
+        _this._current = current;
+        return _this;
     }
+    Object.defineProperty(TreeWalkerImpl.prototype, "currentNode", {
+        /** @inheritdoc */
+        get: function () { return this._current; },
+        set: function (value) { this._current = value; },
+        enumerable: true,
+        configurable: true
+    });
     /** @inheritdoc */
-    get currentNode() { return this._current; }
-    set currentNode(value) { this._current = value; }
-    /** @inheritdoc */
-    parentNode() {
+    TreeWalkerImpl.prototype.parentNode = function () {
         /**
          * 1. Let node be the context object’s current.
          * 2. While node is non-null and is not the context object’s root:
          */
-        let node = this._current;
+        var node = this._current;
         while (node !== null && node !== this._root) {
             /**
              * 2.1. Set node to node’s parent.
@@ -28785,7 +58372,7 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl {
              */
             node = node._parent;
             if (node !== null &&
-                (0, algorithm_1.traversal_filter)(this, node) === interfaces_1.FilterResult.Accept) {
+                algorithm_1.traversal_filter(this, node) === interfaces_1.FilterResult.Accept) {
                 this._current = node;
                 return node;
             }
@@ -28794,44 +58381,44 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl {
          * 3. Return null.
          */
         return null;
-    }
+    };
     /** @inheritdoc */
-    firstChild() {
+    TreeWalkerImpl.prototype.firstChild = function () {
         /**
          * The firstChild() method, when invoked, must traverse children with the
          * context object and first.
          */
-        return (0, algorithm_1.treeWalker_traverseChildren)(this, true);
-    }
+        return algorithm_1.treeWalker_traverseChildren(this, true);
+    };
     /** @inheritdoc */
-    lastChild() {
+    TreeWalkerImpl.prototype.lastChild = function () {
         /**
          * The lastChild() method, when invoked, must traverse children with the
          * context object and last.
          */
-        return (0, algorithm_1.treeWalker_traverseChildren)(this, false);
-    }
+        return algorithm_1.treeWalker_traverseChildren(this, false);
+    };
     /** @inheritdoc */
-    nextSibling() {
+    TreeWalkerImpl.prototype.nextSibling = function () {
         /**
          * The nextSibling() method, when invoked, must traverse siblings with the
          * context object and next.
          */
-        return (0, algorithm_1.treeWalker_traverseSiblings)(this, true);
-    }
+        return algorithm_1.treeWalker_traverseSiblings(this, true);
+    };
     /** @inheritdoc */
-    previousNode() {
+    TreeWalkerImpl.prototype.previousNode = function () {
         /**
          * 1. Let node be the context object’s current.
          * 2. While node is not the context object’s root:
          */
-        let node = this._current;
+        var node = this._current;
         while (node !== this._root) {
             /**
              * 2.1. Let sibling be node’s previous sibling.
              * 2.2. While sibling is non-null:
              */
-            let sibling = node._previousSibling;
+            var sibling = node._previousSibling;
             while (sibling) {
                 /**
                  * 2.2.1. Set node to sibling.
@@ -28839,7 +58426,7 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl {
                  * object.
                  */
                 node = sibling;
-                let result = (0, algorithm_1.traversal_filter)(this, node);
+                var result = algorithm_1.traversal_filter(this, node);
                 /**
                  * 2.2.3. While result is not FILTER_REJECT and node has a child:
                  */
@@ -28850,7 +58437,7 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl {
                      * context object.
                      */
                     node = node._lastChild;
-                    result = (0, algorithm_1.traversal_filter)(this, node);
+                    result = algorithm_1.traversal_filter(this, node);
                 }
                 /**
                  * 2.2.4. If result is FILTER_ACCEPT, then set the context object’s
@@ -28881,7 +58468,7 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl {
              * FILTER_ACCEPT, then set the context object’s current to node and
              * return node.
              */
-            if ((0, algorithm_1.traversal_filter)(this, node) === interfaces_1.FilterResult.Accept) {
+            if (algorithm_1.traversal_filter(this, node) === interfaces_1.FilterResult.Accept) {
                 this._current = node;
                 return node;
             }
@@ -28890,24 +58477,24 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl {
          * 3. Return null.
          */
         return null;
-    }
+    };
     /** @inheritdoc */
-    previousSibling() {
+    TreeWalkerImpl.prototype.previousSibling = function () {
         /**
          * The previousSibling() method, when invoked, must traverse siblings with
          * the context object and previous.
          */
-        return (0, algorithm_1.treeWalker_traverseSiblings)(this, false);
-    }
+        return algorithm_1.treeWalker_traverseSiblings(this, false);
+    };
     /** @inheritdoc */
-    nextNode() {
+    TreeWalkerImpl.prototype.nextNode = function () {
         /**
          * 1. Let node be the context object’s current.
          * 2. Let result be FILTER_ACCEPT.
          * 3. While true:
          */
-        let node = this._current;
-        let result = interfaces_1.FilterResult.Accept;
+        var node = this._current;
+        var result = interfaces_1.FilterResult.Accept;
         while (true) {
             /**
              * 3.1. While result is not FILTER_REJECT and node has a child:
@@ -28921,7 +58508,7 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl {
                  * current to node and return node.
                  */
                 node = node._firstChild;
-                result = (0, algorithm_1.traversal_filter)(this, node);
+                result = algorithm_1.traversal_filter(this, node);
                 if (result === interfaces_1.FilterResult.Accept) {
                     this._current = node;
                     return node;
@@ -28932,8 +58519,8 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl {
              * 3.3. Let temporary be node.
              * 3.4. While temporary is non-null:
              */
-            let sibling = null;
-            let temporary = node;
+            var sibling = null;
+            var temporary = node;
             while (temporary !== null) {
                 /**
                  * 3.4.1. If temporary is the context object’s root, then return null.
@@ -28960,90 +58547,126 @@ class TreeWalkerImpl extends TraverserImpl_1.TraverserImpl {
              * 3.6. If result is FILTER_ACCEPT, then set the context object’s current
              * to node and return node.
              */
-            result = (0, algorithm_1.traversal_filter)(this, node);
+            result = algorithm_1.traversal_filter(this, node);
             if (result === interfaces_1.FilterResult.Accept) {
                 this._current = node;
                 return node;
             }
         }
-    }
+    };
     /**
      * Creates a new `TreeWalker`.
      *
      * @param root - iterator's root node
      * @param current - current node
      */
-    static _create(root, current) {
+    TreeWalkerImpl._create = function (root, current) {
         return new TreeWalkerImpl(root, current);
-    }
-}
+    };
+    return TreeWalkerImpl;
+}(TraverserImpl_1.TraverserImpl));
 exports.TreeWalkerImpl = TreeWalkerImpl;
 //# sourceMappingURL=TreeWalkerImpl.js.map
 
 /***/ }),
 
 /***/ 69067:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.WindowImpl = void 0;
-const EventTargetImpl_1 = __nccwpck_require__(69968);
-const util_1 = __nccwpck_require__(76195);
-const algorithm_1 = __nccwpck_require__(61);
+var EventTargetImpl_1 = __nccwpck_require__(69968);
+var util_1 = __nccwpck_require__(76195);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents a window containing a DOM document.
  */
-class WindowImpl extends EventTargetImpl_1.EventTargetImpl {
-    _currentEvent;
-    _signalSlots = new Set();
-    _mutationObserverMicrotaskQueued = false;
-    _mutationObservers = new Set();
-    _associatedDocument;
-    _iteratorList = new util_1.FixedSizeSet();
+var WindowImpl = /** @class */ (function (_super) {
+    __extends(WindowImpl, _super);
     /**
      * Initializes a new instance of `Window`.
      */
-    constructor() {
-        super();
-        this._associatedDocument = (0, algorithm_1.create_document)();
+    function WindowImpl() {
+        var _this = _super.call(this) || this;
+        _this._signalSlots = new Set();
+        _this._mutationObserverMicrotaskQueued = false;
+        _this._mutationObservers = new Set();
+        _this._iteratorList = new util_1.FixedSizeSet();
+        _this._associatedDocument = algorithm_1.create_document();
+        return _this;
     }
-    /** @inheritdoc */
-    get document() { return this._associatedDocument; }
-    /** @inheritdoc */
-    get event() { return this._currentEvent; }
+    Object.defineProperty(WindowImpl.prototype, "document", {
+        /** @inheritdoc */
+        get: function () { return this._associatedDocument; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(WindowImpl.prototype, "event", {
+        /** @inheritdoc */
+        get: function () { return this._currentEvent; },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Creates a new window with a blank document.
      */
-    static _create() {
+    WindowImpl._create = function () {
         return new WindowImpl();
-    }
-}
+    };
+    return WindowImpl;
+}(EventTargetImpl_1.EventTargetImpl));
 exports.WindowImpl = WindowImpl;
 //# sourceMappingURL=WindowImpl.js.map
 
 /***/ }),
 
 /***/ 21685:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLDocumentImpl = void 0;
-const DocumentImpl_1 = __nccwpck_require__(14333);
+var DocumentImpl_1 = __nccwpck_require__(14333);
 /**
  * Represents an XML document.
  */
-class XMLDocumentImpl extends DocumentImpl_1.DocumentImpl {
+var XMLDocumentImpl = /** @class */ (function (_super) {
+    __extends(XMLDocumentImpl, _super);
     /**
      * Initializes a new instance of `XMLDocument`.
      */
-    constructor() {
-        super();
+    function XMLDocumentImpl() {
+        return _super.call(this) || this;
     }
-}
+    return XMLDocumentImpl;
+}(DocumentImpl_1.DocumentImpl));
 exports.XMLDocumentImpl = XMLDocumentImpl;
 //# sourceMappingURL=XMLDocumentImpl.js.map
 
@@ -29055,106 +58678,105 @@ exports.XMLDocumentImpl = XMLDocumentImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLDocument = exports.Window = exports.TreeWalker = exports.Traverser = exports.Text = exports.StaticRange = exports.ShadowRoot = exports.Range = exports.ProcessingInstruction = exports.NodeListStatic = exports.NodeList = exports.NodeIterator = exports.Node = exports.NodeFilter = exports.NamedNodeMap = exports.MutationRecord = exports.MutationObserver = exports.HTMLCollection = exports.EventTarget = exports.Event = exports.Element = exports.DOMTokenList = exports.DOMImplementation = exports.dom = exports.DocumentType = exports.Document = exports.DocumentFragment = exports.CustomEvent = exports.Comment = exports.CharacterData = exports.CDATASection = exports.Attr = exports.AbstractRange = exports.AbortSignal = exports.AbortController = void 0;
-const util_1 = __nccwpck_require__(76195);
+var util_1 = __nccwpck_require__(76195);
 // Import implementation classes
-const AbortControllerImpl_1 = __nccwpck_require__(66461);
-Object.defineProperty(exports, "AbortController", ({ enumerable: true, get: function () { return AbortControllerImpl_1.AbortControllerImpl; } }));
-const AbortSignalImpl_1 = __nccwpck_require__(10022);
-Object.defineProperty(exports, "AbortSignal", ({ enumerable: true, get: function () { return AbortSignalImpl_1.AbortSignalImpl; } }));
-const AbstractRangeImpl_1 = __nccwpck_require__(57126);
-Object.defineProperty(exports, "AbstractRange", ({ enumerable: true, get: function () { return AbstractRangeImpl_1.AbstractRangeImpl; } }));
-const AttrImpl_1 = __nccwpck_require__(13717);
-Object.defineProperty(exports, "Attr", ({ enumerable: true, get: function () { return AttrImpl_1.AttrImpl; } }));
-const CDATASectionImpl_1 = __nccwpck_require__(23977);
-Object.defineProperty(exports, "CDATASection", ({ enumerable: true, get: function () { return CDATASectionImpl_1.CDATASectionImpl; } }));
-const CharacterDataImpl_1 = __nccwpck_require__(65330);
-Object.defineProperty(exports, "CharacterData", ({ enumerable: true, get: function () { return CharacterDataImpl_1.CharacterDataImpl; } }));
-const ChildNodeImpl_1 = __nccwpck_require__(88264);
-const CommentImpl_1 = __nccwpck_require__(20930);
-Object.defineProperty(exports, "Comment", ({ enumerable: true, get: function () { return CommentImpl_1.CommentImpl; } }));
-const CustomEventImpl_1 = __nccwpck_require__(59857);
-Object.defineProperty(exports, "CustomEvent", ({ enumerable: true, get: function () { return CustomEventImpl_1.CustomEventImpl; } }));
-const DocumentFragmentImpl_1 = __nccwpck_require__(12585);
-Object.defineProperty(exports, "DocumentFragment", ({ enumerable: true, get: function () { return DocumentFragmentImpl_1.DocumentFragmentImpl; } }));
-const DocumentImpl_1 = __nccwpck_require__(14333);
-Object.defineProperty(exports, "Document", ({ enumerable: true, get: function () { return DocumentImpl_1.DocumentImpl; } }));
-const DocumentOrShadowRootImpl_1 = __nccwpck_require__(65274);
-const DocumentTypeImpl_1 = __nccwpck_require__(3173);
-Object.defineProperty(exports, "DocumentType", ({ enumerable: true, get: function () { return DocumentTypeImpl_1.DocumentTypeImpl; } }));
-const DOMImpl_1 = __nccwpck_require__(14177);
-Object.defineProperty(exports, "dom", ({ enumerable: true, get: function () { return DOMImpl_1.dom; } }));
-const DOMImplementationImpl_1 = __nccwpck_require__(42197);
-Object.defineProperty(exports, "DOMImplementation", ({ enumerable: true, get: function () { return DOMImplementationImpl_1.DOMImplementationImpl; } }));
-const DOMTokenListImpl_1 = __nccwpck_require__(65096);
-Object.defineProperty(exports, "DOMTokenList", ({ enumerable: true, get: function () { return DOMTokenListImpl_1.DOMTokenListImpl; } }));
-const ElementImpl_1 = __nccwpck_require__(35975);
-Object.defineProperty(exports, "Element", ({ enumerable: true, get: function () { return ElementImpl_1.ElementImpl; } }));
-const EventImpl_1 = __nccwpck_require__(38245);
-Object.defineProperty(exports, "Event", ({ enumerable: true, get: function () { return EventImpl_1.EventImpl; } }));
-const EventTargetImpl_1 = __nccwpck_require__(69968);
-Object.defineProperty(exports, "EventTarget", ({ enumerable: true, get: function () { return EventTargetImpl_1.EventTargetImpl; } }));
-const HTMLCollectionImpl_1 = __nccwpck_require__(93969);
-Object.defineProperty(exports, "HTMLCollection", ({ enumerable: true, get: function () { return HTMLCollectionImpl_1.HTMLCollectionImpl; } }));
-const MutationObserverImpl_1 = __nccwpck_require__(89616);
-Object.defineProperty(exports, "MutationObserver", ({ enumerable: true, get: function () { return MutationObserverImpl_1.MutationObserverImpl; } }));
-const MutationRecordImpl_1 = __nccwpck_require__(6219);
-Object.defineProperty(exports, "MutationRecord", ({ enumerable: true, get: function () { return MutationRecordImpl_1.MutationRecordImpl; } }));
-const NamedNodeMapImpl_1 = __nccwpck_require__(57206);
-Object.defineProperty(exports, "NamedNodeMap", ({ enumerable: true, get: function () { return NamedNodeMapImpl_1.NamedNodeMapImpl; } }));
-const NodeFilterImpl_1 = __nccwpck_require__(12355);
-Object.defineProperty(exports, "NodeFilter", ({ enumerable: true, get: function () { return NodeFilterImpl_1.NodeFilterImpl; } }));
-const NodeImpl_1 = __nccwpck_require__(91745);
-Object.defineProperty(exports, "Node", ({ enumerable: true, get: function () { return NodeImpl_1.NodeImpl; } }));
-const NodeIteratorImpl_1 = __nccwpck_require__(61997);
-Object.defineProperty(exports, "NodeIterator", ({ enumerable: true, get: function () { return NodeIteratorImpl_1.NodeIteratorImpl; } }));
-const NodeListImpl_1 = __nccwpck_require__(43728);
-Object.defineProperty(exports, "NodeList", ({ enumerable: true, get: function () { return NodeListImpl_1.NodeListImpl; } }));
-const NodeListStaticImpl_1 = __nccwpck_require__(65306);
-Object.defineProperty(exports, "NodeListStatic", ({ enumerable: true, get: function () { return NodeListStaticImpl_1.NodeListStaticImpl; } }));
-const NonDocumentTypeChildNodeImpl_1 = __nccwpck_require__(71032);
-const NonElementParentNodeImpl_1 = __nccwpck_require__(90733);
-const ParentNodeImpl_1 = __nccwpck_require__(85988);
-const ProcessingInstructionImpl_1 = __nccwpck_require__(99430);
-Object.defineProperty(exports, "ProcessingInstruction", ({ enumerable: true, get: function () { return ProcessingInstructionImpl_1.ProcessingInstructionImpl; } }));
-const RangeImpl_1 = __nccwpck_require__(50166);
-Object.defineProperty(exports, "Range", ({ enumerable: true, get: function () { return RangeImpl_1.RangeImpl; } }));
-const ShadowRootImpl_1 = __nccwpck_require__(61911);
-Object.defineProperty(exports, "ShadowRoot", ({ enumerable: true, get: function () { return ShadowRootImpl_1.ShadowRootImpl; } }));
-const SlotableImpl_1 = __nccwpck_require__(21964);
-const StaticRangeImpl_1 = __nccwpck_require__(86357);
-Object.defineProperty(exports, "StaticRange", ({ enumerable: true, get: function () { return StaticRangeImpl_1.StaticRangeImpl; } }));
-const TextImpl_1 = __nccwpck_require__(42191);
-Object.defineProperty(exports, "Text", ({ enumerable: true, get: function () { return TextImpl_1.TextImpl; } }));
-const TraverserImpl_1 = __nccwpck_require__(39782);
-Object.defineProperty(exports, "Traverser", ({ enumerable: true, get: function () { return TraverserImpl_1.TraverserImpl; } }));
-const TreeWalkerImpl_1 = __nccwpck_require__(89261);
-Object.defineProperty(exports, "TreeWalker", ({ enumerable: true, get: function () { return TreeWalkerImpl_1.TreeWalkerImpl; } }));
-const WindowImpl_1 = __nccwpck_require__(69067);
-Object.defineProperty(exports, "Window", ({ enumerable: true, get: function () { return WindowImpl_1.WindowImpl; } }));
-const XMLDocumentImpl_1 = __nccwpck_require__(21685);
-Object.defineProperty(exports, "XMLDocument", ({ enumerable: true, get: function () { return XMLDocumentImpl_1.XMLDocumentImpl; } }));
+var AbortControllerImpl_1 = __nccwpck_require__(66461);
+exports.AbortController = AbortControllerImpl_1.AbortControllerImpl;
+var AbortSignalImpl_1 = __nccwpck_require__(10022);
+exports.AbortSignal = AbortSignalImpl_1.AbortSignalImpl;
+var AbstractRangeImpl_1 = __nccwpck_require__(57126);
+exports.AbstractRange = AbstractRangeImpl_1.AbstractRangeImpl;
+var AttrImpl_1 = __nccwpck_require__(13717);
+exports.Attr = AttrImpl_1.AttrImpl;
+var CDATASectionImpl_1 = __nccwpck_require__(23977);
+exports.CDATASection = CDATASectionImpl_1.CDATASectionImpl;
+var CharacterDataImpl_1 = __nccwpck_require__(65330);
+exports.CharacterData = CharacterDataImpl_1.CharacterDataImpl;
+var ChildNodeImpl_1 = __nccwpck_require__(88264);
+var CommentImpl_1 = __nccwpck_require__(20930);
+exports.Comment = CommentImpl_1.CommentImpl;
+var CustomEventImpl_1 = __nccwpck_require__(59857);
+exports.CustomEvent = CustomEventImpl_1.CustomEventImpl;
+var DocumentFragmentImpl_1 = __nccwpck_require__(12585);
+exports.DocumentFragment = DocumentFragmentImpl_1.DocumentFragmentImpl;
+var DocumentImpl_1 = __nccwpck_require__(14333);
+exports.Document = DocumentImpl_1.DocumentImpl;
+var DocumentOrShadowRootImpl_1 = __nccwpck_require__(65274);
+var DocumentTypeImpl_1 = __nccwpck_require__(3173);
+exports.DocumentType = DocumentTypeImpl_1.DocumentTypeImpl;
+var DOMImpl_1 = __nccwpck_require__(14177);
+exports.dom = DOMImpl_1.dom;
+var DOMImplementationImpl_1 = __nccwpck_require__(42197);
+exports.DOMImplementation = DOMImplementationImpl_1.DOMImplementationImpl;
+var DOMTokenListImpl_1 = __nccwpck_require__(65096);
+exports.DOMTokenList = DOMTokenListImpl_1.DOMTokenListImpl;
+var ElementImpl_1 = __nccwpck_require__(35975);
+exports.Element = ElementImpl_1.ElementImpl;
+var EventImpl_1 = __nccwpck_require__(38245);
+exports.Event = EventImpl_1.EventImpl;
+var EventTargetImpl_1 = __nccwpck_require__(69968);
+exports.EventTarget = EventTargetImpl_1.EventTargetImpl;
+var HTMLCollectionImpl_1 = __nccwpck_require__(93969);
+exports.HTMLCollection = HTMLCollectionImpl_1.HTMLCollectionImpl;
+var MutationObserverImpl_1 = __nccwpck_require__(89616);
+exports.MutationObserver = MutationObserverImpl_1.MutationObserverImpl;
+var MutationRecordImpl_1 = __nccwpck_require__(6219);
+exports.MutationRecord = MutationRecordImpl_1.MutationRecordImpl;
+var NamedNodeMapImpl_1 = __nccwpck_require__(57206);
+exports.NamedNodeMap = NamedNodeMapImpl_1.NamedNodeMapImpl;
+var NodeFilterImpl_1 = __nccwpck_require__(12355);
+exports.NodeFilter = NodeFilterImpl_1.NodeFilterImpl;
+var NodeImpl_1 = __nccwpck_require__(91745);
+exports.Node = NodeImpl_1.NodeImpl;
+var NodeIteratorImpl_1 = __nccwpck_require__(61997);
+exports.NodeIterator = NodeIteratorImpl_1.NodeIteratorImpl;
+var NodeListImpl_1 = __nccwpck_require__(43728);
+exports.NodeList = NodeListImpl_1.NodeListImpl;
+var NodeListStaticImpl_1 = __nccwpck_require__(65306);
+exports.NodeListStatic = NodeListStaticImpl_1.NodeListStaticImpl;
+var NonDocumentTypeChildNodeImpl_1 = __nccwpck_require__(71032);
+var NonElementParentNodeImpl_1 = __nccwpck_require__(90733);
+var ParentNodeImpl_1 = __nccwpck_require__(85988);
+var ProcessingInstructionImpl_1 = __nccwpck_require__(99430);
+exports.ProcessingInstruction = ProcessingInstructionImpl_1.ProcessingInstructionImpl;
+var RangeImpl_1 = __nccwpck_require__(50166);
+exports.Range = RangeImpl_1.RangeImpl;
+var ShadowRootImpl_1 = __nccwpck_require__(61911);
+exports.ShadowRoot = ShadowRootImpl_1.ShadowRootImpl;
+var SlotableImpl_1 = __nccwpck_require__(21964);
+var StaticRangeImpl_1 = __nccwpck_require__(86357);
+exports.StaticRange = StaticRangeImpl_1.StaticRangeImpl;
+var TextImpl_1 = __nccwpck_require__(42191);
+exports.Text = TextImpl_1.TextImpl;
+var TraverserImpl_1 = __nccwpck_require__(39782);
+exports.Traverser = TraverserImpl_1.TraverserImpl;
+var TreeWalkerImpl_1 = __nccwpck_require__(89261);
+exports.TreeWalker = TreeWalkerImpl_1.TreeWalkerImpl;
+var WindowImpl_1 = __nccwpck_require__(69067);
+exports.Window = WindowImpl_1.WindowImpl;
+var XMLDocumentImpl_1 = __nccwpck_require__(21685);
+exports.XMLDocument = XMLDocumentImpl_1.XMLDocumentImpl;
 // Apply mixins
 // ChildNode
-(0, util_1.applyMixin)(ElementImpl_1.ElementImpl, ChildNodeImpl_1.ChildNodeImpl);
-(0, util_1.applyMixin)(CharacterDataImpl_1.CharacterDataImpl, ChildNodeImpl_1.ChildNodeImpl);
-(0, util_1.applyMixin)(DocumentTypeImpl_1.DocumentTypeImpl, ChildNodeImpl_1.ChildNodeImpl);
+util_1.applyMixin(ElementImpl_1.ElementImpl, ChildNodeImpl_1.ChildNodeImpl);
+util_1.applyMixin(CharacterDataImpl_1.CharacterDataImpl, ChildNodeImpl_1.ChildNodeImpl);
+util_1.applyMixin(DocumentTypeImpl_1.DocumentTypeImpl, ChildNodeImpl_1.ChildNodeImpl);
 // DocumentOrShadowRoot
-(0, util_1.applyMixin)(DocumentImpl_1.DocumentImpl, DocumentOrShadowRootImpl_1.DocumentOrShadowRootImpl);
-(0, util_1.applyMixin)(ShadowRootImpl_1.ShadowRootImpl, DocumentOrShadowRootImpl_1.DocumentOrShadowRootImpl);
+util_1.applyMixin(DocumentImpl_1.DocumentImpl, DocumentOrShadowRootImpl_1.DocumentOrShadowRootImpl);
+util_1.applyMixin(ShadowRootImpl_1.ShadowRootImpl, DocumentOrShadowRootImpl_1.DocumentOrShadowRootImpl);
 // NonDocumentTypeChildNode
-(0, util_1.applyMixin)(ElementImpl_1.ElementImpl, NonDocumentTypeChildNodeImpl_1.NonDocumentTypeChildNodeImpl);
-(0, util_1.applyMixin)(CharacterDataImpl_1.CharacterDataImpl, NonDocumentTypeChildNodeImpl_1.NonDocumentTypeChildNodeImpl);
+util_1.applyMixin(ElementImpl_1.ElementImpl, NonDocumentTypeChildNodeImpl_1.NonDocumentTypeChildNodeImpl);
+util_1.applyMixin(CharacterDataImpl_1.CharacterDataImpl, NonDocumentTypeChildNodeImpl_1.NonDocumentTypeChildNodeImpl);
 // NonElementParentNode
-(0, util_1.applyMixin)(DocumentImpl_1.DocumentImpl, NonElementParentNodeImpl_1.NonElementParentNodeImpl);
-(0, util_1.applyMixin)(DocumentFragmentImpl_1.DocumentFragmentImpl, NonElementParentNodeImpl_1.NonElementParentNodeImpl);
+util_1.applyMixin(DocumentImpl_1.DocumentImpl, NonElementParentNodeImpl_1.NonElementParentNodeImpl);
+util_1.applyMixin(DocumentFragmentImpl_1.DocumentFragmentImpl, NonElementParentNodeImpl_1.NonElementParentNodeImpl);
 // ParentNode
-(0, util_1.applyMixin)(DocumentImpl_1.DocumentImpl, ParentNodeImpl_1.ParentNodeImpl);
-(0, util_1.applyMixin)(DocumentFragmentImpl_1.DocumentFragmentImpl, ParentNodeImpl_1.ParentNodeImpl);
-(0, util_1.applyMixin)(ElementImpl_1.ElementImpl, ParentNodeImpl_1.ParentNodeImpl);
+util_1.applyMixin(DocumentImpl_1.DocumentImpl, ParentNodeImpl_1.ParentNodeImpl);
+util_1.applyMixin(DocumentFragmentImpl_1.DocumentFragmentImpl, ParentNodeImpl_1.ParentNodeImpl);
+util_1.applyMixin(ElementImpl_1.ElementImpl, ParentNodeImpl_1.ParentNodeImpl);
 // Slotable
-(0, util_1.applyMixin)(TextImpl_1.TextImpl, SlotableImpl_1.SlotableImpl);
-(0, util_1.applyMixin)(ElementImpl_1.ElementImpl, SlotableImpl_1.SlotableImpl);
+util_1.applyMixin(TextImpl_1.TextImpl, SlotableImpl_1.SlotableImpl);
+util_1.applyMixin(ElementImpl_1.ElementImpl, SlotableImpl_1.SlotableImpl);
 //# sourceMappingURL=index.js.map
 
 /***/ }),
@@ -29165,7 +58787,6 @@ Object.defineProperty(exports, "XMLDocument", ({ enumerable: true, get: function
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.HowToCompare = exports.WhatToShow = exports.FilterResult = exports.Position = exports.NodeType = exports.EventPhase = exports.BoundaryPosition = void 0;
 /**
  * Defines the position of a boundary point relative to another.
  */
@@ -29174,7 +58795,7 @@ var BoundaryPosition;
     BoundaryPosition[BoundaryPosition["Before"] = 0] = "Before";
     BoundaryPosition[BoundaryPosition["Equal"] = 1] = "Equal";
     BoundaryPosition[BoundaryPosition["After"] = 2] = "After";
-})(BoundaryPosition || (exports.BoundaryPosition = BoundaryPosition = {}));
+})(BoundaryPosition = exports.BoundaryPosition || (exports.BoundaryPosition = {}));
 /**
  * Defines the event phase.
  */
@@ -29184,7 +58805,7 @@ var EventPhase;
     EventPhase[EventPhase["Capturing"] = 1] = "Capturing";
     EventPhase[EventPhase["AtTarget"] = 2] = "AtTarget";
     EventPhase[EventPhase["Bubbling"] = 3] = "Bubbling";
-})(EventPhase || (exports.EventPhase = EventPhase = {}));
+})(EventPhase = exports.EventPhase || (exports.EventPhase = {}));
 /**
  * Defines the type of a node object.
  */
@@ -29202,21 +58823,20 @@ var NodeType;
     NodeType[NodeType["DocumentType"] = 10] = "DocumentType";
     NodeType[NodeType["DocumentFragment"] = 11] = "DocumentFragment";
     NodeType[NodeType["Notation"] = 12] = "Notation"; // historical
-})(NodeType || (exports.NodeType = NodeType = {}));
+})(NodeType = exports.NodeType || (exports.NodeType = {}));
 /**
  * Defines the position of a node in the document relative to another
  * node.
  */
 var Position;
 (function (Position) {
-    Position[Position["SameNode"] = 0] = "SameNode";
     Position[Position["Disconnected"] = 1] = "Disconnected";
     Position[Position["Preceding"] = 2] = "Preceding";
     Position[Position["Following"] = 4] = "Following";
     Position[Position["Contains"] = 8] = "Contains";
     Position[Position["ContainedBy"] = 16] = "ContainedBy";
     Position[Position["ImplementationSpecific"] = 32] = "ImplementationSpecific";
-})(Position || (exports.Position = Position = {}));
+})(Position = exports.Position || (exports.Position = {}));
 /**
  * Defines the return value of a filter callback.
  */
@@ -29225,7 +58845,7 @@ var FilterResult;
     FilterResult[FilterResult["Accept"] = 1] = "Accept";
     FilterResult[FilterResult["Reject"] = 2] = "Reject";
     FilterResult[FilterResult["Skip"] = 3] = "Skip";
-})(FilterResult || (exports.FilterResult = FilterResult = {}));
+})(FilterResult = exports.FilterResult || (exports.FilterResult = {}));
 /**
  * Defines what to show in node filter.
  */
@@ -29244,7 +58864,7 @@ var WhatToShow;
     WhatToShow[WhatToShow["DocumentType"] = 512] = "DocumentType";
     WhatToShow[WhatToShow["DocumentFragment"] = 1024] = "DocumentFragment";
     WhatToShow[WhatToShow["Notation"] = 2048] = "Notation";
-})(WhatToShow || (exports.WhatToShow = WhatToShow = {}));
+})(WhatToShow = exports.WhatToShow || (exports.WhatToShow = {}));
 /**
  * Defines how boundary points are compared.
  */
@@ -29254,7 +58874,7 @@ var HowToCompare;
     HowToCompare[HowToCompare["StartToEnd"] = 1] = "StartToEnd";
     HowToCompare[HowToCompare["EndToEnd"] = 2] = "EndToEnd";
     HowToCompare[HowToCompare["EndToStart"] = 3] = "EndToStart";
-})(HowToCompare || (exports.HowToCompare = HowToCompare = {}));
+})(HowToCompare = exports.HowToCompare || (exports.HowToCompare = {}));
 //# sourceMappingURL=interfaces.js.map
 
 /***/ }),
@@ -29265,15 +58885,14 @@ var HowToCompare;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLSerializer = exports.DOMParser = exports.DOMImplementation = void 0;
-const dom_1 = __nccwpck_require__(50633);
+var dom_1 = __nccwpck_require__(50633);
 dom_1.dom.setFeatures(true);
 var dom_2 = __nccwpck_require__(50633);
-Object.defineProperty(exports, "DOMImplementation", ({ enumerable: true, get: function () { return dom_2.DOMImplementation; } }));
+exports.DOMImplementation = dom_2.DOMImplementation;
 var parser_1 = __nccwpck_require__(36216);
-Object.defineProperty(exports, "DOMParser", ({ enumerable: true, get: function () { return parser_1.DOMParser; } }));
+exports.DOMParser = parser_1.DOMParser;
 var serializer_1 = __nccwpck_require__(87119);
-Object.defineProperty(exports, "XMLSerializer", ({ enumerable: true, get: function () { return serializer_1.XMLSerializer; } }));
+exports.XMLSerializer = serializer_1.XMLSerializer;
 //# sourceMappingURL=index.js.map
 
 /***/ }),
@@ -29284,200 +58903,251 @@ Object.defineProperty(exports, "XMLSerializer", ({ enumerable: true, get: functi
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DOMParserImpl = void 0;
-const algorithm_1 = __nccwpck_require__(61);
-const XMLParserImpl_1 = __nccwpck_require__(64126);
+var algorithm_1 = __nccwpck_require__(61);
+var XMLParserImpl_1 = __nccwpck_require__(64126);
 /**
  * Represents a parser for XML and HTML content.
  *
  * See: https://w3c.github.io/DOM-Parsing/#the-domparser-interface
  */
-class DOMParserImpl {
+var DOMParserImpl = /** @class */ (function () {
+    function DOMParserImpl() {
+    }
     /** @inheritdoc */
-    parseFromString(source, mimeType) {
+    DOMParserImpl.prototype.parseFromString = function (source, mimeType) {
         if (mimeType === "text/html")
             throw new Error('HTML parser not implemented.');
         try {
-            const parser = new XMLParserImpl_1.XMLParserImpl();
-            const doc = parser.parse(source);
+            var parser = new XMLParserImpl_1.XMLParserImpl();
+            var doc = parser.parse(source);
             doc._contentType = mimeType;
             return doc;
         }
         catch (e) {
-            const errorNS = "http://www.mozilla.org/newlayout/xml/parsererror.xml";
-            const doc = (0, algorithm_1.create_xmlDocument)();
-            const root = doc.createElementNS(errorNS, "parsererror");
-            const ele = doc.createElementNS(errorNS, "error");
+            var errorNS = "http://www.mozilla.org/newlayout/xml/parsererror.xml";
+            var doc = algorithm_1.create_xmlDocument();
+            var root = doc.createElementNS(errorNS, "parsererror");
+            var ele = doc.createElementNS(errorNS, "error");
             ele.setAttribute("message", e.message);
             root.appendChild(ele);
             doc.appendChild(root);
             return doc;
         }
-    }
-}
+    };
+    return DOMParserImpl;
+}());
 exports.DOMParserImpl = DOMParserImpl;
 //# sourceMappingURL=DOMParserImpl.js.map
 
 /***/ }),
 
 /***/ 64126:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLParserImpl = void 0;
-const XMLStringLexer_1 = __nccwpck_require__(47061);
-const interfaces_1 = __nccwpck_require__(97707);
-const infra_1 = __nccwpck_require__(84251);
-const algorithm_1 = __nccwpck_require__(61);
-const LocalNameSet_1 = __nccwpck_require__(19049);
+var XMLStringLexer_1 = __nccwpck_require__(47061);
+var interfaces_1 = __nccwpck_require__(97707);
+var infra_1 = __nccwpck_require__(84251);
+var algorithm_1 = __nccwpck_require__(61);
+var LocalNameSet_1 = __nccwpck_require__(19049);
 /**
  * Represents a parser for XML content.
  *
  * See: https://html.spec.whatwg.org/#xml-parser
  */
-class XMLParserImpl {
+var XMLParserImpl = /** @class */ (function () {
+    function XMLParserImpl() {
+    }
     /**
      * Parses XML content.
      *
      * @param source - a string containing XML content
      */
-    parse(source) {
-        const lexer = new XMLStringLexer_1.XMLStringLexer(source, { skipWhitespaceOnlyText: true });
-        const doc = (0, algorithm_1.create_document)();
-        let context = doc;
-        let token = lexer.nextToken();
+    XMLParserImpl.prototype.parse = function (source) {
+        var e_1, _a, e_2, _b;
+        var lexer = new XMLStringLexer_1.XMLStringLexer(source, { skipWhitespaceOnlyText: true });
+        var doc = algorithm_1.create_document();
+        var context = doc;
+        var token = lexer.nextToken();
         while (token.type !== interfaces_1.TokenType.EOF) {
             switch (token.type) {
                 case interfaces_1.TokenType.Declaration:
-                    const declaration = token;
+                    var declaration = token;
                     if (declaration.version !== "1.0") {
                         throw new Error("Invalid xml version: " + declaration.version);
                     }
                     break;
                 case interfaces_1.TokenType.DocType:
-                    const doctype = token;
-                    if (!(0, algorithm_1.xml_isPubidChar)(doctype.pubId)) {
+                    var doctype = token;
+                    if (!algorithm_1.xml_isPubidChar(doctype.pubId)) {
                         throw new Error("DocType public identifier does not match PubidChar construct.");
                     }
-                    if (!(0, algorithm_1.xml_isLegalChar)(doctype.sysId) ||
+                    if (!algorithm_1.xml_isLegalChar(doctype.sysId) ||
                         (doctype.sysId.indexOf('"') !== -1 && doctype.sysId.indexOf("'") !== -1)) {
                         throw new Error("DocType system identifier contains invalid characters.");
                     }
                     context.appendChild(doc.implementation.createDocumentType(doctype.name, doctype.pubId, doctype.sysId));
                     break;
                 case interfaces_1.TokenType.CDATA:
-                    const cdata = token;
-                    if (!(0, algorithm_1.xml_isLegalChar)(cdata.data) ||
+                    var cdata = token;
+                    if (!algorithm_1.xml_isLegalChar(cdata.data) ||
                         cdata.data.indexOf("]]>") !== -1) {
                         throw new Error("CDATA contains invalid characters.");
                     }
                     context.appendChild(doc.createCDATASection(cdata.data));
                     break;
                 case interfaces_1.TokenType.Comment:
-                    const comment = token;
-                    if (!(0, algorithm_1.xml_isLegalChar)(comment.data) ||
+                    var comment = token;
+                    if (!algorithm_1.xml_isLegalChar(comment.data) ||
                         comment.data.indexOf("--") !== -1 || comment.data.endsWith("-")) {
                         throw new Error("Comment data contains invalid characters.");
                     }
                     context.appendChild(doc.createComment(comment.data));
                     break;
                 case interfaces_1.TokenType.PI:
-                    const pi = token;
+                    var pi = token;
                     if (pi.target.indexOf(":") !== -1 || (/^xml$/i).test(pi.target)) {
                         throw new Error("Processing instruction target contains invalid characters.");
                     }
-                    if (!(0, algorithm_1.xml_isLegalChar)(pi.data) || pi.data.indexOf("?>") !== -1) {
+                    if (!algorithm_1.xml_isLegalChar(pi.data) || pi.data.indexOf("?>") !== -1) {
                         throw new Error("Processing instruction data contains invalid characters.");
                     }
                     context.appendChild(doc.createProcessingInstruction(pi.target, pi.data));
                     break;
                 case interfaces_1.TokenType.Text:
-                    const text = token;
-                    if (!(0, algorithm_1.xml_isLegalChar)(text.data)) {
+                    var text = token;
+                    if (!algorithm_1.xml_isLegalChar(text.data)) {
                         throw new Error("Text data contains invalid characters.");
                     }
-                    context.appendChild(doc.createTextNode(this._decodeText(text.data)));
+                    context.appendChild(doc.createTextNode(text.data));
                     break;
                 case interfaces_1.TokenType.Element:
-                    const element = token;
+                    var element = token;
                     // inherit namespace from parent
-                    const [prefix, localName] = (0, algorithm_1.namespace_extractQName)(element.name);
-                    if (localName.indexOf(":") !== -1 || !(0, algorithm_1.xml_isName)(localName)) {
+                    var _c = __read(algorithm_1.namespace_extractQName(element.name), 2), prefix = _c[0], localName = _c[1];
+                    if (localName.indexOf(":") !== -1 || !algorithm_1.xml_isName(localName)) {
                         throw new Error("Node local name contains invalid characters.");
                     }
                     if (prefix === "xmlns") {
                         throw new Error("An element cannot have the 'xmlns' prefix.");
                     }
-                    let namespace = context.lookupNamespaceURI(prefix);
+                    var namespace = context.lookupNamespaceURI(prefix);
                     // override namespace if there is a namespace declaration
                     // attribute
                     // also lookup namespace declaration attributes
-                    const nsDeclarations = {};
-                    for (const [attName, attValue] of element.attributes) {
-                        if (attName === "xmlns") {
-                            namespace = attValue;
-                        }
-                        else {
-                            const [attPrefix, attLocalName] = (0, algorithm_1.namespace_extractQName)(attName);
-                            if (attPrefix === "xmlns") {
-                                if (attLocalName === prefix) {
-                                    namespace = attValue;
+                    var nsDeclarations = {};
+                    try {
+                        for (var _d = (e_1 = void 0, __values(element.attributes)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                            var _f = __read(_e.value, 2), attName = _f[0], attValue = _f[1];
+                            if (attName === "xmlns") {
+                                namespace = attValue;
+                            }
+                            else {
+                                var _g = __read(algorithm_1.namespace_extractQName(attName), 2), attPrefix = _g[0], attLocalName = _g[1];
+                                if (attPrefix === "xmlns") {
+                                    if (attLocalName === prefix) {
+                                        namespace = attValue;
+                                    }
+                                    nsDeclarations[attLocalName] = attValue;
                                 }
-                                nsDeclarations[attLocalName] = attValue;
                             }
                         }
                     }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
                     // create the DOM element node
-                    const elementNode = (namespace !== null ?
+                    var elementNode = (namespace !== null ?
                         doc.createElementNS(namespace, element.name) :
                         doc.createElement(element.name));
                     context.appendChild(elementNode);
                     // assign attributes
-                    const localNameSet = new LocalNameSet_1.LocalNameSet();
-                    for (const [attName, attValue] of element.attributes) {
-                        const [attPrefix, attLocalName] = (0, algorithm_1.namespace_extractQName)(attName);
-                        let attNamespace = null;
-                        if (attPrefix === "xmlns" || (attPrefix === null && attLocalName === "xmlns")) {
-                            // namespace declaration attribute
-                            attNamespace = infra_1.namespace.XMLNS;
-                        }
-                        else {
-                            attNamespace = elementNode.lookupNamespaceURI(attPrefix);
-                            if (attNamespace !== null && elementNode.isDefaultNamespace(attNamespace)) {
-                                attNamespace = null;
+                    var localNameSet = new LocalNameSet_1.LocalNameSet();
+                    try {
+                        for (var _h = (e_2 = void 0, __values(element.attributes)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                            var _k = __read(_j.value, 2), attName = _k[0], attValue = _k[1];
+                            var _l = __read(algorithm_1.namespace_extractQName(attName), 2), attPrefix = _l[0], attLocalName = _l[1];
+                            var attNamespace = null;
+                            if (attPrefix === "xmlns" || (attPrefix === null && attLocalName === "xmlns")) {
+                                // namespace declaration attribute
+                                attNamespace = infra_1.namespace.XMLNS;
                             }
-                            else if (attNamespace === null && attPrefix !== null) {
-                                attNamespace = nsDeclarations[attPrefix] || null;
+                            else {
+                                attNamespace = elementNode.lookupNamespaceURI(attPrefix);
+                                if (attNamespace !== null && elementNode.isDefaultNamespace(attNamespace)) {
+                                    attNamespace = null;
+                                }
+                                else if (attNamespace === null && attPrefix !== null) {
+                                    attNamespace = nsDeclarations[attPrefix] || null;
+                                }
                             }
-                        }
-                        if (localNameSet.has(attNamespace, attLocalName)) {
-                            throw new Error("Element contains duplicate attributes.");
-                        }
-                        localNameSet.set(attNamespace, attLocalName);
-                        if (attNamespace === infra_1.namespace.XMLNS) {
-                            if (attValue === infra_1.namespace.XMLNS) {
-                                throw new Error("XMLNS namespace is reserved.");
+                            if (localNameSet.has(attNamespace, attLocalName)) {
+                                throw new Error("Element contains duplicate attributes.");
                             }
+                            localNameSet.set(attNamespace, attLocalName);
+                            if (attNamespace === infra_1.namespace.XMLNS) {
+                                if (attValue === infra_1.namespace.XMLNS) {
+                                    throw new Error("XMLNS namespace is reserved.");
+                                }
+                            }
+                            if (attLocalName.indexOf(":") !== -1 || !algorithm_1.xml_isName(attLocalName)) {
+                                throw new Error("Attribute local name contains invalid characters.");
+                            }
+                            if (attPrefix === "xmlns" && attValue === "") {
+                                throw new Error("Empty XML namespace is not allowed.");
+                            }
+                            if (attNamespace !== null)
+                                elementNode.setAttributeNS(attNamespace, attName, attValue);
+                            else
+                                elementNode.setAttribute(attName, attValue);
                         }
-                        if (attLocalName.indexOf(":") !== -1 || !(0, algorithm_1.xml_isName)(attLocalName)) {
-                            throw new Error("Attribute local name contains invalid characters.");
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
                         }
-                        if (attPrefix === "xmlns" && attValue === "") {
-                            throw new Error("Empty XML namespace is not allowed.");
-                        }
-                        if (attNamespace !== null)
-                            elementNode.setAttributeNS(attNamespace, attName, this._decodeAttributeValue(attValue));
-                        else
-                            elementNode.setAttribute(attName, this._decodeAttributeValue(attValue));
+                        finally { if (e_2) throw e_2.error; }
                     }
                     if (!element.selfClosing) {
                         context = elementNode;
                     }
                     break;
                 case interfaces_1.TokenType.ClosingTag:
-                    const closingTag = token;
+                    var closingTag = token;
                     if (closingTag.name !== context.nodeName) {
                         throw new Error('Closing tag name does not match opening tag name.');
                     }
@@ -29490,59 +59160,52 @@ class XMLParserImpl {
             token = lexer.nextToken();
         }
         return doc;
-    }
-    /**
-     * Decodes serialized text.
-     *
-     * @param text - text value to serialize
-     */
-    _decodeText(text) {
-        return text == null ? text : text.replace(/&lt;/g, '<')
-            .replace(/&gt;/g, '>')
-            .replace(/&amp;/g, '&');
-    }
-    /**
-     * Decodes serialized attribute value.
-     *
-     * @param text - attribute value to serialize
-     */
-    _decodeAttributeValue(text) {
-        return text == null ? text : text.replace(/&lt;/g, '<')
-            .replace(/&gt;/g, '>')
-            .replace(/&amp;/g, '&');
-    }
-}
+    };
+    return XMLParserImpl;
+}());
 exports.XMLParserImpl = XMLParserImpl;
 //# sourceMappingURL=XMLParserImpl.js.map
 
 /***/ }),
 
 /***/ 47061:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLStringLexer = void 0;
-const interfaces_1 = __nccwpck_require__(97707);
+var interfaces_1 = __nccwpck_require__(97707);
 /**
  * Represents a lexer for XML content in a string.
  */
-class XMLStringLexer {
-    _str;
-    _index;
-    _length;
-    _options = {
-        skipWhitespaceOnlyText: false
-    };
-    err = { line: -1, col: -1, index: -1, str: "" };
+var XMLStringLexer = /** @class */ (function () {
     /**
      * Initializes a new instance of `XMLStringLexer`.
      *
      * @param str - the string to tokenize and lex
      * @param options - lexer options
      */
-    constructor(str, options) {
+    function XMLStringLexer(str, options) {
+        this._options = {
+            skipWhitespaceOnlyText: false
+        };
+        this.err = { line: -1, col: -1, index: -1, str: "" };
         this._str = str;
         this._index = 0;
         this._length = str.length;
@@ -29553,11 +59216,11 @@ class XMLStringLexer {
     /**
      * Returns the next token.
      */
-    nextToken() {
+    XMLStringLexer.prototype.nextToken = function () {
         if (this.eof()) {
             return { type: interfaces_1.TokenType.EOF };
         }
-        let token = (this.skipIfStartsWith('<') ? this.openBracket() : this.text());
+        var token = (this.skipIfStartsWith('<') ? this.openBracket() : this.text());
         if (this._options.skipWhitespaceOnlyText) {
             if (token.type === interfaces_1.TokenType.Text &&
                 XMLStringLexer.isWhiteSpaceToken(token)) {
@@ -29565,11 +59228,11 @@ class XMLStringLexer {
             }
         }
         return token;
-    }
+    };
     /**
      * Branches from an opening bracket (`<`).
      */
-    openBracket() {
+    XMLStringLexer.prototype.openBracket = function () {
         if (this.skipIfStartsWith('?')) {
             if (this.skipIfStartsWith('xml')) {
                 if (XMLStringLexer.isSpace(this._str[this._index])) {
@@ -29605,14 +59268,14 @@ class XMLStringLexer {
         else {
             return this.openTag();
         }
-    }
+    };
     /**
      * Produces an XML declaration token.
      */
-    declaration() {
-        let version = '';
-        let encoding = '';
-        let standalone = '';
+    XMLStringLexer.prototype.declaration = function () {
+        var version = '';
+        var encoding = '';
+        var standalone = '';
         while (!this.eof()) {
             this.skipSpace();
             if (this.skipIfStartsWith('?>')) {
@@ -29620,7 +59283,7 @@ class XMLStringLexer {
             }
             else {
                 // attribute name
-                const [attName, attValue] = this.attribute();
+                var _a = __read(this.attribute(), 2), attName = _a[0], attValue = _a[1];
                 if (attName === 'version')
                     version = attValue;
                 else if (attName === 'encoding')
@@ -29632,16 +59295,16 @@ class XMLStringLexer {
             }
         }
         this.throwError('Missing declaration end symbol `?>`');
-    }
+    };
     /**
      * Produces a doc type token.
      */
-    doctype() {
-        let pubId = '';
-        let sysId = '';
+    XMLStringLexer.prototype.doctype = function () {
+        var pubId = '';
+        var sysId = '';
         // name
         this.skipSpace();
-        const name = this.takeUntil2('[', '>', true);
+        var name = this.takeUntil2('[', '>', true);
         this.skipSpace();
         if (this.skipIfStartsWith('PUBLIC')) {
             pubId = this.quotedString();
@@ -29664,12 +59327,12 @@ class XMLStringLexer {
             this.throwError('Missing doctype end symbol `>`');
         }
         return { type: interfaces_1.TokenType.DocType, name: name, pubId: pubId, sysId: sysId };
-    }
+    };
     /**
      * Produces a processing instruction token.
      */
-    pi() {
-        const target = this.takeUntilStartsWith('?>', true);
+    XMLStringLexer.prototype.pi = function () {
+        var target = this.takeUntilStartsWith('?>', true);
         if (this.eof()) {
             this.throwError('Missing processing instruction end symbol `?>`');
         }
@@ -29677,52 +59340,52 @@ class XMLStringLexer {
         if (this.skipIfStartsWith('?>')) {
             return { type: interfaces_1.TokenType.PI, target: target, data: '' };
         }
-        const data = this.takeUntilStartsWith('?>');
+        var data = this.takeUntilStartsWith('?>');
         if (this.eof()) {
             this.throwError('Missing processing instruction end symbol `?>`');
         }
         this.seek(2);
         return { type: interfaces_1.TokenType.PI, target: target, data: data };
-    }
+    };
     /**
      * Produces a text token.
      *
      */
-    text() {
-        const data = this.takeUntil('<');
+    XMLStringLexer.prototype.text = function () {
+        var data = this.takeUntil('<');
         return { type: interfaces_1.TokenType.Text, data: data };
-    }
+    };
     /**
      * Produces a comment token.
      *
      */
-    comment() {
-        const data = this.takeUntilStartsWith('-->');
+    XMLStringLexer.prototype.comment = function () {
+        var data = this.takeUntilStartsWith('-->');
         if (this.eof()) {
             this.throwError('Missing comment end symbol `-->`');
         }
         this.seek(3);
         return { type: interfaces_1.TokenType.Comment, data: data };
-    }
+    };
     /**
      * Produces a CDATA token.
      *
      */
-    cdata() {
-        const data = this.takeUntilStartsWith(']]>');
+    XMLStringLexer.prototype.cdata = function () {
+        var data = this.takeUntilStartsWith(']]>');
         if (this.eof()) {
             this.throwError('Missing CDATA end symbol `]>`');
         }
         this.seek(3);
         return { type: interfaces_1.TokenType.CDATA, data: data };
-    }
+    };
     /**
      * Produces an element token.
      */
-    openTag() {
+    XMLStringLexer.prototype.openTag = function () {
         // element name
         this.skipSpace();
-        const name = this.takeUntil2('>', '/', true);
+        var name = this.takeUntil2('>', '/', true);
         this.skipSpace();
         if (this.skipIfStartsWith('>')) {
             return { type: interfaces_1.TokenType.Element, name: name, attributes: [], selfClosing: false };
@@ -29731,7 +59394,7 @@ class XMLStringLexer {
             return { type: interfaces_1.TokenType.Element, name: name, attributes: [], selfClosing: true };
         }
         // attributes
-        const attributes = [];
+        var attributes = [];
         while (!this.eof()) {
             // end tag
             this.skipSpace();
@@ -29741,66 +59404,66 @@ class XMLStringLexer {
             else if (this.skipIfStartsWith('/>')) {
                 return { type: interfaces_1.TokenType.Element, name: name, attributes: attributes, selfClosing: true };
             }
-            const attr = this.attribute();
+            var attr = this.attribute();
             attributes.push(attr);
         }
         this.throwError('Missing opening element tag end symbol `>`');
-    }
+    };
     /**
      * Produces a closing tag token.
      *
      */
-    closeTag() {
+    XMLStringLexer.prototype.closeTag = function () {
         this.skipSpace();
-        const name = this.takeUntil('>', true);
+        var name = this.takeUntil('>', true);
         this.skipSpace();
         if (!this.skipIfStartsWith('>')) {
             this.throwError('Missing closing element tag end symbol `>`');
         }
         return { type: interfaces_1.TokenType.ClosingTag, name: name };
-    }
+    };
     /**
      * Reads an attribute name, value pair
      */
-    attribute() {
+    XMLStringLexer.prototype.attribute = function () {
         // attribute name
         this.skipSpace();
-        const name = this.takeUntil('=', true);
+        var name = this.takeUntil('=', true);
         this.skipSpace();
         if (!this.skipIfStartsWith('=')) {
             this.throwError('Missing equals sign before attribute value');
         }
         // attribute value
-        const value = this.quotedString();
+        var value = this.quotedString();
         return [name, value];
-    }
+    };
     /**
      * Reads a string between double or single quotes.
      */
-    quotedString() {
+    XMLStringLexer.prototype.quotedString = function () {
         this.skipSpace();
-        const startQuote = this.take(1);
+        var startQuote = this.take(1);
         if (!XMLStringLexer.isQuote(startQuote)) {
             this.throwError('Missing start quote character before quoted value');
         }
-        const value = this.takeUntil(startQuote);
+        var value = this.takeUntil(startQuote);
         if (!this.skipIfStartsWith(startQuote)) {
             this.throwError('Missing end quote character after quoted value');
         }
         return value;
-    }
+    };
     /**
      * Determines if the current index is at or past the end of input string.
      */
-    eof() { return this._index >= this._length; }
+    XMLStringLexer.prototype.eof = function () { return this._index >= this._length; };
     /**
      * Skips the length of the given string if the string from current position
      * starts with the given string.
      *
      * @param str - the string to match
      */
-    skipIfStartsWith(str) {
-        const strLength = str.length;
+    XMLStringLexer.prototype.skipIfStartsWith = function (str) {
+        var strLength = str.length;
         if (strLength === 1) {
             if (this._str[this._index] === str) {
                 this._index++;
@@ -29810,56 +59473,57 @@ class XMLStringLexer {
                 return false;
             }
         }
-        for (let i = 0; i < strLength; i++) {
+        for (var i = 0; i < strLength; i++) {
             if (this._str[this._index + i] !== str[i])
                 return false;
         }
         this._index += strLength;
         return true;
-    }
+    };
     /**
      * Seeks a number of character codes.
      *
      * @param count - number of characters to skip
      */
-    seek(count) {
+    XMLStringLexer.prototype.seek = function (count) {
         this._index += count;
         if (this._index < 0)
             this._index = 0;
         if (this._index > this._length)
             this._index = this._length;
-    }
+    };
     /**
      * Skips space characters.
      */
-    skipSpace() {
+    XMLStringLexer.prototype.skipSpace = function () {
         while (!this.eof() && (XMLStringLexer.isSpace(this._str[this._index]))) {
             this._index++;
         }
-    }
+    };
     /**
      * Takes a given number of characters.
      *
      * @param count - character count
      */
-    take(count) {
+    XMLStringLexer.prototype.take = function (count) {
         if (count === 1) {
             return this._str[this._index++];
         }
-        const startIndex = this._index;
+        var startIndex = this._index;
         this.seek(count);
         return this._str.slice(startIndex, this._index);
-    }
+    };
     /**
      * Takes characters until the next character matches `char`.
      *
      * @param char - a character to match
      * @param space - whether a space character stops iteration
      */
-    takeUntil(char, space = false) {
-        const startIndex = this._index;
+    XMLStringLexer.prototype.takeUntil = function (char, space) {
+        if (space === void 0) { space = false; }
+        var startIndex = this._index;
         while (this._index < this._length) {
-            const c = this._str[this._index];
+            var c = this._str[this._index];
             if (c !== char && (!space || !XMLStringLexer.isSpace(c))) {
                 this._index++;
             }
@@ -29868,7 +59532,7 @@ class XMLStringLexer {
             }
         }
         return this._str.slice(startIndex, this._index);
-    }
+    };
     /**
      * Takes characters until the next character matches `char1` or `char1`.
      *
@@ -29876,10 +59540,11 @@ class XMLStringLexer {
      * @param char2 - a character to match
      * @param space - whether a space character stops iteration
      */
-    takeUntil2(char1, char2, space = false) {
-        const startIndex = this._index;
+    XMLStringLexer.prototype.takeUntil2 = function (char1, char2, space) {
+        if (space === void 0) { space = false; }
+        var startIndex = this._index;
         while (this._index < this._length) {
-            const c = this._str[this._index];
+            var c = this._str[this._index];
             if (c !== char1 && c !== char2 && (!space || !XMLStringLexer.isSpace(c))) {
                 this._index++;
             }
@@ -29888,21 +59553,22 @@ class XMLStringLexer {
             }
         }
         return this._str.slice(startIndex, this._index);
-    }
+    };
     /**
      * Takes characters until the next characters matches `str`.
      *
      * @param str - a string to match
      * @param space - whether a space character stops iteration
      */
-    takeUntilStartsWith(str, space = false) {
-        const startIndex = this._index;
-        const strLength = str.length;
+    XMLStringLexer.prototype.takeUntilStartsWith = function (str, space) {
+        if (space === void 0) { space = false; }
+        var startIndex = this._index;
+        var strLength = str.length;
         while (this._index < this._length) {
-            let match = true;
-            for (let i = 0; i < strLength; i++) {
-                const c = this._str[this._index + i];
-                const char = str[i];
+            var match = true;
+            for (var i = 0; i < strLength; i++) {
+                var c = this._str[this._index + i];
+                var char = str[i];
                 if (space && XMLStringLexer.isSpace(c)) {
                     return this._str.slice(startIndex, this._index);
                 }
@@ -29917,15 +59583,15 @@ class XMLStringLexer {
         }
         this._index = this._length;
         return this._str.slice(startIndex);
-    }
+    };
     /**
      * Skips characters until the next character matches `char`.
      *
      * @param char - a character to match
      */
-    skipUntil(char) {
+    XMLStringLexer.prototype.skipUntil = function (char) {
         while (this._index < this._length) {
-            const c = this._str[this._index];
+            var c = this._str[this._index];
             if (c !== char) {
                 this._index++;
             }
@@ -29933,49 +59599,49 @@ class XMLStringLexer {
                 break;
             }
         }
-    }
+    };
     /**
      * Determines if the given token is entirely whitespace.
      *
      * @param token - the token to check
      */
-    static isWhiteSpaceToken(token) {
-        const str = token.data;
-        for (let i = 0; i < str.length; i++) {
-            const c = str[i];
+    XMLStringLexer.isWhiteSpaceToken = function (token) {
+        var str = token.data;
+        for (var i = 0; i < str.length; i++) {
+            var c = str[i];
             if (c !== ' ' && c !== '\n' && c !== '\r' && c !== '\t' && c !== '\f')
                 return false;
         }
         return true;
-    }
+    };
     /**
      * Determines if the given character is whitespace.
      *
      * @param char - the character to check
      */
-    static isSpace(char) {
+    XMLStringLexer.isSpace = function (char) {
         return char === ' ' || char === '\n' || char === '\r' || char === '\t';
-    }
+    };
     /**
      * Determines if the given character is a quote character.
      *
      * @param char - the character to check
      */
-    static isQuote(char) {
+    XMLStringLexer.isQuote = function (char) {
         return (char === '"' || char === '\'');
-    }
+    };
     /**
      * Throws a parser error and records the line and column numbers in the parsed
      * string.
      *
      * @param msg - error message
      */
-    throwError(msg) {
-        const regexp = /\r\n|\r|\n/g;
-        let match = null;
-        let line = 0;
-        let firstNewLineIndex = 0;
-        let lastNewlineIndex = this._str.length;
+    XMLStringLexer.prototype.throwError = function (msg) {
+        var regexp = /\r\n|\r|\n/g;
+        var match = null;
+        var line = 0;
+        var firstNewLineIndex = 0;
+        var lastNewlineIndex = this._str.length;
         while ((match = regexp.exec(this._str)) !== null) {
             if (match === null)
                 break;
@@ -29996,15 +59662,15 @@ class XMLStringLexer {
         throw new Error(msg + "\nIndex: " + this.err.index +
             "\nLn: " + this.err.line + ", Col: " + this.err.col +
             "\nInput: " + this.err.str);
-    }
+    };
     /**
      * Returns an iterator for the lexer.
      */
-    [Symbol.iterator]() {
+    XMLStringLexer.prototype[Symbol.iterator] = function () {
         this._index = 0;
         return {
             next: function () {
-                const token = this.nextToken();
+                var token = this.nextToken();
                 if (token.type === interfaces_1.TokenType.EOF) {
                     return { done: true, value: null };
                 }
@@ -30013,8 +59679,9 @@ class XMLStringLexer {
                 }
             }.bind(this)
         };
-    }
-}
+    };
+    return XMLStringLexer;
+}());
 exports.XMLStringLexer = XMLStringLexer;
 //# sourceMappingURL=XMLStringLexer.js.map
 
@@ -30026,10 +59693,9 @@ exports.XMLStringLexer = XMLStringLexer;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DOMParser = void 0;
 // Export classes
 var DOMParserImpl_1 = __nccwpck_require__(98845);
-Object.defineProperty(exports, "DOMParser", ({ enumerable: true, get: function () { return DOMParserImpl_1.DOMParserImpl; } }));
+exports.DOMParser = DOMParserImpl_1.DOMParserImpl;
 //# sourceMappingURL=index.js.map
 
 /***/ }),
@@ -30040,7 +59706,6 @@ Object.defineProperty(exports, "DOMParser", ({ enumerable: true, get: function (
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.TokenType = void 0;
 /**
  * Defines the type of a token.
  */
@@ -30055,7 +59720,7 @@ var TokenType;
     TokenType[TokenType["PI"] = 6] = "PI";
     TokenType[TokenType["Comment"] = 7] = "Comment";
     TokenType[TokenType["ClosingTag"] = 8] = "ClosingTag";
-})(TokenType || (exports.TokenType = TokenType = {}));
+})(TokenType = exports.TokenType || (exports.TokenType = {}));
 //# sourceMappingURL=interfaces.js.map
 
 /***/ }),
@@ -30066,7 +59731,6 @@ var TokenType;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.LocalNameSet = void 0;
 /**
  * Represents a set of unique attribute namespaceURI and localName pairs.
  * This set will contain tuples of unique attribute namespaceURI and
@@ -30076,17 +59740,19 @@ exports.LocalNameSet = void 0;
  * This can occur when two otherwise identical attributes on the same
  * element differ only by their prefix values.
  */
-class LocalNameSet {
-    // tuple storage
-    _items = {};
-    _nullItems = {};
+var LocalNameSet = /** @class */ (function () {
+    function LocalNameSet() {
+        // tuple storage
+        this._items = {};
+        this._nullItems = {};
+    }
     /**
      * Adds or replaces a tuple.
      *
      * @param ns - namespace URI
      * @param localName - attribute local name
      */
-    set(ns, localName) {
+    LocalNameSet.prototype.set = function (ns, localName) {
         if (ns === null) {
             this._nullItems[localName] = true;
         }
@@ -30097,14 +59763,14 @@ class LocalNameSet {
             this._items[ns] = {};
             this._items[ns][localName] = true;
         }
-    }
+    };
     /**
      * Determines if the given tuple exists in the set.
      *
      * @param ns - namespace URI
      * @param localName - attribute local name
      */
-    has(ns, localName) {
+    LocalNameSet.prototype.has = function (ns, localName) {
         if (ns === null) {
             return this._nullItems[localName] === true;
         }
@@ -30114,8 +59780,9 @@ class LocalNameSet {
         else {
             return false;
         }
-    }
-}
+    };
+    return LocalNameSet;
+}());
 exports.LocalNameSet = LocalNameSet;
 //# sourceMappingURL=LocalNameSet.js.map
 
@@ -30127,7 +59794,6 @@ exports.LocalNameSet = LocalNameSet;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.NamespacePrefixMap = void 0;
 /**
  * A namespace prefix map is a map that associates namespaceURI and namespace
  * prefix lists, where namespaceURI values are the map's unique keys (which can
@@ -30144,39 +59810,41 @@ exports.NamespacePrefixMap = void 0;
  *
  * See: https://w3c.github.io/DOM-Parsing/#the-namespace-prefix-map
  */
-class NamespacePrefixMap {
-    _items = {};
-    _nullItems = [];
+var NamespacePrefixMap = /** @class */ (function () {
+    function NamespacePrefixMap() {
+        this._items = {};
+        this._nullItems = [];
+    }
     /**
      * Creates a copy of the map.
      */
-    copy() {
+    NamespacePrefixMap.prototype.copy = function () {
         /**
          * To copy a namespace prefix map map means to copy the map's keys into a
          * new empty namespace prefix map, and to copy each of the values in the
          * namespace prefix list associated with each keys' value into a new list
          * which should be associated with the respective key in the new map.
          */
-        const mapCopy = new NamespacePrefixMap();
-        for (const key in this._items) {
+        var mapCopy = new NamespacePrefixMap();
+        for (var key in this._items) {
             mapCopy._items[key] = this._items[key].slice(0);
         }
         mapCopy._nullItems = this._nullItems.slice(0);
         return mapCopy;
-    }
+    };
     /**
      * Retrieves a preferred prefix string from the namespace prefix map.
      *
      * @param preferredPrefix - preferred prefix string
      * @param ns - namespace
      */
-    get(preferredPrefix, ns) {
+    NamespacePrefixMap.prototype.get = function (preferredPrefix, ns) {
         /**
          * 1. Let candidates list be the result of retrieving a list from map where
          * there exists a key in map that matches the value of ns or if there is no
          * such key, then stop running these steps, and return the null value.
          */
-        const candidatesList = ns === null ? this._nullItems : (this._items[ns] || null);
+        var candidatesList = ns === null ? this._nullItems : (this._items[ns] || null);
         if (candidatesList === null) {
             return null;
         }
@@ -30186,8 +59854,8 @@ class NamespacePrefixMap {
          *
          * _Note:_ There will always be at least one prefix value in the list.
          */
-        let prefix = null;
-        for (let i = 0; i < candidatesList.length; i++) {
+        var prefix = null;
+        for (var i = 0; i < candidatesList.length; i++) {
             prefix = candidatesList[i];
             /**
              * 2.1. If prefix matches preferred prefix, then stop running these steps
@@ -30202,7 +59870,7 @@ class NamespacePrefixMap {
         * running these steps and return prefix.
         */
         return prefix;
-    }
+    };
     /**
      * Checks if a prefix string is found in the namespace prefix map associated
      * with the given namespace.
@@ -30210,13 +59878,13 @@ class NamespacePrefixMap {
      * @param prefix - prefix string
      * @param ns - namespace
      */
-    has(prefix, ns) {
+    NamespacePrefixMap.prototype.has = function (prefix, ns) {
         /**
          * 1. Let candidates list be the result of retrieving a list from map where
          * there exists a key in map that matches the value of ns or if there is
          * no such key, then stop running these steps, and return false.
          */
-        const candidatesList = ns === null ? this._nullItems : (this._items[ns] || null);
+        var candidatesList = ns === null ? this._nullItems : (this._items[ns] || null);
         if (candidatesList === null) {
             return false;
         }
@@ -30225,34 +59893,34 @@ class NamespacePrefixMap {
          * return true, otherwise return false.
          */
         return (candidatesList.indexOf(prefix) !== -1);
-    }
+    };
     /**
      * Checks if a prefix string is found in the namespace prefix map.
      *
      * @param prefix - prefix string
      */
-    hasPrefix(prefix) {
+    NamespacePrefixMap.prototype.hasPrefix = function (prefix) {
         if (this._nullItems.indexOf(prefix) !== -1)
             return true;
-        for (const key in this._items) {
+        for (var key in this._items) {
             if (this._items[key].indexOf(prefix) !== -1)
                 return true;
         }
         return false;
-    }
+    };
     /**
      * Adds a prefix string associated with a namespace to the prefix map.
      *
      * @param prefix - prefix string
      * @param ns - namespace
      */
-    set(prefix, ns) {
+    NamespacePrefixMap.prototype.set = function (prefix, ns) {
         /**
          * 1. Let candidates list be the result of retrieving a list from map where
          * there exists a key in map that matches the value of ns or if there is
          * no such key, then let candidates list be null.
          */
-        const candidatesList = ns === null ? this._nullItems : (this._items[ns] || null);
+        var candidatesList = ns === null ? this._nullItems : (this._items[ns] || null);
         /**
          * 2. If candidates list is null, then create a new list with prefix as the
          * only item in the list, and associate that list with a new key ns in map.
@@ -30270,51 +59938,61 @@ class NamespacePrefixMap {
         else {
             candidatesList.push(prefix);
         }
-    }
-}
+    };
+    return NamespacePrefixMap;
+}());
 exports.NamespacePrefixMap = NamespacePrefixMap;
 //# sourceMappingURL=NamespacePrefixMap.js.map
 
 /***/ }),
 
 /***/ 85039:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLSerializerImpl = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
-const LocalNameSet_1 = __nccwpck_require__(19049);
-const NamespacePrefixMap_1 = __nccwpck_require__(90283);
-const DOMException_1 = __nccwpck_require__(13166);
-const infra_1 = __nccwpck_require__(84251);
-const algorithm_1 = __nccwpck_require__(61);
+var interfaces_1 = __nccwpck_require__(27305);
+var LocalNameSet_1 = __nccwpck_require__(19049);
+var NamespacePrefixMap_1 = __nccwpck_require__(90283);
+var DOMException_1 = __nccwpck_require__(13166);
+var infra_1 = __nccwpck_require__(84251);
+var algorithm_1 = __nccwpck_require__(61);
 /**
  * Represents an XML serializer.
  *
  * Implements: https://www.w3.org/TR/DOM-Parsing/#serializing
  */
-class XMLSerializerImpl {
-    static _VoidElementNames = new Set(['area', 'base', 'basefont',
-        'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
-        'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
+var XMLSerializerImpl = /** @class */ (function () {
+    function XMLSerializerImpl() {
+    }
     /** @inheritdoc */
-    serializeToString(root) {
+    XMLSerializerImpl.prototype.serializeToString = function (root) {
         /**
          * The serializeToString(root) method must produce an XML serialization
          * of root passing a value of false for the require well-formed parameter,
          * and return the result.
          */
         return this._xmlSerialization(root, false);
-    }
+    };
     /**
      * Produces an XML serialization of the given node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    _xmlSerialization(node, requireWellFormed) {
+    XMLSerializerImpl.prototype._xmlSerialization = function (node, requireWellFormed) {
         // To increase performance, use a namespace-aware serializer only if the
         // document has namespaced elements
         if (node._nodeDocument === undefined || node._nodeDocument._hasNamespaces) {
@@ -30334,10 +60012,10 @@ class XMLSerializerImpl {
              * serialize a node's namespaceURI (or the namespaceURI of one of node's
              * attributes). See the generate a prefix algorithm.
              */
-            const namespace = null;
-            const prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap();
+            var namespace = null;
+            var prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap();
             prefixMap.set("xml", infra_1.namespace.XML);
-            const prefixIndex = { value: 1 };
+            var prefixIndex = { value: 1 };
             /**
              * 5. Return the result of running the XML serialization algorithm on node
              * passing the context namespace namespace, namespace prefix map prefix map,
@@ -30349,7 +60027,7 @@ class XMLSerializerImpl {
             try {
                 return this._serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
             }
-            catch {
+            catch (_a) {
                 throw new DOMException_1.InvalidStateError();
             }
         }
@@ -30357,11 +60035,11 @@ class XMLSerializerImpl {
             try {
                 return this._serializeNode(node, requireWellFormed);
             }
-            catch {
+            catch (_b) {
                 throw new DOMException_1.InvalidStateError();
             }
         }
-    }
+    };
     /**
      * Produces an XML serialization of a node.
      *
@@ -30371,7 +60049,7 @@ class XMLSerializerImpl {
      * @param prefixIndex - generated namespace prefix index
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeNodeNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed) {
         switch (node.nodeType) {
             case interfaces_1.NodeType.Element:
                 return this._serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
@@ -30390,16 +60068,16 @@ class XMLSerializerImpl {
             case interfaces_1.NodeType.CData:
                 return this._serializeCData(node, requireWellFormed);
             default:
-                throw new Error(`Unknown node type: ${node.nodeType}`);
+                throw new Error("Unknown node type: " + node.nodeType);
         }
-    }
+    };
     /**
      * Produces an XML serialization of a node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeNode(node, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeNode = function (node, requireWellFormed) {
         switch (node.nodeType) {
             case interfaces_1.NodeType.Element:
                 return this._serializeElement(node, requireWellFormed);
@@ -30418,9 +60096,9 @@ class XMLSerializerImpl {
             case interfaces_1.NodeType.CData:
                 return this._serializeCData(node, requireWellFormed);
             default:
-                throw new Error(`Unknown node type: ${node.nodeType}`);
+                throw new Error("Unknown node type: " + node.nodeType);
         }
-    }
+    };
     /**
      * Produces an XML serialization of an element node.
      *
@@ -30430,7 +60108,8 @@ class XMLSerializerImpl {
      * @param prefixIndex - generated namespace prefix index
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeElementNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed) {
+        var e_1, _a;
         /**
          * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node
          *
@@ -30440,7 +60119,7 @@ class XMLSerializerImpl {
          * serialization of this node would not be a well-formed element.
          */
         if (requireWellFormed && (node.localName.indexOf(":") !== -1 ||
-            !(0, algorithm_1.xml_isName)(node.localName))) {
+            !algorithm_1.xml_isName(node.localName))) {
             throw new Error("Node local name contains invalid characters (well-formed required).");
         }
         /**
@@ -30473,15 +60152,15 @@ class XMLSerializerImpl {
          * 9. Let inherited ns be a copy of namespace.
          * 10. Let ns be the value of node's namespaceURI attribute.
          */
-        let markup = "<";
-        let qualifiedName = '';
-        let skipEndTag = false;
-        let ignoreNamespaceDefinitionAttribute = false;
-        let map = prefixMap.copy();
-        let localPrefixesMap = {};
-        let localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap);
-        let inheritedNS = namespace;
-        let ns = node.namespaceURI;
+        var markup = "<";
+        var qualifiedName = '';
+        var skipEndTag = false;
+        var ignoreNamespaceDefinitionAttribute = false;
+        var map = prefixMap.copy();
+        var localPrefixesMap = {};
+        var localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap);
+        var inheritedNS = namespace;
+        var ns = node.namespaceURI;
         /** 11. If inherited ns is equal to ns, then: */
         if (inheritedNS === ns) {
             /**
@@ -30517,14 +60196,14 @@ class XMLSerializerImpl {
              * prefix string prefix from map given namespace ns. The above may return
              * null if no namespace key ns exists in map.
              */
-            let prefix = node.prefix;
+            var prefix = node.prefix;
             /**
              * We don't need to run "retrieving a preferred prefix string" algorithm if
              * the element has no prefix and its namespace matches to the default
              * namespace.
              * See: https://github.com/web-platform-tests/wpt/pull/16703
              */
-            let candidatePrefix = null;
+            var candidatePrefix = null;
             if (prefix !== null || ns !== localDefaultNamespace) {
                 candidatePrefix = map.get(prefix, ns);
             }
@@ -30713,7 +60392,7 @@ class XMLSerializerImpl {
          * tag flag to true.
          * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup.
          */
-        const isHTML = (ns === infra_1.namespace.HTML);
+        var isHTML = (ns === infra_1.namespace.HTML);
         if (isHTML && node.childNodes.length === 0 &&
             XMLSerializerImpl._VoidElementNames.has(node.localName)) {
             markup += " /";
@@ -30749,8 +60428,18 @@ class XMLSerializerImpl {
             // TODO: serialize template contents
         }
         else {
-            for (const childNode of node._children || node.childNodes) {
-                markup += this._serializeNodeNS(childNode, inheritedNS, map, prefixIndex, requireWellFormed);
+            try {
+                for (var _b = __values(node._children || node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var childNode = _c.value;
+                    markup += this._serializeNodeNS(childNode, inheritedNS, map, prefixIndex, requireWellFormed);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
             }
         }
         /**
@@ -30764,7 +60453,7 @@ class XMLSerializerImpl {
          * 21. Return the value of markup.
          */
         return markup;
-    }
+    };
     /**
      * Produces an XML serialization of a document node.
      *
@@ -30774,7 +60463,8 @@ class XMLSerializerImpl {
      * @param prefixIndex - generated namespace prefix index
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeDocumentNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed) {
+        var e_2, _a;
         /**
          * If the require well-formed flag is set (its value is true), and this node
          * has no documentElement (the documentElement attribute's value is null),
@@ -30798,19 +60488,29 @@ class XMLSerializerImpl {
          *
          * 3. Return the value of serialized document.
         */
-        let serializedDocument = "";
-        for (const childNode of node._children || node.childNodes) {
-            serializedDocument += this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
+        var serializedDocument = "";
+        try {
+            for (var _b = __values(node._children || node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var childNode = _c.value;
+                serializedDocument += this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
         }
         return serializedDocument;
-    }
+    };
     /**
      * Produces an XML serialization of a comment node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeComment(node, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeComment = function (node, requireWellFormed) {
         /**
          * If the require well-formed flag is set (its value is true), and node's
          * data contains characters that are not matched by the XML Char production
@@ -30818,7 +60518,7 @@ class XMLSerializerImpl {
          * ends with a "-" (U+002D HYPHEN-MINUS) character, then throw an exception;
          * the serialization of this node's data would not be well-formed.
          */
-        if (requireWellFormed && (!(0, algorithm_1.xml_isLegalChar)(node.data) ||
+        if (requireWellFormed && (!algorithm_1.xml_isLegalChar(node.data) ||
             node.data.indexOf("--") !== -1 || node.data.endsWith("-"))) {
             throw new Error("Comment data contains invalid characters (well-formed required).");
         }
@@ -30826,7 +60526,7 @@ class XMLSerializerImpl {
          * Otherwise, return the concatenation of "<!--", node's data, and "-->".
          */
         return "<!--" + node.data + "-->";
-    }
+    };
     /**
      * Produces an XML serialization of a text node.
      *
@@ -30834,14 +60534,14 @@ class XMLSerializerImpl {
      * @param requireWellFormed - whether to check conformance
      * @param level - current depth of the XML tree
      */
-    _serializeText(node, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeText = function (node, requireWellFormed) {
         /**
          * 1. If the require well-formed flag is set (its value is true), and
          * node's data contains characters that are not matched by the XML Char
          * production, then throw an exception; the serialization of this node's
          * data would not be well-formed.
          */
-        if (requireWellFormed && !(0, algorithm_1.xml_isLegalChar)(node.data)) {
+        if (requireWellFormed && !algorithm_1.xml_isLegalChar(node.data)) {
             throw new Error("Text data contains invalid characters (well-formed required).");
         }
         /**
@@ -30851,9 +60551,9 @@ class XMLSerializerImpl {
          * 5. Replace any occurrences of ">" in markup by "&gt;".
          * 6. Return the value of markup.
          */
-        let result = "";
-        for (let i = 0; i < node.data.length; i++) {
-            const c = node.data[i];
+        var result = "";
+        for (var i = 0; i < node.data.length; i++) {
+            var c = node.data[i];
             if (c === "&")
                 result += "&amp;";
             else if (c === "<")
@@ -30864,7 +60564,7 @@ class XMLSerializerImpl {
                 result += c;
         }
         return result;
-    }
+    };
     /**
      * Produces an XML serialization of a document fragment node.
      *
@@ -30874,7 +60574,8 @@ class XMLSerializerImpl {
      * @param prefixIndex - generated namespace prefix index
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeDocumentFragmentNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed) {
+        var e_3, _a;
         /**
          * 1. Let markup the empty string.
          * 2. For each child child of node, in tree order, run the XML serialization
@@ -30882,26 +60583,36 @@ class XMLSerializerImpl {
          * index, and flag require well-formed. Concatenate the result to markup.
          * 3. Return the value of markup.
          */
-        let markup = "";
-        for (const childNode of node._children || node.childNodes) {
-            markup += this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
+        var markup = "";
+        try {
+            for (var _b = __values(node._children || node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var childNode = _c.value;
+                markup += this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
         }
         return markup;
-    }
+    };
     /**
      * Produces an XML serialization of a document type node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeDocumentType(node, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeDocumentType = function (node, requireWellFormed) {
         /**
          * 1. If the require well-formed flag is true and the node's publicId
          * attribute contains characters that are not matched by the XML PubidChar
          *  production, then throw an exception; the serialization of this node
          * would not be a well-formed document type declaration.
          */
-        if (requireWellFormed && !(0, algorithm_1.xml_isPubidChar)(node.publicId)) {
+        if (requireWellFormed && !algorithm_1.xml_isPubidChar(node.publicId)) {
             throw new Error("DocType public identifier does not match PubidChar construct (well-formed required).");
         }
         /**
@@ -30912,7 +60623,7 @@ class XMLSerializerImpl {
          * of this node would not be a well-formed document type declaration.
          */
         if (requireWellFormed &&
-            (!(0, algorithm_1.xml_isLegalChar)(node.systemId) ||
+            (!algorithm_1.xml_isLegalChar(node.systemId) ||
                 (node.systemId.indexOf('"') !== -1 && node.systemId.indexOf("'") !== -1))) {
             throw new Error("DocType system identifier contains invalid characters (well-formed required).");
         }
@@ -30952,14 +60663,14 @@ class XMLSerializerImpl {
                     "<!DOCTYPE " + node.name + " SYSTEM \"" + node.systemId + "\">"
                     :
                         "<!DOCTYPE " + node.name + ">";
-    }
+    };
     /**
      * Produces an XML serialization of a processing instruction node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeProcessingInstruction(node, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeProcessingInstruction = function (node, requireWellFormed) {
         /**
          * 1. If the require well-formed flag is set (its value is true), and node's
          * target contains a ":" (U+003A COLON) character or is an ASCII
@@ -30976,7 +60687,7 @@ class XMLSerializerImpl {
          * U+003E GREATER-THAN SIGN), then throw an exception; the serialization of
          * this node's data would not be well-formed.
          */
-        if (requireWellFormed && (!(0, algorithm_1.xml_isLegalChar)(node.data) ||
+        if (requireWellFormed && (!algorithm_1.xml_isLegalChar(node.data) ||
             node.data.indexOf("?>") !== -1)) {
             throw new Error("Processing instruction data contains invalid characters (well-formed required).");
         }
@@ -30990,19 +60701,19 @@ class XMLSerializerImpl {
          * 4. Return the value of markup.
          */
         return "<?" + (node.data === "" ? node.target : node.target + " " + node.data) + "?>";
-    }
+    };
     /**
      * Produces an XML serialization of a CDATA node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeCData(node, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeCData = function (node, requireWellFormed) {
         if (requireWellFormed && (node.data.indexOf("]]>") !== -1)) {
             throw new Error("CDATA contains invalid characters (well-formed required).");
         }
         return "<![CDATA[" + node.data + "]]>";
-    }
+    };
     /**
     * Produces an XML serialization of the attributes of an element node.
     *
@@ -31014,7 +60725,8 @@ class XMLSerializerImpl {
      * attributes
      * @param requireWellFormed - whether to check conformance
     */
-    _serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeAttributesNS = function (node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) {
+        var e_4, _a;
         /**
          * 1. Let result be the empty string.
          * 2. Let localname set be a new empty namespace localname set. This
@@ -31025,191 +60737,201 @@ class XMLSerializerImpl {
          * This can occur when two otherwise identical attributes on the same
          * element differ only by their prefix values.
          */
-        let result = "";
-        const localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined;
-        /**
-         * 3. Loop: For each attribute attr in element's attributes, in the order
-         * they are specified in the element's attribute list:
-         */
-        for (const attr of node.attributes) {
-            // Optimize common case
-            if (!ignoreNamespaceDefinitionAttribute && !requireWellFormed && attr.namespaceURI === null) {
-                result += " " + attr.localName + "=\"" +
+        var result = "";
+        var localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined;
+        try {
+            /**
+             * 3. Loop: For each attribute attr in element's attributes, in the order
+             * they are specified in the element's attribute list:
+             */
+            for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var attr = _c.value;
+                // Optimize common case
+                if (!ignoreNamespaceDefinitionAttribute && !requireWellFormed && attr.namespaceURI === null) {
+                    result += " " + attr.localName + "=\"" +
+                        this._serializeAttributeValue(attr.value, requireWellFormed) + "\"";
+                    continue;
+                }
+                /**
+                 * 3.1. If the require well-formed flag is set (its value is true), and the
+                 * localname set contains a tuple whose values match those of a new tuple
+                 * consisting of attr's namespaceURI attribute and localName attribute,
+                 * then throw an exception; the serialization of this attr would fail to
+                 * produce a well-formed element serialization.
+                 */
+                if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) {
+                    throw new Error("Element contains duplicate attributes (well-formed required).");
+                }
+                /**
+                 * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
+                 * localName attribute, and add it to the localname set.
+                 * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
+                 * 3.4. Let candidate prefix be null.
+                 */
+                if (requireWellFormed && localNameSet)
+                    localNameSet.set(attr.namespaceURI, attr.localName);
+                var attributeNamespace = attr.namespaceURI;
+                var candidatePrefix = null;
+                /** 3.5. If attribute namespace is not null, then run these sub-steps: */
+                if (attributeNamespace !== null) {
+                    /**
+                     * 3.5.1. Let candidate prefix be the result of retrieving a preferred
+                     * prefix string from map given namespace attribute namespace with
+                     * preferred prefix being attr's prefix value.
+                     */
+                    candidatePrefix = map.get(attr.prefix, attributeNamespace);
+                    /**
+                     * 3.5.2. If the value of attribute namespace is the XMLNS namespace,
+                     * then run these steps:
+                     */
+                    if (attributeNamespace === infra_1.namespace.XMLNS) {
+                        /**
+                         * 3.5.2.1. If any of the following are true, then stop running these
+                         * steps and goto Loop to visit the next attribute:
+                         * - the attr's value is the XML namespace;
+                         * _Note:_ The XML namespace cannot be redeclared and survive
+                         * round-tripping (unless it defines the prefix "xml"). To avoid this
+                         * problem, this algorithm always prefixes elements in the XML
+                         * namespace with "xml" and drops any related definitions as seen
+                         * in the above condition.
+                         * - the attr's prefix is null and the ignore namespace definition
+                         * attribute flag is true (the Element's default namespace attribute
+                         * should be skipped);
+                         * - the attr's prefix is not null and either
+                         *   * the attr's localName is not a key contained in the local
+                         *     prefixes map, or
+                         *   * the attr's localName is present in the local prefixes map but
+                         *     the value of the key does not match attr's value
+                         * and furthermore that the attr's localName (as the prefix to find)
+                         * is found in the namespace prefix map given the namespace consisting
+                         * of the attr's value (the current namespace prefix definition was
+                         * exactly defined previously--on an ancestor element not the current
+                         * element whose attributes are being processed).
+                         */
+                        if (attr.value === infra_1.namespace.XML ||
+                            (attr.prefix === null && ignoreNamespaceDefinitionAttribute) ||
+                            (attr.prefix !== null && (!(attr.localName in localPrefixesMap) ||
+                                localPrefixesMap[attr.localName] !== attr.value) &&
+                                map.has(attr.localName, attr.value)))
+                            continue;
+                        /**
+                         * 3.5.2.2. If the require well-formed flag is set (its value is true),
+                         * and the value of attr's value attribute matches the XMLNS
+                         * namespace, then throw an exception; the serialization of this
+                         * attribute would produce invalid XML because the XMLNS namespace
+                         * is reserved and cannot be applied as an element's namespace via
+                         * XML parsing.
+                         *
+                         * _Note:_ DOM APIs do allow creation of elements in the XMLNS
+                         * namespace but with strict qualifications.
+                         */
+                        if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) {
+                            throw new Error("XMLNS namespace is reserved (well-formed required).");
+                        }
+                        /**
+                         * 3.5.2.3. If the require well-formed flag is set (its value is true),
+                         * and the value of attr's value attribute is the empty string, then
+                         * throw an exception; namespace prefix declarations cannot be used
+                         * to undeclare a namespace (use a default namespace declaration
+                         * instead).
+                         */
+                        if (requireWellFormed && attr.value === '') {
+                            throw new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required).");
+                        }
+                        /**
+                         * 3.5.2.4. the attr's prefix matches the string "xmlns", then let
+                         * candidate prefix be the string "xmlns".
+                         */
+                        if (attr.prefix === 'xmlns')
+                            candidatePrefix = 'xmlns';
+                        /**
+                         * 3.5.3. Otherwise, the attribute namespace is not the XMLNS namespace.
+                         * Run these steps:
+                         *
+                         * _Note:_ The (candidatePrefix === null) check is not in the spec.
+                         * We deviate from the spec here. Otherwise a prefix is generated for
+                         * all attributes with namespaces.
+                         */
+                    }
+                    else if (candidatePrefix === null) {
+                        if (attr.prefix !== null &&
+                            (!map.hasPrefix(attr.prefix) ||
+                                map.has(attr.prefix, attributeNamespace))) {
+                            /**
+                             * Check if we can use the attribute's own prefix.
+                             * We deviate from the spec here.
+                             * TODO: This is not an efficient way of searching for prefixes.
+                             * Follow developments to the spec.
+                             */
+                            candidatePrefix = attr.prefix;
+                        }
+                        else {
+                            /**
+                             * 3.5.3.1. Let candidate prefix be the result of generating a prefix
+                             * providing map, attribute namespace, and prefix index as input.
+                             */
+                            candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex);
+                        }
+                        /**
+                         * 3.5.3.2. Append the following to result, in the order listed:
+                         * 3.5.3.2.1. " " (U+0020 SPACE);
+                         * 3.5.3.2.2. The string "xmlns:";
+                         * 3.5.3.2.3. The value of candidate prefix;
+                         * 3.5.3.2.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
+                         * 3.5.3.2.5. The result of serializing an attribute value given
+                         * attribute namespace and the require well-formed flag as input;
+                         * 3.5.3.2.6. """ (U+0022 QUOTATION MARK).
+                        */
+                        result += " xmlns:" + candidatePrefix + "=\"" +
+                            this._serializeAttributeValue(attributeNamespace, requireWellFormed) + "\"";
+                    }
+                }
+                /**
+                 * 3.6. Append a " " (U+0020 SPACE) to result.
+                 * 3.7. If candidate prefix is not null, then append to result the
+                 * concatenation of candidate prefix with ":" (U+003A COLON).
+                 */
+                result += " ";
+                if (candidatePrefix !== null) {
+                    result += candidatePrefix + ':';
+                }
+                /**
+                 * 3.8. If the require well-formed flag is set (its value is true), and
+                 * this attr's localName attribute contains the character
+                 * ":" (U+003A COLON) or does not match the XML Name production or
+                 * equals "xmlns" and attribute namespace is null, then throw an
+                 * exception; the serialization of this attr would not be a
+                 * well-formed attribute.
+                 */
+                if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
+                    !algorithm_1.xml_isName(attr.localName) ||
+                    (attr.localName === "xmlns" && attributeNamespace === null))) {
+                    throw new Error("Attribute local name contains invalid characters (well-formed required).");
+                }
+                /**
+                 * 3.9. Append the following strings to result, in the order listed:
+                 * 3.9.1. The value of attr's localName;
+                 * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
+                 * 3.9.3. The result of serializing an attribute value given attr's value
+                 * attribute and the require well-formed flag as input;
+                 * 3.9.4. """ (U+0022 QUOTATION MARK).
+                 */
+                result += attr.localName + "=\"" +
                     this._serializeAttributeValue(attr.value, requireWellFormed) + "\"";
-                continue;
             }
-            /**
-             * 3.1. If the require well-formed flag is set (its value is true), and the
-             * localname set contains a tuple whose values match those of a new tuple
-             * consisting of attr's namespaceURI attribute and localName attribute,
-             * then throw an exception; the serialization of this attr would fail to
-             * produce a well-formed element serialization.
-             */
-            if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) {
-                throw new Error("Element contains duplicate attributes (well-formed required).");
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            /**
-             * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
-             * localName attribute, and add it to the localname set.
-             * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
-             * 3.4. Let candidate prefix be null.
-             */
-            if (requireWellFormed && localNameSet)
-                localNameSet.set(attr.namespaceURI, attr.localName);
-            let attributeNamespace = attr.namespaceURI;
-            let candidatePrefix = null;
-            /** 3.5. If attribute namespace is not null, then run these sub-steps: */
-            if (attributeNamespace !== null) {
-                /**
-                 * 3.5.1. Let candidate prefix be the result of retrieving a preferred
-                 * prefix string from map given namespace attribute namespace with
-                 * preferred prefix being attr's prefix value.
-                 */
-                candidatePrefix = map.get(attr.prefix, attributeNamespace);
-                /**
-                 * 3.5.2. If the value of attribute namespace is the XMLNS namespace,
-                 * then run these steps:
-                 */
-                if (attributeNamespace === infra_1.namespace.XMLNS) {
-                    /**
-                     * 3.5.2.1. If any of the following are true, then stop running these
-                     * steps and goto Loop to visit the next attribute:
-                     * - the attr's value is the XML namespace;
-                     * _Note:_ The XML namespace cannot be redeclared and survive
-                     * round-tripping (unless it defines the prefix "xml"). To avoid this
-                     * problem, this algorithm always prefixes elements in the XML
-                     * namespace with "xml" and drops any related definitions as seen
-                     * in the above condition.
-                     * - the attr's prefix is null and the ignore namespace definition
-                     * attribute flag is true (the Element's default namespace attribute
-                     * should be skipped);
-                     * - the attr's prefix is not null and either
-                     *   * the attr's localName is not a key contained in the local
-                     *     prefixes map, or
-                     *   * the attr's localName is present in the local prefixes map but
-                     *     the value of the key does not match attr's value
-                     * and furthermore that the attr's localName (as the prefix to find)
-                     * is found in the namespace prefix map given the namespace consisting
-                     * of the attr's value (the current namespace prefix definition was
-                     * exactly defined previously--on an ancestor element not the current
-                     * element whose attributes are being processed).
-                     */
-                    if (attr.value === infra_1.namespace.XML ||
-                        (attr.prefix === null && ignoreNamespaceDefinitionAttribute) ||
-                        (attr.prefix !== null && (!(attr.localName in localPrefixesMap) ||
-                            localPrefixesMap[attr.localName] !== attr.value) &&
-                            map.has(attr.localName, attr.value)))
-                        continue;
-                    /**
-                     * 3.5.2.2. If the require well-formed flag is set (its value is true),
-                     * and the value of attr's value attribute matches the XMLNS
-                     * namespace, then throw an exception; the serialization of this
-                     * attribute would produce invalid XML because the XMLNS namespace
-                     * is reserved and cannot be applied as an element's namespace via
-                     * XML parsing.
-                     *
-                     * _Note:_ DOM APIs do allow creation of elements in the XMLNS
-                     * namespace but with strict qualifications.
-                     */
-                    if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) {
-                        throw new Error("XMLNS namespace is reserved (well-formed required).");
-                    }
-                    /**
-                     * 3.5.2.3. If the require well-formed flag is set (its value is true),
-                     * and the value of attr's value attribute is the empty string, then
-                     * throw an exception; namespace prefix declarations cannot be used
-                     * to undeclare a namespace (use a default namespace declaration
-                     * instead).
-                     */
-                    if (requireWellFormed && attr.value === '') {
-                        throw new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required).");
-                    }
-                    /**
-                     * 3.5.2.4. the attr's prefix matches the string "xmlns", then let
-                     * candidate prefix be the string "xmlns".
-                     */
-                    if (attr.prefix === 'xmlns')
-                        candidatePrefix = 'xmlns';
-                    /**
-                     * 3.5.3. Otherwise, the attribute namespace is not the XMLNS namespace.
-                     * Run these steps:
-                     *
-                     * _Note:_ The (candidatePrefix === null) check is not in the spec.
-                     * We deviate from the spec here. Otherwise a prefix is generated for
-                     * all attributes with namespaces.
-                     */
-                }
-                else if (candidatePrefix === null) {
-                    if (attr.prefix !== null &&
-                        (!map.hasPrefix(attr.prefix) ||
-                            map.has(attr.prefix, attributeNamespace))) {
-                        /**
-                         * Check if we can use the attribute's own prefix.
-                         * We deviate from the spec here.
-                         * TODO: This is not an efficient way of searching for prefixes.
-                         * Follow developments to the spec.
-                         */
-                        candidatePrefix = attr.prefix;
-                    }
-                    else {
-                        /**
-                         * 3.5.3.1. Let candidate prefix be the result of generating a prefix
-                         * providing map, attribute namespace, and prefix index as input.
-                         */
-                        candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex);
-                    }
-                    /**
-                     * 3.5.3.2. Append the following to result, in the order listed:
-                     * 3.5.3.2.1. " " (U+0020 SPACE);
-                     * 3.5.3.2.2. The string "xmlns:";
-                     * 3.5.3.2.3. The value of candidate prefix;
-                     * 3.5.3.2.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
-                     * 3.5.3.2.5. The result of serializing an attribute value given
-                     * attribute namespace and the require well-formed flag as input;
-                     * 3.5.3.2.6. """ (U+0022 QUOTATION MARK).
-                    */
-                    result += " xmlns:" + candidatePrefix + "=\"" +
-                        this._serializeAttributeValue(attributeNamespace, requireWellFormed) + "\"";
-                }
-            }
-            /**
-             * 3.6. Append a " " (U+0020 SPACE) to result.
-             * 3.7. If candidate prefix is not null, then append to result the
-             * concatenation of candidate prefix with ":" (U+003A COLON).
-             */
-            result += " ";
-            if (candidatePrefix !== null) {
-                result += candidatePrefix + ':';
-            }
-            /**
-             * 3.8. If the require well-formed flag is set (its value is true), and
-             * this attr's localName attribute contains the character
-             * ":" (U+003A COLON) or does not match the XML Name production or
-             * equals "xmlns" and attribute namespace is null, then throw an
-             * exception; the serialization of this attr would not be a
-             * well-formed attribute.
-             */
-            if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
-                !(0, algorithm_1.xml_isName)(attr.localName) ||
-                (attr.localName === "xmlns" && attributeNamespace === null))) {
-                throw new Error("Attribute local name contains invalid characters (well-formed required).");
-            }
-            /**
-             * 3.9. Append the following strings to result, in the order listed:
-             * 3.9.1. The value of attr's localName;
-             * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
-             * 3.9.3. The result of serializing an attribute value given attr's value
-             * attribute and the require well-formed flag as input;
-             * 3.9.4. """ (U+0022 QUOTATION MARK).
-             */
-            result += attr.localName + "=\"" +
-                this._serializeAttributeValue(attr.value, requireWellFormed) + "\"";
+            finally { if (e_4) throw e_4.error; }
         }
         /**
          * 4. Return the value of result.
          */
         return result;
-    }
+    };
     /**
     * Records namespace information for the given element and returns the
     * default namespace attribute value.
@@ -31218,98 +60940,109 @@ class XMLSerializerImpl {
     * @param map - namespace prefix map
     * @param localPrefixesMap - local prefixes map
     */
-    _recordNamespaceInformation(node, map, localPrefixesMap) {
+    XMLSerializerImpl.prototype._recordNamespaceInformation = function (node, map, localPrefixesMap) {
+        var e_5, _a;
         /**
          * 1. Let default namespace attr value be null.
          */
-        let defaultNamespaceAttrValue = null;
-        /**
-         * 2. Main: For each attribute attr in element's attributes, in the order
-         * they are specified in the element's attribute list:
-         */
-        for (const attr of node.attributes) {
+        var defaultNamespaceAttrValue = null;
+        try {
             /**
-             * _Note:_ The following conditional steps find namespace prefixes. Only
-             * attributes in the XMLNS namespace are considered (e.g., attributes made
-             * to look like namespace declarations via
-             * setAttribute("xmlns:pretend-prefix", "pretend-namespace") are not
-             * included).
+             * 2. Main: For each attribute attr in element's attributes, in the order
+             * they are specified in the element's attribute list:
              */
-            /** 2.1. Let attribute namespace be the value of attr's namespaceURI value. */
-            let attributeNamespace = attr.namespaceURI;
-            /** 2.2. Let attribute prefix be the value of attr's prefix. */
-            let attributePrefix = attr.prefix;
-            /** 2.3. If the attribute namespace is the XMLNS namespace, then: */
-            if (attributeNamespace === infra_1.namespace.XMLNS) {
+            for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var attr = _c.value;
                 /**
-                 * 2.3.1. If attribute prefix is null, then attr is a default namespace
-                 * declaration. Set the default namespace attr value to attr's value and
-                 * stop running these steps, returning to Main to visit the next
-                 * attribute.
+                 * _Note:_ The following conditional steps find namespace prefixes. Only
+                 * attributes in the XMLNS namespace are considered (e.g., attributes made
+                 * to look like namespace declarations via
+                 * setAttribute("xmlns:pretend-prefix", "pretend-namespace") are not
+                 * included).
                  */
-                if (attributePrefix === null) {
-                    defaultNamespaceAttrValue = attr.value;
-                    continue;
+                /** 2.1. Let attribute namespace be the value of attr's namespaceURI value. */
+                var attributeNamespace = attr.namespaceURI;
+                /** 2.2. Let attribute prefix be the value of attr's prefix. */
+                var attributePrefix = attr.prefix;
+                /** 2.3. If the attribute namespace is the XMLNS namespace, then: */
+                if (attributeNamespace === infra_1.namespace.XMLNS) {
                     /**
-                     * 2.3.2. Otherwise, the attribute prefix is not null and attr is a
-                     * namespace prefix definition. Run the following steps:
-                     */
-                }
-                else {
-                    /** 2.3.2.1. Let prefix definition be the value of attr's localName. */
-                    let prefixDefinition = attr.localName;
-                    /** 2.3.2.2. Let namespace definition be the value of attr's value. */
-                    let namespaceDefinition = attr.value;
-                    /**
-                     * 2.3.2.3. If namespace definition is the XML namespace, then stop
-                     * running these steps, and return to Main to visit the next
+                     * 2.3.1. If attribute prefix is null, then attr is a default namespace
+                     * declaration. Set the default namespace attr value to attr's value and
+                     * stop running these steps, returning to Main to visit the next
                      * attribute.
-                     *
-                     * _Note:_ XML namespace definitions in prefixes are completely
-                     * ignored (in order to avoid unnecessary work when there might be
-                     * prefix conflicts). XML namespaced elements are always handled
-                     * uniformly by prefixing (and overriding if necessary) the element's
-                     * localname with the reserved "xml" prefix.
                      */
-                    if (namespaceDefinition === infra_1.namespace.XML) {
+                    if (attributePrefix === null) {
+                        defaultNamespaceAttrValue = attr.value;
                         continue;
+                        /**
+                         * 2.3.2. Otherwise, the attribute prefix is not null and attr is a
+                         * namespace prefix definition. Run the following steps:
+                         */
                     }
-                    /**
-                     * 2.3.2.4. If namespace definition is the empty string (the
-                     * declarative form of having no namespace), then let namespace
-                     * definition be null instead.
-                     */
-                    if (namespaceDefinition === '') {
-                        namespaceDefinition = null;
+                    else {
+                        /** 2.3.2.1. Let prefix definition be the value of attr's localName. */
+                        var prefixDefinition = attr.localName;
+                        /** 2.3.2.2. Let namespace definition be the value of attr's value. */
+                        var namespaceDefinition = attr.value;
+                        /**
+                         * 2.3.2.3. If namespace definition is the XML namespace, then stop
+                         * running these steps, and return to Main to visit the next
+                         * attribute.
+                         *
+                         * _Note:_ XML namespace definitions in prefixes are completely
+                         * ignored (in order to avoid unnecessary work when there might be
+                         * prefix conflicts). XML namespaced elements are always handled
+                         * uniformly by prefixing (and overriding if necessary) the element's
+                         * localname with the reserved "xml" prefix.
+                         */
+                        if (namespaceDefinition === infra_1.namespace.XML) {
+                            continue;
+                        }
+                        /**
+                         * 2.3.2.4. If namespace definition is the empty string (the
+                         * declarative form of having no namespace), then let namespace
+                         * definition be null instead.
+                         */
+                        if (namespaceDefinition === '') {
+                            namespaceDefinition = null;
+                        }
+                        /**
+                         * 2.3.2.5. If prefix definition is found in map given the namespace
+                         * namespace definition, then stop running these steps, and return to
+                         * Main to visit the next attribute.
+                         *
+                         * _Note:_ This step avoids adding duplicate prefix definitions for
+                         * the same namespace in the map. This has the side-effect of avoiding
+                         * later serialization of duplicate namespace prefix declarations in
+                         * any descendant nodes.
+                         */
+                        if (map.has(prefixDefinition, namespaceDefinition)) {
+                            continue;
+                        }
+                        /**
+                         * 2.3.2.6. Add the prefix prefix definition to map given namespace
+                         * namespace definition.
+                         */
+                        map.set(prefixDefinition, namespaceDefinition);
+                        /**
+                         * 2.3.2.7. Add the value of prefix definition as a new key to the
+                         * local prefixes map, with the namespace definition as the key's
+                         * value replacing the value of null with the empty string if
+                         * applicable.
+                         */
+                        localPrefixesMap[prefixDefinition] = namespaceDefinition || '';
                     }
-                    /**
-                     * 2.3.2.5. If prefix definition is found in map given the namespace
-                     * namespace definition, then stop running these steps, and return to
-                     * Main to visit the next attribute.
-                     *
-                     * _Note:_ This step avoids adding duplicate prefix definitions for
-                     * the same namespace in the map. This has the side-effect of avoiding
-                     * later serialization of duplicate namespace prefix declarations in
-                     * any descendant nodes.
-                     */
-                    if (map.has(prefixDefinition, namespaceDefinition)) {
-                        continue;
-                    }
-                    /**
-                     * 2.3.2.6. Add the prefix prefix definition to map given namespace
-                     * namespace definition.
-                     */
-                    map.set(prefixDefinition, namespaceDefinition);
-                    /**
-                     * 2.3.2.7. Add the value of prefix definition as a new key to the
-                     * local prefixes map, with the namespace definition as the key's
-                     * value replacing the value of null with the empty string if
-                     * applicable.
-                     */
-                    localPrefixesMap[prefixDefinition] = namespaceDefinition || '';
                 }
             }
         }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
         /**
          * 3. Return the value of default namespace attr value.
          *
@@ -31317,7 +61050,7 @@ class XMLSerializerImpl {
          * converted to null.
          */
         return defaultNamespaceAttrValue;
-    }
+    };
     /**
     * Generates a new prefix for the given namespace.
     *
@@ -31325,7 +61058,7 @@ class XMLSerializerImpl {
     * @param prefixMap - namespace prefix map
     * @param prefixIndex - generated namespace prefix index
     */
-    _generatePrefix(newNamespace, prefixMap, prefixIndex) {
+    XMLSerializerImpl.prototype._generatePrefix = function (newNamespace, prefixMap, prefixIndex) {
         /**
          * 1. Let generated prefix be the concatenation of the string "ns" and the
          * current numerical value of prefix index.
@@ -31333,18 +61066,18 @@ class XMLSerializerImpl {
          * 3. Add to map the generated prefix given the new namespace namespace.
          * 4. Return the value of generated prefix.
          */
-        let generatedPrefix = "ns" + prefixIndex.value;
+        var generatedPrefix = "ns" + prefixIndex.value;
         prefixIndex.value++;
         prefixMap.set(generatedPrefix, newNamespace);
         return generatedPrefix;
-    }
+    };
     /**
      * Produces an XML serialization of an attribute value.
      *
      * @param value - attribute value
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeAttributeValue(value, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeAttributeValue = function (value, requireWellFormed) {
         /**
          * From: https://w3c.github.io/DOM-Parsing/#dfn-serializing-an-attribute-value
          *
@@ -31353,7 +61086,7 @@ class XMLSerializerImpl {
          * production, then throw an exception; the serialization of this attribute
          * value would fail to produce a well-formed element serialization.
          */
-        if (requireWellFormed && value !== null && !(0, algorithm_1.xml_isLegalChar)(value)) {
+        if (requireWellFormed && value !== null && !algorithm_1.xml_isLegalChar(value)) {
             throw new Error("Invalid characters in attribute value.");
         }
         /**
@@ -31373,9 +61106,9 @@ class XMLSerializerImpl {
          * grammar requirement in the XML specification's AttValue production by
          * also replacing ">" characters.
          */
-        let result = "";
-        for (let i = 0; i < value.length; i++) {
-            const c = value[i];
+        var result = "";
+        for (var i = 0; i < value.length; i++) {
+            var c = value[i];
             if (c === "\"")
                 result += "&quot;";
             else if (c === "&")
@@ -31388,14 +61121,15 @@ class XMLSerializerImpl {
                 result += c;
         }
         return result;
-    }
+    };
     /**
      * Produces an XML serialization of an element node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeElement(node, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeElement = function (node, requireWellFormed) {
+        var e_6, _a;
         /**
          * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node
          *
@@ -31405,7 +61139,7 @@ class XMLSerializerImpl {
          * serialization of this node would not be a well-formed element.
          */
         if (requireWellFormed && (node.localName.indexOf(":") !== -1 ||
-            !(0, algorithm_1.xml_isName)(node.localName))) {
+            !algorithm_1.xml_isName(node.localName))) {
             throw new Error("Node local name contains invalid characters (well-formed required).");
         }
         /**
@@ -31438,7 +61172,7 @@ class XMLSerializerImpl {
          * 9. Let inherited ns be a copy of namespace.
          * 10. Let ns be the value of node's namespaceURI attribute.
          */
-        let skipEndTag = false;
+        var skipEndTag = false;
         /** 11. If inherited ns is equal to ns, then: */
         /**
          * 11.1. If local default namespace is not null, then set ignore
@@ -31448,9 +61182,9 @@ class XMLSerializerImpl {
          * 11.3. Otherwise, append to qualified name the value of node's
          * localName. The node's prefix if it exists, is dropped.
          */
-        const qualifiedName = node.localName;
+        var qualifiedName = node.localName;
         /** 11.4. Append the value of qualified name to markup. */
-        let markup = "<" + qualifiedName;
+        var markup = "<" + qualifiedName;
         /**
          * 13. Append to markup the result of the XML serialization of node's
          * attributes given map, prefix index, local prefixes map, ignore namespace
@@ -31483,23 +61217,33 @@ class XMLSerializerImpl {
          */
         if (skipEndTag)
             return markup;
-        /**
-         * 18. If ns is the HTML namespace, and the node's localName matches the
-         * string "template", then this is a template element. Append to markup the
-         * result of XML serializing a DocumentFragment node given the template
-         * element's template contents (a DocumentFragment), providing inherited
-         * ns, map, prefix index, and the require well-formed flag.
-         *
-         * _Note:_ This allows template content to round-trip, given the rules for
-         * parsing XHTML documents.
-         *
-         * 19. Otherwise, append to markup the result of running the XML
-         * serialization algorithm on each of node's children, in tree order,
-         * providing inherited ns, map, prefix index, and the require well-formed
-         * flag.
-         */
-        for (const childNode of node._children) {
-            markup += this._serializeNode(childNode, requireWellFormed);
+        try {
+            /**
+             * 18. If ns is the HTML namespace, and the node's localName matches the
+             * string "template", then this is a template element. Append to markup the
+             * result of XML serializing a DocumentFragment node given the template
+             * element's template contents (a DocumentFragment), providing inherited
+             * ns, map, prefix index, and the require well-formed flag.
+             *
+             * _Note:_ This allows template content to round-trip, given the rules for
+             * parsing XHTML documents.
+             *
+             * 19. Otherwise, append to markup the result of running the XML
+             * serialization algorithm on each of node's children, in tree order,
+             * providing inherited ns, map, prefix index, and the require well-formed
+             * flag.
+             */
+            for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var childNode = _c.value;
+                markup += this._serializeNode(childNode, requireWellFormed);
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
         }
         /**
          * 20. Append the following to markup, in the order listed:
@@ -31512,14 +61256,15 @@ class XMLSerializerImpl {
          * 21. Return the value of markup.
          */
         return markup;
-    }
+    };
     /**
      * Produces an XML serialization of a document node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeDocument(node, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeDocument = function (node, requireWellFormed) {
+        var e_7, _a;
         /**
          * If the require well-formed flag is set (its value is true), and this node
          * has no documentElement (the documentElement attribute's value is null),
@@ -31543,19 +61288,30 @@ class XMLSerializerImpl {
          *
          * 3. Return the value of serialized document.
         */
-        let serializedDocument = "";
-        for (const childNode of node._children) {
-            serializedDocument += this._serializeNode(childNode, requireWellFormed);
+        var serializedDocument = "";
+        try {
+            for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var childNode = _c.value;
+                serializedDocument += this._serializeNode(childNode, requireWellFormed);
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
         }
         return serializedDocument;
-    }
+    };
     /**
      * Produces an XML serialization of a document fragment node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeDocumentFragment(node, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeDocumentFragment = function (node, requireWellFormed) {
+        var e_8, _a;
         /**
          * 1. Let markup the empty string.
          * 2. For each child child of node, in tree order, run the XML serialization
@@ -31563,19 +61319,30 @@ class XMLSerializerImpl {
          * index, and flag require well-formed. Concatenate the result to markup.
          * 3. Return the value of markup.
          */
-        let markup = "";
-        for (const childNode of node._children) {
-            markup += this._serializeNode(childNode, requireWellFormed);
+        var markup = "";
+        try {
+            for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var childNode = _c.value;
+                markup += this._serializeNode(childNode, requireWellFormed);
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
         }
         return markup;
-    }
+    };
     /**
      * Produces an XML serialization of the attributes of an element node.
      *
      * @param node - node to serialize
      * @param requireWellFormed - whether to check conformance
      */
-    _serializeAttributes(node, requireWellFormed) {
+    XMLSerializerImpl.prototype._serializeAttributes = function (node, requireWellFormed) {
+        var e_9, _a;
         /**
          * 1. Let result be the empty string.
          * 2. Let localname set be a new empty namespace localname set. This
@@ -31586,66 +61353,80 @@ class XMLSerializerImpl {
          * This can occur when two otherwise identical attributes on the same
          * element differ only by their prefix values.
          */
-        let result = "";
-        const localNameSet = requireWellFormed ? {} : undefined;
-        /**
-         * 3. Loop: For each attribute attr in element's attributes, in the order
-         * they are specified in the element's attribute list:
-         */
-        for (const attr of node.attributes) {
+        var result = "";
+        var localNameSet = requireWellFormed ? {} : undefined;
+        try {
             /**
-             * 3.1. If the require well-formed flag is set (its value is true), and the
-             * localname set contains a tuple whose values match those of a new tuple
-             * consisting of attr's namespaceURI attribute and localName attribute,
-             * then throw an exception; the serialization of this attr would fail to
-             * produce a well-formed element serialization.
+             * 3. Loop: For each attribute attr in element's attributes, in the order
+             * they are specified in the element's attribute list:
              */
-            if (requireWellFormed && localNameSet && (attr.localName in localNameSet)) {
-                throw new Error("Element contains duplicate attributes (well-formed required).");
+            for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var attr = _c.value;
+                /**
+                 * 3.1. If the require well-formed flag is set (its value is true), and the
+                 * localname set contains a tuple whose values match those of a new tuple
+                 * consisting of attr's namespaceURI attribute and localName attribute,
+                 * then throw an exception; the serialization of this attr would fail to
+                 * produce a well-formed element serialization.
+                 */
+                if (requireWellFormed && localNameSet && (attr.localName in localNameSet)) {
+                    throw new Error("Element contains duplicate attributes (well-formed required).");
+                }
+                /**
+                 * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
+                 * localName attribute, and add it to the localname set.
+                 * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
+                 * 3.4. Let candidate prefix be null.
+                 */
+                if (requireWellFormed && localNameSet)
+                    localNameSet[attr.localName] = true;
+                /** 3.5. If attribute namespace is not null, then run these sub-steps: */
+                /**
+                 * 3.6. Append a " " (U+0020 SPACE) to result.
+                 * 3.7. If candidate prefix is not null, then append to result the
+                 * concatenation of candidate prefix with ":" (U+003A COLON).
+                 */
+                /**
+                 * 3.8. If the require well-formed flag is set (its value is true), and
+                 * this attr's localName attribute contains the character
+                 * ":" (U+003A COLON) or does not match the XML Name production or
+                 * equals "xmlns" and attribute namespace is null, then throw an
+                 * exception; the serialization of this attr would not be a
+                 * well-formed attribute.
+                 */
+                if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
+                    !algorithm_1.xml_isName(attr.localName))) {
+                    throw new Error("Attribute local name contains invalid characters (well-formed required).");
+                }
+                /**
+                 * 3.9. Append the following strings to result, in the order listed:
+                 * 3.9.1. The value of attr's localName;
+                 * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
+                 * 3.9.3. The result of serializing an attribute value given attr's value
+                 * attribute and the require well-formed flag as input;
+                 * 3.9.4. """ (U+0022 QUOTATION MARK).
+                 */
+                result += " " + attr.localName + "=\"" +
+                    this._serializeAttributeValue(attr.value, requireWellFormed) + "\"";
             }
-            /**
-             * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
-             * localName attribute, and add it to the localname set.
-             * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
-             * 3.4. Let candidate prefix be null.
-             */
-            if (requireWellFormed && localNameSet)
-                localNameSet[attr.localName] = true;
-            /** 3.5. If attribute namespace is not null, then run these sub-steps: */
-            /**
-             * 3.6. Append a " " (U+0020 SPACE) to result.
-             * 3.7. If candidate prefix is not null, then append to result the
-             * concatenation of candidate prefix with ":" (U+003A COLON).
-             */
-            /**
-             * 3.8. If the require well-formed flag is set (its value is true), and
-             * this attr's localName attribute contains the character
-             * ":" (U+003A COLON) or does not match the XML Name production or
-             * equals "xmlns" and attribute namespace is null, then throw an
-             * exception; the serialization of this attr would not be a
-             * well-formed attribute.
-             */
-            if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
-                !(0, algorithm_1.xml_isName)(attr.localName))) {
-                throw new Error("Attribute local name contains invalid characters (well-formed required).");
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
             }
-            /**
-             * 3.9. Append the following strings to result, in the order listed:
-             * 3.9.1. The value of attr's localName;
-             * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
-             * 3.9.3. The result of serializing an attribute value given attr's value
-             * attribute and the require well-formed flag as input;
-             * 3.9.4. """ (U+0022 QUOTATION MARK).
-             */
-            result += " " + attr.localName + "=\"" +
-                this._serializeAttributeValue(attr.value, requireWellFormed) + "\"";
+            finally { if (e_9) throw e_9.error; }
         }
         /**
          * 4. Return the value of result.
          */
         return result;
-    }
-}
+    };
+    XMLSerializerImpl._VoidElementNames = new Set(['area', 'base', 'basefont',
+        'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
+        'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
+    return XMLSerializerImpl;
+}());
 exports.XMLSerializerImpl = XMLSerializerImpl;
 //# sourceMappingURL=XMLSerializerImpl.js.map
 
@@ -31657,10 +61438,9 @@ exports.XMLSerializerImpl = XMLSerializerImpl;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLSerializer = void 0;
 // Export classes
 var XMLSerializerImpl_1 = __nccwpck_require__(85039);
-Object.defineProperty(exports, "XMLSerializer", ({ enumerable: true, get: function () { return XMLSerializerImpl_1.XMLSerializerImpl; } }));
+exports.XMLSerializer = XMLSerializerImpl_1.XMLSerializerImpl;
 //# sourceMappingURL=index.js.map
 
 /***/ }),
@@ -31671,26 +61451,28 @@ Object.defineProperty(exports, "XMLSerializer", ({ enumerable: true, get: functi
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Cast = void 0;
-const Guard_1 = __nccwpck_require__(66862);
+var Guard_1 = __nccwpck_require__(66862);
 /**
  * Contains type casts for DOM objects.
  */
-class Cast {
+var Cast = /** @class */ (function () {
+    function Cast() {
+    }
     /**
      * Casts the given object to a `Node`.
      *
      * @param a - the object to cast
      */
-    static asNode(a) {
+    Cast.asNode = function (a) {
         if (Guard_1.Guard.isNode(a)) {
             return a;
         }
         else {
             throw new Error("Invalid object. Node expected.");
         }
-    }
-}
+    };
+    return Cast;
+}());
 exports.Cast = Cast;
 //# sourceMappingURL=Cast.js.map
 
@@ -31702,51 +61484,64 @@ exports.Cast = Cast;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.EmptySet = void 0;
-class EmptySet {
-    get size() {
-        return 0;
+var EmptySet = /** @class */ (function () {
+    function EmptySet() {
     }
-    add(value) {
+    Object.defineProperty(EmptySet.prototype, "size", {
+        get: function () {
+            return 0;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    EmptySet.prototype.add = function (value) {
         throw new Error("Cannot add to an empty set.");
-    }
-    clear() {
+    };
+    EmptySet.prototype.clear = function () {
         // no-op
-    }
-    delete(value) {
+    };
+    EmptySet.prototype.delete = function (value) {
         return false;
-    }
-    forEach(callbackfn, thisArg) {
+    };
+    EmptySet.prototype.forEach = function (callbackfn, thisArg) {
         // no-op
-    }
-    has(value) {
+    };
+    EmptySet.prototype.has = function (value) {
         return false;
-    }
-    [Symbol.iterator]() {
+    };
+    EmptySet.prototype[Symbol.iterator] = function () {
         return new EmptySetIterator();
-    }
-    entries() {
+    };
+    EmptySet.prototype.entries = function () {
         return new EmptySetIterator();
-    }
-    keys() {
+    };
+    EmptySet.prototype.keys = function () {
         return new EmptySetIterator();
-    }
-    values() {
+    };
+    EmptySet.prototype.values = function () {
         return new EmptySetIterator();
-    }
-    get [Symbol.toStringTag]() {
-        return "EmptySet";
-    }
-}
+    };
+    Object.defineProperty(EmptySet.prototype, Symbol.toStringTag, {
+        get: function () {
+            return "EmptySet";
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return EmptySet;
+}());
 exports.EmptySet = EmptySet;
-class EmptySetIterator {
-    [Symbol.iterator]() {
+var EmptySetIterator = /** @class */ (function () {
+    function EmptySetIterator() {
+    }
+    EmptySetIterator.prototype[Symbol.iterator] = function () {
         return this;
-    }
-    next() {
+    };
+    EmptySetIterator.prototype.next = function () {
         return { done: true, value: null };
-    }
-}
+    };
+    return EmptySetIterator;
+}());
 //# sourceMappingURL=EmptySet.js.map
 
 /***/ }),
@@ -31757,138 +61552,139 @@ class EmptySetIterator {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Guard = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
+var interfaces_1 = __nccwpck_require__(27305);
 /**
  * Contains user-defined type guards for DOM objects.
  */
-class Guard {
+var Guard = /** @class */ (function () {
+    function Guard() {
+    }
     /**
      * Determines if the given object is a `Node`.
      *
      * @param a - the object to check
      */
-    static isNode(a) {
+    Guard.isNode = function (a) {
         return (!!a && a._nodeType !== undefined);
-    }
+    };
     /**
      * Determines if the given object is a `Document`.
      *
      * @param a - the object to check
      */
-    static isDocumentNode(a) {
+    Guard.isDocumentNode = function (a) {
         return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Document);
-    }
+    };
     /**
      * Determines if the given object is a `DocumentType`.
      *
      * @param a - the object to check
      */
-    static isDocumentTypeNode(a) {
+    Guard.isDocumentTypeNode = function (a) {
         return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.DocumentType);
-    }
+    };
     /**
      * Determines if the given object is a `DocumentFragment`.
      *
      * @param a - the object to check
      */
-    static isDocumentFragmentNode(a) {
+    Guard.isDocumentFragmentNode = function (a) {
         return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.DocumentFragment);
-    }
+    };
     /**
      * Determines if the given object is a `Attr`.
      *
      * @param a - the object to check
      */
-    static isAttrNode(a) {
+    Guard.isAttrNode = function (a) {
         return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Attribute);
-    }
+    };
     /**
      * Determines if the given node is a `CharacterData` node.
      *
      * @param a - the object to check
      */
-    static isCharacterDataNode(a) {
+    Guard.isCharacterDataNode = function (a) {
         if (!Guard.isNode(a))
             return false;
-        const type = a._nodeType;
+        var type = a._nodeType;
         return (type === interfaces_1.NodeType.Text ||
             type === interfaces_1.NodeType.ProcessingInstruction ||
             type === interfaces_1.NodeType.Comment ||
             type === interfaces_1.NodeType.CData);
-    }
+    };
     /**
      * Determines if the given object is a `Text` or a `CDATASection`.
      *
      * @param a - the object to check
      */
-    static isTextNode(a) {
+    Guard.isTextNode = function (a) {
         return (Guard.isNode(a) && (a._nodeType === interfaces_1.NodeType.Text || a._nodeType === interfaces_1.NodeType.CData));
-    }
+    };
     /**
      * Determines if the given object is a `Text`.
      *
      * @param a - the object to check
      */
-    static isExclusiveTextNode(a) {
+    Guard.isExclusiveTextNode = function (a) {
         return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Text);
-    }
+    };
     /**
      * Determines if the given object is a `CDATASection`.
      *
      * @param a - the object to check
      */
-    static isCDATASectionNode(a) {
+    Guard.isCDATASectionNode = function (a) {
         return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.CData);
-    }
+    };
     /**
      * Determines if the given object is a `Comment`.
      *
      * @param a - the object to check
      */
-    static isCommentNode(a) {
+    Guard.isCommentNode = function (a) {
         return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Comment);
-    }
+    };
     /**
      * Determines if the given object is a `ProcessingInstruction`.
      *
      * @param a - the object to check
      */
-    static isProcessingInstructionNode(a) {
+    Guard.isProcessingInstructionNode = function (a) {
         return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.ProcessingInstruction);
-    }
+    };
     /**
      * Determines if the given object is an `Element`.
      *
      * @param a - the object to check
      */
-    static isElementNode(a) {
+    Guard.isElementNode = function (a) {
         return (Guard.isNode(a) && a._nodeType === interfaces_1.NodeType.Element);
-    }
+    };
     /**
      * Determines if the given object is a custom `Element`.
      *
      * @param a - the object to check
      */
-    static isCustomElementNode(a) {
+    Guard.isCustomElementNode = function (a) {
         return (Guard.isElementNode(a) && a._customElementState === "custom");
-    }
+    };
     /**
      * Determines if the given object is a `ShadowRoot`.
      *
      * @param a - the object to check
      */
-    static isShadowRoot(a) {
+    Guard.isShadowRoot = function (a) {
         return (!!a && a.host !== undefined);
-    }
+    };
     /**
      * Determines if the given object is a `MouseEvent`.
      *
      * @param a - the object to check
      */
-    static isMouseEvent(a) {
+    Guard.isMouseEvent = function (a) {
         return (!!a && a.screenX !== undefined && a.screenY != undefined);
-    }
+    };
     /**
      * Determines if the given object is a slotable.
      *
@@ -31897,52 +61693,53 @@ class Guard {
      *
      * @param a - the object to check
      */
-    static isSlotable(a) {
+    Guard.isSlotable = function (a) {
         return (!!a && a._name !== undefined && a._assignedSlot !== undefined &&
             (Guard.isTextNode(a) || Guard.isElementNode(a)));
-    }
+    };
     /**
      * Determines if the given object is a slot.
      *
      * @param a - the object to check
      */
-    static isSlot(a) {
+    Guard.isSlot = function (a) {
         return (!!a && a._name !== undefined && a._assignedNodes !== undefined &&
             Guard.isElementNode(a));
-    }
+    };
     /**
      * Determines if the given object is a `Window`.
      *
      * @param a - the object to check
      */
-    static isWindow(a) {
+    Guard.isWindow = function (a) {
         return (!!a && a.navigator !== undefined);
-    }
+    };
     /**
      * Determines if the given object is an `EventListener`.
      *
      * @param a - the object to check
      */
-    static isEventListener(a) {
+    Guard.isEventListener = function (a) {
         return (!!a && a.handleEvent !== undefined);
-    }
+    };
     /**
      * Determines if the given object is a `RegisteredObserver`.
      *
      * @param a - the object to check
      */
-    static isRegisteredObserver(a) {
+    Guard.isRegisteredObserver = function (a) {
         return (!!a && a.observer !== undefined && a.options !== undefined);
-    }
+    };
     /**
    * Determines if the given object is a `TransientRegisteredObserver`.
    *
    * @param a - the object to check
    */
-    static isTransientRegisteredObserver(a) {
+    Guard.isTransientRegisteredObserver = function (a) {
         return (!!a && a.source !== undefined && Guard.isRegisteredObserver(a));
-    }
-}
+    };
+    return Guard;
+}());
 exports.Guard = Guard;
 //# sourceMappingURL=Guard.js.map
 
@@ -31954,13 +61751,12 @@ exports.Guard = Guard;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.EmptySet = exports.Guard = exports.Cast = void 0;
 var Cast_1 = __nccwpck_require__(75483);
-Object.defineProperty(exports, "Cast", ({ enumerable: true, get: function () { return Cast_1.Cast; } }));
+exports.Cast = Cast_1.Cast;
 var Guard_1 = __nccwpck_require__(66862);
-Object.defineProperty(exports, "Guard", ({ enumerable: true, get: function () { return Guard_1.Guard; } }));
+exports.Guard = Guard_1.Guard;
 var EmptySet_1 = __nccwpck_require__(88392);
-Object.defineProperty(exports, "EmptySet", ({ enumerable: true, get: function () { return EmptySet_1.EmptySet; } }));
+exports.EmptySet = EmptySet_1.EmptySet;
 //# sourceMappingURL=index.js.map
 
 /***/ }),
@@ -31971,9 +61767,7 @@ Object.defineProperty(exports, "EmptySet", ({ enumerable: true, get: function ()
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.forgivingBase64Encode = forgivingBase64Encode;
-exports.forgivingBase64Decode = forgivingBase64Decode;
-const CodePoints_1 = __nccwpck_require__(28548);
+var CodePoints_1 = __nccwpck_require__(28548);
 /**
  * Base-64 encodes the given string.
  *
@@ -31987,6 +61781,7 @@ function forgivingBase64Encode(input) {
      */
     return Buffer.from(input).toString('base64');
 }
+exports.forgivingBase64Encode = forgivingBase64Encode;
 /**
  * Decodes a base-64 string.
  *
@@ -32050,6 +61845,7 @@ function forgivingBase64Decode(input) {
      */
     return Buffer.from(input, 'base64').toString('utf8');
 }
+exports.forgivingBase64Decode = forgivingBase64Decode;
 //# sourceMappingURL=Base64.js.map
 
 /***/ }),
@@ -32060,7 +61856,6 @@ function forgivingBase64Decode(input) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.isASCIIByte = isASCIIByte;
 /**
  * Determines if the given number is an ASCII byte.
  *
@@ -32072,23 +61867,37 @@ function isASCIIByte(byte) {
      */
     return byte >= 0x00 && byte <= 0x7F;
 }
+exports.isASCIIByte = isASCIIByte;
 //# sourceMappingURL=Byte.js.map
 
 /***/ }),
 
 /***/ 71627:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.length = length;
-exports.byteLowercase = byteLowercase;
-exports.byteUppercase = byteUppercase;
-exports.byteCaseInsensitiveMatch = byteCaseInsensitiveMatch;
-exports.startsWith = startsWith;
-exports.byteLessThan = byteLessThan;
-exports.isomorphicDecode = isomorphicDecode;
 /**
  * Returns the count of bytes in a sequence.
  *
@@ -32100,6 +61909,7 @@ function length(list) {
      */
     return list.length;
 }
+exports.length = length;
 /**
  * Converts each byte to lowercase.
  *
@@ -32110,13 +61920,14 @@ function byteLowercase(list) {
      * To byte-lowercase a byte sequence, increase each byte it contains, in the
      * range 0x41 (A) to 0x5A (Z), inclusive, by 0x20.
      */
-    for (let i = 0; i < list.length; i++) {
-        const c = list[i];
+    for (var i = 0; i < list.length; i++) {
+        var c = list[i];
         if (c >= 0x41 && c <= 0x5A) {
             list[i] = c + 0x20;
         }
     }
 }
+exports.byteLowercase = byteLowercase;
 /**
  * Converts each byte to uppercase.
  *
@@ -32127,13 +61938,14 @@ function byteUppercase(list) {
      * To byte-uppercase a byte sequence, subtract each byte it contains, in the
      * range 0x61 (a) to 0x7A (z), inclusive, by 0x20.
      */
-    for (let i = 0; i < list.length; i++) {
-        const c = list[i];
+    for (var i = 0; i < list.length; i++) {
+        var c = list[i];
         if (c >= 0x61 && c <= 0x7A) {
             list[i] = c - 0x20;
         }
     }
 }
+exports.byteUppercase = byteUppercase;
 /**
  * Compares two byte sequences.
  *
@@ -32147,9 +61959,9 @@ function byteCaseInsensitiveMatch(listA, listB) {
      */
     if (listA.length !== listB.length)
         return false;
-    for (let i = 0; i < listA.length; i++) {
-        let a = listA[i];
-        let b = listB[i];
+    for (var i = 0; i < listA.length; i++) {
+        var a = listA[i];
+        var b = listB[i];
         if (a >= 0x41 && a <= 0x5A)
             a += 0x20;
         if (b >= 0x41 && b <= 0x5A)
@@ -32159,6 +61971,7 @@ function byteCaseInsensitiveMatch(listA, listB) {
     }
     return true;
 }
+exports.byteCaseInsensitiveMatch = byteCaseInsensitiveMatch;
 /**
  * Determines if `listA` starts with `listB`.
  *
@@ -32175,7 +61988,7 @@ function startsWith(listA, listB) {
      * 2.5. Return false if aByte is not bByte.
      * 2.6. Set i to i + 1.
      */
-    let i = 0;
+    var i = 0;
     while (true) {
         if (i >= listA.length)
             return false;
@@ -32186,6 +61999,7 @@ function startsWith(listA, listB) {
         i++;
     }
 }
+exports.startsWith = startsWith;
 /**
  * Determines if `listA` is less than `listB`.
  *
@@ -32202,14 +62016,14 @@ function byteLessThan(listA, listB) {
      * 4. If the nth byte of a is less than the nth byte of b, then return true.
      * 5. Return false.
      */
-    let i = 0;
+    var i = 0;
     while (true) {
         if (i >= listA.length)
             return false;
         if (i >= listB.length)
             return true;
-        const a = listA[i];
-        const b = listB[i];
+        var a = listA[i];
+        var b = listB[i];
         if (a < b)
             return true;
         else if (a > b)
@@ -32217,6 +62031,7 @@ function byteLessThan(listA, listB) {
         i++;
     }
 }
+exports.byteLessThan = byteLessThan;
 /**
  * Decodes a byte sequence into a string.
  *
@@ -32228,8 +62043,9 @@ function isomorphicDecode(list) {
      * equal to input’s length and whose code points have the same values as
      * input’s bytes, in the same order.
      */
-    return String.fromCodePoint(...list);
+    return String.fromCodePoint.apply(String, __spread(list));
 }
+exports.isomorphicDecode = isomorphicDecode;
 //# sourceMappingURL=ByteSequence.js.map
 
 /***/ }),
@@ -32240,7 +62056,6 @@ function isomorphicDecode(list) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ASCIIAlphanumeric = exports.ASCIIAlpha = exports.ASCIILowerAlpha = exports.ASCIIUpperAlpha = exports.ASCIIHexDigit = exports.ASCIILowerHexDigit = exports.ASCIIUpperHexDigit = exports.ASCIIDigit = exports.Control = exports.C0ControlOrSpace = exports.C0Control = exports.ASCIIWhiteSpace = exports.ASCIITabOrNewLine = exports.ASCIICodePoint = exports.NonCharacter = exports.ScalarValue = exports.Surrogate = void 0;
 /**
  * A surrogate is a code point that is in the range U+D800 to U+DFFF, inclusive.
  */
@@ -32328,16 +62143,23 @@ exports.ASCIIAlphanumeric = /[0-9A-Za-z]/;
 /***/ }),
 
 /***/ 99387:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.parseJSONFromBytes = parseJSONFromBytes;
-exports.serializeJSONToBytes = serializeJSONToBytes;
-exports.parseJSONIntoInfraValues = parseJSONIntoInfraValues;
-exports.convertAJSONDerivedJavaScriptValueToAnInfraValue = convertAJSONDerivedJavaScriptValueToAnInfraValue;
-const util_1 = __nccwpck_require__(76195);
+var util_1 = __nccwpck_require__(76195);
 /**
  * Parses the given byte sequence representing a JSON string into an object.
  *
@@ -32348,9 +62170,10 @@ function parseJSONFromBytes(bytes) {
      * 1. Let jsonText be the result of running UTF-8 decode on bytes. [ENCODING]
      * 2. Return ? Call(%JSONParse%, undefined, « jsonText »).
      */
-    const jsonText = (0, util_1.utf8Decode)(bytes);
+    var jsonText = util_1.utf8Decode(bytes);
     return JSON.parse.call(undefined, jsonText);
 }
+exports.parseJSONFromBytes = parseJSONFromBytes;
 /**
  * Serialize the given JavaScript value into a byte sequence.
  *
@@ -32361,9 +62184,10 @@ function serializeJSONToBytes(value) {
      * 1. Let jsonString be ? Call(%JSONStringify%, undefined, « value »).
      * 2. Return the result of running UTF-8 encode on jsonString. [ENCODING]
      */
-    const jsonString = JSON.stringify.call(undefined, value);
-    return (0, util_1.utf8Encode)(jsonString);
+    var jsonString = JSON.stringify.call(undefined, value);
+    return util_1.utf8Encode(jsonString);
 }
+exports.serializeJSONToBytes = serializeJSONToBytes;
 /**
  * Parses the given JSON string into a Realm-independent JavaScript value.
  *
@@ -32375,19 +62199,21 @@ function parseJSONIntoInfraValues(jsonText) {
      * 2. Return the result of converting a JSON-derived JavaScript value to an
      * Infra value, given jsValue.
      */
-    const jsValue = JSON.parse.call(undefined, jsonText);
+    var jsValue = JSON.parse.call(undefined, jsonText);
     return convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue);
 }
+exports.parseJSONIntoInfraValues = parseJSONIntoInfraValues;
 /**
  * Parses the value into a Realm-independent JavaScript value.
  *
  * @param jsValue - a JavaScript value
  */
 function convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue) {
+    var e_1, _a;
     /**
      * 1. If Type(jsValue) is Null, String, or Number, then return jsValue.
      */
-    if (jsValue === null || (0, util_1.isString)(jsValue) || (0, util_1.isNumber)(jsValue))
+    if (jsValue === null || util_1.isString(jsValue) || util_1.isNumber(jsValue))
         return jsValue;
     /**
      * 2. If IsArray(jsValue) is true, then:
@@ -32401,14 +62227,24 @@ function convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue) {
      * 2.3.4. Append infraValueAtIndex to result.
      * 2.8. Return result.
      */
-    if ((0, util_1.isArray)(jsValue)) {
-        const result = new Array();
-        for (const jsValueAtIndex of jsValue) {
-            result.push(convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValueAtIndex));
+    if (util_1.isArray(jsValue)) {
+        var result = new Array();
+        try {
+            for (var jsValue_1 = __values(jsValue), jsValue_1_1 = jsValue_1.next(); !jsValue_1_1.done; jsValue_1_1 = jsValue_1.next()) {
+                var jsValueAtIndex = jsValue_1_1.value;
+                result.push(convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValueAtIndex));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (jsValue_1_1 && !jsValue_1_1.done && (_a = jsValue_1.return)) _a.call(jsValue_1);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
         return result;
     }
-    else if ((0, util_1.isObject)(jsValue)) {
+    else if (util_1.isObject(jsValue)) {
         /**
          * 3. Let result be an empty ordered map.
          * 4. For each key of ! jsValue.[[OwnPropertyKeys]]():
@@ -32418,11 +62254,11 @@ function convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue) {
          * 4.3. Set result[key] to infraValueAtKey.
          * 5. Return result.
          */
-        const result = new Map();
-        for (const key in jsValue) {
+        var result = new Map();
+        for (var key in jsValue) {
             /* istanbul ignore else */
             if (jsValue.hasOwnProperty(key)) {
-                const jsValueAtKey = jsValue[key];
+                var jsValueAtKey = jsValue[key];
                 result.set(key, convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValueAtKey));
             }
         }
@@ -32431,31 +62267,76 @@ function convertAJSONDerivedJavaScriptValueToAnInfraValue(jsValue) {
     /* istanbul ignore next */
     return jsValue;
 }
+exports.convertAJSONDerivedJavaScriptValueToAnInfraValue = convertAJSONDerivedJavaScriptValueToAnInfraValue;
 //# sourceMappingURL=JSON.js.map
 
 /***/ }),
 
 /***/ 20340:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.append = append;
-exports.extend = extend;
-exports.prepend = prepend;
-exports.replace = replace;
-exports.insert = insert;
-exports.remove = remove;
-exports.empty = empty;
-exports.contains = contains;
-exports.size = size;
-exports.isEmpty = isEmpty;
-exports.forEach = forEach;
-exports.clone = clone;
-exports.sortInAscendingOrder = sortInAscendingOrder;
-exports.sortInDescendingOrder = sortInDescendingOrder;
-const util_1 = __nccwpck_require__(76195);
+var util_1 = __nccwpck_require__(76195);
 /**
  * Adds the given item to the end of the list.
  *
@@ -32465,6 +62346,7 @@ const util_1 = __nccwpck_require__(76195);
 function append(list, item) {
     list.push(item);
 }
+exports.append = append;
 /**
  * Extends a list by appending all items from another list.
  *
@@ -32472,8 +62354,9 @@ function append(list, item) {
  * @param listB - a list containing items to append to `listA`
  */
 function extend(listA, listB) {
-    listA.push(...listB);
+    listA.push.apply(listA, __spread(listB));
 }
+exports.extend = extend;
 /**
  * Inserts the given item to the start of the list.
  *
@@ -32483,6 +62366,7 @@ function extend(listA, listB) {
 function prepend(list, item) {
     list.unshift(item);
 }
+exports.prepend = prepend;
 /**
  * Replaces the given item or all items matching condition with a new item.
  *
@@ -32492,20 +62376,32 @@ function prepend(list, item) {
  * @param item - an item
  */
 function replace(list, conditionOrItem, newItem) {
-    let i = 0;
-    for (const oldItem of list) {
-        if ((0, util_1.isFunction)(conditionOrItem)) {
-            if (!!conditionOrItem.call(null, oldItem)) {
-                list[i] = newItem;
+    var e_1, _a;
+    var i = 0;
+    try {
+        for (var list_1 = __values(list), list_1_1 = list_1.next(); !list_1_1.done; list_1_1 = list_1.next()) {
+            var oldItem = list_1_1.value;
+            if (util_1.isFunction(conditionOrItem)) {
+                if (!!conditionOrItem.call(null, oldItem)) {
+                    list[i] = newItem;
+                }
             }
+            else if (oldItem === conditionOrItem) {
+                list[i] = newItem;
+                return;
+            }
+            i++;
         }
-        else if (oldItem === conditionOrItem) {
-            list[i] = newItem;
-            return;
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (list_1_1 && !list_1_1.done && (_a = list_1.return)) _a.call(list_1);
         }
-        i++;
+        finally { if (e_1) throw e_1.error; }
     }
 }
+exports.replace = replace;
 /**
  * Inserts the given item before the given index.
  *
@@ -32515,6 +62411,7 @@ function replace(list, conditionOrItem, newItem) {
 function insert(list, item, index) {
     list.splice(index, 0, item);
 }
+exports.insert = insert;
 /**
  * Removes the given item or all items matching condition.
  *
@@ -32523,10 +62420,10 @@ function insert(list, item, index) {
  * to remove
  */
 function remove(list, conditionOrItem) {
-    let i = list.length;
+    var i = list.length;
     while (i--) {
-        const oldItem = list[i];
-        if ((0, util_1.isFunction)(conditionOrItem)) {
+        var oldItem = list[i];
+        if (util_1.isFunction(conditionOrItem)) {
             if (!!conditionOrItem.call(null, oldItem)) {
                 list.splice(i, 1);
             }
@@ -32537,12 +62434,14 @@ function remove(list, conditionOrItem) {
         }
     }
 }
+exports.remove = remove;
 /**
  * Removes all items from the list.
  */
 function empty(list) {
     list.length = 0;
 }
+exports.empty = empty;
 /**
  * Determines if the list contains the given item or any items matching
  * condition.
@@ -32551,18 +62450,30 @@ function empty(list) {
  * @param conditionOrItem - an item to a condition to match
  */
 function contains(list, conditionOrItem) {
-    for (const oldItem of list) {
-        if ((0, util_1.isFunction)(conditionOrItem)) {
-            if (!!conditionOrItem.call(null, oldItem)) {
+    var e_2, _a;
+    try {
+        for (var list_2 = __values(list), list_2_1 = list_2.next(); !list_2_1.done; list_2_1 = list_2.next()) {
+            var oldItem = list_2_1.value;
+            if (util_1.isFunction(conditionOrItem)) {
+                if (!!conditionOrItem.call(null, oldItem)) {
+                    return true;
+                }
+            }
+            else if (oldItem === conditionOrItem) {
                 return true;
             }
         }
-        else if (oldItem === conditionOrItem) {
-            return true;
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (list_2_1 && !list_2_1.done && (_a = list_2.return)) _a.call(list_2);
         }
+        finally { if (e_2) throw e_2.error; }
     }
     return false;
 }
+exports.contains = contains;
 /**
  * Returns the count of items in the list matching the given condition.
  *
@@ -32570,19 +62481,31 @@ function contains(list, conditionOrItem) {
  * @param condition - an optional condition to match
  */
 function size(list, condition) {
+    var e_3, _a;
     if (condition === undefined) {
         return list.length;
     }
     else {
-        let count = 0;
-        for (const item of list) {
-            if (!!condition.call(null, item)) {
-                count++;
+        var count = 0;
+        try {
+            for (var list_3 = __values(list), list_3_1 = list_3.next(); !list_3_1.done; list_3_1 = list_3.next()) {
+                var item = list_3_1.value;
+                if (!!condition.call(null, item)) {
+                    count++;
+                }
             }
         }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (list_3_1 && !list_3_1.done && (_a = list_3.return)) _a.call(list_3);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
         return count;
     }
 }
+exports.size = size;
 /**
  * Determines if the list is empty.
  *
@@ -32591,32 +62514,64 @@ function size(list, condition) {
 function isEmpty(list) {
     return list.length === 0;
 }
+exports.isEmpty = isEmpty;
 /**
  * Returns an iterator for the items of the list.
  *
  * @param list - a list
  * @param condition - an optional condition to match
  */
-function* forEach(list, condition) {
-    if (condition === undefined) {
-        yield* list;
-    }
-    else {
-        for (const item of list) {
-            if (!!condition.call(null, item)) {
-                yield item;
-            }
+function forEach(list, condition) {
+    var list_4, list_4_1, item, e_4_1;
+    var e_4, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                if (!(condition === undefined)) return [3 /*break*/, 2];
+                return [5 /*yield**/, __values(list)];
+            case 1:
+                _b.sent();
+                return [3 /*break*/, 9];
+            case 2:
+                _b.trys.push([2, 7, 8, 9]);
+                list_4 = __values(list), list_4_1 = list_4.next();
+                _b.label = 3;
+            case 3:
+                if (!!list_4_1.done) return [3 /*break*/, 6];
+                item = list_4_1.value;
+                if (!!!condition.call(null, item)) return [3 /*break*/, 5];
+                return [4 /*yield*/, item];
+            case 4:
+                _b.sent();
+                _b.label = 5;
+            case 5:
+                list_4_1 = list_4.next();
+                return [3 /*break*/, 3];
+            case 6: return [3 /*break*/, 9];
+            case 7:
+                e_4_1 = _b.sent();
+                e_4 = { error: e_4_1 };
+                return [3 /*break*/, 9];
+            case 8:
+                try {
+                    if (list_4_1 && !list_4_1.done && (_a = list_4.return)) _a.call(list_4);
+                }
+                finally { if (e_4) throw e_4.error; }
+                return [7 /*endfinally*/];
+            case 9: return [2 /*return*/];
         }
-    }
+    });
 }
+exports.forEach = forEach;
 /**
  * Creates and returns a shallow clone of list.
  *
  * @param list - a list
  */
 function clone(list) {
-    return new Array(...list);
+    return new (Array.bind.apply(Array, __spread([void 0], list)))();
 }
+exports.clone = clone;
 /**
  * Returns a new list containing items from the list sorted in ascending
  * order.
@@ -32626,8 +62581,11 @@ function clone(list) {
  * is less than its second argument, and `false` otherwise.
  */
 function sortInAscendingOrder(list, lessThanAlgo) {
-    return list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? -1 : 1);
+    return list.sort(function (itemA, itemB) {
+        return lessThanAlgo.call(null, itemA, itemB) ? -1 : 1;
+    });
 }
+exports.sortInAscendingOrder = sortInAscendingOrder;
 /**
  * Returns a new list containing items from the list sorted in descending
  * order.
@@ -32637,31 +62595,80 @@ function sortInAscendingOrder(list, lessThanAlgo) {
  * is less than its second argument, and `false` otherwise.
  */
 function sortInDescendingOrder(list, lessThanAlgo) {
-    return list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? 1 : -1);
+    return list.sort(function (itemA, itemB) {
+        return lessThanAlgo.call(null, itemA, itemB) ? 1 : -1;
+    });
 }
+exports.sortInDescendingOrder = sortInDescendingOrder;
 //# sourceMappingURL=List.js.map
 
 /***/ }),
 
 /***/ 22298:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.get = get;
-exports.set = set;
-exports.remove = remove;
-exports.contains = contains;
-exports.keys = keys;
-exports.values = values;
-exports.size = size;
-exports.isEmpty = isEmpty;
-exports.forEach = forEach;
-exports.clone = clone;
-exports.sortInAscendingOrder = sortInAscendingOrder;
-exports.sortInDescendingOrder = sortInDescendingOrder;
-const util_1 = __nccwpck_require__(76195);
+var util_1 = __nccwpck_require__(76195);
 /**
  * Gets the value corresponding to the given key.
  *
@@ -32671,6 +62678,7 @@ const util_1 = __nccwpck_require__(76195);
 function get(map, key) {
     return map.get(key);
 }
+exports.get = get;
 /**
  * Sets the value corresponding to the given key.
  *
@@ -32681,6 +62689,7 @@ function get(map, key) {
 function set(map, key, val) {
     map.set(key, val);
 }
+exports.set = set;
 /**
  * Removes the item with the given key or all items matching condition.
  *
@@ -32689,21 +62698,43 @@ function set(map, key, val) {
  * items to remove
  */
 function remove(map, conditionOrItem) {
-    if (!(0, util_1.isFunction)(conditionOrItem)) {
+    var e_1, _a, e_2, _b;
+    if (!util_1.isFunction(conditionOrItem)) {
         map.delete(conditionOrItem);
     }
     else {
-        const toRemove = [];
-        for (const item of map) {
-            if (!!conditionOrItem.call(null, item)) {
-                toRemove.push(item[0]);
+        var toRemove = [];
+        try {
+            for (var map_1 = __values(map), map_1_1 = map_1.next(); !map_1_1.done; map_1_1 = map_1.next()) {
+                var item = map_1_1.value;
+                if (!!conditionOrItem.call(null, item)) {
+                    toRemove.push(item[0]);
+                }
             }
         }
-        for (const key of toRemove) {
-            map.delete(key);
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (map_1_1 && !map_1_1.done && (_a = map_1.return)) _a.call(map_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var toRemove_1 = __values(toRemove), toRemove_1_1 = toRemove_1.next(); !toRemove_1_1.done; toRemove_1_1 = toRemove_1.next()) {
+                var key = toRemove_1_1.value;
+                map.delete(key);
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (toRemove_1_1 && !toRemove_1_1.done && (_b = toRemove_1.return)) _b.call(toRemove_1);
+            }
+            finally { if (e_2) throw e_2.error; }
         }
     }
 }
+exports.remove = remove;
 /**
  * Determines if the map contains a value with the given key.
  *
@@ -32712,18 +62743,30 @@ function remove(map, conditionOrItem) {
  * items
  */
 function contains(map, conditionOrItem) {
-    if (!(0, util_1.isFunction)(conditionOrItem)) {
+    var e_3, _a;
+    if (!util_1.isFunction(conditionOrItem)) {
         return map.has(conditionOrItem);
     }
     else {
-        for (const item of map) {
-            if (!!conditionOrItem.call(null, item)) {
-                return true;
+        try {
+            for (var map_2 = __values(map), map_2_1 = map_2.next(); !map_2_1.done; map_2_1 = map_2.next()) {
+                var item = map_2_1.value;
+                if (!!conditionOrItem.call(null, item)) {
+                    return true;
+                }
             }
         }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (map_2_1 && !map_2_1.done && (_a = map_2.return)) _a.call(map_2);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
         return false;
     }
 }
+exports.contains = contains;
 /**
  * Gets the keys of the map.
  *
@@ -32732,14 +62775,16 @@ function contains(map, conditionOrItem) {
 function keys(map) {
     return new Set(map.keys());
 }
+exports.keys = keys;
 /**
  * Gets the values of the map.
  *
  * @param map - a map
  */
 function values(map) {
-    return [...map.values()];
+    return __spread(map.values());
 }
+exports.values = values;
 /**
  * Gets the size of the map.
  *
@@ -32747,19 +62792,31 @@ function values(map) {
  * @param condition - an optional condition to match
  */
 function size(map, condition) {
+    var e_4, _a;
     if (condition === undefined) {
         return map.size;
     }
     else {
-        let count = 0;
-        for (const item of map) {
-            if (!!condition.call(null, item)) {
-                count++;
+        var count = 0;
+        try {
+            for (var map_3 = __values(map), map_3_1 = map_3.next(); !map_3_1.done; map_3_1 = map_3.next()) {
+                var item = map_3_1.value;
+                if (!!condition.call(null, item)) {
+                    count++;
+                }
             }
         }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (map_3_1 && !map_3_1.done && (_a = map_3.return)) _a.call(map_3);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
         return count;
     }
 }
+exports.size = size;
 /**
  * Determines if the map is empty.
  *
@@ -32768,24 +62825,55 @@ function size(map, condition) {
 function isEmpty(map) {
     return map.size === 0;
 }
+exports.isEmpty = isEmpty;
 /**
  * Returns an iterator for the items of the map.
  *
  * @param map - a map
  * @param condition - an optional condition to match
  */
-function* forEach(map, condition) {
-    if (condition === undefined) {
-        yield* map;
-    }
-    else {
-        for (const item of map) {
-            if (!!condition.call(null, item)) {
-                yield item;
-            }
+function forEach(map, condition) {
+    var map_4, map_4_1, item, e_5_1;
+    var e_5, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                if (!(condition === undefined)) return [3 /*break*/, 2];
+                return [5 /*yield**/, __values(map)];
+            case 1:
+                _b.sent();
+                return [3 /*break*/, 9];
+            case 2:
+                _b.trys.push([2, 7, 8, 9]);
+                map_4 = __values(map), map_4_1 = map_4.next();
+                _b.label = 3;
+            case 3:
+                if (!!map_4_1.done) return [3 /*break*/, 6];
+                item = map_4_1.value;
+                if (!!!condition.call(null, item)) return [3 /*break*/, 5];
+                return [4 /*yield*/, item];
+            case 4:
+                _b.sent();
+                _b.label = 5;
+            case 5:
+                map_4_1 = map_4.next();
+                return [3 /*break*/, 3];
+            case 6: return [3 /*break*/, 9];
+            case 7:
+                e_5_1 = _b.sent();
+                e_5 = { error: e_5_1 };
+                return [3 /*break*/, 9];
+            case 8:
+                try {
+                    if (map_4_1 && !map_4_1.done && (_a = map_4.return)) _a.call(map_4);
+                }
+                finally { if (e_5) throw e_5.error; }
+                return [7 /*endfinally*/];
+            case 9: return [2 /*return*/];
         }
-    }
+    });
 }
+exports.forEach = forEach;
 /**
  * Creates and returns a shallow clone of map.
  *
@@ -32794,6 +62882,7 @@ function* forEach(map, condition) {
 function clone(map) {
     return new Map(map);
 }
+exports.clone = clone;
 /**
  * Returns a new map containing items from the map sorted in ascending
  * order.
@@ -32803,10 +62892,13 @@ function clone(map) {
  * is less than its second argument, and `false` otherwise.
  */
 function sortInAscendingOrder(map, lessThanAlgo) {
-    const list = new Array(...map);
-    list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? -1 : 1);
+    var list = new (Array.bind.apply(Array, __spread([void 0], map)))();
+    list.sort(function (itemA, itemB) {
+        return lessThanAlgo.call(null, itemA, itemB) ? -1 : 1;
+    });
     return new Map(list);
 }
+exports.sortInAscendingOrder = sortInAscendingOrder;
 /**
  * Returns a new map containing items from the map sorted in descending
  * order.
@@ -32816,10 +62908,13 @@ function sortInAscendingOrder(map, lessThanAlgo) {
  * is less than its second argument, and `false` otherwise.
  */
 function sortInDescendingOrder(map, lessThanAlgo) {
-    const list = new Array(...map);
-    list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? 1 : -1);
+    var list = new (Array.bind.apply(Array, __spread([void 0], map)))();
+    list.sort(function (itemA, itemB) {
+        return lessThanAlgo.call(null, itemA, itemB) ? 1 : -1;
+    });
     return new Map(list);
 }
+exports.sortInDescendingOrder = sortInDescendingOrder;
 //# sourceMappingURL=Map.js.map
 
 /***/ }),
@@ -32830,7 +62925,6 @@ function sortInDescendingOrder(map, lessThanAlgo) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XLink = exports.SVG = exports.MathML = exports.XMLNS = exports.XML = exports.HTML = void 0;
 exports.HTML = "http://www.w3.org/1999/xhtml";
 exports.XML = "http://www.w3.org/XML/1998/namespace";
 exports.XMLNS = "http://www.w3.org/2000/xmlns/";
@@ -32847,8 +62941,6 @@ exports.XLink = "http://www.w3.org/1999/xlink";
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.enqueue = enqueue;
-exports.dequeue = dequeue;
 /**
  * Appends the given item to the queue.
  *
@@ -32858,6 +62950,7 @@ exports.dequeue = dequeue;
 function enqueue(list, item) {
     list.push(item);
 }
+exports.enqueue = enqueue;
 /**
  * Removes and returns an item from the queue.
  *
@@ -32866,36 +62959,76 @@ function enqueue(list, item) {
 function dequeue(list) {
     return list.shift() || null;
 }
+exports.dequeue = dequeue;
 //# sourceMappingURL=Queue.js.map
 
 /***/ }),
 
 /***/ 35931:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.append = append;
-exports.extend = extend;
-exports.prepend = prepend;
-exports.replace = replace;
-exports.insert = insert;
-exports.remove = remove;
-exports.empty = empty;
-exports.contains = contains;
-exports.size = size;
-exports.isEmpty = isEmpty;
-exports.forEach = forEach;
-exports.clone = clone;
-exports.sortInAscendingOrder = sortInAscendingOrder;
-exports.sortInDescendingOrder = sortInDescendingOrder;
-exports.isSubsetOf = isSubsetOf;
-exports.isSupersetOf = isSupersetOf;
-exports.intersection = intersection;
-exports.union = union;
-exports.range = range;
-const util_1 = __nccwpck_require__(76195);
+var util_1 = __nccwpck_require__(76195);
 /**
  * Adds the given item to the end of the set.
  *
@@ -32905,6 +63038,7 @@ const util_1 = __nccwpck_require__(76195);
 function append(set, item) {
     set.add(item);
 }
+exports.append = append;
 /**
  * Extends a set by appending all items from another set.
  *
@@ -32914,6 +63048,7 @@ function append(set, item) {
 function extend(setA, setB) {
     setB.forEach(setA.add, setA);
 }
+exports.extend = extend;
 /**
  * Inserts the given item to the start of the set.
  *
@@ -32921,11 +63056,12 @@ function extend(setA, setB) {
  * @param item - an item
  */
 function prepend(set, item) {
-    const cloned = new Set(set);
+    var cloned = new Set(set);
     set.clear();
     set.add(item);
     cloned.forEach(set.add, set);
 }
+exports.prepend = prepend;
 /**
  * Replaces the given item or all items matching condition with a new item.
  *
@@ -32935,26 +63071,38 @@ function prepend(set, item) {
  * @param item - an item
  */
 function replace(set, conditionOrItem, newItem) {
-    const newSet = new Set();
-    for (const oldItem of set) {
-        if ((0, util_1.isFunction)(conditionOrItem)) {
-            if (!!conditionOrItem.call(null, oldItem)) {
+    var e_1, _a;
+    var newSet = new Set();
+    try {
+        for (var set_1 = __values(set), set_1_1 = set_1.next(); !set_1_1.done; set_1_1 = set_1.next()) {
+            var oldItem = set_1_1.value;
+            if (util_1.isFunction(conditionOrItem)) {
+                if (!!conditionOrItem.call(null, oldItem)) {
+                    newSet.add(newItem);
+                }
+                else {
+                    newSet.add(oldItem);
+                }
+            }
+            else if (oldItem === conditionOrItem) {
                 newSet.add(newItem);
             }
             else {
                 newSet.add(oldItem);
             }
         }
-        else if (oldItem === conditionOrItem) {
-            newSet.add(newItem);
-        }
-        else {
-            newSet.add(oldItem);
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (set_1_1 && !set_1_1.done && (_a = set_1.return)) _a.call(set_1);
         }
+        finally { if (e_1) throw e_1.error; }
     }
     set.clear();
     newSet.forEach(set.add, set);
 }
+exports.replace = replace;
 /**
  * Inserts the given item before the given index.
  *
@@ -32962,17 +63110,29 @@ function replace(set, conditionOrItem, newItem) {
  * @param item - an item
  */
 function insert(set, item, index) {
-    const newSet = new Set();
-    let i = 0;
-    for (const oldItem of set) {
-        if (i === index)
-            newSet.add(item);
-        newSet.add(oldItem);
-        i++;
+    var e_2, _a;
+    var newSet = new Set();
+    var i = 0;
+    try {
+        for (var set_2 = __values(set), set_2_1 = set_2.next(); !set_2_1.done; set_2_1 = set_2.next()) {
+            var oldItem = set_2_1.value;
+            if (i === index)
+                newSet.add(item);
+            newSet.add(oldItem);
+            i++;
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (set_2_1 && !set_2_1.done && (_a = set_2.return)) _a.call(set_2);
+        }
+        finally { if (e_2) throw e_2.error; }
     }
     set.clear();
     newSet.forEach(set.add, set);
 }
+exports.insert = insert;
 /**
  * Removes the given item or all items matching condition.
  *
@@ -32981,27 +63141,50 @@ function insert(set, item, index) {
  * to remove
  */
 function remove(set, conditionOrItem) {
-    if (!(0, util_1.isFunction)(conditionOrItem)) {
+    var e_3, _a, e_4, _b;
+    if (!util_1.isFunction(conditionOrItem)) {
         set.delete(conditionOrItem);
     }
     else {
-        const toRemove = [];
-        for (const item of set) {
-            if (!!conditionOrItem.call(null, item)) {
-                toRemove.push(item);
+        var toRemove = [];
+        try {
+            for (var set_3 = __values(set), set_3_1 = set_3.next(); !set_3_1.done; set_3_1 = set_3.next()) {
+                var item = set_3_1.value;
+                if (!!conditionOrItem.call(null, item)) {
+                    toRemove.push(item);
+                }
             }
         }
-        for (const oldItem of toRemove) {
-            set.delete(oldItem);
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (set_3_1 && !set_3_1.done && (_a = set_3.return)) _a.call(set_3);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        try {
+            for (var toRemove_1 = __values(toRemove), toRemove_1_1 = toRemove_1.next(); !toRemove_1_1.done; toRemove_1_1 = toRemove_1.next()) {
+                var oldItem = toRemove_1_1.value;
+                set.delete(oldItem);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (toRemove_1_1 && !toRemove_1_1.done && (_b = toRemove_1.return)) _b.call(toRemove_1);
+            }
+            finally { if (e_4) throw e_4.error; }
         }
     }
 }
+exports.remove = remove;
 /**
  * Removes all items from the set.
  */
 function empty(set) {
     set.clear();
 }
+exports.empty = empty;
 /**
  * Determines if the set contains the given item or any items matching
  * condition.
@@ -33010,18 +63193,30 @@ function empty(set) {
  * @param conditionOrItem - an item to a condition to match
  */
 function contains(set, conditionOrItem) {
-    if (!(0, util_1.isFunction)(conditionOrItem)) {
+    var e_5, _a;
+    if (!util_1.isFunction(conditionOrItem)) {
         return set.has(conditionOrItem);
     }
     else {
-        for (const oldItem of set) {
-            if (!!conditionOrItem.call(null, oldItem)) {
-                return true;
+        try {
+            for (var set_4 = __values(set), set_4_1 = set_4.next(); !set_4_1.done; set_4_1 = set_4.next()) {
+                var oldItem = set_4_1.value;
+                if (!!conditionOrItem.call(null, oldItem)) {
+                    return true;
+                }
             }
         }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (set_4_1 && !set_4_1.done && (_a = set_4.return)) _a.call(set_4);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
     }
     return false;
 }
+exports.contains = contains;
 /**
  * Returns the count of items in the set matching the given condition.
  *
@@ -33029,19 +63224,31 @@ function contains(set, conditionOrItem) {
  * @param condition - an optional condition to match
  */
 function size(set, condition) {
+    var e_6, _a;
     if (condition === undefined) {
         return set.size;
     }
     else {
-        let count = 0;
-        for (const item of set) {
-            if (!!condition.call(null, item)) {
-                count++;
+        var count = 0;
+        try {
+            for (var set_5 = __values(set), set_5_1 = set_5.next(); !set_5_1.done; set_5_1 = set_5.next()) {
+                var item = set_5_1.value;
+                if (!!condition.call(null, item)) {
+                    count++;
+                }
             }
         }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (set_5_1 && !set_5_1.done && (_a = set_5.return)) _a.call(set_5);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
         return count;
     }
 }
+exports.size = size;
 /**
  * Determines if the set is empty.
  *
@@ -33050,24 +63257,55 @@ function size(set, condition) {
 function isEmpty(set) {
     return set.size === 0;
 }
+exports.isEmpty = isEmpty;
 /**
  * Returns an iterator for the items of the set.
  *
  * @param set - a set
  * @param condition - an optional condition to match
  */
-function* forEach(set, condition) {
-    if (condition === undefined) {
-        yield* set;
-    }
-    else {
-        for (const item of set) {
-            if (!!condition.call(null, item)) {
-                yield item;
-            }
+function forEach(set, condition) {
+    var set_6, set_6_1, item, e_7_1;
+    var e_7, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                if (!(condition === undefined)) return [3 /*break*/, 2];
+                return [5 /*yield**/, __values(set)];
+            case 1:
+                _b.sent();
+                return [3 /*break*/, 9];
+            case 2:
+                _b.trys.push([2, 7, 8, 9]);
+                set_6 = __values(set), set_6_1 = set_6.next();
+                _b.label = 3;
+            case 3:
+                if (!!set_6_1.done) return [3 /*break*/, 6];
+                item = set_6_1.value;
+                if (!!!condition.call(null, item)) return [3 /*break*/, 5];
+                return [4 /*yield*/, item];
+            case 4:
+                _b.sent();
+                _b.label = 5;
+            case 5:
+                set_6_1 = set_6.next();
+                return [3 /*break*/, 3];
+            case 6: return [3 /*break*/, 9];
+            case 7:
+                e_7_1 = _b.sent();
+                e_7 = { error: e_7_1 };
+                return [3 /*break*/, 9];
+            case 8:
+                try {
+                    if (set_6_1 && !set_6_1.done && (_a = set_6.return)) _a.call(set_6);
+                }
+                finally { if (e_7) throw e_7.error; }
+                return [7 /*endfinally*/];
+            case 9: return [2 /*return*/];
         }
-    }
+    });
 }
+exports.forEach = forEach;
 /**
  * Creates and returns a shallow clone of set.
  *
@@ -33076,6 +63314,7 @@ function* forEach(set, condition) {
 function clone(set) {
     return new Set(set);
 }
+exports.clone = clone;
 /**
  * Returns a new set containing items from the set sorted in ascending
  * order.
@@ -33085,10 +63324,13 @@ function clone(set) {
  * is less than its second argument, and `false` otherwise.
  */
 function sortInAscendingOrder(set, lessThanAlgo) {
-    const list = new Array(...set);
-    list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? -1 : 1);
+    var list = new (Array.bind.apply(Array, __spread([void 0], set)))();
+    list.sort(function (itemA, itemB) {
+        return lessThanAlgo.call(null, itemA, itemB) ? -1 : 1;
+    });
     return new Set(list);
 }
+exports.sortInAscendingOrder = sortInAscendingOrder;
 /**
  * Returns a new set containing items from the set sorted in descending
  * order.
@@ -33098,10 +63340,13 @@ function sortInAscendingOrder(set, lessThanAlgo) {
  * is less than its second argument, and `false` otherwise.
  */
 function sortInDescendingOrder(set, lessThanAlgo) {
-    const list = new Array(...set);
-    list.sort((itemA, itemB) => lessThanAlgo.call(null, itemA, itemB) ? 1 : -1);
+    var list = new (Array.bind.apply(Array, __spread([void 0], set)))();
+    list.sort(function (itemA, itemB) {
+        return lessThanAlgo.call(null, itemA, itemB) ? 1 : -1;
+    });
     return new Set(list);
 }
+exports.sortInDescendingOrder = sortInDescendingOrder;
 /**
  * Determines if a set is a subset of another set.
  *
@@ -33109,12 +63354,24 @@ function sortInDescendingOrder(set, lessThanAlgo) {
  * @param superset - a superset possibly containing all items from `subset`.
  */
 function isSubsetOf(subset, superset) {
-    for (const item of subset) {
-        if (!superset.has(item))
-            return false;
+    var e_8, _a;
+    try {
+        for (var subset_1 = __values(subset), subset_1_1 = subset_1.next(); !subset_1_1.done; subset_1_1 = subset_1.next()) {
+            var item = subset_1_1.value;
+            if (!superset.has(item))
+                return false;
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (subset_1_1 && !subset_1_1.done && (_a = subset_1.return)) _a.call(subset_1);
+        }
+        finally { if (e_8) throw e_8.error; }
     }
     return true;
 }
+exports.isSubsetOf = isSubsetOf;
 /**
  * Determines if a set is a superset of another set.
  *
@@ -33124,6 +63381,7 @@ function isSubsetOf(subset, superset) {
 function isSupersetOf(superset, subset) {
     return isSubsetOf(subset, superset);
 }
+exports.isSupersetOf = isSupersetOf;
 /**
  * Returns a new set with items that are contained in both sets.
  *
@@ -33131,13 +63389,25 @@ function isSupersetOf(superset, subset) {
  * @param setB - a set
  */
 function intersection(setA, setB) {
-    const newSet = new Set();
-    for (const item of setA) {
-        if (setB.has(item))
-            newSet.add(item);
+    var e_9, _a;
+    var newSet = new Set();
+    try {
+        for (var setA_1 = __values(setA), setA_1_1 = setA_1.next(); !setA_1_1.done; setA_1_1 = setA_1.next()) {
+            var item = setA_1_1.value;
+            if (setB.has(item))
+                newSet.add(item);
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (setA_1_1 && !setA_1_1.done && (_a = setA_1.return)) _a.call(setA_1);
+        }
+        finally { if (e_9) throw e_9.error; }
     }
     return newSet;
 }
+exports.intersection = intersection;
 /**
  * Returns a new set with items from both sets.
  *
@@ -33145,10 +63415,11 @@ function intersection(setA, setB) {
  * @param setB - a set
  */
 function union(setA, setB) {
-    const newSet = new Set(setA);
+    var newSet = new Set(setA);
     setB.forEach(newSet.add, newSet);
     return newSet;
 }
+exports.union = union;
 /**
  * Returns a set of integers from `n` to `m` inclusive.
  *
@@ -33156,12 +63427,13 @@ function union(setA, setB) {
  * @param m - ending number
  */
 function range(n, m) {
-    const newSet = new Set();
-    for (let i = n; i <= m; i++) {
+    var newSet = new Set();
+    for (var i = n; i <= m; i++) {
         newSet.add(i);
     }
     return newSet;
 }
+exports.range = range;
 //# sourceMappingURL=Set.js.map
 
 /***/ }),
@@ -33172,8 +63444,6 @@ function range(n, m) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.push = push;
-exports.pop = pop;
 /**
  * Pushes the given item to the stack.
  *
@@ -33183,6 +63453,7 @@ exports.pop = pop;
 function push(list, item) {
     list.push(item);
 }
+exports.push = push;
 /**
  * Pops and returns an item from the stack.
  *
@@ -33191,39 +63462,32 @@ function push(list, item) {
 function pop(list) {
     return list.pop() || null;
 }
+exports.pop = pop;
 //# sourceMappingURL=Stack.js.map
 
 /***/ }),
 
 /***/ 13203:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.isCodeUnitPrefix = isCodeUnitPrefix;
-exports.isCodeUnitLessThan = isCodeUnitLessThan;
-exports.isomorphicEncode = isomorphicEncode;
-exports.isASCIIString = isASCIIString;
-exports.asciiLowercase = asciiLowercase;
-exports.asciiUppercase = asciiUppercase;
-exports.asciiCaseInsensitiveMatch = asciiCaseInsensitiveMatch;
-exports.asciiEncode = asciiEncode;
-exports.asciiDecode = asciiDecode;
-exports.stripNewlines = stripNewlines;
-exports.normalizeNewlines = normalizeNewlines;
-exports.stripLeadingAndTrailingASCIIWhitespace = stripLeadingAndTrailingASCIIWhitespace;
-exports.stripAndCollapseASCIIWhitespace = stripAndCollapseASCIIWhitespace;
-exports.collectASequenceOfCodePoints = collectASequenceOfCodePoints;
-exports.skipASCIIWhitespace = skipASCIIWhitespace;
-exports.strictlySplit = strictlySplit;
-exports.splitAStringOnASCIIWhitespace = splitAStringOnASCIIWhitespace;
-exports.splitAStringOnCommas = splitAStringOnCommas;
-exports.concatenate = concatenate;
-const CodePoints_1 = __nccwpck_require__(28548);
-const ByteSequence_1 = __nccwpck_require__(71627);
-const Byte_1 = __nccwpck_require__(42460);
-const util_1 = __nccwpck_require__(76195);
+var CodePoints_1 = __nccwpck_require__(28548);
+var ByteSequence_1 = __nccwpck_require__(71627);
+var Byte_1 = __nccwpck_require__(42460);
+var util_1 = __nccwpck_require__(76195);
 /**
  * Determines if the string `a` is a code unit prefix of string `b`.
  *
@@ -33242,10 +63506,10 @@ function isCodeUnitPrefix(a, b) {
      * 2.4. Return false if aCodeUnit is different from bCodeUnit.
      * 2.5. Set i to i + 1.
      */
-    let i = 0;
+    var i = 0;
     while (true) {
-        const aCodeUnit = i < a.length ? a.charCodeAt(i) : null;
-        const bCodeUnit = i < b.length ? b.charCodeAt(i) : null;
+        var aCodeUnit = i < a.length ? a.charCodeAt(i) : null;
+        var bCodeUnit = i < b.length ? b.charCodeAt(i) : null;
         if (aCodeUnit === null)
             return true;
         if (aCodeUnit !== bCodeUnit)
@@ -33253,6 +63517,7 @@ function isCodeUnitPrefix(a, b) {
         i++;
     }
 }
+exports.isCodeUnitPrefix = isCodeUnitPrefix;
 /**
  * Determines if the string `a` is a code unit less than string `b`.
  *
@@ -33274,9 +63539,9 @@ function isCodeUnitLessThan(a, b) {
         return false;
     if (isCodeUnitPrefix(a, b))
         return true;
-    for (let i = 0; i < Math.min(a.length, b.length); i++) {
-        const aCodeUnit = a.charCodeAt(i);
-        const bCodeUnit = b.charCodeAt(i);
+    for (var i = 0; i < Math.min(a.length, b.length); i++) {
+        var aCodeUnit = a.charCodeAt(i);
+        var bCodeUnit = b.charCodeAt(i);
         if (aCodeUnit === bCodeUnit)
             continue;
         return (aCodeUnit < bCodeUnit);
@@ -33284,29 +63549,42 @@ function isCodeUnitLessThan(a, b) {
     /* istanbul ignore next */
     return false;
 }
+exports.isCodeUnitLessThan = isCodeUnitLessThan;
 /**
  * Isomorphic encodes the given string.
  *
  * @param str - a string
  */
 function isomorphicEncode(str) {
+    var e_1, _a;
     /**
      * 1. Assert: input contains no code points greater than U+00FF.
      * 2. Return a byte sequence whose length is equal to input’s length and whose
      * bytes have the same values as input’s code points, in the same order.
      */
-    const codePoints = Array.from(str);
-    const bytes = new Uint8Array(codePoints.length);
-    let i = 0;
-    for (const codePoint of str) {
-        const byte = codePoint.codePointAt(0);
-        console.assert(byte !== undefined && byte <= 0x00FF, "isomorphicEncode requires string bytes to be less than or equal to 0x00FF.");
-        if (byte !== undefined && byte <= 0x00FF) {
-            bytes[i++] = byte;
+    var codePoints = Array.from(str);
+    var bytes = new Uint8Array(codePoints.length);
+    var i = 0;
+    try {
+        for (var str_1 = __values(str), str_1_1 = str_1.next(); !str_1_1.done; str_1_1 = str_1.next()) {
+            var codePoint = str_1_1.value;
+            var byte = codePoint.codePointAt(0);
+            console.assert(byte !== undefined && byte <= 0x00FF, "isomorphicEncode requires string bytes to be less than or equal to 0x00FF.");
+            if (byte !== undefined && byte <= 0x00FF) {
+                bytes[i++] = byte;
+            }
         }
     }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (str_1_1 && !str_1_1.done && (_a = str_1.return)) _a.call(str_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
     return bytes;
 }
+exports.isomorphicEncode = isomorphicEncode;
 /**
  * Determines if the given string is An ASCII string.
  *
@@ -33318,50 +63596,75 @@ function isASCIIString(str) {
      */
     return /^[\u0000-\u007F]*$/.test(str);
 }
+exports.isASCIIString = isASCIIString;
 /**
  * Converts all uppercase ASCII code points to lowercase.
  *
  * @param str - a string
  */
 function asciiLowercase(str) {
+    var e_2, _a;
     /**
      * To ASCII lowercase a string, replace all ASCII upper alphas in the string
      * with their corresponding code point in ASCII lower alpha.
      */
-    let result = "";
-    for (const c of str) {
-        const code = c.codePointAt(0);
-        if (code !== undefined && code >= 0x41 && code <= 0x5A) {
-            result += String.fromCodePoint(code + 0x20);
+    var result = "";
+    try {
+        for (var str_2 = __values(str), str_2_1 = str_2.next(); !str_2_1.done; str_2_1 = str_2.next()) {
+            var c = str_2_1.value;
+            var code = c.codePointAt(0);
+            if (code !== undefined && code >= 0x41 && code <= 0x5A) {
+                result += String.fromCodePoint(code + 0x20);
+            }
+            else {
+                result += c;
+            }
         }
-        else {
-            result += c;
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (str_2_1 && !str_2_1.done && (_a = str_2.return)) _a.call(str_2);
         }
+        finally { if (e_2) throw e_2.error; }
     }
     return result;
 }
+exports.asciiLowercase = asciiLowercase;
 /**
  * Converts all uppercase ASCII code points to uppercase.
  *
  * @param str - a string
  */
 function asciiUppercase(str) {
+    var e_3, _a;
     /**
      * To ASCII uppercase a string, replace all ASCII lower alphas in the string
      * with their corresponding code point in ASCII upper alpha.
      */
-    let result = "";
-    for (const c of str) {
-        const code = c.codePointAt(0);
-        if (code !== undefined && code >= 0x61 && code <= 0x7A) {
-            result += String.fromCodePoint(code - 0x20);
+    var result = "";
+    try {
+        for (var str_3 = __values(str), str_3_1 = str_3.next(); !str_3_1.done; str_3_1 = str_3.next()) {
+            var c = str_3_1.value;
+            var code = c.codePointAt(0);
+            if (code !== undefined && code >= 0x61 && code <= 0x7A) {
+                result += String.fromCodePoint(code - 0x20);
+            }
+            else {
+                result += c;
+            }
         }
-        else {
-            result += c;
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (str_3_1 && !str_3_1.done && (_a = str_3.return)) _a.call(str_3);
         }
+        finally { if (e_3) throw e_3.error; }
     }
     return result;
 }
+exports.asciiUppercase = asciiUppercase;
 /**
  * Compares two ASCII strings case-insensitively.
  *
@@ -33375,6 +63678,7 @@ function asciiCaseInsensitiveMatch(a, b) {
      */
     return asciiLowercase(a) === asciiLowercase(b);
 }
+exports.asciiCaseInsensitiveMatch = asciiCaseInsensitiveMatch;
 /**
  * ASCII encodes a string.
  *
@@ -33388,21 +63692,34 @@ function asciiEncode(str) {
     console.assert(isASCIIString(str), "asciiEncode requires an ASCII string.");
     return isomorphicEncode(str);
 }
+exports.asciiEncode = asciiEncode;
 /**
  * ASCII decodes a byte sequence.
  *
  * @param bytes - a byte sequence
  */
 function asciiDecode(bytes) {
-    /**
-     * 1. Assert: All bytes in input are ASCII bytes.
-     * 2. Return the isomorphic decoding of input.
-     */
-    for (const byte of bytes) {
-        console.assert((0, Byte_1.isASCIIByte)(byte), "asciiDecode requires an ASCII byte sequence.");
+    var e_4, _a;
+    try {
+        /**
+         * 1. Assert: All bytes in input are ASCII bytes.
+         * 2. Return the isomorphic decoding of input.
+         */
+        for (var bytes_1 = __values(bytes), bytes_1_1 = bytes_1.next(); !bytes_1_1.done; bytes_1_1 = bytes_1.next()) {
+            var byte = bytes_1_1.value;
+            console.assert(Byte_1.isASCIIByte(byte), "asciiDecode requires an ASCII byte sequence.");
+        }
     }
-    return (0, ByteSequence_1.isomorphicDecode)(bytes);
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (bytes_1_1 && !bytes_1_1.done && (_a = bytes_1.return)) _a.call(bytes_1);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return ByteSequence_1.isomorphicDecode(bytes);
 }
+exports.asciiDecode = asciiDecode;
 /**
  * Strips newline characters from a string.
  *
@@ -33415,6 +63732,7 @@ function stripNewlines(str) {
      */
     return str.replace(/[\n\r]/g, "");
 }
+exports.stripNewlines = stripNewlines;
 /**
  * Normalizes newline characters in a string by converting consecutive
  * carriage-return newline characters and also single carriage return characters
@@ -33430,6 +63748,7 @@ function normalizeNewlines(str) {
      */
     return str.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
 }
+exports.normalizeNewlines = normalizeNewlines;
 /**
  * Removes leading and trailing whitespace characters from a string.
  *
@@ -33442,6 +63761,7 @@ function stripLeadingAndTrailingASCIIWhitespace(str) {
      */
     return str.replace(/^[\t\n\f\r ]+/, "").replace(/[\t\n\f\r ]+$/, "");
 }
+exports.stripLeadingAndTrailingASCIIWhitespace = stripLeadingAndTrailingASCIIWhitespace;
 /**
  * Removes consecutive newline characters from a string.
  *
@@ -33456,6 +63776,7 @@ function stripAndCollapseASCIIWhitespace(str) {
      */
     return stripLeadingAndTrailingASCIIWhitespace(str.replace(/[\t\n\f\r ]{2,}/g, " "));
 }
+exports.stripAndCollapseASCIIWhitespace = stripAndCollapseASCIIWhitespace;
 /**
  * Collects a sequence of code points matching a given condition from the input
  * string.
@@ -33473,15 +63794,16 @@ function collectASequenceOfCodePoints(condition, input, options) {
      * 2.2. Advance position by 1.
      * 3. Return result.
      */
-    if (!(0, util_1.isArray)(input))
+    if (!util_1.isArray(input))
         return collectASequenceOfCodePoints(condition, Array.from(input), options);
-    let result = "";
+    var result = "";
     while (options.position < input.length && !!condition.call(null, input[options.position])) {
         result += input[options.position];
         options.position++;
     }
     return result;
 }
+exports.collectASequenceOfCodePoints = collectASequenceOfCodePoints;
 /**
  * Skips over ASCII whitespace.
  *
@@ -33495,8 +63817,9 @@ function skipASCIIWhitespace(input, options) {
      * input given position. The collected code points are not used, but position
      * is still updated.
      */
-    collectASequenceOfCodePoints(str => CodePoints_1.ASCIIWhiteSpace.test(str), input, options);
+    collectASequenceOfCodePoints(function (str) { return CodePoints_1.ASCIIWhiteSpace.test(str); }, input, options);
 }
+exports.skipASCIIWhitespace = skipASCIIWhitespace;
 /**
  * Solits a string at the given delimiter.
  *
@@ -33519,20 +63842,21 @@ function strictlySplit(input, delimiter) {
      * 5.4. Append token to tokens.
      * 6. Return tokens.
      */
-    if (!(0, util_1.isArray)(input))
+    if (!util_1.isArray(input))
         return strictlySplit(Array.from(input), delimiter);
-    const options = { position: 0 };
-    const tokens = [];
-    let token = collectASequenceOfCodePoints(str => delimiter !== str, input, options);
+    var options = { position: 0 };
+    var tokens = [];
+    var token = collectASequenceOfCodePoints(function (str) { return delimiter !== str; }, input, options);
     tokens.push(token);
     while (options.position < input.length) {
         console.assert(input[options.position] === delimiter, "strictlySplit found no delimiter in input string.");
         options.position++;
-        token = collectASequenceOfCodePoints(str => delimiter !== str, input, options);
+        token = collectASequenceOfCodePoints(function (str) { return delimiter !== str; }, input, options);
         tokens.push(token);
     }
     return tokens;
 }
+exports.strictlySplit = strictlySplit;
 /**
  * Splits a string on ASCII whitespace.
  *
@@ -33551,18 +63875,19 @@ function splitAStringOnASCIIWhitespace(input) {
      * 4.3. Skip ASCII whitespace within input given position.
      * 5. Return tokens.
      */
-    if (!(0, util_1.isArray)(input))
+    if (!util_1.isArray(input))
         return splitAStringOnASCIIWhitespace(Array.from(input));
-    const options = { position: 0 };
-    const tokens = [];
+    var options = { position: 0 };
+    var tokens = [];
     skipASCIIWhitespace(input, options);
     while (options.position < input.length) {
-        const token = collectASequenceOfCodePoints(str => !CodePoints_1.ASCIIWhiteSpace.test(str), input, options);
+        var token = collectASequenceOfCodePoints(function (str) { return !CodePoints_1.ASCIIWhiteSpace.test(str); }, input, options);
         tokens.push(token);
         skipASCIIWhitespace(input, options);
     }
     return tokens;
 }
+exports.splitAStringOnASCIIWhitespace = splitAStringOnASCIIWhitespace;
 /**
  * Splits a string on commas.
  *
@@ -33583,12 +63908,12 @@ function splitAStringOnCommas(input) {
      * 3.4.2. Advance position by 1.
      * 4. Return tokens.
      */
-    if (!(0, util_1.isArray)(input))
+    if (!util_1.isArray(input))
         return splitAStringOnCommas(Array.from(input));
-    const options = { position: 0 };
-    const tokens = [];
+    var options = { position: 0 };
+    var tokens = [];
     while (options.position < input.length) {
-        const token = collectASequenceOfCodePoints(str => str !== ',', input, options);
+        var token = collectASequenceOfCodePoints(function (str) { return str !== ','; }, input, options);
         tokens.push(stripLeadingAndTrailingASCIIWhitespace(token));
         if (options.position < input.length) {
             console.assert(input[options.position] === ',', "splitAStringOnCommas found no delimiter in input string.");
@@ -33597,13 +63922,15 @@ function splitAStringOnCommas(input) {
     }
     return tokens;
 }
+exports.splitAStringOnCommas = splitAStringOnCommas;
 /**
  * Concatenates a list of strings with the given separator.
  *
  * @param list - a list of strings
  * @param separator - a separator string
  */
-function concatenate(list, separator = "") {
+function concatenate(list, separator) {
+    if (separator === void 0) { separator = ""; }
     /**
      * 1. If list is empty, then return the empty string.
      * 2. If separator is not given, then set separator to the empty string.
@@ -33614,6 +63941,7 @@ function concatenate(list, separator = "") {
         return "";
     return list.join(separator);
 }
+exports.concatenate = concatenate;
 //# sourceMappingURL=String.js.map
 
 /***/ }),
@@ -33623,125 +63951,84 @@ function concatenate(list, separator = "") {
 
 "use strict";
 
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.string = exports.stack = exports.set = exports.queue = exports.namespace = exports.map = exports.list = exports.json = exports.codePoint = exports.byteSequence = exports.byte = exports.base64 = void 0;
-const base64 = __importStar(__nccwpck_require__(28585));
+var base64 = __importStar(__nccwpck_require__(28585));
 exports.base64 = base64;
-const byte = __importStar(__nccwpck_require__(42460));
+var byte = __importStar(__nccwpck_require__(42460));
 exports.byte = byte;
-const byteSequence = __importStar(__nccwpck_require__(71627));
+var byteSequence = __importStar(__nccwpck_require__(71627));
 exports.byteSequence = byteSequence;
-const codePoint = __importStar(__nccwpck_require__(28548));
+var codePoint = __importStar(__nccwpck_require__(28548));
 exports.codePoint = codePoint;
-const json = __importStar(__nccwpck_require__(99387));
+var json = __importStar(__nccwpck_require__(99387));
 exports.json = json;
-const list = __importStar(__nccwpck_require__(20340));
+var list = __importStar(__nccwpck_require__(20340));
 exports.list = list;
-const map = __importStar(__nccwpck_require__(22298));
+var map = __importStar(__nccwpck_require__(22298));
 exports.map = map;
-const namespace = __importStar(__nccwpck_require__(93764));
+var namespace = __importStar(__nccwpck_require__(93764));
 exports.namespace = namespace;
-const queue = __importStar(__nccwpck_require__(39201));
+var queue = __importStar(__nccwpck_require__(39201));
 exports.queue = queue;
-const set = __importStar(__nccwpck_require__(35931));
+var set = __importStar(__nccwpck_require__(35931));
 exports.set = set;
-const stack = __importStar(__nccwpck_require__(38784));
+var stack = __importStar(__nccwpck_require__(38784));
 exports.stack = stack;
-const string = __importStar(__nccwpck_require__(13203));
+var string = __importStar(__nccwpck_require__(13203));
 exports.string = string;
 //# sourceMappingURL=index.js.map
 
 /***/ }),
 
 /***/ 53568:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.setValidationErrorCallback = setValidationErrorCallback;
-exports.newURL = newURL;
-exports.isSpecialScheme = isSpecialScheme;
-exports.isSpecial = isSpecial;
-exports.defaultPort = defaultPort;
-exports.includesCredentials = includesCredentials;
-exports.cannotHaveAUsernamePasswordPort = cannotHaveAUsernamePasswordPort;
-exports.urlSerializer = urlSerializer;
-exports.hostSerializer = hostSerializer;
-exports.iPv4Serializer = iPv4Serializer;
-exports.iPv6Serializer = iPv6Serializer;
-exports.urlParser = urlParser;
-exports.basicURLParser = basicURLParser;
-exports.setTheUsername = setTheUsername;
-exports.setThePassword = setThePassword;
-exports.isSingleDotPathSegment = isSingleDotPathSegment;
-exports.isDoubleDotPathSegment = isDoubleDotPathSegment;
-exports.shorten = shorten;
-exports.isNormalizedWindowsDriveLetter = isNormalizedWindowsDriveLetter;
-exports.isWindowsDriveLetter = isWindowsDriveLetter;
-exports.startsWithAWindowsDriveLetter = startsWithAWindowsDriveLetter;
-exports.hostParser = hostParser;
-exports.iPv4NumberParser = iPv4NumberParser;
-exports.iPv4Parser = iPv4Parser;
-exports.iPv6Parser = iPv6Parser;
-exports.opaqueHostParser = opaqueHostParser;
-exports.resolveABlobURL = resolveABlobURL;
-exports.percentEncode = percentEncode;
-exports.percentDecode = percentDecode;
-exports.stringPercentDecode = stringPercentDecode;
-exports.utf8PercentEncode = utf8PercentEncode;
-exports.hostEquals = hostEquals;
-exports.urlEquals = urlEquals;
-exports.urlEncodedStringParser = urlEncodedStringParser;
-exports.urlEncodedParser = urlEncodedParser;
-exports.urlEncodedByteSerializer = urlEncodedByteSerializer;
-exports.urlEncodedSerializer = urlEncodedSerializer;
-exports.origin = origin;
-exports.domainToASCII = domainToASCII;
-exports.domainToUnicode = domainToUnicode;
-exports.asciiSerializationOfAnOrigin = asciiSerializationOfAnOrigin;
-const util_1 = __nccwpck_require__(76195);
-const interfaces_1 = __nccwpck_require__(31752);
-const infra_1 = __nccwpck_require__(84251);
-const url_1 = __nccwpck_require__(57310);
-let _validationErrorCallback;
+var util_1 = __nccwpck_require__(76195);
+var interfaces_1 = __nccwpck_require__(31752);
+var infra_1 = __nccwpck_require__(84251);
+var url_1 = __nccwpck_require__(57310);
+var _validationErrorCallback;
 /**
  * Default ports for a special URL scheme.
  */
-const _defaultPorts = {
+var _defaultPorts = {
     "ftp": 21,
     "file": null,
     "http": 80,
@@ -33753,23 +64040,23 @@ const _defaultPorts = {
  * The C0 control percent-encode set are the C0 controls and all code points
  * greater than U+007E (~).
  */
-const _c0ControlPercentEncodeSet = /[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+var _c0ControlPercentEncodeSet = /[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
 /**
  * The fragment percent-encode set is the C0 control percent-encode set and
  * U+0020 SPACE, U+0022 ("), U+003C (<), U+003E (>), and U+0060 (`).
  */
-const _fragmentPercentEncodeSet = /[ "<>`]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+var _fragmentPercentEncodeSet = /[ "<>`]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
 /**
  * The path percent-encode set is the fragment percent-encode set and
  * U+0023 (#), U+003F (?), U+007B ({), and U+007D (}).
  */
-const _pathPercentEncodeSet = /[ "<>`#?{}]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+var _pathPercentEncodeSet = /[ "<>`#?{}]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
 /**
  * The userinfo percent-encode set is the path percent-encode set and
  * U+002F (/), U+003A (:), U+003B (;), U+003D (=), U+0040 (@), U+005B ([),
  * U+005C (\), U+005D (]), U+005E (^), and U+007C (|).
  */
-const _userInfoPercentEncodeSet = /[ "<>`#?{}/:;=@\[\]\\\^\|]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+var _userInfoPercentEncodeSet = /[ "<>`#?{}/:;=@\[\]\\\^\|]|[\0-\x1F\x7F-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
 /**
  * The URL code points are ASCII alphanumeric, U+0021 (!), U+0024 ($),
  * U+0026 (&), U+0027 ('), U+0028 LEFT PARENTHESIS, U+0029 RIGHT PARENTHESIS,
@@ -33778,13 +64065,13 @@ const _userInfoPercentEncodeSet = /[ "<>`#?{}/:;=@\[\]\\\^\|]|[\0-\x1F\x7F-\uD7F
  * U+007E (~), and code points in the range U+00A0 to U+10FFFD, inclusive,
  * excluding surrogates and noncharacters.
  */
-const _urlCodePoints = /[0-9A-Za-z!\$&-\/:;=\?@_~\xA0-\uD7FF\uE000-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uD83E\uD840-\uD87E\uD880-\uD8BE\uD8C0-\uD8FE\uD900-\uD93E\uD940-\uD97E\uD980-\uD9BE\uD9C0-\uD9FE\uDA00-\uDA3E\uDA40-\uDA7E\uDA80-\uDABE\uDAC0-\uDAFE\uDB00-\uDB3E\uDB40-\uDB7E\uDB80-\uDBBE\uDBC0-\uDBFE][\uDC00-\uDFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDC00-\uDFFD]/;
+var _urlCodePoints = /[0-9A-Za-z!\$&-\/:;=\?@_~\xA0-\uD7FF\uE000-\uFDCF\uFDF0-\uFFFD]|[\uD800-\uD83E\uD840-\uD87E\uD880-\uD8BE\uD8C0-\uD8FE\uD900-\uD93E\uD940-\uD97E\uD980-\uD9BE\uD9C0-\uD9FE\uDA00-\uDA3E\uDA40-\uDA7E\uDA80-\uDABE\uDAC0-\uDAFE\uDB00-\uDB3E\uDB40-\uDB7E\uDB80-\uDBBE\uDBC0-\uDBFE][\uDC00-\uDFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDC00-\uDFFD]/;
 /**
  * A forbidden host code point is U+0000 NULL, U+0009 TAB, U+000A LF,
  * U+000D CR, U+0020 SPACE, U+0023 (#), U+0025 (%), U+002F (/), U+003A (:),
  * U+003F (?), U+0040 (@), U+005B ([), U+005C (\), or U+005D (]).
  */
-const _forbiddenHostCodePoint = /[\0\t\f\r #%/:?@\[\\\]]/;
+var _forbiddenHostCodePoint = /[\0\t\f\r #%/:?@\[\\\]]/;
 /**
  * Sets the callback function for validation errors.
  *
@@ -33794,6 +64081,7 @@ const _forbiddenHostCodePoint = /[\0\t\f\r #%/:?@\[\\\]]/;
 function setValidationErrorCallback(validationErrorCallback) {
     _validationErrorCallback = validationErrorCallback;
 }
+exports.setValidationErrorCallback = setValidationErrorCallback;
 /**
  * Generates a validation error.
  *
@@ -33821,6 +64109,7 @@ function newURL() {
         _blobURLEntry: null
     };
 }
+exports.newURL = newURL;
 /**
  * Determines if the scheme is a special scheme.
  *
@@ -33829,6 +64118,7 @@ function newURL() {
 function isSpecialScheme(scheme) {
     return (scheme in _defaultPorts);
 }
+exports.isSpecialScheme = isSpecialScheme;
 /**
  * Determines if the URL has a special scheme.
  *
@@ -33837,6 +64127,7 @@ function isSpecialScheme(scheme) {
 function isSpecial(url) {
     return isSpecialScheme(url.scheme);
 }
+exports.isSpecial = isSpecial;
 /**
  * Returns the default port for a special scheme.
  *
@@ -33845,6 +64136,7 @@ function isSpecial(url) {
 function defaultPort(scheme) {
     return _defaultPorts[scheme] || null;
 }
+exports.defaultPort = defaultPort;
 /**
  * Determines if the URL has credentials.
  *
@@ -33853,6 +64145,7 @@ function defaultPort(scheme) {
 function includesCredentials(url) {
     return url.username !== '' || url.password !== '';
 }
+exports.includesCredentials = includesCredentials;
 /**
  * Determines if an URL cannot have credentials.
  *
@@ -33867,16 +64160,19 @@ function cannotHaveAUsernamePasswordPort(url) {
     return (url.host === null || url.host === "" || url._cannotBeABaseURLFlag ||
         url.scheme === "file");
 }
+exports.cannotHaveAUsernamePasswordPort = cannotHaveAUsernamePasswordPort;
 /**
  * Serializes an URL into a string.
  *
  * @param url - an URL
  */
-function urlSerializer(url, excludeFragmentFlag = false) {
+function urlSerializer(url, excludeFragmentFlag) {
+    var e_1, _a;
+    if (excludeFragmentFlag === void 0) { excludeFragmentFlag = false; }
     /**
      * 1. Let output be url’s scheme and U+003A (:) concatenated.
      */
-    let output = url.scheme + ':';
+    var output = url.scheme + ':';
     /**
      * 2. If url’s host is non-null:
      */
@@ -33927,8 +64223,18 @@ function urlSerializer(url, excludeFragmentFlag = false) {
         output += url.path[0];
     }
     else {
-        for (const str of url.path) {
-            output += '/' + str;
+        try {
+            for (var _b = __values(url.path), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var str = _c.value;
+                output += '/' + str;
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
     }
     /**
@@ -33946,6 +64252,7 @@ function urlSerializer(url, excludeFragmentFlag = false) {
     }
     return output;
 }
+exports.urlSerializer = urlSerializer;
 /**
  * Serializes a host into a string.
  *
@@ -33960,16 +64267,17 @@ function hostSerializer(host) {
      * U+005D (]).
      * 3. Otherwise, host is a domain, opaque host, or empty host, return host.
      */
-    if ((0, util_1.isNumber)(host)) {
+    if (util_1.isNumber(host)) {
         return iPv4Serializer(host);
     }
-    else if ((0, util_1.isArray)(host)) {
+    else if (util_1.isArray(host)) {
         return '[' + iPv6Serializer(host) + ']';
     }
     else {
         return host;
     }
 }
+exports.hostSerializer = hostSerializer;
 /**
  * Serializes an IPv4 address into a string.
  *
@@ -33985,9 +64293,9 @@ function iPv4Serializer(address) {
      * 3.3. Set n to floor(n / 256).
      * 4. Return output.
      */
-    let output = "";
-    let n = address;
-    for (let i = 1; i <= 4; i++) {
+    var output = "";
+    var n = address;
+    for (var i = 1; i <= 4; i++) {
         output = (n % 256).toString() + output;
         if (i !== 4) {
             output = '.' + output;
@@ -33996,6 +64304,7 @@ function iPv4Serializer(address) {
     }
     return output;
 }
+exports.iPv4Serializer = iPv4Serializer;
 /**
  * Serializes an IPv6 address into a string.
  *
@@ -34010,16 +64319,16 @@ function iPv6Serializer(address) {
      * 3. If there is no sequence of address’s IPv6 pieces that are 0 that is
      * longer than 1, then set compress to null.
      */
-    let output = "";
-    let compress = null;
-    let lastIndex = -1;
-    let count = 0;
-    let lastCount = 0;
-    for (let i = 0; i < 8; i++) {
+    var output = "";
+    var compress = null;
+    var lastIndex = -1;
+    var count = 0;
+    var lastCount = 0;
+    for (var i = 0; i < 8; i++) {
         if (address[i] !== 0)
             continue;
         count = 1;
-        for (let j = i + 1; j < 8; j++) {
+        for (var j = i + 1; j < 8; j++) {
             if (address[j] !== 0)
                 break;
             count++;
@@ -34036,8 +64345,8 @@ function iPv6Serializer(address) {
      * 4. Let ignore0 be false.
      * 5. For each pieceIndex in the range 0 to 7, inclusive:
      */
-    let ignore0 = false;
-    for (let pieceIndex = 0; pieceIndex < 8; pieceIndex++) {
+    var ignore0 = false;
+    for (var pieceIndex = 0; pieceIndex < 8; pieceIndex++) {
         /**
          * 5.1. If ignore0 is true and address[pieceIndex] is 0, then continue.
          * 5.2. Otherwise, if ignore0 is true, set ignore0 to false.
@@ -34071,6 +64380,7 @@ function iPv6Serializer(address) {
      */
     return output;
 }
+exports.iPv6Serializer = iPv6Serializer;
 /**
  * Parses an URL string.
  *
@@ -34088,12 +64398,12 @@ function urlParser(input, baseURL, encodingOverride) {
      * if that did not return failure, and null otherwise.
      * 5. Return url.
      */
-    const url = basicURLParser(input, baseURL, encodingOverride);
+    var url = basicURLParser(input, baseURL, encodingOverride);
     if (url === null)
         return null;
     if (url.scheme !== "blob")
         return url;
-    const entry = resolveABlobURL(url);
+    var entry = resolveABlobURL(url);
     if (entry !== null) {
         url._blobURLEntry = entry;
     }
@@ -34102,6 +64412,7 @@ function urlParser(input, baseURL, encodingOverride) {
     }
     return url;
 }
+exports.urlParser = urlParser;
 /**
  * Parses an URL string.
  *
@@ -34110,6 +64421,7 @@ function urlParser(input, baseURL, encodingOverride) {
  * @param encodingOverride - encoding override
  */
 function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
+    var e_2, _a, e_3, _b;
     /**
      * 1. If url is not given:
      * 1.1. Set url to a new URL.
@@ -34120,8 +64432,8 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
     if (url === undefined) {
         url = newURL();
         // leading
-        const leadingControlOrSpace = /^[\u0000-\u001F\u0020]+/;
-        const trailingControlOrSpace = /[\u0000-\u001F\u0020]+$/;
+        var leadingControlOrSpace = /^[\u0000-\u001F\u0020]+/;
+        var trailingControlOrSpace = /[\u0000-\u001F\u0020]+$/;
         if (leadingControlOrSpace.test(input) || trailingControlOrSpace.test(input)) {
             validationError("Input string contains leading or trailing control characters or space.");
         }
@@ -34132,7 +64444,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
      * 2. If input contains any ASCII tab or newline, validation error.
      * 3. Remove all ASCII tab or newline from input.
      */
-    const tabOrNewline = /[\u0009\u000A\u000D]/g;
+    var tabOrNewline = /[\u0009\u000A\u000D]/g;
     if (tabOrNewline.test(input)) {
         validationError("Input string contains tab or newline characters.");
     }
@@ -34144,10 +64456,10 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
      * 7. If encoding override is given, set encoding to the result of getting
      * an output encoding from encoding override.
      */
-    let state = (stateOverride === undefined ? interfaces_1.ParserState.SchemeStart : stateOverride);
+    var state = (stateOverride === undefined ? interfaces_1.ParserState.SchemeStart : stateOverride);
     if (baseURL === undefined)
         baseURL = null;
-    let encoding = (encodingOverride === undefined ||
+    var encoding = (encodingOverride === undefined ||
         encodingOverride === "replacement" || encodingOverride === "UTF-16BE" ||
         encodingOverride === "UTF-16LE" ? "UTF-8" : encodingOverride);
     /**
@@ -34155,12 +64467,12 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
      * 9. Let the @ flag, [] flag, and passwordTokenSeenFlag be unset.
      * 10. Let pointer be a pointer to first code point in input.
      */
-    let buffer = "";
-    let atFlag = false;
-    let arrayFlag = false;
-    let passwordTokenSeenFlag = false;
-    const EOF = "";
-    const walker = new util_1.StringWalker(input);
+    var buffer = "";
+    var atFlag = false;
+    var arrayFlag = false;
+    var passwordTokenSeenFlag = false;
+    var EOF = "";
+    var walker = new util_1.StringWalker(input);
     /**
      * 11. Keep running the following state machine by switching on state. If
      * after a run pointer points to the EOF code point, go to the next step.
@@ -34538,27 +64850,37 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
                     if (atFlag)
                         buffer = '%40' + buffer;
                     atFlag = true;
-                    for (const codePoint of buffer) {
-                        /**
-                         * 1.4.1. If codePoint is U+003A (:) and passwordTokenSeenFlag is
-                         * unset, then set passwordTokenSeenFlag and continue.
-                         * 1.4.2. Let encodedCodePoints be the result of running UTF-8
-                         * percent encode codePoint using the userinfo percent-encode set.
-                         * 1.4.3. If passwordTokenSeenFlag is set, then append
-                         * encodedCodePoints to url’s password.
-                         * 1.4.4. Otherwise, append encodedCodePoints to url’s username.
-                         */
-                        if (codePoint === ':' && !passwordTokenSeenFlag) {
-                            passwordTokenSeenFlag = true;
-                            continue;
+                    try {
+                        for (var buffer_1 = (e_2 = void 0, __values(buffer)), buffer_1_1 = buffer_1.next(); !buffer_1_1.done; buffer_1_1 = buffer_1.next()) {
+                            var codePoint = buffer_1_1.value;
+                            /**
+                             * 1.4.1. If codePoint is U+003A (:) and passwordTokenSeenFlag is
+                             * unset, then set passwordTokenSeenFlag and continue.
+                             * 1.4.2. Let encodedCodePoints be the result of running UTF-8
+                             * percent encode codePoint using the userinfo percent-encode set.
+                             * 1.4.3. If passwordTokenSeenFlag is set, then append
+                             * encodedCodePoints to url’s password.
+                             * 1.4.4. Otherwise, append encodedCodePoints to url’s username.
+                             */
+                            if (codePoint === ':' && !passwordTokenSeenFlag) {
+                                passwordTokenSeenFlag = true;
+                                continue;
+                            }
+                            var encodedCodePoints = utf8PercentEncode(codePoint, _userInfoPercentEncodeSet);
+                            if (passwordTokenSeenFlag) {
+                                url.password += encodedCodePoints;
+                            }
+                            else {
+                                url.username += encodedCodePoints;
+                            }
                         }
-                        const encodedCodePoints = utf8PercentEncode(codePoint, _userInfoPercentEncodeSet);
-                        if (passwordTokenSeenFlag) {
-                            url.password += encodedCodePoints;
-                        }
-                        else {
-                            url.username += encodedCodePoints;
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (buffer_1_1 && !buffer_1_1.done && (_a = buffer_1.return)) _a.call(buffer_1);
                         }
+                        finally { if (e_2) throw e_2.error; }
                     }
                     /**
                      * 1.5. Set buffer to the empty string.
@@ -34619,7 +64941,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
                         validationError("Invalid input string.");
                         return null;
                     }
-                    const host = hostParser(buffer, !isSpecial(url));
+                    var host = hostParser(buffer, !isSpecial(url));
                     if (host === null)
                         return null;
                     url.host = host;
@@ -34657,7 +64979,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
                         validationError("Invalid input string.");
                         return url;
                     }
-                    const host = hostParser(buffer, !isSpecial(url));
+                    var host = hostParser(buffer, !isSpecial(url));
                     if (host === null)
                         return null;
                     url.host = host;
@@ -34709,7 +65031,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
                          * 2.1.4. Set buffer to the empty string.
                          */
                         if (buffer !== "") {
-                            const port = parseInt(buffer, 10);
+                            var port = parseInt(buffer, 10);
                             if (port > Math.pow(2, 16) - 1) {
                                 validationError("Invalid port number.");
                                 return null;
@@ -34905,7 +65227,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
                          * 1.3.6. Set buffer to the empty string and state to path start
                          * state.
                          */
-                        let host = hostParser(buffer, !isSpecial(url));
+                        var host = hostParser(buffer, !isSpecial(url));
                         if (host === null)
                             return null;
                         if (host === "localhost")
@@ -35023,7 +65345,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
                                 validationError("Invalid input string.");
                                 url.host = "";
                             }
-                            const bufferCodePoints = Array.from(buffer);
+                            var bufferCodePoints = Array.from(buffer);
                             buffer = bufferCodePoints.slice(0, 1) + ':' + bufferCodePoints.slice(2);
                         }
                         /**
@@ -35157,7 +65479,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
                     if (encoding.toUpperCase() !== "UTF-8") {
                         throw new Error("Only UTF-8 encoding is supported.");
                     }
-                    let bytes = (0, util_1.utf8Encode)(walker.c());
+                    var bytes = util_1.utf8Encode(walker.c());
                     /**
                      * 3.4. If bytes starts with `&#` and ends with 0x3B (;), then:
                      */
@@ -35174,26 +65496,36 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
                         url.query += "%26%23" + infra_1.byteSequence.isomorphicDecode(bytes) + "%3B";
                     }
                     else {
-                        /**
-                         * 3.5. Otherwise, for each byte in bytes:
-                         * 3.5.1. If one of the following is true
-                         * - byte is less than 0x21 (!)
-                         * - byte is greater than 0x7E (~)
-                         * - byte is 0x22 ("), 0x23 (#), 0x3C (<), or 0x3E (>)
-                         * - byte is 0x27 (') and url is special
-                         * then append byte, percent encoded, to url’s query.
-                         * 3.5.2. Otherwise, append a code point whose value is byte to
-                         * url’s query.
-                         */
-                        for (const byte of bytes) {
-                            if (byte < 0x21 || byte > 0x7E || byte === 0x22 ||
-                                byte === 0x23 || byte === 0x3C || byte === 0x3E ||
-                                (byte === 0x27 && isSpecial(url))) {
-                                url.query += percentEncode(byte);
+                        try {
+                            /**
+                             * 3.5. Otherwise, for each byte in bytes:
+                             * 3.5.1. If one of the following is true
+                             * - byte is less than 0x21 (!)
+                             * - byte is greater than 0x7E (~)
+                             * - byte is 0x22 ("), 0x23 (#), 0x3C (<), or 0x3E (>)
+                             * - byte is 0x27 (') and url is special
+                             * then append byte, percent encoded, to url’s query.
+                             * 3.5.2. Otherwise, append a code point whose value is byte to
+                             * url’s query.
+                             */
+                            for (var bytes_1 = (e_3 = void 0, __values(bytes)), bytes_1_1 = bytes_1.next(); !bytes_1_1.done; bytes_1_1 = bytes_1.next()) {
+                                var byte = bytes_1_1.value;
+                                if (byte < 0x21 || byte > 0x7E || byte === 0x22 ||
+                                    byte === 0x23 || byte === 0x3C || byte === 0x3E ||
+                                    (byte === 0x27 && isSpecial(url))) {
+                                    url.query += percentEncode(byte);
+                                }
+                                else {
+                                    url.query += String.fromCharCode(byte);
+                                }
                             }
-                            else {
-                                url.query += String.fromCharCode(byte);
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (bytes_1_1 && !bytes_1_1.done && (_b = bytes_1.return)) _b.call(bytes_1);
                             }
+                            finally { if (e_3) throw e_3.error; }
                         }
                     }
                 }
@@ -35240,6 +65572,7 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
      */
     return url;
 }
+exports.basicURLParser = basicURLParser;
 /**
  * Sets a URL's username.
  *
@@ -35247,17 +65580,29 @@ function basicURLParser(input, baseURL, encodingOverride, url, stateOverride) {
  * @param username - username string
  */
 function setTheUsername(url, username) {
+    var e_4, _a;
     /**
      * 1. Set url’s username to the empty string.
      * 2. For each code point in username, UTF-8 percent encode it using the
      * userinfo percent-encode set, and append the result to url’s username.
      */
-    let result = "";
-    for (const codePoint of username) {
-        result += utf8PercentEncode(codePoint, _userInfoPercentEncodeSet);
+    var result = "";
+    try {
+        for (var username_1 = __values(username), username_1_1 = username_1.next(); !username_1_1.done; username_1_1 = username_1.next()) {
+            var codePoint = username_1_1.value;
+            result += utf8PercentEncode(codePoint, _userInfoPercentEncodeSet);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (username_1_1 && !username_1_1.done && (_a = username_1.return)) _a.call(username_1);
+        }
+        finally { if (e_4) throw e_4.error; }
     }
     url.username = result;
 }
+exports.setTheUsername = setTheUsername;
 /**
  * Sets a URL's password.
  *
@@ -35265,17 +65610,29 @@ function setTheUsername(url, username) {
  * @param username - password string
  */
 function setThePassword(url, password) {
+    var e_5, _a;
     /**
      * 1. Set url’s password to the empty string.
      * 2. For each code point in password, UTF-8 percent encode it using the
      * userinfo percent-encode set, and append the result to url’s password.
      */
-    let result = "";
-    for (const codePoint of password) {
-        result += utf8PercentEncode(codePoint, _userInfoPercentEncodeSet);
+    var result = "";
+    try {
+        for (var password_1 = __values(password), password_1_1 = password_1.next(); !password_1_1.done; password_1_1 = password_1.next()) {
+            var codePoint = password_1_1.value;
+            result += utf8PercentEncode(codePoint, _userInfoPercentEncodeSet);
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (password_1_1 && !password_1_1.done && (_a = password_1.return)) _a.call(password_1);
+        }
+        finally { if (e_5) throw e_5.error; }
     }
     url.password = result;
 }
+exports.setThePassword = setThePassword;
 /**
  * Determines if the string represents a single dot path.
  *
@@ -35284,16 +65641,18 @@ function setThePassword(url, password) {
 function isSingleDotPathSegment(str) {
     return str === '.' || str.toLowerCase() === "%2e";
 }
+exports.isSingleDotPathSegment = isSingleDotPathSegment;
 /**
  * Determines if the string represents a double dot path.
  *
  * @param str - a string
  */
 function isDoubleDotPathSegment(str) {
-    const lowerStr = str.toLowerCase();
+    var lowerStr = str.toLowerCase();
     return lowerStr === ".." || lowerStr === ".%2e" ||
         lowerStr === "%2e." || lowerStr === "%2e%2e";
 }
+exports.isDoubleDotPathSegment = isDoubleDotPathSegment;
 /**
  * Shorten's URL's path.
  *
@@ -35307,7 +65666,7 @@ function shorten(url) {
      * normalized Windows drive letter, then return.
      * 4. Remove path’s last item.
      */
-    const path = url.path;
+    var path = url.path;
     if (path.length === 0)
         return;
     if (url.scheme === "file" && path.length === 1 &&
@@ -35315,6 +65674,7 @@ function shorten(url) {
         return;
     url.path.splice(url.path.length - 1, 1);
 }
+exports.shorten = shorten;
 /**
  * Determines if a string is a normalized Windows drive letter.
  *
@@ -35328,6 +65688,7 @@ function isNormalizedWindowsDriveLetter(str) {
     return str.length >= 2 && infra_1.codePoint.ASCIIAlpha.test(str[0]) &&
         str[1] === ':';
 }
+exports.isNormalizedWindowsDriveLetter = isNormalizedWindowsDriveLetter;
 /**
  * Determines if a string is a Windows drive letter.
  *
@@ -35341,6 +65702,7 @@ function isWindowsDriveLetter(str) {
     return str.length >= 2 && infra_1.codePoint.ASCIIAlpha.test(str[0]) &&
         (str[1] === ':' || str[1] === '|');
 }
+exports.isWindowsDriveLetter = isWindowsDriveLetter;
 /**
  * Determines if a string starts with a Windows drive letter.
  *
@@ -35359,6 +65721,7 @@ function startsWithAWindowsDriveLetter(str) {
         (str.length === 2 || (str[2] === '/' || str[2] === '\\' ||
             str[2] === '?' || str[2] === '#'));
 }
+exports.startsWithAWindowsDriveLetter = startsWithAWindowsDriveLetter;
 /**
  * Parses a host string.
  *
@@ -35366,7 +65729,8 @@ function startsWithAWindowsDriveLetter(str) {
  * @param isNotSpecial - `true` if the source URL is not special; otherwise
  * `false`.
  */
-function hostParser(input, isNotSpecial = false) {
+function hostParser(input, isNotSpecial) {
+    if (isNotSpecial === void 0) { isNotSpecial = false; }
     /**
      * 1. If isNotSpecial is not given, then set isNotSpecial to false.
      * 2. If input starts with U+005B ([), then:
@@ -35396,14 +65760,14 @@ function hostParser(input, isNotSpecial = false) {
      * coupled with an early return for failure, as domain to ASCII fails
      * on U+FFFD REPLACEMENT CHARACTER.
      */
-    const domain = (0, util_1.utf8Decode)(stringPercentDecode(input));
+    var domain = util_1.utf8Decode(stringPercentDecode(input));
     /**
      * 5. Let asciiDomain be the result of running domain to ASCII on domain.
      * 6. If asciiDomain is failure, validation error, return failure.
      * 7. If asciiDomain contains a forbidden host code point, validation error,
      * return failure.
      */
-    const asciiDomain = domainToASCII(domain);
+    var asciiDomain = domainToASCII(domain);
     if (asciiDomain === null) {
         validationError("Invalid domain.");
         return null;
@@ -35417,11 +65781,12 @@ function hostParser(input, isNotSpecial = false) {
      * 9. If ipv4Host is an IPv4 address or failure, return ipv4Host.
      * 10. Return asciiDomain.
      */
-    const ipv4Host = iPv4Parser(asciiDomain);
-    if (ipv4Host === null || (0, util_1.isNumber)(ipv4Host))
+    var ipv4Host = iPv4Parser(asciiDomain);
+    if (ipv4Host === null || util_1.isNumber(ipv4Host))
         return ipv4Host;
     return asciiDomain;
 }
+exports.hostParser = hostParser;
 /**
  * Parses a string containing an IP v4 address.
  *
@@ -35429,11 +65794,12 @@ function hostParser(input, isNotSpecial = false) {
  * @param isNotSpecial - `true` if the source URL is not special; otherwise
  * `false`.
  */
-function iPv4NumberParser(input, validationErrorFlag = { value: false }) {
+function iPv4NumberParser(input, validationErrorFlag) {
+    if (validationErrorFlag === void 0) { validationErrorFlag = { value: false }; }
     /**
      * 1. Let R be 10.
      */
-    let R = 10;
+    var R = 10;
     if (input.startsWith("0x") || input.startsWith("0X")) {
         /**
          * 2. If input contains at least two code points and the first two code
@@ -35465,7 +65831,7 @@ function iPv4NumberParser(input, validationErrorFlag = { value: false }) {
      */
     if (input === "")
         return 0;
-    const radixRDigits = (R === 10 ? /^[0-9]+$/ : (R === 16 ? /^[0-9A-Fa-f]+$/ : /^[0-7]+$/));
+    var radixRDigits = (R === 10 ? /^[0-9]+$/ : (R === 16 ? /^[0-9A-Fa-f]+$/ : /^[0-7]+$/));
     if (!radixRDigits.test(input))
         return null;
     /**
@@ -35475,18 +65841,20 @@ function iPv4NumberParser(input, validationErrorFlag = { value: false }) {
      */
     return parseInt(input, R);
 }
+exports.iPv4NumberParser = iPv4NumberParser;
 /**
  * Parses a string containing an IP v4 address.
  *
  * @param input - input string
  */
 function iPv4Parser(input) {
+    var e_6, _a, e_7, _b;
     /**
      * 1. Let validationErrorFlag be unset.
      * 2. Let parts be input split on U+002E (.).
      */
-    const validationErrorFlag = { value: false };
-    const parts = input.split('.');
+    var validationErrorFlag = { value: false };
+    var parts = input.split('.');
     /**
      * 3. If the last item in parts is the empty string, then:
      * 3.1. Set validationErrorFlag.
@@ -35511,14 +65879,24 @@ function iPv4Parser(input) {
      * 6.3. If n is failure, return input.
      * 6.4. Append n to numbers.
      */
-    const numbers = [];
-    for (const part of parts) {
-        if (part === "")
-            return input;
-        const n = iPv4NumberParser(part, validationErrorFlag);
-        if (n === null)
-            return input;
-        numbers.push(n);
+    var numbers = [];
+    try {
+        for (var parts_1 = __values(parts), parts_1_1 = parts_1.next(); !parts_1_1.done; parts_1_1 = parts_1.next()) {
+            var part = parts_1_1.value;
+            if (part === "")
+                return input;
+            var n = iPv4NumberParser(part, validationErrorFlag);
+            if (n === null)
+                return input;
+            numbers.push(n);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (parts_1_1 && !parts_1_1.done && (_a = parts_1.return)) _a.call(parts_1);
+        }
+        finally { if (e_6) throw e_6.error; }
     }
     /**
      * 7. If validationErrorFlag is set, validation error.
@@ -35530,8 +65908,8 @@ function iPv4Parser(input) {
      */
     if (validationErrorFlag.value)
         validationError("Invalid IP v4 address.");
-    for (let i = 0; i < numbers.length; i++) {
-        const item = numbers[i];
+    for (var i = 0; i < numbers.length; i++) {
+        var item = numbers[i];
         if (item > 255) {
             validationError("Invalid IP v4 address.");
             if (i < numbers.length - 1)
@@ -35546,7 +65924,7 @@ function iPv4Parser(input) {
      * 11. Let ipv4 be the last item in numbers.
      * 12. Remove the last item from numbers.
      */
-    let ipv4 = numbers[numbers.length - 1];
+    var ipv4 = numbers[numbers.length - 1];
     numbers.pop();
     /**
      * 13. Let counter be zero.
@@ -35554,22 +65932,34 @@ function iPv4Parser(input) {
      * 14.2. Increment ipv4 by n × 256**(3 − counter).
      * 14.2. Increment counter by 1.
      */
-    let counter = 0;
-    for (const n of numbers) {
-        ipv4 += n * Math.pow(256, 3 - counter);
-        counter++;
+    var counter = 0;
+    try {
+        for (var numbers_1 = __values(numbers), numbers_1_1 = numbers_1.next(); !numbers_1_1.done; numbers_1_1 = numbers_1.next()) {
+            var n = numbers_1_1.value;
+            ipv4 += n * Math.pow(256, 3 - counter);
+            counter++;
+        }
+    }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
+    finally {
+        try {
+            if (numbers_1_1 && !numbers_1_1.done && (_b = numbers_1.return)) _b.call(numbers_1);
+        }
+        finally { if (e_7) throw e_7.error; }
     }
     /**
      * 15. Return ipv4.
      */
     return ipv4;
 }
+exports.iPv4Parser = iPv4Parser;
 /**
  * Parses a string containing an IP v6 address.
  *
  * @param input - input string
  */
 function iPv6Parser(input) {
+    var _a;
     /**
      * 1. Let address be a new IPv6 address whose IPv6 pieces are all 0.
      * 2. Let pieceIndex be 0.
@@ -35577,11 +65967,11 @@ function iPv6Parser(input) {
      * 4. Let pointer be a pointer into input, initially 0 (pointing to the
      * first code point).
      */
-    const EOF = "";
-    const address = [0, 0, 0, 0, 0, 0, 0, 0];
-    let pieceIndex = 0;
-    let compress = null;
-    const walker = new util_1.StringWalker(input);
+    var EOF = "";
+    var address = [0, 0, 0, 0, 0, 0, 0, 0];
+    var pieceIndex = 0;
+    var compress = null;
+    var walker = new util_1.StringWalker(input);
     /**
      * 5. If c is U+003A (:), then:
      * 5.1. If remaining does not start with U+003A (:), validation error,
@@ -35631,8 +66021,8 @@ function iPv6Parser(input) {
          * to value × 0x10 + c interpreted as hexadecimal number, and increase
          * pointer and length by 1.
          */
-        let value = 0;
-        let length = 0;
+        var value = 0;
+        var length = 0;
         while (length < 4 && infra_1.codePoint.ASCIIHexDigit.test(walker.c())) {
             value = value * 0x10 + parseInt(walker.c(), 16);
             walker.pointer++;
@@ -35658,7 +66048,7 @@ function iPv6Parser(input) {
                 validationError("Invalid IP v6 address.");
                 return null;
             }
-            let numbersSeen = 0;
+            var numbersSeen = 0;
             /**
              * 6.5.5. While c is not the EOF code point:
              */
@@ -35666,7 +66056,7 @@ function iPv6Parser(input) {
                 /**
                  * 6.5.5.1. Let ipv4Piece be null.
                  */
-                let ipv4Piece = null;
+                var ipv4Piece = null;
                 /**
                  * 6.5.5.2. If numbersSeen is greater than 0, then:
                  * 6.5.5.2.1. If c is a U+002E (.) and numbersSeen is less than 4, then
@@ -35697,7 +66087,7 @@ function iPv6Parser(input) {
                     /**
                      * 6.5.5.4.1. Let number be c interpreted as decimal number.
                      */
-                    const number = parseInt(walker.c(), 10);
+                    var number = parseInt(walker.c(), 10);
                     /**
                      * 6.5.5.4.2. If ipv4Piece is null, then set ipv4Piece to number.
                      * Otherwise, if ipv4Piece is 0, validation error, return failure.
@@ -35785,11 +66175,10 @@ function iPv6Parser(input) {
      * both pieceIndex and swaps by 1.
      */
     if (compress !== null) {
-        let swaps = pieceIndex - compress;
+        var swaps = pieceIndex - compress;
         pieceIndex = 7;
         while (pieceIndex !== 0 && swaps > 0) {
-            [address[pieceIndex], address[compress + swaps - 1]] =
-                [address[compress + swaps - 1], address[pieceIndex]];
+            _a = __read([address[compress + swaps - 1], address[pieceIndex]], 2), address[pieceIndex] = _a[0], address[compress + swaps - 1] = _a[1];
             pieceIndex--;
             swaps--;
         }
@@ -35807,12 +66196,14 @@ function iPv6Parser(input) {
      */
     return address;
 }
+exports.iPv6Parser = iPv6Parser;
 /**
  * Parses an opaque host string.
  *
  * @param input - a string
  */
 function opaqueHostParser(input) {
+    var e_8, _a;
     /**
      * 1. If input contains a forbidden host code point excluding U+0025 (%),
      * validation error, return failure.
@@ -35821,17 +66212,28 @@ function opaqueHostParser(input) {
      * control percent-encode set, and append the result to output.
      * 4. Return output.
      */
-    const forbiddenChars = /[\x00\t\f\r #/:?@\[\\\]]/;
+    var forbiddenChars = /[\x00\t\f\r #/:?@\[\\\]]/;
     if (forbiddenChars.test(input)) {
         validationError("Invalid host string.");
         return null;
     }
-    let output = "";
-    for (const codePoint of input) {
-        output += utf8PercentEncode(codePoint, _c0ControlPercentEncodeSet);
+    var output = "";
+    try {
+        for (var input_1 = __values(input), input_1_1 = input_1.next(); !input_1_1.done; input_1_1 = input_1.next()) {
+            var codePoint = input_1_1.value;
+            output += utf8PercentEncode(codePoint, _c0ControlPercentEncodeSet);
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (input_1_1 && !input_1_1.done && (_a = input_1.return)) _a.call(input_1);
+        }
+        finally { if (e_8) throw e_8.error; }
     }
     return output;
 }
+exports.opaqueHostParser = opaqueHostParser;
 /**
  * Resolves a Blob URL from the user agent's Blob URL store.
  * function is not implemented.
@@ -35842,6 +66244,7 @@ function opaqueHostParser(input) {
 function resolveABlobURL(url) {
     return null;
 }
+exports.resolveABlobURL = resolveABlobURL;
 /**
  * Percent encodes a byte.
  *
@@ -35855,13 +66258,14 @@ function percentEncode(value) {
      */
     return '%' + ('00' + value.toString(16).toUpperCase()).slice(-2);
 }
+exports.percentEncode = percentEncode;
 /**
  * Percent decodes a byte sequence input.
  *
  * @param input - a byte sequence
  */
 function percentDecode(input) {
-    const isHexDigit = (byte) => {
+    var isHexDigit = function (byte) {
         return (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x46) ||
             (byte >= 0x61 && byte <= 0x66);
     };
@@ -35869,10 +66273,10 @@ function percentDecode(input) {
      * 1. Let output be an empty byte sequence.
      * 2. For each byte byte in input:
      */
-    const output = new Uint8Array(input.length);
-    let n = 0;
-    for (let i = 0; i < input.length; i++) {
-        const byte = input[i];
+    var output = new Uint8Array(input.length);
+    var n = 0;
+    for (var i = 0; i < input.length; i++) {
+        var byte = input[i];
         /**
          * 2.1. If byte is not 0x25 (%), then append byte to output.
          * 2.2. Otherwise, if byte is 0x25 (%) and the next two bytes after byte
@@ -35898,7 +66302,7 @@ function percentDecode(input) {
             n++;
         }
         else {
-            const bytePoint = parseInt((0, util_1.utf8Decode)(Uint8Array.of(input[i + 1], input[i + 2])), 16);
+            var bytePoint = parseInt(util_1.utf8Decode(Uint8Array.of(input[i + 1], input[i + 2])), 16);
             output[n] = bytePoint;
             n++;
             i += 2;
@@ -35906,6 +66310,7 @@ function percentDecode(input) {
     }
     return output.subarray(0, n);
 }
+exports.percentDecode = percentDecode;
 /**
  * String percent decodes a string.
  *
@@ -35916,8 +66321,9 @@ function stringPercentDecode(input) {
      * 1. Let bytes be the UTF-8 encoding of input.
      * 2. Return the percent decoding of bytes.
      */
-    return percentDecode((0, util_1.utf8Encode)(input));
+    return percentDecode(util_1.utf8Encode(input));
 }
+exports.stringPercentDecode = stringPercentDecode;
 /**
  * UTF-8 percent encodes a code point, using a percent encode set.
  *
@@ -35925,6 +66331,7 @@ function stringPercentDecode(input) {
  * @param percentEncodeSet - a percent encode set
  */
 function utf8PercentEncode(codePoint, percentEncodeSet) {
+    var e_9, _a;
     /**
      * 1. If codePoint is not in percentEncodeSet, then return codePoint.
      * 2. Let bytes be the result of running UTF-8 encode on codePoint.
@@ -35933,13 +66340,24 @@ function utf8PercentEncode(codePoint, percentEncodeSet) {
      */
     if (!percentEncodeSet.test(codePoint))
         return codePoint;
-    const bytes = (0, util_1.utf8Encode)(codePoint);
-    let result = "";
-    for (const byte of bytes) {
-        result += percentEncode(byte);
+    var bytes = util_1.utf8Encode(codePoint);
+    var result = "";
+    try {
+        for (var bytes_2 = __values(bytes), bytes_2_1 = bytes_2.next(); !bytes_2_1.done; bytes_2_1 = bytes_2.next()) {
+            var byte = bytes_2_1.value;
+            result += percentEncode(byte);
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (bytes_2_1 && !bytes_2_1.done && (_a = bytes_2.return)) _a.call(bytes_2);
+        }
+        finally { if (e_9) throw e_9.error; }
     }
     return result;
 }
+exports.utf8PercentEncode = utf8PercentEncode;
 /**
  * Determines if two hosts are considered equal.
  *
@@ -35949,6 +66367,7 @@ function utf8PercentEncode(codePoint, percentEncodeSet) {
 function hostEquals(hostA, hostB) {
     return hostA === hostB;
 }
+exports.hostEquals = hostEquals;
 /**
  * Determines if two URLs are considered equal.
  *
@@ -35956,7 +66375,8 @@ function hostEquals(hostA, hostB) {
  * @param urlB - a URL
  * @param excludeFragmentsFlag - whether to ignore fragments while comparing
  */
-function urlEquals(urlA, urlB, excludeFragmentsFlag = false) {
+function urlEquals(urlA, urlB, excludeFragmentsFlag) {
+    if (excludeFragmentsFlag === void 0) { excludeFragmentsFlag = false; }
     /**
      * 1. Let serializedA be the result of serializing A, with the exclude
      * fragment flag set if the exclude fragments flag is set.
@@ -35967,6 +66387,7 @@ function urlEquals(urlA, urlB, excludeFragmentsFlag = false) {
     return urlSerializer(urlA, excludeFragmentsFlag) ===
         urlSerializer(urlB, excludeFragmentsFlag);
 }
+exports.urlEquals = urlEquals;
 /**
  * Parses an `application/x-www-form-urlencoded` string.
  *
@@ -35978,27 +66399,39 @@ function urlEncodedStringParser(input) {
      * UTF-8 encodes it, and then returns the result of
      * application/x-www-form-urlencoded parsing it.
      */
-    return urlEncodedParser((0, util_1.utf8Encode)(input));
+    return urlEncodedParser(util_1.utf8Encode(input));
 }
+exports.urlEncodedStringParser = urlEncodedStringParser;
 /**
  * Parses `application/x-www-form-urlencoded` bytes.
  *
  * @param input - a byte sequence
  */
 function urlEncodedParser(input) {
+    var e_10, _a, e_11, _b;
     /**
      * 1. Let sequences be the result of splitting input on 0x26 (&).
      */
-    const sequences = [];
-    let currentSequence = [];
-    for (const byte of input) {
-        if (byte === 0x26) {
-            sequences.push(Uint8Array.from(currentSequence));
-            currentSequence = [];
+    var sequences = [];
+    var currentSequence = [];
+    try {
+        for (var input_2 = __values(input), input_2_1 = input_2.next(); !input_2_1.done; input_2_1 = input_2.next()) {
+            var byte = input_2_1.value;
+            if (byte === 0x26) {
+                sequences.push(Uint8Array.from(currentSequence));
+                currentSequence = [];
+            }
+            else {
+                currentSequence.push(byte);
+            }
         }
-        else {
-            currentSequence.push(byte);
+    }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
+    finally {
+        try {
+            if (input_2_1 && !input_2_1.done && (_a = input_2.return)) _a.call(input_2);
         }
+        finally { if (e_10) throw e_10.error; }
     }
     if (currentSequence.length !== 0) {
         sequences.push(Uint8Array.from(currentSequence));
@@ -36006,60 +66439,72 @@ function urlEncodedParser(input) {
     /**
      * 2. Let output be an initially empty list of name-value tuples where both name and value hold a string.
      */
-    const output = [];
-    /**
-     * 3. For each byte sequence bytes in sequences:
-     */
-    for (const bytes of sequences) {
+    var output = [];
+    try {
         /**
-         * 3.1. If bytes is the empty byte sequence, then continue.
+         * 3. For each byte sequence bytes in sequences:
          */
-        if (bytes.length === 0)
-            continue;
-        /**
-         * 3.2. If bytes contains a 0x3D (=), then let name be the bytes from the
-         * start of bytes up to but excluding its first 0x3D (=), and let value be
-         * the bytes, if any, after the first 0x3D (=) up to the end of bytes.
-         * If 0x3D (=) is the first byte, then name will be the empty byte
-         * sequence. If it is the last, then value will be the empty byte sequence.
-         * 3.3. Otherwise, let name have the value of bytes and let value be the
-         * empty byte sequence.
-         */
-        const index = bytes.indexOf(0x3D);
-        const name = (index !== -1 ? bytes.slice(0, index) : bytes);
-        const value = (index !== -1 ? bytes.slice(index + 1) : new Uint8Array());
-        /**
-         * 3.4. Replace any 0x2B (+) in name and value with 0x20 (SP).
-         */
-        for (let i = 0; i < name.length; i++)
-            if (name[i] === 0x2B)
-                name[i] = 0x20;
-        for (let i = 0; i < value.length; i++)
-            if (value[i] === 0x2B)
-                value[i] = 0x20;
-        /**
-         * 3.5. Let nameString and valueString be the result of running UTF-8
-         * decode without BOM on the percent decoding of name and value,
-         * respectively.
-         */
-        const nameString = (0, util_1.utf8Decode)(name);
-        const valueString = (0, util_1.utf8Decode)(value);
-        /**
-         * 3.6. Append (nameString, valueString) to output.
-         */
-        output.push([nameString, valueString]);
+        for (var sequences_1 = __values(sequences), sequences_1_1 = sequences_1.next(); !sequences_1_1.done; sequences_1_1 = sequences_1.next()) {
+            var bytes = sequences_1_1.value;
+            /**
+             * 3.1. If bytes is the empty byte sequence, then continue.
+             */
+            if (bytes.length === 0)
+                continue;
+            /**
+             * 3.2. If bytes contains a 0x3D (=), then let name be the bytes from the
+             * start of bytes up to but excluding its first 0x3D (=), and let value be
+             * the bytes, if any, after the first 0x3D (=) up to the end of bytes.
+             * If 0x3D (=) is the first byte, then name will be the empty byte
+             * sequence. If it is the last, then value will be the empty byte sequence.
+             * 3.3. Otherwise, let name have the value of bytes and let value be the
+             * empty byte sequence.
+             */
+            var index = bytes.indexOf(0x3D);
+            var name = (index !== -1 ? bytes.slice(0, index) : bytes);
+            var value = (index !== -1 ? bytes.slice(index + 1) : new Uint8Array());
+            /**
+             * 3.4. Replace any 0x2B (+) in name and value with 0x20 (SP).
+             */
+            for (var i = 0; i < name.length; i++)
+                if (name[i] === 0x2B)
+                    name[i] = 0x20;
+            for (var i = 0; i < value.length; i++)
+                if (value[i] === 0x2B)
+                    value[i] = 0x20;
+            /**
+             * 3.5. Let nameString and valueString be the result of running UTF-8
+             * decode without BOM on the percent decoding of name and value,
+             * respectively.
+             */
+            var nameString = util_1.utf8Decode(name);
+            var valueString = util_1.utf8Decode(value);
+            /**
+             * 3.6. Append (nameString, valueString) to output.
+             */
+            output.push([nameString, valueString]);
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (sequences_1_1 && !sequences_1_1.done && (_b = sequences_1.return)) _b.call(sequences_1);
+        }
+        finally { if (e_11) throw e_11.error; }
     }
     /**
      * 4. Return output.
      */
     return output;
 }
+exports.urlEncodedParser = urlEncodedParser;
 /**
  * Serializes `application/x-www-form-urlencoded` bytes.
  *
  * @param input - a byte sequence
  */
 function urlEncodedByteSerializer(input) {
+    var e_12, _a;
     /**
      * 1. Let output be the empty string.
      * 2. For each byte in input, depending on byte:
@@ -36079,22 +66524,33 @@ function urlEncodedByteSerializer(input) {
      * Append byte, percent encoded, to output.
      * 3. Return output.
      */
-    let output = "";
-    for (const byte of input) {
-        if (byte === 0x20) {
-            output += '+';
+    var output = "";
+    try {
+        for (var input_3 = __values(input), input_3_1 = input_3.next(); !input_3_1.done; input_3_1 = input_3.next()) {
+            var byte = input_3_1.value;
+            if (byte === 0x20) {
+                output += '+';
+            }
+            else if (byte === 0x2A || byte === 0x2D || byte === 0x2E ||
+                (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x5A) ||
+                byte === 0x5F || (byte >= 0x61 && byte <= 0x7A)) {
+                output += String.fromCodePoint(byte);
+            }
+            else {
+                output += percentEncode(byte);
+            }
         }
-        else if (byte === 0x2A || byte === 0x2D || byte === 0x2E ||
-            (byte >= 0x30 && byte <= 0x39) || (byte >= 0x41 && byte <= 0x5A) ||
-            byte === 0x5F || (byte >= 0x61 && byte <= 0x7A)) {
-            output += String.fromCodePoint(byte);
-        }
-        else {
-            output += percentEncode(byte);
+    }
+    catch (e_12_1) { e_12 = { error: e_12_1 }; }
+    finally {
+        try {
+            if (input_3_1 && !input_3_1.done && (_a = input_3.return)) _a.call(input_3);
         }
+        finally { if (e_12) throw e_12.error; }
     }
     return output;
 }
+exports.urlEncodedByteSerializer = urlEncodedByteSerializer;
 /**
  * Serializes `application/x-www-form-urlencoded` tuples.
  *
@@ -36102,12 +66558,13 @@ function urlEncodedByteSerializer(input) {
  * @param encodingOverride: encoding override
  */
 function urlEncodedSerializer(tuples, encodingOverride) {
+    var e_13, _a;
     /**
      * 1. Let encoding be UTF-8.
      * 2. If encoding override is given, set encoding to the result of getting
      * an output encoding from encoding override.
      */
-    const encoding = (encodingOverride === undefined ||
+    var encoding = (encodingOverride === undefined ||
         encodingOverride === "replacement" || encodingOverride === "UTF-16BE" ||
         encodingOverride === "UTF-16LE" ? "UTF-8" : encodingOverride);
     if (encoding.toUpperCase() !== "UTF-8") {
@@ -36116,45 +66573,56 @@ function urlEncodedSerializer(tuples, encodingOverride) {
     /**
      * 3. Let output be the empty string.
      */
-    let output = "";
-    /**
-     * 4. For each tuple in tuples:
-     */
-    for (const tuple of tuples) {
+    var output = "";
+    try {
         /**
-         * 4.1. Let name be the result of serializing the result of encoding
-         * tuple’s name, using encoding.
+         * 4. For each tuple in tuples:
          */
-        const name = urlEncodedByteSerializer((0, util_1.utf8Encode)(tuple[0]));
-        /**
-         * 4.2. Let value be tuple’s value.
-         */
-        let value = tuple[1];
-        /**
-         * TODO:
-         * 4.3. If value is a file, then set value to value’s filename.
-         */
-        /**
-         * 4.4. Set value to the result of serializing the result of encoding
-         * value, using encoding.
-         */
-        value = urlEncodedByteSerializer((0, util_1.utf8Encode)(value));
-        /**
-         * 4.5. If tuple is not the first pair in tuples, then append U+0026 (&)
-         * to output.
-         */
-        if (output !== "")
-            output += '&';
-        /**
-         * 4.6. Append name, followed by U+003D (=), followed by value, to output.
-         */
-        output += name + '=' + value;
+        for (var tuples_1 = __values(tuples), tuples_1_1 = tuples_1.next(); !tuples_1_1.done; tuples_1_1 = tuples_1.next()) {
+            var tuple = tuples_1_1.value;
+            /**
+             * 4.1. Let name be the result of serializing the result of encoding
+             * tuple’s name, using encoding.
+             */
+            var name = urlEncodedByteSerializer(util_1.utf8Encode(tuple[0]));
+            /**
+             * 4.2. Let value be tuple’s value.
+             */
+            var value = tuple[1];
+            /**
+             * TODO:
+             * 4.3. If value is a file, then set value to value’s filename.
+             */
+            /**
+             * 4.4. Set value to the result of serializing the result of encoding
+             * value, using encoding.
+             */
+            value = urlEncodedByteSerializer(util_1.utf8Encode(value));
+            /**
+             * 4.5. If tuple is not the first pair in tuples, then append U+0026 (&)
+             * to output.
+             */
+            if (output !== "")
+                output += '&';
+            /**
+             * 4.6. Append name, followed by U+003D (=), followed by value, to output.
+             */
+            output += name + '=' + value;
+        }
+    }
+    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    finally {
+        try {
+            if (tuples_1_1 && !tuples_1_1.done && (_a = tuples_1.return)) _a.call(tuples_1);
+        }
+        finally { if (e_13) throw e_13.error; }
     }
     /**
      * 5. Return output.
      */
     return output;
 }
+exports.urlEncodedSerializer = urlEncodedSerializer;
 /**
  * Returns a URL's origin.
  *
@@ -36188,7 +66656,7 @@ function origin(url) {
             if (url._blobURLEntry !== null) {
                 // TODO: return URL’s blob URL entry’s environment’s origin.
             }
-            const parsedURL = basicURLParser(url.path[0]);
+            var parsedURL = basicURLParser(url.path[0]);
             if (parsedURL === null)
                 return interfaces_1.OpaqueOrigin;
             else
@@ -36205,12 +66673,14 @@ function origin(url) {
             return interfaces_1.OpaqueOrigin;
     }
 }
+exports.origin = origin;
 /**
  * Converts a domain string to ASCII.
  *
  * @param domain - a domain string
  */
-function domainToASCII(domain, beStrict = false) {
+function domainToASCII(domain, beStrict) {
+    if (beStrict === void 0) { beStrict = false; }
     /**
      * 1. If beStrict is not given, set it to false.
      * 2. Let result be the result of running Unicode ToASCII with domain_name
@@ -36221,19 +66691,21 @@ function domainToASCII(domain, beStrict = false) {
      * 4. Return result.
      */
     // Use node.js function
-    const result = (0, url_1.domainToASCII)(domain);
+    var result = url_1.domainToASCII(domain);
     if (result === "") {
         validationError("Invalid domain name.");
         return null;
     }
     return result;
 }
+exports.domainToASCII = domainToASCII;
 /**
  * Converts a domain string to Unicode.
  *
  * @param domain - a domain string
  */
-function domainToUnicode(domain, beStrict = false) {
+function domainToUnicode(domain, beStrict) {
+    if (beStrict === void 0) { beStrict = false; }
     /**
      * 1. Let result be the result of running Unicode ToUnicode with domain_name
      * set to domain, CheckHyphens set to false, CheckBidi set to true,
@@ -36243,12 +66715,13 @@ function domainToUnicode(domain, beStrict = false) {
      * return result.
      */
     // Use node.js function
-    const result = (0, url_1.domainToUnicode)(domain);
+    var result = url_1.domainToUnicode(domain);
     if (result === "") {
         validationError("Invalid domain name.");
     }
     return result;
 }
+exports.domainToUnicode = domainToUnicode;
 /**
  * Serializes an origin.
  * function is from the HTML spec:
@@ -36269,11 +66742,12 @@ function asciiSerializationOfAnOrigin(origin) {
     if (origin[0] === "" && origin[1] === "" && origin[2] === null && origin[3] === null) {
         return "null";
     }
-    let result = origin[0] + "://" + hostSerializer(origin[1]);
+    var result = origin[0] + "://" + hostSerializer(origin[1]);
     if (origin[2] !== null)
         result += ":" + origin[2].toString();
     return result;
 }
+exports.asciiSerializationOfAnOrigin = asciiSerializationOfAnOrigin;
 //# sourceMappingURL=URLAlgorithm.js.map
 
 /***/ }),
@@ -36284,7 +66758,6 @@ function asciiSerializationOfAnOrigin(origin) {
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.OpaqueOrigin = exports.ParserState = void 0;
 /**
  * Represents the state of the URL parser.
  */
@@ -36311,7 +66784,7 @@ var ParserState;
     ParserState[ParserState["CannotBeABaseURLPath"] = 18] = "CannotBeABaseURLPath";
     ParserState[ParserState["Query"] = 19] = "Query";
     ParserState[ParserState["Fragment"] = 20] = "Fragment";
-})(ParserState || (exports.ParserState = ParserState = {}));
+})(ParserState = exports.ParserState || (exports.ParserState = {}));
 exports.OpaqueOrigin = ["", "", null, null];
 //# sourceMappingURL=interfaces.js.map
 
@@ -36323,7 +66796,6 @@ exports.OpaqueOrigin = ["", "", null, null];
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.CompareCache = void 0;
 /**
  * Represents a cache for storing order between equal objects.
  *
@@ -36337,16 +66809,16 @@ exports.CompareCache = void 0;
  *
  * The cache has a size limit which is defined on initialization.
  */
-class CompareCache {
-    _limit;
-    _items = new Map();
+var CompareCache = /** @class */ (function () {
     /**
      * Initializes a new instance of `CompareCache`.
      *
      * @param limit - maximum number of items to keep in the cache. When the limit
      * is exceeded the first item is removed from the cache.
      */
-    constructor(limit = 1000) {
+    function CompareCache(limit) {
+        if (limit === void 0) { limit = 1000; }
+        this._items = new Map();
         this._limit = limit;
     }
     /**
@@ -36356,12 +66828,12 @@ class CompareCache {
      * @param objA - an item to compare
      * @param objB - an item to compare
      */
-    check(objA, objB) {
+    CompareCache.prototype.check = function (objA, objB) {
         if (this._items.get(objA) === objB)
             return true;
         else if (this._items.get(objB) === objA)
             return false;
-        const result = (Math.random() < 0.5);
+        var result = (Math.random() < 0.5);
         if (result) {
             this._items.set(objA, objB);
         }
@@ -36369,40 +66841,78 @@ class CompareCache {
             this._items.set(objB, objA);
         }
         if (this._items.size > this._limit) {
-            const it = this._items.keys().next();
+            var it_1 = this._items.keys().next();
             /* istanbul ignore else */
-            if (!it.done) {
-                this._items.delete(it.value);
+            if (!it_1.done) {
+                this._items.delete(it_1.value);
             }
         }
         return result;
-    }
-}
+    };
+    return CompareCache;
+}());
 exports.CompareCache = CompareCache;
 //# sourceMappingURL=CompareCache.js.map
 
 /***/ }),
 
 /***/ 16006:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.FixedSizeSet = void 0;
 /**
  * Represents a set of objects with a size limit.
  */
-class FixedSizeSet {
-    _limit;
-    _items = new Set();
+var FixedSizeSet = /** @class */ (function () {
     /**
      * Initializes a new instance of `FixedSizeSet`.
      *
      * @param limit - maximum number of items to keep in the set. When the limit
      * is exceeded the first item is removed from the set.
      */
-    constructor(limit = 1000) {
+    function FixedSizeSet(limit) {
+        if (limit === void 0) { limit = 1000; }
+        this._items = new Set();
         this._limit = limit;
     }
     /**
@@ -36410,80 +66920,118 @@ class FixedSizeSet {
      *
      * @param item - an item
      */
-    add(item) {
+    FixedSizeSet.prototype.add = function (item) {
         this._items.add(item);
         if (this._items.size > this._limit) {
-            const it = this._items.values().next();
+            var it_1 = this._items.values().next();
             /* istanbul ignore else */
-            if (!it.done) {
-                this._items.delete(it.value);
+            if (!it_1.done) {
+                this._items.delete(it_1.value);
             }
         }
         return this;
-    }
+    };
     /**
      * Removes an item from the set.
      *
      * @param item - an item
      */
-    delete(item) {
+    FixedSizeSet.prototype.delete = function (item) {
         return this._items.delete(item);
-    }
+    };
     /**
      * Determines if an item is in the set.
      *
      * @param item - an item
      */
-    has(item) {
+    FixedSizeSet.prototype.has = function (item) {
         return this._items.has(item);
-    }
+    };
     /**
      * Removes all items from the set.
      */
-    clear() {
+    FixedSizeSet.prototype.clear = function () {
         this._items.clear();
-    }
-    /**
-     * Gets the number of items in the set.
-     */
-    get size() { return this._items.size; }
+    };
+    Object.defineProperty(FixedSizeSet.prototype, "size", {
+        /**
+         * Gets the number of items in the set.
+         */
+        get: function () { return this._items.size; },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Applies the given callback function to all elements of the set.
      */
-    forEach(callback, thisArg) {
-        this._items.forEach(e => callback.call(thisArg, e, e, this));
-    }
+    FixedSizeSet.prototype.forEach = function (callback, thisArg) {
+        var _this = this;
+        this._items.forEach(function (e) { return callback.call(thisArg, e, e, _this); });
+    };
     /**
      * Iterates through the items in the set.
      */
-    *keys() {
-        yield* this._items.keys();
-    }
+    FixedSizeSet.prototype.keys = function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(this._items.keys())];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    };
     /**
      * Iterates through the items in the set.
      */
-    *values() {
-        yield* this._items.values();
-    }
+    FixedSizeSet.prototype.values = function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(this._items.values())];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    };
     /**
      * Iterates through the items in the set.
      */
-    *entries() {
-        yield* this._items.entries();
-    }
+    FixedSizeSet.prototype.entries = function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(this._items.entries())];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    };
     /**
      * Iterates through the items in the set.
      */
-    *[Symbol.iterator]() {
-        yield* this._items;
-    }
-    /**
-     * Returns the string tag of the set.
-     */
-    get [Symbol.toStringTag]() {
-        return "FixedSizeSet";
-    }
-}
+    FixedSizeSet.prototype[Symbol.iterator] = function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(this._items)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    };
+    Object.defineProperty(FixedSizeSet.prototype, Symbol.toStringTag, {
+        /**
+         * Returns the string tag of the set.
+         */
+        get: function () {
+            return "FixedSizeSet";
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return FixedSizeSet;
+}());
 exports.FixedSizeSet = FixedSizeSet;
 //# sourceMappingURL=FixedSizeSet.js.map
 
@@ -36495,59 +67043,98 @@ exports.FixedSizeSet = FixedSizeSet;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.Lazy = void 0;
 /**
  * Represents an object with lazy initialization.
  */
-class Lazy {
-    _initialized = false;
-    _initFunc;
-    _value;
+var Lazy = /** @class */ (function () {
     /**
      * Initializes a new instance of `Lazy`.
      *
      * @param initFunc - initializer function
      */
-    constructor(initFunc) {
+    function Lazy(initFunc) {
+        this._initialized = false;
         this._value = undefined;
         this._initFunc = initFunc;
     }
-    /**
-     * Gets the value of the object.
-     */
-    get value() {
-        if (!this._initialized) {
-            this._value = this._initFunc();
-            this._initialized = true;
-        }
-        return this._value;
-    }
-}
+    Object.defineProperty(Lazy.prototype, "value", {
+        /**
+         * Gets the value of the object.
+         */
+        get: function () {
+            if (!this._initialized) {
+                this._value = this._initFunc();
+                this._initialized = true;
+            }
+            return this._value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return Lazy;
+}());
 exports.Lazy = Lazy;
 //# sourceMappingURL=Lazy.js.map
 
 /***/ }),
 
 /***/ 25798:
-/***/ ((__unused_webpack_module, exports) => {
+/***/ (function(__unused_webpack_module, exports) {
 
 "use strict";
 
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ObjectCache = void 0;
 /**
  * Represents a cache of objects with a size limit.
  */
-class ObjectCache {
-    _limit;
-    _items = new Map();
+var ObjectCache = /** @class */ (function () {
     /**
      * Initializes a new instance of `ObjectCache`.
      *
      * @param limit - maximum number of items to keep in the cache. When the limit
      * is exceeded the first item is removed from the cache.
      */
-    constructor(limit = 1000) {
+    function ObjectCache(limit) {
+        if (limit === void 0) { limit = 1000; }
+        this._items = new Map();
         this._limit = limit;
     }
     /**
@@ -36555,88 +67142,125 @@ class ObjectCache {
      *
      * @param key - object key
      */
-    get(key) {
+    ObjectCache.prototype.get = function (key) {
         return this._items.get(key);
-    }
+    };
     /**
      * Adds a new item to the cache.
      *
      * @param key - object key
      * @param value - object value
      */
-    set(key, value) {
+    ObjectCache.prototype.set = function (key, value) {
         this._items.set(key, value);
         if (this._items.size > this._limit) {
-            const it = this._items.keys().next();
+            var it_1 = this._items.keys().next();
             /* istanbul ignore else */
-            if (!it.done) {
-                this._items.delete(it.value);
+            if (!it_1.done) {
+                this._items.delete(it_1.value);
             }
         }
-    }
+    };
     /**
      * Removes an item from the cache.
      *
      * @param item - an item
      */
-    delete(key) {
+    ObjectCache.prototype.delete = function (key) {
         return this._items.delete(key);
-    }
+    };
     /**
      * Determines if an item is in the cache.
      *
      * @param item - an item
      */
-    has(key) {
+    ObjectCache.prototype.has = function (key) {
         return this._items.has(key);
-    }
+    };
     /**
      * Removes all items from the cache.
      */
-    clear() {
+    ObjectCache.prototype.clear = function () {
         this._items.clear();
-    }
-    /**
-     * Gets the number of items in the cache.
-     */
-    get size() { return this._items.size; }
+    };
+    Object.defineProperty(ObjectCache.prototype, "size", {
+        /**
+         * Gets the number of items in the cache.
+         */
+        get: function () { return this._items.size; },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Applies the given callback function to all elements of the cache.
      */
-    forEach(callback, thisArg) {
-        this._items.forEach((v, k) => callback.call(thisArg, k, v));
-    }
+    ObjectCache.prototype.forEach = function (callback, thisArg) {
+        this._items.forEach(function (v, k) { return callback.call(thisArg, k, v); });
+    };
     /**
      * Iterates through the items in the set.
      */
-    *keys() {
-        yield* this._items.keys();
-    }
+    ObjectCache.prototype.keys = function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(this._items.keys())];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    };
     /**
      * Iterates through the items in the set.
      */
-    *values() {
-        yield* this._items.values();
-    }
+    ObjectCache.prototype.values = function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(this._items.values())];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    };
     /**
      * Iterates through the items in the set.
      */
-    *entries() {
-        yield* this._items.entries();
-    }
+    ObjectCache.prototype.entries = function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(this._items.entries())];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    };
     /**
      * Iterates through the items in the set.
      */
-    *[Symbol.iterator]() {
-        yield* this._items;
-    }
-    /**
-     * Returns the string tag of the cache.
-     */
-    get [Symbol.toStringTag]() {
-        return "ObjectCache";
-    }
-}
+    ObjectCache.prototype[Symbol.iterator] = function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [5 /*yield**/, __values(this._items)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    };
+    Object.defineProperty(ObjectCache.prototype, Symbol.toStringTag, {
+        /**
+         * Returns the string tag of the cache.
+         */
+        get: function () {
+            return "ObjectCache";
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return ObjectCache;
+}());
 exports.ObjectCache = ObjectCache;
 //# sourceMappingURL=ObjectCache.js.map
 
@@ -36648,46 +67272,47 @@ exports.ObjectCache = ObjectCache;
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.StringWalker = void 0;
 /**
  * Walks through the code points of a string.
  */
-class StringWalker {
-    _chars;
-    _length;
-    _pointer = 0;
-    _codePoint;
-    _c;
-    _remaining;
-    _substring;
+var StringWalker = /** @class */ (function () {
     /**
      * Initializes a new `StringWalker`.
      *
      * @param input - input string
      */
-    constructor(input) {
+    function StringWalker(input) {
+        this._pointer = 0;
         this._chars = Array.from(input);
         this._length = this._chars.length;
     }
-    /**
-     * Determines if the current position is beyond the end of string.
-     */
-    get eof() { return this._pointer >= this._length; }
-    /**
-     * Returns the number of code points in the input string.
-     */
-    get length() { return this._length; }
+    Object.defineProperty(StringWalker.prototype, "eof", {
+        /**
+         * Determines if the current position is beyond the end of string.
+         */
+        get: function () { return this._pointer >= this._length; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(StringWalker.prototype, "length", {
+        /**
+         * Returns the number of code points in the input string.
+         */
+        get: function () { return this._length; },
+        enumerable: true,
+        configurable: true
+    });
     /**
      * Returns the current code point. Returns `-1` if the position is beyond
      * the end of string.
      */
-    codePoint() {
+    StringWalker.prototype.codePoint = function () {
         if (this._codePoint === undefined) {
             if (this.eof) {
                 this._codePoint = -1;
             }
             else {
-                const cp = this._chars[this._pointer].codePointAt(0);
+                var cp = this._chars[this._pointer].codePointAt(0);
                 /* istanbul ignore else */
                 if (cp !== undefined) {
                     this._codePoint = cp;
@@ -36698,96 +67323,88 @@ class StringWalker {
             }
         }
         return this._codePoint;
-    }
+    };
     /**
      * Returns the current character. Returns an empty string if the position is
      * beyond the end of string.
      */
-    c() {
+    StringWalker.prototype.c = function () {
         if (this._c === undefined) {
             this._c = (this.eof ? "" : this._chars[this._pointer]);
         }
         return this._c;
-    }
+    };
     /**
      * Returns the remaining string.
      */
-    remaining() {
+    StringWalker.prototype.remaining = function () {
         if (this._remaining === undefined) {
             this._remaining = (this.eof ?
                 "" : this._chars.slice(this._pointer + 1).join(''));
         }
         return this._remaining;
-    }
+    };
     /**
      * Returns the substring from the current character to the end of string.
      */
-    substring() {
+    StringWalker.prototype.substring = function () {
         if (this._substring === undefined) {
             this._substring = (this.eof ?
                 "" : this._chars.slice(this._pointer).join(''));
         }
         return this._substring;
-    }
-    /**
-     * Gets or sets the current position.
-     */
-    get pointer() { return this._pointer; }
-    set pointer(val) {
-        if (val === this._pointer)
-            return;
-        this._pointer = val;
-        this._codePoint = undefined;
-        this._c = undefined;
-        this._remaining = undefined;
-        this._substring = undefined;
-    }
-}
+    };
+    Object.defineProperty(StringWalker.prototype, "pointer", {
+        /**
+         * Gets or sets the current position.
+         */
+        get: function () { return this._pointer; },
+        set: function (val) {
+            if (val === this._pointer)
+                return;
+            this._pointer = val;
+            this._codePoint = undefined;
+            this._c = undefined;
+            this._remaining = undefined;
+            this._substring = undefined;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return StringWalker;
+}());
 exports.StringWalker = StringWalker;
 //# sourceMappingURL=StringWalker.js.map
 
 /***/ }),
 
 /***/ 76195:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
 
 "use strict";
 
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.StringWalker = exports.Lazy = exports.CompareCache = exports.ObjectCache = exports.FixedSizeSet = void 0;
-exports.applyMixin = applyMixin;
-exports.applyDefaults = applyDefaults;
-exports.forEachArray = forEachArray;
-exports.forEachObject = forEachObject;
-exports.arrayLength = arrayLength;
-exports.objectLength = objectLength;
-exports.getObjectValue = getObjectValue;
-exports.removeObjectValue = removeObjectValue;
-exports.clone = clone;
-exports.isBoolean = isBoolean;
-exports.isNumber = isNumber;
-exports.isString = isString;
-exports.isFunction = isFunction;
-exports.isObject = isObject;
-exports.isArray = isArray;
-exports.isSet = isSet;
-exports.isMap = isMap;
-exports.isEmpty = isEmpty;
-exports.isPlainObject = isPlainObject;
-exports.isIterable = isIterable;
-exports.getValue = getValue;
-exports.utf8Encode = utf8Encode;
-exports.utf8Decode = utf8Decode;
-var FixedSizeSet_js_1 = __nccwpck_require__(16006);
-Object.defineProperty(exports, "FixedSizeSet", ({ enumerable: true, get: function () { return FixedSizeSet_js_1.FixedSizeSet; } }));
-var ObjectCache_js_1 = __nccwpck_require__(25798);
-Object.defineProperty(exports, "ObjectCache", ({ enumerable: true, get: function () { return ObjectCache_js_1.ObjectCache; } }));
-var CompareCache_js_1 = __nccwpck_require__(27561);
-Object.defineProperty(exports, "CompareCache", ({ enumerable: true, get: function () { return CompareCache_js_1.CompareCache; } }));
-var Lazy_js_1 = __nccwpck_require__(11857);
-Object.defineProperty(exports, "Lazy", ({ enumerable: true, get: function () { return Lazy_js_1.Lazy; } }));
-var StringWalker_js_1 = __nccwpck_require__(34145);
-Object.defineProperty(exports, "StringWalker", ({ enumerable: true, get: function () { return StringWalker_js_1.StringWalker; } }));
+var FixedSizeSet_1 = __nccwpck_require__(16006);
+exports.FixedSizeSet = FixedSizeSet_1.FixedSizeSet;
+var ObjectCache_1 = __nccwpck_require__(25798);
+exports.ObjectCache = ObjectCache_1.ObjectCache;
+var CompareCache_1 = __nccwpck_require__(27561);
+exports.CompareCache = CompareCache_1.CompareCache;
+var Lazy_1 = __nccwpck_require__(11857);
+exports.Lazy = Lazy_1.Lazy;
+var StringWalker_1 = __nccwpck_require__(34145);
+exports.StringWalker = StringWalker_1.StringWalker;
 /**
  * Applies the mixin to a given class.
  *
@@ -36797,17 +67414,21 @@ Object.defineProperty(exports, "StringWalker", ({ enumerable: true, get: functio
  * functions whose names are in this array will be kept by prepending an
  * underscore to their names.
  */
-function applyMixin(baseClass, mixinClass, ...overrides) {
-    Object.getOwnPropertyNames(mixinClass.prototype).forEach(name => {
+function applyMixin(baseClass, mixinClass) {
+    var overrides = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+        overrides[_i - 2] = arguments[_i];
+    }
+    Object.getOwnPropertyNames(mixinClass.prototype).forEach(function (name) {
         if (name !== "constructor") {
             if (overrides.indexOf(name) !== -1) {
-                const orgPropDesc = Object.getOwnPropertyDescriptor(baseClass.prototype, name);
+                var orgPropDesc = Object.getOwnPropertyDescriptor(baseClass.prototype, name);
                 /* istanbul ignore else */
                 if (orgPropDesc) {
                     Object.defineProperty(baseClass.prototype, "_" + name, orgPropDesc);
                 }
             }
-            const propDesc = Object.getOwnPropertyDescriptor(mixinClass.prototype, name);
+            var propDesc = Object.getOwnPropertyDescriptor(mixinClass.prototype, name);
             /* istanbul ignore else */
             if (propDesc) {
                 Object.defineProperty(baseClass.prototype, name, propDesc);
@@ -36815,6 +67436,7 @@ function applyMixin(baseClass, mixinClass, ...overrides) {
         }
     });
 }
+exports.applyMixin = applyMixin;
 /**
  * Applies default values to the given object.
  *
@@ -36823,9 +67445,10 @@ function applyMixin(baseClass, mixinClass, ...overrides) {
  * @param overwrite - if set to `true` defaults object always overwrites object
  * values, whether they are `undefined` or not.
  */
-function applyDefaults(obj, defaults, overwrite = false) {
-    const result = clone(obj || {});
-    forEachObject(defaults, (key, val) => {
+function applyDefaults(obj, defaults, overwrite) {
+    if (overwrite === void 0) { overwrite = false; }
+    var result = clone(obj || {});
+    forEachObject(defaults, function (key, val) {
         if (isPlainObject(val)) {
             result[key] = applyDefaults(result[key], val, overwrite);
         }
@@ -36835,6 +67458,7 @@ function applyDefaults(obj, defaults, overwrite = false) {
     });
     return result;
 }
+exports.applyDefaults = applyDefaults;
 /**
  * Iterates over items of an array or set.
  *
@@ -36846,6 +67470,7 @@ function applyDefaults(obj, defaults, overwrite = false) {
 function forEachArray(arr, callback, thisArg) {
     arr.forEach(callback, thisArg);
 }
+exports.forEachArray = forEachArray;
 /**
  * Iterates over key/value pairs of a map or object.
  *
@@ -36856,10 +67481,10 @@ function forEachArray(arr, callback, thisArg) {
  */
 function forEachObject(obj, callback, thisArg) {
     if (isMap(obj)) {
-        obj.forEach((value, key) => callback.call(thisArg, key, value));
+        obj.forEach(function (value, key) { return callback.call(thisArg, key, value); });
     }
     else {
-        for (const key in obj) {
+        for (var key in obj) {
             /* istanbul ignore else */
             if (obj.hasOwnProperty(key)) {
                 callback.call(thisArg, key, obj[key]);
@@ -36867,6 +67492,7 @@ function forEachObject(obj, callback, thisArg) {
         }
     }
 }
+exports.forEachObject = forEachObject;
 /**
  * Returns the number of entries in an array or set.
  *
@@ -36880,6 +67506,7 @@ function arrayLength(obj) {
         return obj.length;
     }
 }
+exports.arrayLength = arrayLength;
 /**
  * Returns the number of entries in a map or object.
  *
@@ -36893,6 +67520,7 @@ function objectLength(obj) {
         return Object.keys(obj).length;
     }
 }
+exports.objectLength = objectLength;
 /**
  * Gets the value of a key from a map or object.
  *
@@ -36907,6 +67535,7 @@ function getObjectValue(obj, key) {
         return obj[key];
     }
 }
+exports.getObjectValue = getObjectValue;
 /**
  * Removes a property from a map or object.
  *
@@ -36921,28 +67550,40 @@ function removeObjectValue(obj, key) {
         delete obj[key];
     }
 }
+exports.removeObjectValue = removeObjectValue;
 /**
  * Deep clones the given object.
  *
  * @param obj - an object
  */
 function clone(obj) {
+    var e_1, _a;
     if (isFunction(obj)) {
         return obj;
     }
     else if (isArray(obj)) {
-        const result = [];
-        for (const item of obj) {
-            result.push(clone(item));
+        var result = [];
+        try {
+            for (var obj_1 = __values(obj), obj_1_1 = obj_1.next(); !obj_1_1.done; obj_1_1 = obj_1.next()) {
+                var item = obj_1_1.value;
+                result.push(clone(item));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (obj_1_1 && !obj_1_1.done && (_a = obj_1.return)) _a.call(obj_1);
+            }
+            finally { if (e_1) throw e_1.error; }
         }
         return result;
     }
-    else if (isPlainObject(obj)) {
-        const result = {};
-        for (const key in obj) {
+    else if (isObject(obj)) {
+        var result = {};
+        for (var key in obj) {
             /* istanbul ignore next */
             if (obj.hasOwnProperty(key)) {
-                const val = obj[key];
+                var val = obj[key];
                 result[key] = clone(val);
             }
         }
@@ -36952,6 +67593,7 @@ function clone(obj) {
         return obj;
     }
 }
+exports.clone = clone;
 /**
  * Type guard for boolean types
  *
@@ -36960,6 +67602,7 @@ function clone(obj) {
 function isBoolean(x) {
     return typeof x === "boolean";
 }
+exports.isBoolean = isBoolean;
 /**
  * Type guard for numeric types
  *
@@ -36968,6 +67611,7 @@ function isBoolean(x) {
 function isNumber(x) {
     return typeof x === "number";
 }
+exports.isNumber = isNumber;
 /**
  * Type guard for strings
  *
@@ -36976,14 +67620,16 @@ function isNumber(x) {
 function isString(x) {
     return typeof x === "string";
 }
+exports.isString = isString;
 /**
  * Type guard for function objects
  *
  * @param x - a variable to type check
  */
 function isFunction(x) {
-    return !!x && typeof x === 'function';
+    return !!x && Object.prototype.toString.call(x) === '[object Function]';
 }
+exports.isFunction = isFunction;
 /**
  * Type guard for JS objects
  *
@@ -36992,9 +67638,10 @@ function isFunction(x) {
  * @param x - a variable to type check
  */
 function isObject(x) {
-    const type = typeof x;
+    var type = typeof x;
     return !!x && (type === 'function' || type === 'object');
 }
+exports.isObject = isObject;
 /**
  * Type guard for arrays
  *
@@ -37003,6 +67650,7 @@ function isObject(x) {
 function isArray(x) {
     return Array.isArray(x);
 }
+exports.isArray = isArray;
 /**
  * Type guard for sets.
  *
@@ -37011,6 +67659,7 @@ function isArray(x) {
 function isSet(x) {
     return x instanceof Set;
 }
+exports.isSet = isSet;
 /**
  * Type guard for maps.
  *
@@ -37019,6 +67668,7 @@ function isSet(x) {
 function isMap(x) {
     return x instanceof Map;
 }
+exports.isMap = isMap;
 /**
  * Determines if `x` is an empty Array or an Object with no own properties.
  *
@@ -37035,7 +67685,7 @@ function isEmpty(x) {
         return !x.size;
     }
     else if (isObject(x)) {
-        for (const key in x) {
+        for (var key in x) {
             if (x.hasOwnProperty(key)) {
                 return false;
             }
@@ -37044,6 +67694,7 @@ function isEmpty(x) {
     }
     return false;
 }
+exports.isEmpty = isEmpty;
 /**
  * Determines if `x` is a plain Object.
  *
@@ -37051,14 +67702,15 @@ function isEmpty(x) {
  */
 function isPlainObject(x) {
     if (isObject(x)) {
-        const proto = Object.getPrototypeOf(x);
-        const ctor = proto.constructor;
+        var proto = Object.getPrototypeOf(x);
+        var ctor = proto.constructor;
         return proto && ctor &&
             (typeof ctor === 'function') && (ctor instanceof ctor) &&
             (Function.prototype.toString.call(ctor) === Function.prototype.toString.call(Object));
     }
     return false;
 }
+exports.isPlainObject = isPlainObject;
 /**
  * Determines if `x` is an iterable Object.
  *
@@ -37067,6 +67719,7 @@ function isPlainObject(x) {
 function isIterable(x) {
     return x && (typeof x[Symbol.iterator] === 'function');
 }
+exports.isIterable = isIterable;
 /**
  * Gets the primitive value of an object.
  */
@@ -37078,16 +67731,17 @@ function getValue(obj) {
         return obj;
     }
 }
+exports.getValue = getValue;
 /**
  * UTF-8 encodes the given string.
  *
  * @param input - a string
  */
 function utf8Encode(input) {
-    const bytes = new Uint8Array(input.length * 4);
-    let byteIndex = 0;
-    for (let i = 0; i < input.length; i++) {
-        let char = input.charCodeAt(i);
+    var bytes = new Uint8Array(input.length * 4);
+    var byteIndex = 0;
+    for (var i = 0; i < input.length; i++) {
+        var char = input.charCodeAt(i);
         if (char < 128) {
             bytes[byteIndex++] = char;
             continue;
@@ -37100,7 +67754,7 @@ function utf8Encode(input) {
                 if (++i >= input.length) {
                     throw new Error("Incomplete surrogate pair.");
                 }
-                const c2 = input.charCodeAt(i);
+                var c2 = input.charCodeAt(i);
                 if (c2 < 0xdc00 || c2 > 0xdfff) {
                     throw new Error("Invalid surrogate character.");
                 }
@@ -37117,14 +67771,15 @@ function utf8Encode(input) {
     }
     return bytes.subarray(0, byteIndex);
 }
+exports.utf8Encode = utf8Encode;
 /**
  * UTF-8 decodes the given byte sequence into a string.
  *
  * @param bytes - a byte sequence
  */
 function utf8Decode(bytes) {
-    let result = "";
-    let i = 0;
+    var result = "";
+    var i = 0;
     while (i < bytes.length) {
         var c = bytes[i++];
         if (c > 127) {
@@ -37164,6 +67819,7 @@ function utf8Decode(bytes) {
     }
     return result;
 }
+exports.utf8Decode = utf8Decode;
 //# sourceMappingURL=index.js.map
 
 /***/ }),
@@ -43970,4120 +74626,6 @@ function parseProxyResponse(socket) {
 exports.parseProxyResponse = parseProxyResponse;
 //# sourceMappingURL=parse-proxy-response.js.map
 
-/***/ }),
-
-/***/ 21917:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-
-var loader = __nccwpck_require__(51161);
-var dumper = __nccwpck_require__(68866);
-
-
-function renamed(from, to) {
-  return function () {
-    throw new Error('Function yaml.' + from + ' is removed in js-yaml 4. ' +
-      'Use yaml.' + to + ' instead, which is now safe by default.');
-  };
-}
-
-
-module.exports.Type = __nccwpck_require__(6073);
-module.exports.Schema = __nccwpck_require__(21082);
-module.exports.FAILSAFE_SCHEMA = __nccwpck_require__(28562);
-module.exports.JSON_SCHEMA = __nccwpck_require__(1035);
-module.exports.CORE_SCHEMA = __nccwpck_require__(12011);
-module.exports.DEFAULT_SCHEMA = __nccwpck_require__(18759);
-module.exports.load                = loader.load;
-module.exports.loadAll             = loader.loadAll;
-module.exports.dump                = dumper.dump;
-module.exports.YAMLException = __nccwpck_require__(68179);
-
-// Re-export all types in case user wants to create custom schema
-module.exports.types = {
-  binary:    __nccwpck_require__(77900),
-  float:     __nccwpck_require__(42705),
-  map:       __nccwpck_require__(86150),
-  null:      __nccwpck_require__(20721),
-  pairs:     __nccwpck_require__(96860),
-  set:       __nccwpck_require__(79548),
-  timestamp: __nccwpck_require__(99212),
-  bool:      __nccwpck_require__(64993),
-  int:       __nccwpck_require__(11615),
-  merge:     __nccwpck_require__(86104),
-  omap:      __nccwpck_require__(19046),
-  seq:       __nccwpck_require__(67283),
-  str:       __nccwpck_require__(23619)
-};
-
-// Removed functions from JS-YAML 3.0.x
-module.exports.safeLoad            = renamed('safeLoad', 'load');
-module.exports.safeLoadAll         = renamed('safeLoadAll', 'loadAll');
-module.exports.safeDump            = renamed('safeDump', 'dump');
-
-
-/***/ }),
-
-/***/ 26829:
-/***/ ((module) => {
-
-"use strict";
-
-
-
-function isNothing(subject) {
-  return (typeof subject === 'undefined') || (subject === null);
-}
-
-
-function isObject(subject) {
-  return (typeof subject === 'object') && (subject !== null);
-}
-
-
-function toArray(sequence) {
-  if (Array.isArray(sequence)) return sequence;
-  else if (isNothing(sequence)) return [];
-
-  return [ sequence ];
-}
-
-
-function extend(target, source) {
-  var index, length, key, sourceKeys;
-
-  if (source) {
-    sourceKeys = Object.keys(source);
-
-    for (index = 0, length = sourceKeys.length; index < length; index += 1) {
-      key = sourceKeys[index];
-      target[key] = source[key];
-    }
-  }
-
-  return target;
-}
-
-
-function repeat(string, count) {
-  var result = '', cycle;
-
-  for (cycle = 0; cycle < count; cycle += 1) {
-    result += string;
-  }
-
-  return result;
-}
-
-
-function isNegativeZero(number) {
-  return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);
-}
-
-
-module.exports.isNothing      = isNothing;
-module.exports.isObject       = isObject;
-module.exports.toArray        = toArray;
-module.exports.repeat         = repeat;
-module.exports.isNegativeZero = isNegativeZero;
-module.exports.extend         = extend;
-
-
-/***/ }),
-
-/***/ 68866:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-/*eslint-disable no-use-before-define*/
-
-var common              = __nccwpck_require__(26829);
-var YAMLException       = __nccwpck_require__(68179);
-var DEFAULT_SCHEMA      = __nccwpck_require__(18759);
-
-var _toString       = Object.prototype.toString;
-var _hasOwnProperty = Object.prototype.hasOwnProperty;
-
-var CHAR_BOM                  = 0xFEFF;
-var CHAR_TAB                  = 0x09; /* Tab */
-var CHAR_LINE_FEED            = 0x0A; /* LF */
-var CHAR_CARRIAGE_RETURN      = 0x0D; /* CR */
-var CHAR_SPACE                = 0x20; /* Space */
-var CHAR_EXCLAMATION          = 0x21; /* ! */
-var CHAR_DOUBLE_QUOTE         = 0x22; /* " */
-var CHAR_SHARP                = 0x23; /* # */
-var CHAR_PERCENT              = 0x25; /* % */
-var CHAR_AMPERSAND            = 0x26; /* & */
-var CHAR_SINGLE_QUOTE         = 0x27; /* ' */
-var CHAR_ASTERISK             = 0x2A; /* * */
-var CHAR_COMMA                = 0x2C; /* , */
-var CHAR_MINUS                = 0x2D; /* - */
-var CHAR_COLON                = 0x3A; /* : */
-var CHAR_EQUALS               = 0x3D; /* = */
-var CHAR_GREATER_THAN         = 0x3E; /* > */
-var CHAR_QUESTION             = 0x3F; /* ? */
-var CHAR_COMMERCIAL_AT        = 0x40; /* @ */
-var CHAR_LEFT_SQUARE_BRACKET  = 0x5B; /* [ */
-var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
-var CHAR_GRAVE_ACCENT         = 0x60; /* ` */
-var CHAR_LEFT_CURLY_BRACKET   = 0x7B; /* { */
-var CHAR_VERTICAL_LINE        = 0x7C; /* | */
-var CHAR_RIGHT_CURLY_BRACKET  = 0x7D; /* } */
-
-var ESCAPE_SEQUENCES = {};
-
-ESCAPE_SEQUENCES[0x00]   = '\\0';
-ESCAPE_SEQUENCES[0x07]   = '\\a';
-ESCAPE_SEQUENCES[0x08]   = '\\b';
-ESCAPE_SEQUENCES[0x09]   = '\\t';
-ESCAPE_SEQUENCES[0x0A]   = '\\n';
-ESCAPE_SEQUENCES[0x0B]   = '\\v';
-ESCAPE_SEQUENCES[0x0C]   = '\\f';
-ESCAPE_SEQUENCES[0x0D]   = '\\r';
-ESCAPE_SEQUENCES[0x1B]   = '\\e';
-ESCAPE_SEQUENCES[0x22]   = '\\"';
-ESCAPE_SEQUENCES[0x5C]   = '\\\\';
-ESCAPE_SEQUENCES[0x85]   = '\\N';
-ESCAPE_SEQUENCES[0xA0]   = '\\_';
-ESCAPE_SEQUENCES[0x2028] = '\\L';
-ESCAPE_SEQUENCES[0x2029] = '\\P';
-
-var DEPRECATED_BOOLEANS_SYNTAX = [
-  'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
-  'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
-];
-
-var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-
-function compileStyleMap(schema, map) {
-  var result, keys, index, length, tag, style, type;
-
-  if (map === null) return {};
-
-  result = {};
-  keys = Object.keys(map);
-
-  for (index = 0, length = keys.length; index < length; index += 1) {
-    tag = keys[index];
-    style = String(map[tag]);
-
-    if (tag.slice(0, 2) === '!!') {
-      tag = 'tag:yaml.org,2002:' + tag.slice(2);
-    }
-    type = schema.compiledTypeMap['fallback'][tag];
-
-    if (type && _hasOwnProperty.call(type.styleAliases, style)) {
-      style = type.styleAliases[style];
-    }
-
-    result[tag] = style;
-  }
-
-  return result;
-}
-
-function encodeHex(character) {
-  var string, handle, length;
-
-  string = character.toString(16).toUpperCase();
-
-  if (character <= 0xFF) {
-    handle = 'x';
-    length = 2;
-  } else if (character <= 0xFFFF) {
-    handle = 'u';
-    length = 4;
-  } else if (character <= 0xFFFFFFFF) {
-    handle = 'U';
-    length = 8;
-  } else {
-    throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF');
-  }
-
-  return '\\' + handle + common.repeat('0', length - string.length) + string;
-}
-
-
-var QUOTING_TYPE_SINGLE = 1,
-    QUOTING_TYPE_DOUBLE = 2;
-
-function State(options) {
-  this.schema        = options['schema'] || DEFAULT_SCHEMA;
-  this.indent        = Math.max(1, (options['indent'] || 2));
-  this.noArrayIndent = options['noArrayIndent'] || false;
-  this.skipInvalid   = options['skipInvalid'] || false;
-  this.flowLevel     = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
-  this.styleMap      = compileStyleMap(this.schema, options['styles'] || null);
-  this.sortKeys      = options['sortKeys'] || false;
-  this.lineWidth     = options['lineWidth'] || 80;
-  this.noRefs        = options['noRefs'] || false;
-  this.noCompatMode  = options['noCompatMode'] || false;
-  this.condenseFlow  = options['condenseFlow'] || false;
-  this.quotingType   = options['quotingType'] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE;
-  this.forceQuotes   = options['forceQuotes'] || false;
-  this.replacer      = typeof options['replacer'] === 'function' ? options['replacer'] : null;
-
-  this.implicitTypes = this.schema.compiledImplicit;
-  this.explicitTypes = this.schema.compiledExplicit;
-
-  this.tag = null;
-  this.result = '';
-
-  this.duplicates = [];
-  this.usedDuplicates = null;
-}
-
-// Indents every line in a string. Empty lines (\n only) are not indented.
-function indentString(string, spaces) {
-  var ind = common.repeat(' ', spaces),
-      position = 0,
-      next = -1,
-      result = '',
-      line,
-      length = string.length;
-
-  while (position < length) {
-    next = string.indexOf('\n', position);
-    if (next === -1) {
-      line = string.slice(position);
-      position = length;
-    } else {
-      line = string.slice(position, next + 1);
-      position = next + 1;
-    }
-
-    if (line.length && line !== '\n') result += ind;
-
-    result += line;
-  }
-
-  return result;
-}
-
-function generateNextLine(state, level) {
-  return '\n' + common.repeat(' ', state.indent * level);
-}
-
-function testImplicitResolving(state, str) {
-  var index, length, type;
-
-  for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
-    type = state.implicitTypes[index];
-
-    if (type.resolve(str)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-// [33] s-white ::= s-space | s-tab
-function isWhitespace(c) {
-  return c === CHAR_SPACE || c === CHAR_TAB;
-}
-
-// Returns true if the character can be printed without escaping.
-// From YAML 1.2: "any allowed characters known to be non-printable
-// should also be escaped. [However,] This isn’t mandatory"
-// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
-function isPrintable(c) {
-  return  (0x00020 <= c && c <= 0x00007E)
-      || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)
-      || ((0x0E000 <= c && c <= 0x00FFFD) && c !== CHAR_BOM)
-      ||  (0x10000 <= c && c <= 0x10FFFF);
-}
-
-// [34] ns-char ::= nb-char - s-white
-// [27] nb-char ::= c-printable - b-char - c-byte-order-mark
-// [26] b-char  ::= b-line-feed | b-carriage-return
-// Including s-white (for some reason, examples doesn't match specs in this aspect)
-// ns-char ::= c-printable - b-line-feed - b-carriage-return - c-byte-order-mark
-function isNsCharOrWhitespace(c) {
-  return isPrintable(c)
-    && c !== CHAR_BOM
-    // - b-char
-    && c !== CHAR_CARRIAGE_RETURN
-    && c !== CHAR_LINE_FEED;
-}
-
-// [127]  ns-plain-safe(c) ::= c = flow-out  ⇒ ns-plain-safe-out
-//                             c = flow-in   ⇒ ns-plain-safe-in
-//                             c = block-key ⇒ ns-plain-safe-out
-//                             c = flow-key  ⇒ ns-plain-safe-in
-// [128] ns-plain-safe-out ::= ns-char
-// [129]  ns-plain-safe-in ::= ns-char - c-flow-indicator
-// [130]  ns-plain-char(c) ::=  ( ns-plain-safe(c) - “:” - “#” )
-//                            | ( /* An ns-char preceding */ “#” )
-//                            | ( “:” /* Followed by an ns-plain-safe(c) */ )
-function isPlainSafe(c, prev, inblock) {
-  var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
-  var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
-  return (
-    // ns-plain-safe
-    inblock ? // c = flow-in
-      cIsNsCharOrWhitespace
-      : cIsNsCharOrWhitespace
-        // - c-flow-indicator
-        && c !== CHAR_COMMA
-        && c !== CHAR_LEFT_SQUARE_BRACKET
-        && c !== CHAR_RIGHT_SQUARE_BRACKET
-        && c !== CHAR_LEFT_CURLY_BRACKET
-        && c !== CHAR_RIGHT_CURLY_BRACKET
-  )
-    // ns-plain-char
-    && c !== CHAR_SHARP // false on '#'
-    && !(prev === CHAR_COLON && !cIsNsChar) // false on ': '
-    || (isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP) // change to true on '[^ ]#'
-    || (prev === CHAR_COLON && cIsNsChar); // change to true on ':[^ ]'
-}
-
-// Simplified test for values allowed as the first character in plain style.
-function isPlainSafeFirst(c) {
-  // Uses a subset of ns-char - c-indicator
-  // where ns-char = nb-char - s-white.
-  // No support of ( ( “?” | “:” | “-” ) /* Followed by an ns-plain-safe(c)) */ ) part
-  return isPrintable(c) && c !== CHAR_BOM
-    && !isWhitespace(c) // - s-white
-    // - (c-indicator ::=
-    // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
-    && c !== CHAR_MINUS
-    && c !== CHAR_QUESTION
-    && c !== CHAR_COLON
-    && c !== CHAR_COMMA
-    && c !== CHAR_LEFT_SQUARE_BRACKET
-    && c !== CHAR_RIGHT_SQUARE_BRACKET
-    && c !== CHAR_LEFT_CURLY_BRACKET
-    && c !== CHAR_RIGHT_CURLY_BRACKET
-    // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"”
-    && c !== CHAR_SHARP
-    && c !== CHAR_AMPERSAND
-    && c !== CHAR_ASTERISK
-    && c !== CHAR_EXCLAMATION
-    && c !== CHAR_VERTICAL_LINE
-    && c !== CHAR_EQUALS
-    && c !== CHAR_GREATER_THAN
-    && c !== CHAR_SINGLE_QUOTE
-    && c !== CHAR_DOUBLE_QUOTE
-    // | “%” | “@” | “`”)
-    && c !== CHAR_PERCENT
-    && c !== CHAR_COMMERCIAL_AT
-    && c !== CHAR_GRAVE_ACCENT;
-}
-
-// Simplified test for values allowed as the last character in plain style.
-function isPlainSafeLast(c) {
-  // just not whitespace or colon, it will be checked to be plain character later
-  return !isWhitespace(c) && c !== CHAR_COLON;
-}
-
-// Same as 'string'.codePointAt(pos), but works in older browsers.
-function codePointAt(string, pos) {
-  var first = string.charCodeAt(pos), second;
-  if (first >= 0xD800 && first <= 0xDBFF && pos + 1 < string.length) {
-    second = string.charCodeAt(pos + 1);
-    if (second >= 0xDC00 && second <= 0xDFFF) {
-      // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
-      return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
-    }
-  }
-  return first;
-}
-
-// Determines whether block indentation indicator is required.
-function needIndentIndicator(string) {
-  var leadingSpaceRe = /^\n* /;
-  return leadingSpaceRe.test(string);
-}
-
-var STYLE_PLAIN   = 1,
-    STYLE_SINGLE  = 2,
-    STYLE_LITERAL = 3,
-    STYLE_FOLDED  = 4,
-    STYLE_DOUBLE  = 5;
-
-// Determines which scalar styles are possible and returns the preferred style.
-// lineWidth = -1 => no limit.
-// Pre-conditions: str.length > 0.
-// Post-conditions:
-//    STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
-//    STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
-//    STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
-function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth,
-  testAmbiguousType, quotingType, forceQuotes, inblock) {
-
-  var i;
-  var char = 0;
-  var prevChar = null;
-  var hasLineBreak = false;
-  var hasFoldableLine = false; // only checked if shouldTrackWidth
-  var shouldTrackWidth = lineWidth !== -1;
-  var previousLineBreak = -1; // count the first line correctly
-  var plain = isPlainSafeFirst(codePointAt(string, 0))
-          && isPlainSafeLast(codePointAt(string, string.length - 1));
-
-  if (singleLineOnly || forceQuotes) {
-    // Case: no block styles.
-    // Check for disallowed characters to rule out plain and single.
-    for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
-      char = codePointAt(string, i);
-      if (!isPrintable(char)) {
-        return STYLE_DOUBLE;
-      }
-      plain = plain && isPlainSafe(char, prevChar, inblock);
-      prevChar = char;
-    }
-  } else {
-    // Case: block styles permitted.
-    for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
-      char = codePointAt(string, i);
-      if (char === CHAR_LINE_FEED) {
-        hasLineBreak = true;
-        // Check if any line can be folded.
-        if (shouldTrackWidth) {
-          hasFoldableLine = hasFoldableLine ||
-            // Foldable line = too long, and not more-indented.
-            (i - previousLineBreak - 1 > lineWidth &&
-             string[previousLineBreak + 1] !== ' ');
-          previousLineBreak = i;
-        }
-      } else if (!isPrintable(char)) {
-        return STYLE_DOUBLE;
-      }
-      plain = plain && isPlainSafe(char, prevChar, inblock);
-      prevChar = char;
-    }
-    // in case the end is missing a \n
-    hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
-      (i - previousLineBreak - 1 > lineWidth &&
-       string[previousLineBreak + 1] !== ' '));
-  }
-  // Although every style can represent \n without escaping, prefer block styles
-  // for multiline, since they're more readable and they don't add empty lines.
-  // Also prefer folding a super-long line.
-  if (!hasLineBreak && !hasFoldableLine) {
-    // Strings interpretable as another type have to be quoted;
-    // e.g. the string 'true' vs. the boolean true.
-    if (plain && !forceQuotes && !testAmbiguousType(string)) {
-      return STYLE_PLAIN;
-    }
-    return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
-  }
-  // Edge case: block indentation indicator can only have one digit.
-  if (indentPerLevel > 9 && needIndentIndicator(string)) {
-    return STYLE_DOUBLE;
-  }
-  // At this point we know block styles are valid.
-  // Prefer literal style unless we want to fold.
-  if (!forceQuotes) {
-    return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
-  }
-  return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
-}
-
-// Note: line breaking/folding is implemented for only the folded style.
-// NB. We drop the last trailing newline (if any) of a returned block scalar
-//  since the dumper adds its own newline. This always works:
-//    • No ending newline => unaffected; already using strip "-" chomping.
-//    • Ending newline    => removed then restored.
-//  Importantly, this keeps the "+" chomp indicator from gaining an extra line.
-function writeScalar(state, string, level, iskey, inblock) {
-  state.dump = (function () {
-    if (string.length === 0) {
-      return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
-    }
-    if (!state.noCompatMode) {
-      if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) {
-        return state.quotingType === QUOTING_TYPE_DOUBLE ? ('"' + string + '"') : ("'" + string + "'");
-      }
-    }
-
-    var indent = state.indent * Math.max(1, level); // no 0-indent scalars
-    // As indentation gets deeper, let the width decrease monotonically
-    // to the lower bound min(state.lineWidth, 40).
-    // Note that this implies
-    //  state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.
-    //  state.lineWidth > 40 + state.indent: width decreases until the lower bound.
-    // This behaves better than a constant minimum width which disallows narrower options,
-    // or an indent threshold which causes the width to suddenly increase.
-    var lineWidth = state.lineWidth === -1
-      ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
-
-    // Without knowing if keys are implicit/explicit, assume implicit for safety.
-    var singleLineOnly = iskey
-      // No block styles in flow mode.
-      || (state.flowLevel > -1 && level >= state.flowLevel);
-    function testAmbiguity(string) {
-      return testImplicitResolving(state, string);
-    }
-
-    switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth,
-      testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
-
-      case STYLE_PLAIN:
-        return string;
-      case STYLE_SINGLE:
-        return "'" + string.replace(/'/g, "''") + "'";
-      case STYLE_LITERAL:
-        return '|' + blockHeader(string, state.indent)
-          + dropEndingNewline(indentString(string, indent));
-      case STYLE_FOLDED:
-        return '>' + blockHeader(string, state.indent)
-          + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
-      case STYLE_DOUBLE:
-        return '"' + escapeString(string, lineWidth) + '"';
-      default:
-        throw new YAMLException('impossible error: invalid scalar style');
-    }
-  }());
-}
-
-// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
-function blockHeader(string, indentPerLevel) {
-  var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';
-
-  // note the special case: the string '\n' counts as a "trailing" empty line.
-  var clip =          string[string.length - 1] === '\n';
-  var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
-  var chomp = keep ? '+' : (clip ? '' : '-');
-
-  return indentIndicator + chomp + '\n';
-}
-
-// (See the note for writeScalar.)
-function dropEndingNewline(string) {
-  return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
-}
-
-// Note: a long line without a suitable break point will exceed the width limit.
-// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
-function foldString(string, width) {
-  // In folded style, $k$ consecutive newlines output as $k+1$ newlines—
-  // unless they're before or after a more-indented line, or at the very
-  // beginning or end, in which case $k$ maps to $k$.
-  // Therefore, parse each chunk as newline(s) followed by a content line.
-  var lineRe = /(\n+)([^\n]*)/g;
-
-  // first line (possibly an empty line)
-  var result = (function () {
-    var nextLF = string.indexOf('\n');
-    nextLF = nextLF !== -1 ? nextLF : string.length;
-    lineRe.lastIndex = nextLF;
-    return foldLine(string.slice(0, nextLF), width);
-  }());
-  // If we haven't reached the first content line yet, don't add an extra \n.
-  var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
-  var moreIndented;
-
-  // rest of the lines
-  var match;
-  while ((match = lineRe.exec(string))) {
-    var prefix = match[1], line = match[2];
-    moreIndented = (line[0] === ' ');
-    result += prefix
-      + (!prevMoreIndented && !moreIndented && line !== ''
-        ? '\n' : '')
-      + foldLine(line, width);
-    prevMoreIndented = moreIndented;
-  }
-
-  return result;
-}
-
-// Greedy line breaking.
-// Picks the longest line under the limit each time,
-// otherwise settles for the shortest line over the limit.
-// NB. More-indented lines *cannot* be folded, as that would add an extra \n.
-function foldLine(line, width) {
-  if (line === '' || line[0] === ' ') return line;
-
-  // Since a more-indented line adds a \n, breaks can't be followed by a space.
-  var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
-  var match;
-  // start is an inclusive index. end, curr, and next are exclusive.
-  var start = 0, end, curr = 0, next = 0;
-  var result = '';
-
-  // Invariants: 0 <= start <= length-1.
-  //   0 <= curr <= next <= max(0, length-2). curr - start <= width.
-  // Inside the loop:
-  //   A match implies length >= 2, so curr and next are <= length-2.
-  while ((match = breakRe.exec(line))) {
-    next = match.index;
-    // maintain invariant: curr - start <= width
-    if (next - start > width) {
-      end = (curr > start) ? curr : next; // derive end <= length-2
-      result += '\n' + line.slice(start, end);
-      // skip the space that was output as \n
-      start = end + 1;                    // derive start <= length-1
-    }
-    curr = next;
-  }
-
-  // By the invariants, start <= length-1, so there is something left over.
-  // It is either the whole string or a part starting from non-whitespace.
-  result += '\n';
-  // Insert a break if the remainder is too long and there is a break available.
-  if (line.length - start > width && curr > start) {
-    result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
-  } else {
-    result += line.slice(start);
-  }
-
-  return result.slice(1); // drop extra \n joiner
-}
-
-// Escapes a double-quoted string.
-function escapeString(string) {
-  var result = '';
-  var char = 0;
-  var escapeSeq;
-
-  for (var i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) {
-    char = codePointAt(string, i);
-    escapeSeq = ESCAPE_SEQUENCES[char];
-
-    if (!escapeSeq && isPrintable(char)) {
-      result += string[i];
-      if (char >= 0x10000) result += string[i + 1];
-    } else {
-      result += escapeSeq || encodeHex(char);
-    }
-  }
-
-  return result;
-}
-
-function writeFlowSequence(state, level, object) {
-  var _result = '',
-      _tag    = state.tag,
-      index,
-      length,
-      value;
-
-  for (index = 0, length = object.length; index < length; index += 1) {
-    value = object[index];
-
-    if (state.replacer) {
-      value = state.replacer.call(object, String(index), value);
-    }
-
-    // Write only valid elements, put null instead of invalid elements.
-    if (writeNode(state, level, value, false, false) ||
-        (typeof value === 'undefined' &&
-         writeNode(state, level, null, false, false))) {
-
-      if (_result !== '') _result += ',' + (!state.condenseFlow ? ' ' : '');
-      _result += state.dump;
-    }
-  }
-
-  state.tag = _tag;
-  state.dump = '[' + _result + ']';
-}
-
-function writeBlockSequence(state, level, object, compact) {
-  var _result = '',
-      _tag    = state.tag,
-      index,
-      length,
-      value;
-
-  for (index = 0, length = object.length; index < length; index += 1) {
-    value = object[index];
-
-    if (state.replacer) {
-      value = state.replacer.call(object, String(index), value);
-    }
-
-    // Write only valid elements, put null instead of invalid elements.
-    if (writeNode(state, level + 1, value, true, true, false, true) ||
-        (typeof value === 'undefined' &&
-         writeNode(state, level + 1, null, true, true, false, true))) {
-
-      if (!compact || _result !== '') {
-        _result += generateNextLine(state, level);
-      }
-
-      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
-        _result += '-';
-      } else {
-        _result += '- ';
-      }
-
-      _result += state.dump;
-    }
-  }
-
-  state.tag = _tag;
-  state.dump = _result || '[]'; // Empty sequence if no valid values.
-}
-
-function writeFlowMapping(state, level, object) {
-  var _result       = '',
-      _tag          = state.tag,
-      objectKeyList = Object.keys(object),
-      index,
-      length,
-      objectKey,
-      objectValue,
-      pairBuffer;
-
-  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
-
-    pairBuffer = '';
-    if (_result !== '') pairBuffer += ', ';
-
-    if (state.condenseFlow) pairBuffer += '"';
-
-    objectKey = objectKeyList[index];
-    objectValue = object[objectKey];
-
-    if (state.replacer) {
-      objectValue = state.replacer.call(object, objectKey, objectValue);
-    }
-
-    if (!writeNode(state, level, objectKey, false, false)) {
-      continue; // Skip this pair because of invalid key;
-    }
-
-    if (state.dump.length > 1024) pairBuffer += '? ';
-
-    pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');
-
-    if (!writeNode(state, level, objectValue, false, false)) {
-      continue; // Skip this pair because of invalid value.
-    }
-
-    pairBuffer += state.dump;
-
-    // Both key and value are valid.
-    _result += pairBuffer;
-  }
-
-  state.tag = _tag;
-  state.dump = '{' + _result + '}';
-}
-
-function writeBlockMapping(state, level, object, compact) {
-  var _result       = '',
-      _tag          = state.tag,
-      objectKeyList = Object.keys(object),
-      index,
-      length,
-      objectKey,
-      objectValue,
-      explicitPair,
-      pairBuffer;
-
-  // Allow sorting keys so that the output file is deterministic
-  if (state.sortKeys === true) {
-    // Default sorting
-    objectKeyList.sort();
-  } else if (typeof state.sortKeys === 'function') {
-    // Custom sort function
-    objectKeyList.sort(state.sortKeys);
-  } else if (state.sortKeys) {
-    // Something is wrong
-    throw new YAMLException('sortKeys must be a boolean or a function');
-  }
-
-  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
-    pairBuffer = '';
-
-    if (!compact || _result !== '') {
-      pairBuffer += generateNextLine(state, level);
-    }
-
-    objectKey = objectKeyList[index];
-    objectValue = object[objectKey];
-
-    if (state.replacer) {
-      objectValue = state.replacer.call(object, objectKey, objectValue);
-    }
-
-    if (!writeNode(state, level + 1, objectKey, true, true, true)) {
-      continue; // Skip this pair because of invalid key.
-    }
-
-    explicitPair = (state.tag !== null && state.tag !== '?') ||
-                   (state.dump && state.dump.length > 1024);
-
-    if (explicitPair) {
-      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
-        pairBuffer += '?';
-      } else {
-        pairBuffer += '? ';
-      }
-    }
-
-    pairBuffer += state.dump;
-
-    if (explicitPair) {
-      pairBuffer += generateNextLine(state, level);
-    }
-
-    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
-      continue; // Skip this pair because of invalid value.
-    }
-
-    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
-      pairBuffer += ':';
-    } else {
-      pairBuffer += ': ';
-    }
-
-    pairBuffer += state.dump;
-
-    // Both key and value are valid.
-    _result += pairBuffer;
-  }
-
-  state.tag = _tag;
-  state.dump = _result || '{}'; // Empty mapping if no valid pairs.
-}
-
-function detectType(state, object, explicit) {
-  var _result, typeList, index, length, type, style;
-
-  typeList = explicit ? state.explicitTypes : state.implicitTypes;
-
-  for (index = 0, length = typeList.length; index < length; index += 1) {
-    type = typeList[index];
-
-    if ((type.instanceOf  || type.predicate) &&
-        (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
-        (!type.predicate  || type.predicate(object))) {
-
-      if (explicit) {
-        if (type.multi && type.representName) {
-          state.tag = type.representName(object);
-        } else {
-          state.tag = type.tag;
-        }
-      } else {
-        state.tag = '?';
-      }
-
-      if (type.represent) {
-        style = state.styleMap[type.tag] || type.defaultStyle;
-
-        if (_toString.call(type.represent) === '[object Function]') {
-          _result = type.represent(object, style);
-        } else if (_hasOwnProperty.call(type.represent, style)) {
-          _result = type.represent[style](object, style);
-        } else {
-          throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
-        }
-
-        state.dump = _result;
-      }
-
-      return true;
-    }
-  }
-
-  return false;
-}
-
-// Serializes `object` and writes it to global `result`.
-// Returns true on success, or false on invalid object.
-//
-function writeNode(state, level, object, block, compact, iskey, isblockseq) {
-  state.tag = null;
-  state.dump = object;
-
-  if (!detectType(state, object, false)) {
-    detectType(state, object, true);
-  }
-
-  var type = _toString.call(state.dump);
-  var inblock = block;
-  var tagStr;
-
-  if (block) {
-    block = (state.flowLevel < 0 || state.flowLevel > level);
-  }
-
-  var objectOrArray = type === '[object Object]' || type === '[object Array]',
-      duplicateIndex,
-      duplicate;
-
-  if (objectOrArray) {
-    duplicateIndex = state.duplicates.indexOf(object);
-    duplicate = duplicateIndex !== -1;
-  }
-
-  if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
-    compact = false;
-  }
-
-  if (duplicate && state.usedDuplicates[duplicateIndex]) {
-    state.dump = '*ref_' + duplicateIndex;
-  } else {
-    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
-      state.usedDuplicates[duplicateIndex] = true;
-    }
-    if (type === '[object Object]') {
-      if (block && (Object.keys(state.dump).length !== 0)) {
-        writeBlockMapping(state, level, state.dump, compact);
-        if (duplicate) {
-          state.dump = '&ref_' + duplicateIndex + state.dump;
-        }
-      } else {
-        writeFlowMapping(state, level, state.dump);
-        if (duplicate) {
-          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
-        }
-      }
-    } else if (type === '[object Array]') {
-      if (block && (state.dump.length !== 0)) {
-        if (state.noArrayIndent && !isblockseq && level > 0) {
-          writeBlockSequence(state, level - 1, state.dump, compact);
-        } else {
-          writeBlockSequence(state, level, state.dump, compact);
-        }
-        if (duplicate) {
-          state.dump = '&ref_' + duplicateIndex + state.dump;
-        }
-      } else {
-        writeFlowSequence(state, level, state.dump);
-        if (duplicate) {
-          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
-        }
-      }
-    } else if (type === '[object String]') {
-      if (state.tag !== '?') {
-        writeScalar(state, state.dump, level, iskey, inblock);
-      }
-    } else if (type === '[object Undefined]') {
-      return false;
-    } else {
-      if (state.skipInvalid) return false;
-      throw new YAMLException('unacceptable kind of an object to dump ' + type);
-    }
-
-    if (state.tag !== null && state.tag !== '?') {
-      // Need to encode all characters except those allowed by the spec:
-      //
-      // [35] ns-dec-digit    ::=  [#x30-#x39] /* 0-9 */
-      // [36] ns-hex-digit    ::=  ns-dec-digit
-      //                         | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */
-      // [37] ns-ascii-letter ::=  [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */
-      // [38] ns-word-char    ::=  ns-dec-digit | ns-ascii-letter | “-”
-      // [39] ns-uri-char     ::=  “%” ns-hex-digit ns-hex-digit | ns-word-char | “#”
-      //                         | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,”
-      //                         | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]”
-      //
-      // Also need to encode '!' because it has special meaning (end of tag prefix).
-      //
-      tagStr = encodeURI(
-        state.tag[0] === '!' ? state.tag.slice(1) : state.tag
-      ).replace(/!/g, '%21');
-
-      if (state.tag[0] === '!') {
-        tagStr = '!' + tagStr;
-      } else if (tagStr.slice(0, 18) === 'tag:yaml.org,2002:') {
-        tagStr = '!!' + tagStr.slice(18);
-      } else {
-        tagStr = '!<' + tagStr + '>';
-      }
-
-      state.dump = tagStr + ' ' + state.dump;
-    }
-  }
-
-  return true;
-}
-
-function getDuplicateReferences(object, state) {
-  var objects = [],
-      duplicatesIndexes = [],
-      index,
-      length;
-
-  inspectNode(object, objects, duplicatesIndexes);
-
-  for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
-    state.duplicates.push(objects[duplicatesIndexes[index]]);
-  }
-  state.usedDuplicates = new Array(length);
-}
-
-function inspectNode(object, objects, duplicatesIndexes) {
-  var objectKeyList,
-      index,
-      length;
-
-  if (object !== null && typeof object === 'object') {
-    index = objects.indexOf(object);
-    if (index !== -1) {
-      if (duplicatesIndexes.indexOf(index) === -1) {
-        duplicatesIndexes.push(index);
-      }
-    } else {
-      objects.push(object);
-
-      if (Array.isArray(object)) {
-        for (index = 0, length = object.length; index < length; index += 1) {
-          inspectNode(object[index], objects, duplicatesIndexes);
-        }
-      } else {
-        objectKeyList = Object.keys(object);
-
-        for (index = 0, length = objectKeyList.length; index < length; index += 1) {
-          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
-        }
-      }
-    }
-  }
-}
-
-function dump(input, options) {
-  options = options || {};
-
-  var state = new State(options);
-
-  if (!state.noRefs) getDuplicateReferences(input, state);
-
-  var value = input;
-
-  if (state.replacer) {
-    value = state.replacer.call({ '': value }, '', value);
-  }
-
-  if (writeNode(state, 0, value, true, true)) return state.dump + '\n';
-
-  return '';
-}
-
-module.exports.dump = dump;
-
-
-/***/ }),
-
-/***/ 68179:
-/***/ ((module) => {
-
-"use strict";
-// YAML error class. http://stackoverflow.com/questions/8458984
-//
-
-
-
-function formatError(exception, compact) {
-  var where = '', message = exception.reason || '(unknown reason)';
-
-  if (!exception.mark) return message;
-
-  if (exception.mark.name) {
-    where += 'in "' + exception.mark.name + '" ';
-  }
-
-  where += '(' + (exception.mark.line + 1) + ':' + (exception.mark.column + 1) + ')';
-
-  if (!compact && exception.mark.snippet) {
-    where += '\n\n' + exception.mark.snippet;
-  }
-
-  return message + ' ' + where;
-}
-
-
-function YAMLException(reason, mark) {
-  // Super constructor
-  Error.call(this);
-
-  this.name = 'YAMLException';
-  this.reason = reason;
-  this.mark = mark;
-  this.message = formatError(this, false);
-
-  // Include stack trace in error object
-  if (Error.captureStackTrace) {
-    // Chrome and NodeJS
-    Error.captureStackTrace(this, this.constructor);
-  } else {
-    // FF, IE 10+ and Safari 6+. Fallback for others
-    this.stack = (new Error()).stack || '';
-  }
-}
-
-
-// Inherit from Error
-YAMLException.prototype = Object.create(Error.prototype);
-YAMLException.prototype.constructor = YAMLException;
-
-
-YAMLException.prototype.toString = function toString(compact) {
-  return this.name + ': ' + formatError(this, compact);
-};
-
-
-module.exports = YAMLException;
-
-
-/***/ }),
-
-/***/ 51161:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-/*eslint-disable max-len,no-use-before-define*/
-
-var common              = __nccwpck_require__(26829);
-var YAMLException       = __nccwpck_require__(68179);
-var makeSnippet         = __nccwpck_require__(96975);
-var DEFAULT_SCHEMA      = __nccwpck_require__(18759);
-
-
-var _hasOwnProperty = Object.prototype.hasOwnProperty;
-
-
-var CONTEXT_FLOW_IN   = 1;
-var CONTEXT_FLOW_OUT  = 2;
-var CONTEXT_BLOCK_IN  = 3;
-var CONTEXT_BLOCK_OUT = 4;
-
-
-var CHOMPING_CLIP  = 1;
-var CHOMPING_STRIP = 2;
-var CHOMPING_KEEP  = 3;
-
-
-var PATTERN_NON_PRINTABLE         = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
-var PATTERN_FLOW_INDICATORS       = /[,\[\]\{\}]/;
-var PATTERN_TAG_HANDLE            = /^(?:!|!!|![a-z\-]+!)$/i;
-var PATTERN_TAG_URI               = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
-
-
-function _class(obj) { return Object.prototype.toString.call(obj); }
-
-function is_EOL(c) {
-  return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);
-}
-
-function is_WHITE_SPACE(c) {
-  return (c === 0x09/* Tab */) || (c === 0x20/* Space */);
-}
-
-function is_WS_OR_EOL(c) {
-  return (c === 0x09/* Tab */) ||
-         (c === 0x20/* Space */) ||
-         (c === 0x0A/* LF */) ||
-         (c === 0x0D/* CR */);
-}
-
-function is_FLOW_INDICATOR(c) {
-  return c === 0x2C/* , */ ||
-         c === 0x5B/* [ */ ||
-         c === 0x5D/* ] */ ||
-         c === 0x7B/* { */ ||
-         c === 0x7D/* } */;
-}
-
-function fromHexCode(c) {
-  var lc;
-
-  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
-    return c - 0x30;
-  }
-
-  /*eslint-disable no-bitwise*/
-  lc = c | 0x20;
-
-  if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {
-    return lc - 0x61 + 10;
-  }
-
-  return -1;
-}
-
-function escapedHexLen(c) {
-  if (c === 0x78/* x */) { return 2; }
-  if (c === 0x75/* u */) { return 4; }
-  if (c === 0x55/* U */) { return 8; }
-  return 0;
-}
-
-function fromDecimalCode(c) {
-  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
-    return c - 0x30;
-  }
-
-  return -1;
-}
-
-function simpleEscapeSequence(c) {
-  /* eslint-disable indent */
-  return (c === 0x30/* 0 */) ? '\x00' :
-        (c === 0x61/* a */) ? '\x07' :
-        (c === 0x62/* b */) ? '\x08' :
-        (c === 0x74/* t */) ? '\x09' :
-        (c === 0x09/* Tab */) ? '\x09' :
-        (c === 0x6E/* n */) ? '\x0A' :
-        (c === 0x76/* v */) ? '\x0B' :
-        (c === 0x66/* f */) ? '\x0C' :
-        (c === 0x72/* r */) ? '\x0D' :
-        (c === 0x65/* e */) ? '\x1B' :
-        (c === 0x20/* Space */) ? ' ' :
-        (c === 0x22/* " */) ? '\x22' :
-        (c === 0x2F/* / */) ? '/' :
-        (c === 0x5C/* \ */) ? '\x5C' :
-        (c === 0x4E/* N */) ? '\x85' :
-        (c === 0x5F/* _ */) ? '\xA0' :
-        (c === 0x4C/* L */) ? '\u2028' :
-        (c === 0x50/* P */) ? '\u2029' : '';
-}
-
-function charFromCodepoint(c) {
-  if (c <= 0xFFFF) {
-    return String.fromCharCode(c);
-  }
-  // Encode UTF-16 surrogate pair
-  // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF
-  return String.fromCharCode(
-    ((c - 0x010000) >> 10) + 0xD800,
-    ((c - 0x010000) & 0x03FF) + 0xDC00
-  );
-}
-
-// set a property of a literal object, while protecting against prototype pollution,
-// see https://github.com/nodeca/js-yaml/issues/164 for more details
-function setProperty(object, key, value) {
-  // used for this specific key only because Object.defineProperty is slow
-  if (key === '__proto__') {
-    Object.defineProperty(object, key, {
-      configurable: true,
-      enumerable: true,
-      writable: true,
-      value: value
-    });
-  } else {
-    object[key] = value;
-  }
-}
-
-var simpleEscapeCheck = new Array(256); // integer, for fast access
-var simpleEscapeMap = new Array(256);
-for (var i = 0; i < 256; i++) {
-  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
-  simpleEscapeMap[i] = simpleEscapeSequence(i);
-}
-
-
-function State(input, options) {
-  this.input = input;
-
-  this.filename  = options['filename']  || null;
-  this.schema    = options['schema']    || DEFAULT_SCHEMA;
-  this.onWarning = options['onWarning'] || null;
-  // (Hidden) Remove? makes the loader to expect YAML 1.1 documents
-  // if such documents have no explicit %YAML directive
-  this.legacy    = options['legacy']    || false;
-
-  this.json      = options['json']      || false;
-  this.listener  = options['listener']  || null;
-
-  this.implicitTypes = this.schema.compiledImplicit;
-  this.typeMap       = this.schema.compiledTypeMap;
-
-  this.length     = input.length;
-  this.position   = 0;
-  this.line       = 0;
-  this.lineStart  = 0;
-  this.lineIndent = 0;
-
-  // position of first leading tab in the current line,
-  // used to make sure there are no tabs in the indentation
-  this.firstTabInLine = -1;
-
-  this.documents = [];
-
-  /*
-  this.version;
-  this.checkLineBreaks;
-  this.tagMap;
-  this.anchorMap;
-  this.tag;
-  this.anchor;
-  this.kind;
-  this.result;*/
-
-}
-
-
-function generateError(state, message) {
-  var mark = {
-    name:     state.filename,
-    buffer:   state.input.slice(0, -1), // omit trailing \0
-    position: state.position,
-    line:     state.line,
-    column:   state.position - state.lineStart
-  };
-
-  mark.snippet = makeSnippet(mark);
-
-  return new YAMLException(message, mark);
-}
-
-function throwError(state, message) {
-  throw generateError(state, message);
-}
-
-function throwWarning(state, message) {
-  if (state.onWarning) {
-    state.onWarning.call(null, generateError(state, message));
-  }
-}
-
-
-var directiveHandlers = {
-
-  YAML: function handleYamlDirective(state, name, args) {
-
-    var match, major, minor;
-
-    if (state.version !== null) {
-      throwError(state, 'duplication of %YAML directive');
-    }
-
-    if (args.length !== 1) {
-      throwError(state, 'YAML directive accepts exactly one argument');
-    }
-
-    match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
-
-    if (match === null) {
-      throwError(state, 'ill-formed argument of the YAML directive');
-    }
-
-    major = parseInt(match[1], 10);
-    minor = parseInt(match[2], 10);
-
-    if (major !== 1) {
-      throwError(state, 'unacceptable YAML version of the document');
-    }
-
-    state.version = args[0];
-    state.checkLineBreaks = (minor < 2);
-
-    if (minor !== 1 && minor !== 2) {
-      throwWarning(state, 'unsupported YAML version of the document');
-    }
-  },
-
-  TAG: function handleTagDirective(state, name, args) {
-
-    var handle, prefix;
-
-    if (args.length !== 2) {
-      throwError(state, 'TAG directive accepts exactly two arguments');
-    }
-
-    handle = args[0];
-    prefix = args[1];
-
-    if (!PATTERN_TAG_HANDLE.test(handle)) {
-      throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
-    }
-
-    if (_hasOwnProperty.call(state.tagMap, handle)) {
-      throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
-    }
-
-    if (!PATTERN_TAG_URI.test(prefix)) {
-      throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
-    }
-
-    try {
-      prefix = decodeURIComponent(prefix);
-    } catch (err) {
-      throwError(state, 'tag prefix is malformed: ' + prefix);
-    }
-
-    state.tagMap[handle] = prefix;
-  }
-};
-
-
-function captureSegment(state, start, end, checkJson) {
-  var _position, _length, _character, _result;
-
-  if (start < end) {
-    _result = state.input.slice(start, end);
-
-    if (checkJson) {
-      for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
-        _character = _result.charCodeAt(_position);
-        if (!(_character === 0x09 ||
-              (0x20 <= _character && _character <= 0x10FFFF))) {
-          throwError(state, 'expected valid JSON character');
-        }
-      }
-    } else if (PATTERN_NON_PRINTABLE.test(_result)) {
-      throwError(state, 'the stream contains non-printable characters');
-    }
-
-    state.result += _result;
-  }
-}
-
-function mergeMappings(state, destination, source, overridableKeys) {
-  var sourceKeys, key, index, quantity;
-
-  if (!common.isObject(source)) {
-    throwError(state, 'cannot merge mappings; the provided source object is unacceptable');
-  }
-
-  sourceKeys = Object.keys(source);
-
-  for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
-    key = sourceKeys[index];
-
-    if (!_hasOwnProperty.call(destination, key)) {
-      setProperty(destination, key, source[key]);
-      overridableKeys[key] = true;
-    }
-  }
-}
-
-function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode,
-  startLine, startLineStart, startPos) {
-
-  var index, quantity;
-
-  // The output is a plain object here, so keys can only be strings.
-  // We need to convert keyNode to a string, but doing so can hang the process
-  // (deeply nested arrays that explode exponentially using aliases).
-  if (Array.isArray(keyNode)) {
-    keyNode = Array.prototype.slice.call(keyNode);
-
-    for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
-      if (Array.isArray(keyNode[index])) {
-        throwError(state, 'nested arrays are not supported inside keys');
-      }
-
-      if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
-        keyNode[index] = '[object Object]';
-      }
-    }
-  }
-
-  // Avoid code execution in load() via toString property
-  // (still use its own toString for arrays, timestamps,
-  // and whatever user schema extensions happen to have @@toStringTag)
-  if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
-    keyNode = '[object Object]';
-  }
-
-
-  keyNode = String(keyNode);
-
-  if (_result === null) {
-    _result = {};
-  }
-
-  if (keyTag === 'tag:yaml.org,2002:merge') {
-    if (Array.isArray(valueNode)) {
-      for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
-        mergeMappings(state, _result, valueNode[index], overridableKeys);
-      }
-    } else {
-      mergeMappings(state, _result, valueNode, overridableKeys);
-    }
-  } else {
-    if (!state.json &&
-        !_hasOwnProperty.call(overridableKeys, keyNode) &&
-        _hasOwnProperty.call(_result, keyNode)) {
-      state.line = startLine || state.line;
-      state.lineStart = startLineStart || state.lineStart;
-      state.position = startPos || state.position;
-      throwError(state, 'duplicated mapping key');
-    }
-
-    setProperty(_result, keyNode, valueNode);
-    delete overridableKeys[keyNode];
-  }
-
-  return _result;
-}
-
-function readLineBreak(state) {
-  var ch;
-
-  ch = state.input.charCodeAt(state.position);
-
-  if (ch === 0x0A/* LF */) {
-    state.position++;
-  } else if (ch === 0x0D/* CR */) {
-    state.position++;
-    if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {
-      state.position++;
-    }
-  } else {
-    throwError(state, 'a line break is expected');
-  }
-
-  state.line += 1;
-  state.lineStart = state.position;
-  state.firstTabInLine = -1;
-}
-
-function skipSeparationSpace(state, allowComments, checkIndent) {
-  var lineBreaks = 0,
-      ch = state.input.charCodeAt(state.position);
-
-  while (ch !== 0) {
-    while (is_WHITE_SPACE(ch)) {
-      if (ch === 0x09/* Tab */ && state.firstTabInLine === -1) {
-        state.firstTabInLine = state.position;
-      }
-      ch = state.input.charCodeAt(++state.position);
-    }
-
-    if (allowComments && ch === 0x23/* # */) {
-      do {
-        ch = state.input.charCodeAt(++state.position);
-      } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);
-    }
-
-    if (is_EOL(ch)) {
-      readLineBreak(state);
-
-      ch = state.input.charCodeAt(state.position);
-      lineBreaks++;
-      state.lineIndent = 0;
-
-      while (ch === 0x20/* Space */) {
-        state.lineIndent++;
-        ch = state.input.charCodeAt(++state.position);
-      }
-    } else {
-      break;
-    }
-  }
-
-  if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
-    throwWarning(state, 'deficient indentation');
-  }
-
-  return lineBreaks;
-}
-
-function testDocumentSeparator(state) {
-  var _position = state.position,
-      ch;
-
-  ch = state.input.charCodeAt(_position);
-
-  // Condition state.position === state.lineStart is tested
-  // in parent on each call, for efficiency. No needs to test here again.
-  if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
-      ch === state.input.charCodeAt(_position + 1) &&
-      ch === state.input.charCodeAt(_position + 2)) {
-
-    _position += 3;
-
-    ch = state.input.charCodeAt(_position);
-
-    if (ch === 0 || is_WS_OR_EOL(ch)) {
-      return true;
-    }
-  }
-
-  return false;
-}
-
-function writeFoldedLines(state, count) {
-  if (count === 1) {
-    state.result += ' ';
-  } else if (count > 1) {
-    state.result += common.repeat('\n', count - 1);
-  }
-}
-
-
-function readPlainScalar(state, nodeIndent, withinFlowCollection) {
-  var preceding,
-      following,
-      captureStart,
-      captureEnd,
-      hasPendingContent,
-      _line,
-      _lineStart,
-      _lineIndent,
-      _kind = state.kind,
-      _result = state.result,
-      ch;
-
-  ch = state.input.charCodeAt(state.position);
-
-  if (is_WS_OR_EOL(ch)      ||
-      is_FLOW_INDICATOR(ch) ||
-      ch === 0x23/* # */    ||
-      ch === 0x26/* & */    ||
-      ch === 0x2A/* * */    ||
-      ch === 0x21/* ! */    ||
-      ch === 0x7C/* | */    ||
-      ch === 0x3E/* > */    ||
-      ch === 0x27/* ' */    ||
-      ch === 0x22/* " */    ||
-      ch === 0x25/* % */    ||
-      ch === 0x40/* @ */    ||
-      ch === 0x60/* ` */) {
-    return false;
-  }
-
-  if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
-    following = state.input.charCodeAt(state.position + 1);
-
-    if (is_WS_OR_EOL(following) ||
-        withinFlowCollection && is_FLOW_INDICATOR(following)) {
-      return false;
-    }
-  }
-
-  state.kind = 'scalar';
-  state.result = '';
-  captureStart = captureEnd = state.position;
-  hasPendingContent = false;
-
-  while (ch !== 0) {
-    if (ch === 0x3A/* : */) {
-      following = state.input.charCodeAt(state.position + 1);
-
-      if (is_WS_OR_EOL(following) ||
-          withinFlowCollection && is_FLOW_INDICATOR(following)) {
-        break;
-      }
-
-    } else if (ch === 0x23/* # */) {
-      preceding = state.input.charCodeAt(state.position - 1);
-
-      if (is_WS_OR_EOL(preceding)) {
-        break;
-      }
-
-    } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
-               withinFlowCollection && is_FLOW_INDICATOR(ch)) {
-      break;
-
-    } else if (is_EOL(ch)) {
-      _line = state.line;
-      _lineStart = state.lineStart;
-      _lineIndent = state.lineIndent;
-      skipSeparationSpace(state, false, -1);
-
-      if (state.lineIndent >= nodeIndent) {
-        hasPendingContent = true;
-        ch = state.input.charCodeAt(state.position);
-        continue;
-      } else {
-        state.position = captureEnd;
-        state.line = _line;
-        state.lineStart = _lineStart;
-        state.lineIndent = _lineIndent;
-        break;
-      }
-    }
-
-    if (hasPendingContent) {
-      captureSegment(state, captureStart, captureEnd, false);
-      writeFoldedLines(state, state.line - _line);
-      captureStart = captureEnd = state.position;
-      hasPendingContent = false;
-    }
-
-    if (!is_WHITE_SPACE(ch)) {
-      captureEnd = state.position + 1;
-    }
-
-    ch = state.input.charCodeAt(++state.position);
-  }
-
-  captureSegment(state, captureStart, captureEnd, false);
-
-  if (state.result) {
-    return true;
-  }
-
-  state.kind = _kind;
-  state.result = _result;
-  return false;
-}
-
-function readSingleQuotedScalar(state, nodeIndent) {
-  var ch,
-      captureStart, captureEnd;
-
-  ch = state.input.charCodeAt(state.position);
-
-  if (ch !== 0x27/* ' */) {
-    return false;
-  }
-
-  state.kind = 'scalar';
-  state.result = '';
-  state.position++;
-  captureStart = captureEnd = state.position;
-
-  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
-    if (ch === 0x27/* ' */) {
-      captureSegment(state, captureStart, state.position, true);
-      ch = state.input.charCodeAt(++state.position);
-
-      if (ch === 0x27/* ' */) {
-        captureStart = state.position;
-        state.position++;
-        captureEnd = state.position;
-      } else {
-        return true;
-      }
-
-    } else if (is_EOL(ch)) {
-      captureSegment(state, captureStart, captureEnd, true);
-      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
-      captureStart = captureEnd = state.position;
-
-    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
-      throwError(state, 'unexpected end of the document within a single quoted scalar');
-
-    } else {
-      state.position++;
-      captureEnd = state.position;
-    }
-  }
-
-  throwError(state, 'unexpected end of the stream within a single quoted scalar');
-}
-
-function readDoubleQuotedScalar(state, nodeIndent) {
-  var captureStart,
-      captureEnd,
-      hexLength,
-      hexResult,
-      tmp,
-      ch;
-
-  ch = state.input.charCodeAt(state.position);
-
-  if (ch !== 0x22/* " */) {
-    return false;
-  }
-
-  state.kind = 'scalar';
-  state.result = '';
-  state.position++;
-  captureStart = captureEnd = state.position;
-
-  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
-    if (ch === 0x22/* " */) {
-      captureSegment(state, captureStart, state.position, true);
-      state.position++;
-      return true;
-
-    } else if (ch === 0x5C/* \ */) {
-      captureSegment(state, captureStart, state.position, true);
-      ch = state.input.charCodeAt(++state.position);
-
-      if (is_EOL(ch)) {
-        skipSeparationSpace(state, false, nodeIndent);
-
-        // TODO: rework to inline fn with no type cast?
-      } else if (ch < 256 && simpleEscapeCheck[ch]) {
-        state.result += simpleEscapeMap[ch];
-        state.position++;
-
-      } else if ((tmp = escapedHexLen(ch)) > 0) {
-        hexLength = tmp;
-        hexResult = 0;
-
-        for (; hexLength > 0; hexLength--) {
-          ch = state.input.charCodeAt(++state.position);
-
-          if ((tmp = fromHexCode(ch)) >= 0) {
-            hexResult = (hexResult << 4) + tmp;
-
-          } else {
-            throwError(state, 'expected hexadecimal character');
-          }
-        }
-
-        state.result += charFromCodepoint(hexResult);
-
-        state.position++;
-
-      } else {
-        throwError(state, 'unknown escape sequence');
-      }
-
-      captureStart = captureEnd = state.position;
-
-    } else if (is_EOL(ch)) {
-      captureSegment(state, captureStart, captureEnd, true);
-      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
-      captureStart = captureEnd = state.position;
-
-    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
-      throwError(state, 'unexpected end of the document within a double quoted scalar');
-
-    } else {
-      state.position++;
-      captureEnd = state.position;
-    }
-  }
-
-  throwError(state, 'unexpected end of the stream within a double quoted scalar');
-}
-
-function readFlowCollection(state, nodeIndent) {
-  var readNext = true,
-      _line,
-      _lineStart,
-      _pos,
-      _tag     = state.tag,
-      _result,
-      _anchor  = state.anchor,
-      following,
-      terminator,
-      isPair,
-      isExplicitPair,
-      isMapping,
-      overridableKeys = Object.create(null),
-      keyNode,
-      keyTag,
-      valueNode,
-      ch;
-
-  ch = state.input.charCodeAt(state.position);
-
-  if (ch === 0x5B/* [ */) {
-    terminator = 0x5D;/* ] */
-    isMapping = false;
-    _result = [];
-  } else if (ch === 0x7B/* { */) {
-    terminator = 0x7D;/* } */
-    isMapping = true;
-    _result = {};
-  } else {
-    return false;
-  }
-
-  if (state.anchor !== null) {
-    state.anchorMap[state.anchor] = _result;
-  }
-
-  ch = state.input.charCodeAt(++state.position);
-
-  while (ch !== 0) {
-    skipSeparationSpace(state, true, nodeIndent);
-
-    ch = state.input.charCodeAt(state.position);
-
-    if (ch === terminator) {
-      state.position++;
-      state.tag = _tag;
-      state.anchor = _anchor;
-      state.kind = isMapping ? 'mapping' : 'sequence';
-      state.result = _result;
-      return true;
-    } else if (!readNext) {
-      throwError(state, 'missed comma between flow collection entries');
-    } else if (ch === 0x2C/* , */) {
-      // "flow collection entries can never be completely empty", as per YAML 1.2, section 7.4
-      throwError(state, "expected the node content, but found ','");
-    }
-
-    keyTag = keyNode = valueNode = null;
-    isPair = isExplicitPair = false;
-
-    if (ch === 0x3F/* ? */) {
-      following = state.input.charCodeAt(state.position + 1);
-
-      if (is_WS_OR_EOL(following)) {
-        isPair = isExplicitPair = true;
-        state.position++;
-        skipSeparationSpace(state, true, nodeIndent);
-      }
-    }
-
-    _line = state.line; // Save the current line.
-    _lineStart = state.lineStart;
-    _pos = state.position;
-    composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
-    keyTag = state.tag;
-    keyNode = state.result;
-    skipSeparationSpace(state, true, nodeIndent);
-
-    ch = state.input.charCodeAt(state.position);
-
-    if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
-      isPair = true;
-      ch = state.input.charCodeAt(++state.position);
-      skipSeparationSpace(state, true, nodeIndent);
-      composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
-      valueNode = state.result;
-    }
-
-    if (isMapping) {
-      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos);
-    } else if (isPair) {
-      _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos));
-    } else {
-      _result.push(keyNode);
-    }
-
-    skipSeparationSpace(state, true, nodeIndent);
-
-    ch = state.input.charCodeAt(state.position);
-
-    if (ch === 0x2C/* , */) {
-      readNext = true;
-      ch = state.input.charCodeAt(++state.position);
-    } else {
-      readNext = false;
-    }
-  }
-
-  throwError(state, 'unexpected end of the stream within a flow collection');
-}
-
-function readBlockScalar(state, nodeIndent) {
-  var captureStart,
-      folding,
-      chomping       = CHOMPING_CLIP,
-      didReadContent = false,
-      detectedIndent = false,
-      textIndent     = nodeIndent,
-      emptyLines     = 0,
-      atMoreIndented = false,
-      tmp,
-      ch;
-
-  ch = state.input.charCodeAt(state.position);
-
-  if (ch === 0x7C/* | */) {
-    folding = false;
-  } else if (ch === 0x3E/* > */) {
-    folding = true;
-  } else {
-    return false;
-  }
-
-  state.kind = 'scalar';
-  state.result = '';
-
-  while (ch !== 0) {
-    ch = state.input.charCodeAt(++state.position);
-
-    if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
-      if (CHOMPING_CLIP === chomping) {
-        chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;
-      } else {
-        throwError(state, 'repeat of a chomping mode identifier');
-      }
-
-    } else if ((tmp = fromDecimalCode(ch)) >= 0) {
-      if (tmp === 0) {
-        throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
-      } else if (!detectedIndent) {
-        textIndent = nodeIndent + tmp - 1;
-        detectedIndent = true;
-      } else {
-        throwError(state, 'repeat of an indentation width identifier');
-      }
-
-    } else {
-      break;
-    }
-  }
-
-  if (is_WHITE_SPACE(ch)) {
-    do { ch = state.input.charCodeAt(++state.position); }
-    while (is_WHITE_SPACE(ch));
-
-    if (ch === 0x23/* # */) {
-      do { ch = state.input.charCodeAt(++state.position); }
-      while (!is_EOL(ch) && (ch !== 0));
-    }
-  }
-
-  while (ch !== 0) {
-    readLineBreak(state);
-    state.lineIndent = 0;
-
-    ch = state.input.charCodeAt(state.position);
-
-    while ((!detectedIndent || state.lineIndent < textIndent) &&
-           (ch === 0x20/* Space */)) {
-      state.lineIndent++;
-      ch = state.input.charCodeAt(++state.position);
-    }
-
-    if (!detectedIndent && state.lineIndent > textIndent) {
-      textIndent = state.lineIndent;
-    }
-
-    if (is_EOL(ch)) {
-      emptyLines++;
-      continue;
-    }
-
-    // End of the scalar.
-    if (state.lineIndent < textIndent) {
-
-      // Perform the chomping.
-      if (chomping === CHOMPING_KEEP) {
-        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
-      } else if (chomping === CHOMPING_CLIP) {
-        if (didReadContent) { // i.e. only if the scalar is not empty.
-          state.result += '\n';
-        }
-      }
-
-      // Break this `while` cycle and go to the funciton's epilogue.
-      break;
-    }
-
-    // Folded style: use fancy rules to handle line breaks.
-    if (folding) {
-
-      // Lines starting with white space characters (more-indented lines) are not folded.
-      if (is_WHITE_SPACE(ch)) {
-        atMoreIndented = true;
-        // except for the first content line (cf. Example 8.1)
-        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
-
-      // End of more-indented block.
-      } else if (atMoreIndented) {
-        atMoreIndented = false;
-        state.result += common.repeat('\n', emptyLines + 1);
-
-      // Just one line break - perceive as the same line.
-      } else if (emptyLines === 0) {
-        if (didReadContent) { // i.e. only if we have already read some scalar content.
-          state.result += ' ';
-        }
-
-      // Several line breaks - perceive as different lines.
-      } else {
-        state.result += common.repeat('\n', emptyLines);
-      }
-
-    // Literal style: just add exact number of line breaks between content lines.
-    } else {
-      // Keep all line breaks except the header line break.
-      state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
-    }
-
-    didReadContent = true;
-    detectedIndent = true;
-    emptyLines = 0;
-    captureStart = state.position;
-
-    while (!is_EOL(ch) && (ch !== 0)) {
-      ch = state.input.charCodeAt(++state.position);
-    }
-
-    captureSegment(state, captureStart, state.position, false);
-  }
-
-  return true;
-}
-
-function readBlockSequence(state, nodeIndent) {
-  var _line,
-      _tag      = state.tag,
-      _anchor   = state.anchor,
-      _result   = [],
-      following,
-      detected  = false,
-      ch;
-
-  // there is a leading tab before this token, so it can't be a block sequence/mapping;
-  // it can still be flow sequence/mapping or a scalar
-  if (state.firstTabInLine !== -1) return false;
-
-  if (state.anchor !== null) {
-    state.anchorMap[state.anchor] = _result;
-  }
-
-  ch = state.input.charCodeAt(state.position);
-
-  while (ch !== 0) {
-    if (state.firstTabInLine !== -1) {
-      state.position = state.firstTabInLine;
-      throwError(state, 'tab characters must not be used in indentation');
-    }
-
-    if (ch !== 0x2D/* - */) {
-      break;
-    }
-
-    following = state.input.charCodeAt(state.position + 1);
-
-    if (!is_WS_OR_EOL(following)) {
-      break;
-    }
-
-    detected = true;
-    state.position++;
-
-    if (skipSeparationSpace(state, true, -1)) {
-      if (state.lineIndent <= nodeIndent) {
-        _result.push(null);
-        ch = state.input.charCodeAt(state.position);
-        continue;
-      }
-    }
-
-    _line = state.line;
-    composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
-    _result.push(state.result);
-    skipSeparationSpace(state, true, -1);
-
-    ch = state.input.charCodeAt(state.position);
-
-    if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
-      throwError(state, 'bad indentation of a sequence entry');
-    } else if (state.lineIndent < nodeIndent) {
-      break;
-    }
-  }
-
-  if (detected) {
-    state.tag = _tag;
-    state.anchor = _anchor;
-    state.kind = 'sequence';
-    state.result = _result;
-    return true;
-  }
-  return false;
-}
-
-function readBlockMapping(state, nodeIndent, flowIndent) {
-  var following,
-      allowCompact,
-      _line,
-      _keyLine,
-      _keyLineStart,
-      _keyPos,
-      _tag          = state.tag,
-      _anchor       = state.anchor,
-      _result       = {},
-      overridableKeys = Object.create(null),
-      keyTag        = null,
-      keyNode       = null,
-      valueNode     = null,
-      atExplicitKey = false,
-      detected      = false,
-      ch;
-
-  // there is a leading tab before this token, so it can't be a block sequence/mapping;
-  // it can still be flow sequence/mapping or a scalar
-  if (state.firstTabInLine !== -1) return false;
-
-  if (state.anchor !== null) {
-    state.anchorMap[state.anchor] = _result;
-  }
-
-  ch = state.input.charCodeAt(state.position);
-
-  while (ch !== 0) {
-    if (!atExplicitKey && state.firstTabInLine !== -1) {
-      state.position = state.firstTabInLine;
-      throwError(state, 'tab characters must not be used in indentation');
-    }
-
-    following = state.input.charCodeAt(state.position + 1);
-    _line = state.line; // Save the current line.
-
-    //
-    // Explicit notation case. There are two separate blocks:
-    // first for the key (denoted by "?") and second for the value (denoted by ":")
-    //
-    if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {
-
-      if (ch === 0x3F/* ? */) {
-        if (atExplicitKey) {
-          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
-          keyTag = keyNode = valueNode = null;
-        }
-
-        detected = true;
-        atExplicitKey = true;
-        allowCompact = true;
-
-      } else if (atExplicitKey) {
-        // i.e. 0x3A/* : */ === character after the explicit key.
-        atExplicitKey = false;
-        allowCompact = true;
-
-      } else {
-        throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
-      }
-
-      state.position += 1;
-      ch = following;
-
-    //
-    // Implicit notation case. Flow-style node as the key first, then ":", and the value.
-    //
-    } else {
-      _keyLine = state.line;
-      _keyLineStart = state.lineStart;
-      _keyPos = state.position;
-
-      if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
-        // Neither implicit nor explicit notation.
-        // Reading is done. Go to the epilogue.
-        break;
-      }
-
-      if (state.line === _line) {
-        ch = state.input.charCodeAt(state.position);
-
-        while (is_WHITE_SPACE(ch)) {
-          ch = state.input.charCodeAt(++state.position);
-        }
-
-        if (ch === 0x3A/* : */) {
-          ch = state.input.charCodeAt(++state.position);
-
-          if (!is_WS_OR_EOL(ch)) {
-            throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');
-          }
-
-          if (atExplicitKey) {
-            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
-            keyTag = keyNode = valueNode = null;
-          }
-
-          detected = true;
-          atExplicitKey = false;
-          allowCompact = false;
-          keyTag = state.tag;
-          keyNode = state.result;
-
-        } else if (detected) {
-          throwError(state, 'can not read an implicit mapping pair; a colon is missed');
-
-        } else {
-          state.tag = _tag;
-          state.anchor = _anchor;
-          return true; // Keep the result of `composeNode`.
-        }
-
-      } else if (detected) {
-        throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
-
-      } else {
-        state.tag = _tag;
-        state.anchor = _anchor;
-        return true; // Keep the result of `composeNode`.
-      }
-    }
-
-    //
-    // Common reading code for both explicit and implicit notations.
-    //
-    if (state.line === _line || state.lineIndent > nodeIndent) {
-      if (atExplicitKey) {
-        _keyLine = state.line;
-        _keyLineStart = state.lineStart;
-        _keyPos = state.position;
-      }
-
-      if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
-        if (atExplicitKey) {
-          keyNode = state.result;
-        } else {
-          valueNode = state.result;
-        }
-      }
-
-      if (!atExplicitKey) {
-        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos);
-        keyTag = keyNode = valueNode = null;
-      }
-
-      skipSeparationSpace(state, true, -1);
-      ch = state.input.charCodeAt(state.position);
-    }
-
-    if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
-      throwError(state, 'bad indentation of a mapping entry');
-    } else if (state.lineIndent < nodeIndent) {
-      break;
-    }
-  }
-
-  //
-  // Epilogue.
-  //
-
-  // Special case: last mapping's node contains only the key in explicit notation.
-  if (atExplicitKey) {
-    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
-  }
-
-  // Expose the resulting mapping.
-  if (detected) {
-    state.tag = _tag;
-    state.anchor = _anchor;
-    state.kind = 'mapping';
-    state.result = _result;
-  }
-
-  return detected;
-}
-
-function readTagProperty(state) {
-  var _position,
-      isVerbatim = false,
-      isNamed    = false,
-      tagHandle,
-      tagName,
-      ch;
-
-  ch = state.input.charCodeAt(state.position);
-
-  if (ch !== 0x21/* ! */) return false;
-
-  if (state.tag !== null) {
-    throwError(state, 'duplication of a tag property');
-  }
-
-  ch = state.input.charCodeAt(++state.position);
-
-  if (ch === 0x3C/* < */) {
-    isVerbatim = true;
-    ch = state.input.charCodeAt(++state.position);
-
-  } else if (ch === 0x21/* ! */) {
-    isNamed = true;
-    tagHandle = '!!';
-    ch = state.input.charCodeAt(++state.position);
-
-  } else {
-    tagHandle = '!';
-  }
-
-  _position = state.position;
-
-  if (isVerbatim) {
-    do { ch = state.input.charCodeAt(++state.position); }
-    while (ch !== 0 && ch !== 0x3E/* > */);
-
-    if (state.position < state.length) {
-      tagName = state.input.slice(_position, state.position);
-      ch = state.input.charCodeAt(++state.position);
-    } else {
-      throwError(state, 'unexpected end of the stream within a verbatim tag');
-    }
-  } else {
-    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
-
-      if (ch === 0x21/* ! */) {
-        if (!isNamed) {
-          tagHandle = state.input.slice(_position - 1, state.position + 1);
-
-          if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
-            throwError(state, 'named tag handle cannot contain such characters');
-          }
-
-          isNamed = true;
-          _position = state.position + 1;
-        } else {
-          throwError(state, 'tag suffix cannot contain exclamation marks');
-        }
-      }
-
-      ch = state.input.charCodeAt(++state.position);
-    }
-
-    tagName = state.input.slice(_position, state.position);
-
-    if (PATTERN_FLOW_INDICATORS.test(tagName)) {
-      throwError(state, 'tag suffix cannot contain flow indicator characters');
-    }
-  }
-
-  if (tagName && !PATTERN_TAG_URI.test(tagName)) {
-    throwError(state, 'tag name cannot contain such characters: ' + tagName);
-  }
-
-  try {
-    tagName = decodeURIComponent(tagName);
-  } catch (err) {
-    throwError(state, 'tag name is malformed: ' + tagName);
-  }
-
-  if (isVerbatim) {
-    state.tag = tagName;
-
-  } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
-    state.tag = state.tagMap[tagHandle] + tagName;
-
-  } else if (tagHandle === '!') {
-    state.tag = '!' + tagName;
-
-  } else if (tagHandle === '!!') {
-    state.tag = 'tag:yaml.org,2002:' + tagName;
-
-  } else {
-    throwError(state, 'undeclared tag handle "' + tagHandle + '"');
-  }
-
-  return true;
-}
-
-function readAnchorProperty(state) {
-  var _position,
-      ch;
-
-  ch = state.input.charCodeAt(state.position);
-
-  if (ch !== 0x26/* & */) return false;
-
-  if (state.anchor !== null) {
-    throwError(state, 'duplication of an anchor property');
-  }
-
-  ch = state.input.charCodeAt(++state.position);
-  _position = state.position;
-
-  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
-    ch = state.input.charCodeAt(++state.position);
-  }
-
-  if (state.position === _position) {
-    throwError(state, 'name of an anchor node must contain at least one character');
-  }
-
-  state.anchor = state.input.slice(_position, state.position);
-  return true;
-}
-
-function readAlias(state) {
-  var _position, alias,
-      ch;
-
-  ch = state.input.charCodeAt(state.position);
-
-  if (ch !== 0x2A/* * */) return false;
-
-  ch = state.input.charCodeAt(++state.position);
-  _position = state.position;
-
-  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
-    ch = state.input.charCodeAt(++state.position);
-  }
-
-  if (state.position === _position) {
-    throwError(state, 'name of an alias node must contain at least one character');
-  }
-
-  alias = state.input.slice(_position, state.position);
-
-  if (!_hasOwnProperty.call(state.anchorMap, alias)) {
-    throwError(state, 'unidentified alias "' + alias + '"');
-  }
-
-  state.result = state.anchorMap[alias];
-  skipSeparationSpace(state, true, -1);
-  return true;
-}
-
-function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
-  var allowBlockStyles,
-      allowBlockScalars,
-      allowBlockCollections,
-      indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
-      atNewLine  = false,
-      hasContent = false,
-      typeIndex,
-      typeQuantity,
-      typeList,
-      type,
-      flowIndent,
-      blockIndent;
-
-  if (state.listener !== null) {
-    state.listener('open', state);
-  }
-
-  state.tag    = null;
-  state.anchor = null;
-  state.kind   = null;
-  state.result = null;
-
-  allowBlockStyles = allowBlockScalars = allowBlockCollections =
-    CONTEXT_BLOCK_OUT === nodeContext ||
-    CONTEXT_BLOCK_IN  === nodeContext;
-
-  if (allowToSeek) {
-    if (skipSeparationSpace(state, true, -1)) {
-      atNewLine = true;
-
-      if (state.lineIndent > parentIndent) {
-        indentStatus = 1;
-      } else if (state.lineIndent === parentIndent) {
-        indentStatus = 0;
-      } else if (state.lineIndent < parentIndent) {
-        indentStatus = -1;
-      }
-    }
-  }
-
-  if (indentStatus === 1) {
-    while (readTagProperty(state) || readAnchorProperty(state)) {
-      if (skipSeparationSpace(state, true, -1)) {
-        atNewLine = true;
-        allowBlockCollections = allowBlockStyles;
-
-        if (state.lineIndent > parentIndent) {
-          indentStatus = 1;
-        } else if (state.lineIndent === parentIndent) {
-          indentStatus = 0;
-        } else if (state.lineIndent < parentIndent) {
-          indentStatus = -1;
-        }
-      } else {
-        allowBlockCollections = false;
-      }
-    }
-  }
-
-  if (allowBlockCollections) {
-    allowBlockCollections = atNewLine || allowCompact;
-  }
-
-  if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
-    if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
-      flowIndent = parentIndent;
-    } else {
-      flowIndent = parentIndent + 1;
-    }
-
-    blockIndent = state.position - state.lineStart;
-
-    if (indentStatus === 1) {
-      if (allowBlockCollections &&
-          (readBlockSequence(state, blockIndent) ||
-           readBlockMapping(state, blockIndent, flowIndent)) ||
-          readFlowCollection(state, flowIndent)) {
-        hasContent = true;
-      } else {
-        if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
-            readSingleQuotedScalar(state, flowIndent) ||
-            readDoubleQuotedScalar(state, flowIndent)) {
-          hasContent = true;
-
-        } else if (readAlias(state)) {
-          hasContent = true;
-
-          if (state.tag !== null || state.anchor !== null) {
-            throwError(state, 'alias node should not have any properties');
-          }
-
-        } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
-          hasContent = true;
-
-          if (state.tag === null) {
-            state.tag = '?';
-          }
-        }
-
-        if (state.anchor !== null) {
-          state.anchorMap[state.anchor] = state.result;
-        }
-      }
-    } else if (indentStatus === 0) {
-      // Special case: block sequences are allowed to have same indentation level as the parent.
-      // http://www.yaml.org/spec/1.2/spec.html#id2799784
-      hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
-    }
-  }
-
-  if (state.tag === null) {
-    if (state.anchor !== null) {
-      state.anchorMap[state.anchor] = state.result;
-    }
-
-  } else if (state.tag === '?') {
-    // Implicit resolving is not allowed for non-scalar types, and '?'
-    // non-specific tag is only automatically assigned to plain scalars.
-    //
-    // We only need to check kind conformity in case user explicitly assigns '?'
-    // tag, for example like this: "!<?> [0]"
-    //
-    if (state.result !== null && state.kind !== 'scalar') {
-      throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
-    }
-
-    for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
-      type = state.implicitTypes[typeIndex];
-
-      if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
-        state.result = type.construct(state.result);
-        state.tag = type.tag;
-        if (state.anchor !== null) {
-          state.anchorMap[state.anchor] = state.result;
-        }
-        break;
-      }
-    }
-  } else if (state.tag !== '!') {
-    if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
-      type = state.typeMap[state.kind || 'fallback'][state.tag];
-    } else {
-      // looking for multi type
-      type = null;
-      typeList = state.typeMap.multi[state.kind || 'fallback'];
-
-      for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) {
-        if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) {
-          type = typeList[typeIndex];
-          break;
-        }
-      }
-    }
-
-    if (!type) {
-      throwError(state, 'unknown tag !<' + state.tag + '>');
-    }
-
-    if (state.result !== null && type.kind !== state.kind) {
-      throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
-    }
-
-    if (!type.resolve(state.result, state.tag)) { // `state.result` updated in resolver if matched
-      throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
-    } else {
-      state.result = type.construct(state.result, state.tag);
-      if (state.anchor !== null) {
-        state.anchorMap[state.anchor] = state.result;
-      }
-    }
-  }
-
-  if (state.listener !== null) {
-    state.listener('close', state);
-  }
-  return state.tag !== null ||  state.anchor !== null || hasContent;
-}
-
-function readDocument(state) {
-  var documentStart = state.position,
-      _position,
-      directiveName,
-      directiveArgs,
-      hasDirectives = false,
-      ch;
-
-  state.version = null;
-  state.checkLineBreaks = state.legacy;
-  state.tagMap = Object.create(null);
-  state.anchorMap = Object.create(null);
-
-  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
-    skipSeparationSpace(state, true, -1);
-
-    ch = state.input.charCodeAt(state.position);
-
-    if (state.lineIndent > 0 || ch !== 0x25/* % */) {
-      break;
-    }
-
-    hasDirectives = true;
-    ch = state.input.charCodeAt(++state.position);
-    _position = state.position;
-
-    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
-      ch = state.input.charCodeAt(++state.position);
-    }
-
-    directiveName = state.input.slice(_position, state.position);
-    directiveArgs = [];
-
-    if (directiveName.length < 1) {
-      throwError(state, 'directive name must not be less than one character in length');
-    }
-
-    while (ch !== 0) {
-      while (is_WHITE_SPACE(ch)) {
-        ch = state.input.charCodeAt(++state.position);
-      }
-
-      if (ch === 0x23/* # */) {
-        do { ch = state.input.charCodeAt(++state.position); }
-        while (ch !== 0 && !is_EOL(ch));
-        break;
-      }
-
-      if (is_EOL(ch)) break;
-
-      _position = state.position;
-
-      while (ch !== 0 && !is_WS_OR_EOL(ch)) {
-        ch = state.input.charCodeAt(++state.position);
-      }
-
-      directiveArgs.push(state.input.slice(_position, state.position));
-    }
-
-    if (ch !== 0) readLineBreak(state);
-
-    if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
-      directiveHandlers[directiveName](state, directiveName, directiveArgs);
-    } else {
-      throwWarning(state, 'unknown document directive "' + directiveName + '"');
-    }
-  }
-
-  skipSeparationSpace(state, true, -1);
-
-  if (state.lineIndent === 0 &&
-      state.input.charCodeAt(state.position)     === 0x2D/* - */ &&
-      state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
-      state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
-    state.position += 3;
-    skipSeparationSpace(state, true, -1);
-
-  } else if (hasDirectives) {
-    throwError(state, 'directives end mark is expected');
-  }
-
-  composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
-  skipSeparationSpace(state, true, -1);
-
-  if (state.checkLineBreaks &&
-      PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
-    throwWarning(state, 'non-ASCII line breaks are interpreted as content');
-  }
-
-  state.documents.push(state.result);
-
-  if (state.position === state.lineStart && testDocumentSeparator(state)) {
-
-    if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
-      state.position += 3;
-      skipSeparationSpace(state, true, -1);
-    }
-    return;
-  }
-
-  if (state.position < (state.length - 1)) {
-    throwError(state, 'end of the stream or a document separator is expected');
-  } else {
-    return;
-  }
-}
-
-
-function loadDocuments(input, options) {
-  input = String(input);
-  options = options || {};
-
-  if (input.length !== 0) {
-
-    // Add tailing `\n` if not exists
-    if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
-        input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
-      input += '\n';
-    }
-
-    // Strip BOM
-    if (input.charCodeAt(0) === 0xFEFF) {
-      input = input.slice(1);
-    }
-  }
-
-  var state = new State(input, options);
-
-  var nullpos = input.indexOf('\0');
-
-  if (nullpos !== -1) {
-    state.position = nullpos;
-    throwError(state, 'null byte is not allowed in input');
-  }
-
-  // Use 0 as string terminator. That significantly simplifies bounds check.
-  state.input += '\0';
-
-  while (state.input.charCodeAt(state.position) === 0x20/* Space */) {
-    state.lineIndent += 1;
-    state.position += 1;
-  }
-
-  while (state.position < (state.length - 1)) {
-    readDocument(state);
-  }
-
-  return state.documents;
-}
-
-
-function loadAll(input, iterator, options) {
-  if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {
-    options = iterator;
-    iterator = null;
-  }
-
-  var documents = loadDocuments(input, options);
-
-  if (typeof iterator !== 'function') {
-    return documents;
-  }
-
-  for (var index = 0, length = documents.length; index < length; index += 1) {
-    iterator(documents[index]);
-  }
-}
-
-
-function load(input, options) {
-  var documents = loadDocuments(input, options);
-
-  if (documents.length === 0) {
-    /*eslint-disable no-undefined*/
-    return undefined;
-  } else if (documents.length === 1) {
-    return documents[0];
-  }
-  throw new YAMLException('expected a single document in the stream, but found more');
-}
-
-
-module.exports.loadAll = loadAll;
-module.exports.load    = load;
-
-
-/***/ }),
-
-/***/ 21082:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-/*eslint-disable max-len*/
-
-var YAMLException = __nccwpck_require__(68179);
-var Type          = __nccwpck_require__(6073);
-
-
-function compileList(schema, name) {
-  var result = [];
-
-  schema[name].forEach(function (currentType) {
-    var newIndex = result.length;
-
-    result.forEach(function (previousType, previousIndex) {
-      if (previousType.tag === currentType.tag &&
-          previousType.kind === currentType.kind &&
-          previousType.multi === currentType.multi) {
-
-        newIndex = previousIndex;
-      }
-    });
-
-    result[newIndex] = currentType;
-  });
-
-  return result;
-}
-
-
-function compileMap(/* lists... */) {
-  var result = {
-        scalar: {},
-        sequence: {},
-        mapping: {},
-        fallback: {},
-        multi: {
-          scalar: [],
-          sequence: [],
-          mapping: [],
-          fallback: []
-        }
-      }, index, length;
-
-  function collectType(type) {
-    if (type.multi) {
-      result.multi[type.kind].push(type);
-      result.multi['fallback'].push(type);
-    } else {
-      result[type.kind][type.tag] = result['fallback'][type.tag] = type;
-    }
-  }
-
-  for (index = 0, length = arguments.length; index < length; index += 1) {
-    arguments[index].forEach(collectType);
-  }
-  return result;
-}
-
-
-function Schema(definition) {
-  return this.extend(definition);
-}
-
-
-Schema.prototype.extend = function extend(definition) {
-  var implicit = [];
-  var explicit = [];
-
-  if (definition instanceof Type) {
-    // Schema.extend(type)
-    explicit.push(definition);
-
-  } else if (Array.isArray(definition)) {
-    // Schema.extend([ type1, type2, ... ])
-    explicit = explicit.concat(definition);
-
-  } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
-    // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] })
-    if (definition.implicit) implicit = implicit.concat(definition.implicit);
-    if (definition.explicit) explicit = explicit.concat(definition.explicit);
-
-  } else {
-    throw new YAMLException('Schema.extend argument should be a Type, [ Type ], ' +
-      'or a schema definition ({ implicit: [...], explicit: [...] })');
-  }
-
-  implicit.forEach(function (type) {
-    if (!(type instanceof Type)) {
-      throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
-    }
-
-    if (type.loadKind && type.loadKind !== 'scalar') {
-      throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
-    }
-
-    if (type.multi) {
-      throw new YAMLException('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.');
-    }
-  });
-
-  explicit.forEach(function (type) {
-    if (!(type instanceof Type)) {
-      throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
-    }
-  });
-
-  var result = Object.create(Schema.prototype);
-
-  result.implicit = (this.implicit || []).concat(implicit);
-  result.explicit = (this.explicit || []).concat(explicit);
-
-  result.compiledImplicit = compileList(result, 'implicit');
-  result.compiledExplicit = compileList(result, 'explicit');
-  result.compiledTypeMap  = compileMap(result.compiledImplicit, result.compiledExplicit);
-
-  return result;
-};
-
-
-module.exports = Schema;
-
-
-/***/ }),
-
-/***/ 12011:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-// Standard YAML's Core schema.
-// http://www.yaml.org/spec/1.2/spec.html#id2804923
-//
-// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
-// So, Core schema has no distinctions from JSON schema is JS-YAML.
-
-
-
-
-
-module.exports = __nccwpck_require__(1035);
-
-
-/***/ }),
-
-/***/ 18759:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-// JS-YAML's default schema for `safeLoad` function.
-// It is not described in the YAML specification.
-//
-// This schema is based on standard YAML's Core schema and includes most of
-// extra types described at YAML tag repository. (http://yaml.org/type/)
-
-
-
-
-
-module.exports = (__nccwpck_require__(12011).extend)({
-  implicit: [
-    __nccwpck_require__(99212),
-    __nccwpck_require__(86104)
-  ],
-  explicit: [
-    __nccwpck_require__(77900),
-    __nccwpck_require__(19046),
-    __nccwpck_require__(96860),
-    __nccwpck_require__(79548)
-  ]
-});
-
-
-/***/ }),
-
-/***/ 28562:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-// Standard YAML's Failsafe schema.
-// http://www.yaml.org/spec/1.2/spec.html#id2802346
-
-
-
-
-
-var Schema = __nccwpck_require__(21082);
-
-
-module.exports = new Schema({
-  explicit: [
-    __nccwpck_require__(23619),
-    __nccwpck_require__(67283),
-    __nccwpck_require__(86150)
-  ]
-});
-
-
-/***/ }),
-
-/***/ 1035:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-// Standard YAML's JSON schema.
-// http://www.yaml.org/spec/1.2/spec.html#id2803231
-//
-// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
-// So, this schema is not such strict as defined in the YAML specification.
-// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc.
-
-
-
-
-
-module.exports = (__nccwpck_require__(28562).extend)({
-  implicit: [
-    __nccwpck_require__(20721),
-    __nccwpck_require__(64993),
-    __nccwpck_require__(11615),
-    __nccwpck_require__(42705)
-  ]
-});
-
-
-/***/ }),
-
-/***/ 96975:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-
-var common = __nccwpck_require__(26829);
-
-
-// get snippet for a single line, respecting maxLength
-function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
-  var head = '';
-  var tail = '';
-  var maxHalfLength = Math.floor(maxLineLength / 2) - 1;
-
-  if (position - lineStart > maxHalfLength) {
-    head = ' ... ';
-    lineStart = position - maxHalfLength + head.length;
-  }
-
-  if (lineEnd - position > maxHalfLength) {
-    tail = ' ...';
-    lineEnd = position + maxHalfLength - tail.length;
-  }
-
-  return {
-    str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail,
-    pos: position - lineStart + head.length // relative position
-  };
-}
-
-
-function padStart(string, max) {
-  return common.repeat(' ', max - string.length) + string;
-}
-
-
-function makeSnippet(mark, options) {
-  options = Object.create(options || null);
-
-  if (!mark.buffer) return null;
-
-  if (!options.maxLength) options.maxLength = 79;
-  if (typeof options.indent      !== 'number') options.indent      = 1;
-  if (typeof options.linesBefore !== 'number') options.linesBefore = 3;
-  if (typeof options.linesAfter  !== 'number') options.linesAfter  = 2;
-
-  var re = /\r?\n|\r|\0/g;
-  var lineStarts = [ 0 ];
-  var lineEnds = [];
-  var match;
-  var foundLineNo = -1;
-
-  while ((match = re.exec(mark.buffer))) {
-    lineEnds.push(match.index);
-    lineStarts.push(match.index + match[0].length);
-
-    if (mark.position <= match.index && foundLineNo < 0) {
-      foundLineNo = lineStarts.length - 2;
-    }
-  }
-
-  if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
-
-  var result = '', i, line;
-  var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
-  var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
-
-  for (i = 1; i <= options.linesBefore; i++) {
-    if (foundLineNo - i < 0) break;
-    line = getLine(
-      mark.buffer,
-      lineStarts[foundLineNo - i],
-      lineEnds[foundLineNo - i],
-      mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]),
-      maxLineLength
-    );
-    result = common.repeat(' ', options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) +
-      ' | ' + line.str + '\n' + result;
-  }
-
-  line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
-  result += common.repeat(' ', options.indent) + padStart((mark.line + 1).toString(), lineNoLength) +
-    ' | ' + line.str + '\n';
-  result += common.repeat('-', options.indent + lineNoLength + 3 + line.pos) + '^' + '\n';
-
-  for (i = 1; i <= options.linesAfter; i++) {
-    if (foundLineNo + i >= lineEnds.length) break;
-    line = getLine(
-      mark.buffer,
-      lineStarts[foundLineNo + i],
-      lineEnds[foundLineNo + i],
-      mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]),
-      maxLineLength
-    );
-    result += common.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) +
-      ' | ' + line.str + '\n';
-  }
-
-  return result.replace(/\n$/, '');
-}
-
-
-module.exports = makeSnippet;
-
-
-/***/ }),
-
-/***/ 6073:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var YAMLException = __nccwpck_require__(68179);
-
-var TYPE_CONSTRUCTOR_OPTIONS = [
-  'kind',
-  'multi',
-  'resolve',
-  'construct',
-  'instanceOf',
-  'predicate',
-  'represent',
-  'representName',
-  'defaultStyle',
-  'styleAliases'
-];
-
-var YAML_NODE_KINDS = [
-  'scalar',
-  'sequence',
-  'mapping'
-];
-
-function compileStyleAliases(map) {
-  var result = {};
-
-  if (map !== null) {
-    Object.keys(map).forEach(function (style) {
-      map[style].forEach(function (alias) {
-        result[String(alias)] = style;
-      });
-    });
-  }
-
-  return result;
-}
-
-function Type(tag, options) {
-  options = options || {};
-
-  Object.keys(options).forEach(function (name) {
-    if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
-      throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
-    }
-  });
-
-  // TODO: Add tag format check.
-  this.options       = options; // keep original options in case user wants to extend this type later
-  this.tag           = tag;
-  this.kind          = options['kind']          || null;
-  this.resolve       = options['resolve']       || function () { return true; };
-  this.construct     = options['construct']     || function (data) { return data; };
-  this.instanceOf    = options['instanceOf']    || null;
-  this.predicate     = options['predicate']     || null;
-  this.represent     = options['represent']     || null;
-  this.representName = options['representName'] || null;
-  this.defaultStyle  = options['defaultStyle']  || null;
-  this.multi         = options['multi']         || false;
-  this.styleAliases  = compileStyleAliases(options['styleAliases'] || null);
-
-  if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
-    throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
-  }
-}
-
-module.exports = Type;
-
-
-/***/ }),
-
-/***/ 77900:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-/*eslint-disable no-bitwise*/
-
-
-var Type = __nccwpck_require__(6073);
-
-
-// [ 64, 65, 66 ] -> [ padding, CR, LF ]
-var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
-
-
-function resolveYamlBinary(data) {
-  if (data === null) return false;
-
-  var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
-
-  // Convert one by one.
-  for (idx = 0; idx < max; idx++) {
-    code = map.indexOf(data.charAt(idx));
-
-    // Skip CR/LF
-    if (code > 64) continue;
-
-    // Fail on illegal characters
-    if (code < 0) return false;
-
-    bitlen += 6;
-  }
-
-  // If there are any bits left, source was corrupted
-  return (bitlen % 8) === 0;
-}
-
-function constructYamlBinary(data) {
-  var idx, tailbits,
-      input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan
-      max = input.length,
-      map = BASE64_MAP,
-      bits = 0,
-      result = [];
-
-  // Collect by 6*4 bits (3 bytes)
-
-  for (idx = 0; idx < max; idx++) {
-    if ((idx % 4 === 0) && idx) {
-      result.push((bits >> 16) & 0xFF);
-      result.push((bits >> 8) & 0xFF);
-      result.push(bits & 0xFF);
-    }
-
-    bits = (bits << 6) | map.indexOf(input.charAt(idx));
-  }
-
-  // Dump tail
-
-  tailbits = (max % 4) * 6;
-
-  if (tailbits === 0) {
-    result.push((bits >> 16) & 0xFF);
-    result.push((bits >> 8) & 0xFF);
-    result.push(bits & 0xFF);
-  } else if (tailbits === 18) {
-    result.push((bits >> 10) & 0xFF);
-    result.push((bits >> 2) & 0xFF);
-  } else if (tailbits === 12) {
-    result.push((bits >> 4) & 0xFF);
-  }
-
-  return new Uint8Array(result);
-}
-
-function representYamlBinary(object /*, style*/) {
-  var result = '', bits = 0, idx, tail,
-      max = object.length,
-      map = BASE64_MAP;
-
-  // Convert every three bytes to 4 ASCII characters.
-
-  for (idx = 0; idx < max; idx++) {
-    if ((idx % 3 === 0) && idx) {
-      result += map[(bits >> 18) & 0x3F];
-      result += map[(bits >> 12) & 0x3F];
-      result += map[(bits >> 6) & 0x3F];
-      result += map[bits & 0x3F];
-    }
-
-    bits = (bits << 8) + object[idx];
-  }
-
-  // Dump tail
-
-  tail = max % 3;
-
-  if (tail === 0) {
-    result += map[(bits >> 18) & 0x3F];
-    result += map[(bits >> 12) & 0x3F];
-    result += map[(bits >> 6) & 0x3F];
-    result += map[bits & 0x3F];
-  } else if (tail === 2) {
-    result += map[(bits >> 10) & 0x3F];
-    result += map[(bits >> 4) & 0x3F];
-    result += map[(bits << 2) & 0x3F];
-    result += map[64];
-  } else if (tail === 1) {
-    result += map[(bits >> 2) & 0x3F];
-    result += map[(bits << 4) & 0x3F];
-    result += map[64];
-    result += map[64];
-  }
-
-  return result;
-}
-
-function isBinary(obj) {
-  return Object.prototype.toString.call(obj) ===  '[object Uint8Array]';
-}
-
-module.exports = new Type('tag:yaml.org,2002:binary', {
-  kind: 'scalar',
-  resolve: resolveYamlBinary,
-  construct: constructYamlBinary,
-  predicate: isBinary,
-  represent: representYamlBinary
-});
-
-
-/***/ }),
-
-/***/ 64993:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var Type = __nccwpck_require__(6073);
-
-function resolveYamlBoolean(data) {
-  if (data === null) return false;
-
-  var max = data.length;
-
-  return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
-         (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
-}
-
-function constructYamlBoolean(data) {
-  return data === 'true' ||
-         data === 'True' ||
-         data === 'TRUE';
-}
-
-function isBoolean(object) {
-  return Object.prototype.toString.call(object) === '[object Boolean]';
-}
-
-module.exports = new Type('tag:yaml.org,2002:bool', {
-  kind: 'scalar',
-  resolve: resolveYamlBoolean,
-  construct: constructYamlBoolean,
-  predicate: isBoolean,
-  represent: {
-    lowercase: function (object) { return object ? 'true' : 'false'; },
-    uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
-    camelcase: function (object) { return object ? 'True' : 'False'; }
-  },
-  defaultStyle: 'lowercase'
-});
-
-
-/***/ }),
-
-/***/ 42705:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var common = __nccwpck_require__(26829);
-var Type   = __nccwpck_require__(6073);
-
-var YAML_FLOAT_PATTERN = new RegExp(
-  // 2.5e4, 2.5 and integers
-  '^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
-  // .2e4, .2
-  // special case, seems not from spec
-  '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +
-  // .inf
-  '|[-+]?\\.(?:inf|Inf|INF)' +
-  // .nan
-  '|\\.(?:nan|NaN|NAN))$');
-
-function resolveYamlFloat(data) {
-  if (data === null) return false;
-
-  if (!YAML_FLOAT_PATTERN.test(data) ||
-      // Quick hack to not allow integers end with `_`
-      // Probably should update regexp & check speed
-      data[data.length - 1] === '_') {
-    return false;
-  }
-
-  return true;
-}
-
-function constructYamlFloat(data) {
-  var value, sign;
-
-  value  = data.replace(/_/g, '').toLowerCase();
-  sign   = value[0] === '-' ? -1 : 1;
-
-  if ('+-'.indexOf(value[0]) >= 0) {
-    value = value.slice(1);
-  }
-
-  if (value === '.inf') {
-    return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
-
-  } else if (value === '.nan') {
-    return NaN;
-  }
-  return sign * parseFloat(value, 10);
-}
-
-
-var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
-
-function representYamlFloat(object, style) {
-  var res;
-
-  if (isNaN(object)) {
-    switch (style) {
-      case 'lowercase': return '.nan';
-      case 'uppercase': return '.NAN';
-      case 'camelcase': return '.NaN';
-    }
-  } else if (Number.POSITIVE_INFINITY === object) {
-    switch (style) {
-      case 'lowercase': return '.inf';
-      case 'uppercase': return '.INF';
-      case 'camelcase': return '.Inf';
-    }
-  } else if (Number.NEGATIVE_INFINITY === object) {
-    switch (style) {
-      case 'lowercase': return '-.inf';
-      case 'uppercase': return '-.INF';
-      case 'camelcase': return '-.Inf';
-    }
-  } else if (common.isNegativeZero(object)) {
-    return '-0.0';
-  }
-
-  res = object.toString(10);
-
-  // JS stringifier can build scientific format without dots: 5e-100,
-  // while YAML requres dot: 5.e-100. Fix it with simple hack
-
-  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
-}
-
-function isFloat(object) {
-  return (Object.prototype.toString.call(object) === '[object Number]') &&
-         (object % 1 !== 0 || common.isNegativeZero(object));
-}
-
-module.exports = new Type('tag:yaml.org,2002:float', {
-  kind: 'scalar',
-  resolve: resolveYamlFloat,
-  construct: constructYamlFloat,
-  predicate: isFloat,
-  represent: representYamlFloat,
-  defaultStyle: 'lowercase'
-});
-
-
-/***/ }),
-
-/***/ 11615:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var common = __nccwpck_require__(26829);
-var Type   = __nccwpck_require__(6073);
-
-function isHexCode(c) {
-  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||
-         ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||
-         ((0x61/* a */ <= c) && (c <= 0x66/* f */));
-}
-
-function isOctCode(c) {
-  return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));
-}
-
-function isDecCode(c) {
-  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));
-}
-
-function resolveYamlInteger(data) {
-  if (data === null) return false;
-
-  var max = data.length,
-      index = 0,
-      hasDigits = false,
-      ch;
-
-  if (!max) return false;
-
-  ch = data[index];
-
-  // sign
-  if (ch === '-' || ch === '+') {
-    ch = data[++index];
-  }
-
-  if (ch === '0') {
-    // 0
-    if (index + 1 === max) return true;
-    ch = data[++index];
-
-    // base 2, base 8, base 16
-
-    if (ch === 'b') {
-      // base 2
-      index++;
-
-      for (; index < max; index++) {
-        ch = data[index];
-        if (ch === '_') continue;
-        if (ch !== '0' && ch !== '1') return false;
-        hasDigits = true;
-      }
-      return hasDigits && ch !== '_';
-    }
-
-
-    if (ch === 'x') {
-      // base 16
-      index++;
-
-      for (; index < max; index++) {
-        ch = data[index];
-        if (ch === '_') continue;
-        if (!isHexCode(data.charCodeAt(index))) return false;
-        hasDigits = true;
-      }
-      return hasDigits && ch !== '_';
-    }
-
-
-    if (ch === 'o') {
-      // base 8
-      index++;
-
-      for (; index < max; index++) {
-        ch = data[index];
-        if (ch === '_') continue;
-        if (!isOctCode(data.charCodeAt(index))) return false;
-        hasDigits = true;
-      }
-      return hasDigits && ch !== '_';
-    }
-  }
-
-  // base 10 (except 0)
-
-  // value should not start with `_`;
-  if (ch === '_') return false;
-
-  for (; index < max; index++) {
-    ch = data[index];
-    if (ch === '_') continue;
-    if (!isDecCode(data.charCodeAt(index))) {
-      return false;
-    }
-    hasDigits = true;
-  }
-
-  // Should have digits and should not end with `_`
-  if (!hasDigits || ch === '_') return false;
-
-  return true;
-}
-
-function constructYamlInteger(data) {
-  var value = data, sign = 1, ch;
-
-  if (value.indexOf('_') !== -1) {
-    value = value.replace(/_/g, '');
-  }
-
-  ch = value[0];
-
-  if (ch === '-' || ch === '+') {
-    if (ch === '-') sign = -1;
-    value = value.slice(1);
-    ch = value[0];
-  }
-
-  if (value === '0') return 0;
-
-  if (ch === '0') {
-    if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);
-    if (value[1] === 'x') return sign * parseInt(value.slice(2), 16);
-    if (value[1] === 'o') return sign * parseInt(value.slice(2), 8);
-  }
-
-  return sign * parseInt(value, 10);
-}
-
-function isInteger(object) {
-  return (Object.prototype.toString.call(object)) === '[object Number]' &&
-         (object % 1 === 0 && !common.isNegativeZero(object));
-}
-
-module.exports = new Type('tag:yaml.org,2002:int', {
-  kind: 'scalar',
-  resolve: resolveYamlInteger,
-  construct: constructYamlInteger,
-  predicate: isInteger,
-  represent: {
-    binary:      function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); },
-    octal:       function (obj) { return obj >= 0 ? '0o'  + obj.toString(8) : '-0o'  + obj.toString(8).slice(1); },
-    decimal:     function (obj) { return obj.toString(10); },
-    /* eslint-disable max-len */
-    hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() :  '-0x' + obj.toString(16).toUpperCase().slice(1); }
-  },
-  defaultStyle: 'decimal',
-  styleAliases: {
-    binary:      [ 2,  'bin' ],
-    octal:       [ 8,  'oct' ],
-    decimal:     [ 10, 'dec' ],
-    hexadecimal: [ 16, 'hex' ]
-  }
-});
-
-
-/***/ }),
-
-/***/ 86150:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var Type = __nccwpck_require__(6073);
-
-module.exports = new Type('tag:yaml.org,2002:map', {
-  kind: 'mapping',
-  construct: function (data) { return data !== null ? data : {}; }
-});
-
-
-/***/ }),
-
-/***/ 86104:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var Type = __nccwpck_require__(6073);
-
-function resolveYamlMerge(data) {
-  return data === '<<' || data === null;
-}
-
-module.exports = new Type('tag:yaml.org,2002:merge', {
-  kind: 'scalar',
-  resolve: resolveYamlMerge
-});
-
-
-/***/ }),
-
-/***/ 20721:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var Type = __nccwpck_require__(6073);
-
-function resolveYamlNull(data) {
-  if (data === null) return true;
-
-  var max = data.length;
-
-  return (max === 1 && data === '~') ||
-         (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
-}
-
-function constructYamlNull() {
-  return null;
-}
-
-function isNull(object) {
-  return object === null;
-}
-
-module.exports = new Type('tag:yaml.org,2002:null', {
-  kind: 'scalar',
-  resolve: resolveYamlNull,
-  construct: constructYamlNull,
-  predicate: isNull,
-  represent: {
-    canonical: function () { return '~';    },
-    lowercase: function () { return 'null'; },
-    uppercase: function () { return 'NULL'; },
-    camelcase: function () { return 'Null'; },
-    empty:     function () { return '';     }
-  },
-  defaultStyle: 'lowercase'
-});
-
-
-/***/ }),
-
-/***/ 19046:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var Type = __nccwpck_require__(6073);
-
-var _hasOwnProperty = Object.prototype.hasOwnProperty;
-var _toString       = Object.prototype.toString;
-
-function resolveYamlOmap(data) {
-  if (data === null) return true;
-
-  var objectKeys = [], index, length, pair, pairKey, pairHasKey,
-      object = data;
-
-  for (index = 0, length = object.length; index < length; index += 1) {
-    pair = object[index];
-    pairHasKey = false;
-
-    if (_toString.call(pair) !== '[object Object]') return false;
-
-    for (pairKey in pair) {
-      if (_hasOwnProperty.call(pair, pairKey)) {
-        if (!pairHasKey) pairHasKey = true;
-        else return false;
-      }
-    }
-
-    if (!pairHasKey) return false;
-
-    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
-    else return false;
-  }
-
-  return true;
-}
-
-function constructYamlOmap(data) {
-  return data !== null ? data : [];
-}
-
-module.exports = new Type('tag:yaml.org,2002:omap', {
-  kind: 'sequence',
-  resolve: resolveYamlOmap,
-  construct: constructYamlOmap
-});
-
-
-/***/ }),
-
-/***/ 96860:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var Type = __nccwpck_require__(6073);
-
-var _toString = Object.prototype.toString;
-
-function resolveYamlPairs(data) {
-  if (data === null) return true;
-
-  var index, length, pair, keys, result,
-      object = data;
-
-  result = new Array(object.length);
-
-  for (index = 0, length = object.length; index < length; index += 1) {
-    pair = object[index];
-
-    if (_toString.call(pair) !== '[object Object]') return false;
-
-    keys = Object.keys(pair);
-
-    if (keys.length !== 1) return false;
-
-    result[index] = [ keys[0], pair[keys[0]] ];
-  }
-
-  return true;
-}
-
-function constructYamlPairs(data) {
-  if (data === null) return [];
-
-  var index, length, pair, keys, result,
-      object = data;
-
-  result = new Array(object.length);
-
-  for (index = 0, length = object.length; index < length; index += 1) {
-    pair = object[index];
-
-    keys = Object.keys(pair);
-
-    result[index] = [ keys[0], pair[keys[0]] ];
-  }
-
-  return result;
-}
-
-module.exports = new Type('tag:yaml.org,2002:pairs', {
-  kind: 'sequence',
-  resolve: resolveYamlPairs,
-  construct: constructYamlPairs
-});
-
-
-/***/ }),
-
-/***/ 67283:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var Type = __nccwpck_require__(6073);
-
-module.exports = new Type('tag:yaml.org,2002:seq', {
-  kind: 'sequence',
-  construct: function (data) { return data !== null ? data : []; }
-});
-
-
-/***/ }),
-
-/***/ 79548:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var Type = __nccwpck_require__(6073);
-
-var _hasOwnProperty = Object.prototype.hasOwnProperty;
-
-function resolveYamlSet(data) {
-  if (data === null) return true;
-
-  var key, object = data;
-
-  for (key in object) {
-    if (_hasOwnProperty.call(object, key)) {
-      if (object[key] !== null) return false;
-    }
-  }
-
-  return true;
-}
-
-function constructYamlSet(data) {
-  return data !== null ? data : {};
-}
-
-module.exports = new Type('tag:yaml.org,2002:set', {
-  kind: 'mapping',
-  resolve: resolveYamlSet,
-  construct: constructYamlSet
-});
-
-
-/***/ }),
-
-/***/ 23619:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var Type = __nccwpck_require__(6073);
-
-module.exports = new Type('tag:yaml.org,2002:str', {
-  kind: 'scalar',
-  construct: function (data) { return data !== null ? data : ''; }
-});
-
-
-/***/ }),
-
-/***/ 99212:
-/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
-
-"use strict";
-
-
-var Type = __nccwpck_require__(6073);
-
-var YAML_DATE_REGEXP = new RegExp(
-  '^([0-9][0-9][0-9][0-9])'          + // [1] year
-  '-([0-9][0-9])'                    + // [2] month
-  '-([0-9][0-9])$');                   // [3] day
-
-var YAML_TIMESTAMP_REGEXP = new RegExp(
-  '^([0-9][0-9][0-9][0-9])'          + // [1] year
-  '-([0-9][0-9]?)'                   + // [2] month
-  '-([0-9][0-9]?)'                   + // [3] day
-  '(?:[Tt]|[ \\t]+)'                 + // ...
-  '([0-9][0-9]?)'                    + // [4] hour
-  ':([0-9][0-9])'                    + // [5] minute
-  ':([0-9][0-9])'                    + // [6] second
-  '(?:\\.([0-9]*))?'                 + // [7] fraction
-  '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
-  '(?::([0-9][0-9]))?))?$');           // [11] tz_minute
-
-function resolveYamlTimestamp(data) {
-  if (data === null) return false;
-  if (YAML_DATE_REGEXP.exec(data) !== null) return true;
-  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
-  return false;
-}
-
-function constructYamlTimestamp(data) {
-  var match, year, month, day, hour, minute, second, fraction = 0,
-      delta = null, tz_hour, tz_minute, date;
-
-  match = YAML_DATE_REGEXP.exec(data);
-  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
-
-  if (match === null) throw new Error('Date resolve error');
-
-  // match: [1] year [2] month [3] day
-
-  year = +(match[1]);
-  month = +(match[2]) - 1; // JS month starts with 0
-  day = +(match[3]);
-
-  if (!match[4]) { // no hour
-    return new Date(Date.UTC(year, month, day));
-  }
-
-  // match: [4] hour [5] minute [6] second [7] fraction
-
-  hour = +(match[4]);
-  minute = +(match[5]);
-  second = +(match[6]);
-
-  if (match[7]) {
-    fraction = match[7].slice(0, 3);
-    while (fraction.length < 3) { // milli-seconds
-      fraction += '0';
-    }
-    fraction = +fraction;
-  }
-
-  // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute
-
-  if (match[9]) {
-    tz_hour = +(match[10]);
-    tz_minute = +(match[11] || 0);
-    delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
-    if (match[9] === '-') delta = -delta;
-  }
-
-  date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
-
-  if (delta) date.setTime(date.getTime() - delta);
-
-  return date;
-}
-
-function representYamlTimestamp(object /*, style*/) {
-  return object.toISOString();
-}
-
-module.exports = new Type('tag:yaml.org,2002:timestamp', {
-  kind: 'scalar',
-  resolve: resolveYamlTimestamp,
-  construct: constructYamlTimestamp,
-  instanceOf: Date,
-  represent: representYamlTimestamp
-});
-
-
 /***/ }),
 
 /***/ 83973:
@@ -48233,6 +74775,8 @@ function Minimatch (pattern, options) {
   }
 
   this.options = options
+  this.maxGlobstarRecursion = options.maxGlobstarRecursion !== undefined
+    ? options.maxGlobstarRecursion : 200
   this.set = []
   this.pattern = pattern
   this.regexp = null
@@ -48481,6 +75025,9 @@ function parse (pattern, isSub) {
           continue
         }
 
+        // coalesce consecutive non-globstar * characters
+        if (c === '*' && stateChar === '*') continue
+
         // if we already have a stateChar, then it means
         // that there was something like ** or +? in there.
         // Handle the stateChar, then proceed with this one.
@@ -48875,19 +75422,163 @@ Minimatch.prototype.match = function match (f, partial) {
 // out of pattern, then that's fine, as long as all
 // the parts match.
 Minimatch.prototype.matchOne = function (file, pattern, partial) {
-  var options = this.options
+  if (pattern.indexOf(GLOBSTAR) !== -1) {
+    return this._matchGlobstar(file, pattern, partial, 0, 0)
+  }
+  return this._matchOne(file, pattern, partial, 0, 0)
+}
 
-  this.debug('matchOne',
-    { 'this': this, file: file, pattern: pattern })
+Minimatch.prototype._matchGlobstar = function (file, pattern, partial, fileIndex, patternIndex) {
+  var i
 
-  this.debug('matchOne', file.length, pattern.length)
+  // find first globstar from patternIndex
+  var firstgs = -1
+  for (i = patternIndex; i < pattern.length; i++) {
+    if (pattern[i] === GLOBSTAR) { firstgs = i; break }
+  }
 
-  for (var fi = 0,
-      pi = 0,
-      fl = file.length,
-      pl = pattern.length
-      ; (fi < fl) && (pi < pl)
-      ; fi++, pi++) {
+  // find last globstar
+  var lastgs = -1
+  for (i = pattern.length - 1; i >= 0; i--) {
+    if (pattern[i] === GLOBSTAR) { lastgs = i; break }
+  }
+
+  var head = pattern.slice(patternIndex, firstgs)
+  var body = partial ? pattern.slice(firstgs + 1) : pattern.slice(firstgs + 1, lastgs)
+  var tail = partial ? [] : pattern.slice(lastgs + 1)
+
+  // check the head
+  if (head.length) {
+    var fileHead = file.slice(fileIndex, fileIndex + head.length)
+    if (!this._matchOne(fileHead, head, partial, 0, 0)) {
+      return false
+    }
+    fileIndex += head.length
+  }
+
+  // check the tail
+  var fileTailMatch = 0
+  if (tail.length) {
+    if (tail.length + fileIndex > file.length) return false
+
+    var tailStart = file.length - tail.length
+    if (this._matchOne(file, tail, partial, tailStart, 0)) {
+      fileTailMatch = tail.length
+    } else {
+      // affordance for stuff like a/**/* matching a/b/
+      if (file[file.length - 1] !== '' ||
+          fileIndex + tail.length === file.length) {
+        return false
+      }
+      tailStart--
+      if (!this._matchOne(file, tail, partial, tailStart, 0)) {
+        return false
+      }
+      fileTailMatch = tail.length + 1
+    }
+  }
+
+  // if body is empty (single ** between head and tail)
+  if (!body.length) {
+    var sawSome = !!fileTailMatch
+    for (i = fileIndex; i < file.length - fileTailMatch; i++) {
+      var f = String(file[i])
+      sawSome = true
+      if (f === '.' || f === '..' ||
+          (!this.options.dot && f.charAt(0) === '.')) {
+        return false
+      }
+    }
+    return partial || sawSome
+  }
+
+  // split body into segments at each GLOBSTAR
+  var bodySegments = [[[], 0]]
+  var currentBody = bodySegments[0]
+  var nonGsParts = 0
+  var nonGsPartsSums = [0]
+  for (var bi = 0; bi < body.length; bi++) {
+    var b = body[bi]
+    if (b === GLOBSTAR) {
+      nonGsPartsSums.push(nonGsParts)
+      currentBody = [[], 0]
+      bodySegments.push(currentBody)
+    } else {
+      currentBody[0].push(b)
+      nonGsParts++
+    }
+  }
+
+  var idx = bodySegments.length - 1
+  var fileLength = file.length - fileTailMatch
+  for (var si = 0; si < bodySegments.length; si++) {
+    bodySegments[si][1] = fileLength -
+      (nonGsPartsSums[idx--] + bodySegments[si][0].length)
+  }
+
+  return !!this._matchGlobStarBodySections(
+    file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch
+  )
+}
+
+// return false for "nope, not matching"
+// return null for "not matching, cannot keep trying"
+Minimatch.prototype._matchGlobStarBodySections = function (
+  file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail
+) {
+  var bs = bodySegments[bodyIndex]
+  if (!bs) {
+    // just make sure there are no bad dots
+    for (var i = fileIndex; i < file.length; i++) {
+      sawTail = true
+      var f = file[i]
+      if (f === '.' || f === '..' ||
+          (!this.options.dot && f.charAt(0) === '.')) {
+        return false
+      }
+    }
+    return sawTail
+  }
+
+  var body = bs[0]
+  var after = bs[1]
+  while (fileIndex <= after) {
+    var m = this._matchOne(
+      file.slice(0, fileIndex + body.length),
+      body,
+      partial,
+      fileIndex,
+      0
+    )
+    // if limit exceeded, no match. intentional false negative,
+    // acceptable break in correctness for security.
+    if (m && globStarDepth < this.maxGlobstarRecursion) {
+      var sub = this._matchGlobStarBodySections(
+        file, bodySegments,
+        fileIndex + body.length, bodyIndex + 1,
+        partial, globStarDepth + 1, sawTail
+      )
+      if (sub !== false) {
+        return sub
+      }
+    }
+    var f = file[fileIndex]
+    if (f === '.' || f === '..' ||
+        (!this.options.dot && f.charAt(0) === '.')) {
+      return false
+    }
+    fileIndex++
+  }
+  return partial || null
+}
+
+Minimatch.prototype._matchOne = function (file, pattern, partial, fileIndex, patternIndex) {
+  var fi, pi, fl, pl
+  for (
+    fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length
+    ; (fi < fl) && (pi < pl)
+    ; fi++, pi++
+  ) {
     this.debug('matchOne loop')
     var p = pattern[pi]
     var f = file[fi]
@@ -48897,87 +75588,7 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
     // should be impossible.
     // some invalid regexp stuff in the set.
     /* istanbul ignore if */
-    if (p === false) return false
-
-    if (p === GLOBSTAR) {
-      this.debug('GLOBSTAR', [pattern, p, f])
-
-      // "**"
-      // a/**/b/**/c would match the following:
-      // a/b/x/y/z/c
-      // a/x/y/z/b/c
-      // a/b/x/b/x/c
-      // a/b/c
-      // To do this, take the rest of the pattern after
-      // the **, and see if it would match the file remainder.
-      // If so, return success.
-      // If not, the ** "swallows" a segment, and try again.
-      // This is recursively awful.
-      //
-      // a/**/b/**/c matching a/b/x/y/z/c
-      // - a matches a
-      // - doublestar
-      //   - matchOne(b/x/y/z/c, b/**/c)
-      //     - b matches b
-      //     - doublestar
-      //       - matchOne(x/y/z/c, c) -> no
-      //       - matchOne(y/z/c, c) -> no
-      //       - matchOne(z/c, c) -> no
-      //       - matchOne(c, c) yes, hit
-      var fr = fi
-      var pr = pi + 1
-      if (pr === pl) {
-        this.debug('** at the end')
-        // a ** at the end will just swallow the rest.
-        // We have found a match.
-        // however, it will not swallow /.x, unless
-        // options.dot is set.
-        // . and .. are *never* matched by **, for explosively
-        // exponential reasons.
-        for (; fi < fl; fi++) {
-          if (file[fi] === '.' || file[fi] === '..' ||
-            (!options.dot && file[fi].charAt(0) === '.')) return false
-        }
-        return true
-      }
-
-      // ok, let's see if we can swallow whatever we can.
-      while (fr < fl) {
-        var swallowee = file[fr]
-
-        this.debug('\nglobstar while', file, fr, pattern, pr, swallowee)
-
-        // XXX remove this slice.  Just pass the start index.
-        if (this.matchOne(file.slice(fr), pattern.slice(pr), partial)) {
-          this.debug('globstar found match!', fr, fl, swallowee)
-          // found a match.
-          return true
-        } else {
-          // can't swallow "." or ".." ever.
-          // can only swallow ".foo" when explicitly asked.
-          if (swallowee === '.' || swallowee === '..' ||
-            (!options.dot && swallowee.charAt(0) === '.')) {
-            this.debug('dot detected!', file, fr, pattern, pr)
-            break
-          }
-
-          // ** swallows a segment, and continue.
-          this.debug('globstar swallow a segment, and continue')
-          fr++
-        }
-      }
-
-      // no match was found.
-      // However, in partial mode, we can't say this is necessarily over.
-      // If there's more *pattern* left, then
-      /* istanbul ignore if */
-      if (partial) {
-        // ran out of file
-        this.debug('\n>>> no match, partial?', file, fr, pattern, pr)
-        if (fr === fl) return true
-      }
-      return false
-    }
+    if (p === false || p === GLOBSTAR) return false
 
     // something other than **
     // non-magic patterns just have to match exactly
@@ -48994,17 +75605,6 @@ Minimatch.prototype.matchOne = function (file, pattern, partial) {
     if (!hit) return false
   }
 
-  // Note: ending in / means that we'll get a final ""
-  // at the end of the pattern.  This can only match a
-  // corresponding "" at the end of the file.
-  // If the file ends in /, then it can only match a
-  // a pattern that ends in /, unless the pattern just
-  // doesn't have any more for it. But, a/b/ should *not*
-  // match "a/b/*", even though "" matches against the
-  // [^/]*? pattern, except in partial mode, where it might
-  // simply not be reached yet.
-  // However, a/b/ should still satisfy a/*
-
   // now either we fell off the end of the pattern, or we're done.
   if (fi === fl && pi === pl) {
     // ran out of pattern and filename at the same time.
@@ -74900,6 +101500,10263 @@ function v4(options, buf, offset) {
 module.exports = v4;
 
 
+/***/ }),
+
+/***/ 95696:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var interfaces_1 = __nccwpck_require__(56417);
+var util_1 = __nccwpck_require__(76195);
+var util_2 = __nccwpck_require__(65282);
+var _1 = __nccwpck_require__(44260);
+var dom_1 = __nccwpck_require__(40770);
+/** @inheritdoc */
+function builder(p1, p2) {
+    var options = formatBuilderOptions(isXMLBuilderCreateOptions(p1) ? p1 : interfaces_1.DefaultBuilderOptions);
+    var nodes = util_2.Guard.isNode(p1) || util_1.isArray(p1) ? p1 : p2;
+    if (nodes === undefined) {
+        throw new Error("Invalid arguments.");
+    }
+    if (util_1.isArray(nodes)) {
+        var builders = [];
+        for (var i = 0; i < nodes.length; i++) {
+            var builder_1 = new _1.XMLBuilderImpl(nodes[i]);
+            builder_1.set(options);
+            builders.push(builder_1);
+        }
+        return builders;
+    }
+    else {
+        var builder_2 = new _1.XMLBuilderImpl(nodes);
+        builder_2.set(options);
+        return builder_2;
+    }
+}
+exports.builder = builder;
+/** @inheritdoc */
+function create(p1, p2) {
+    var options = formatBuilderOptions(p1 === undefined || isXMLBuilderCreateOptions(p1) ?
+        p1 : interfaces_1.DefaultBuilderOptions);
+    var contents = isXMLBuilderCreateOptions(p1) ? p2 : p1;
+    var doc = dom_1.createDocument();
+    setOptions(doc, options);
+    var builder = new _1.XMLBuilderImpl(doc);
+    if (contents !== undefined) {
+        // parse contents
+        builder.ele(contents);
+    }
+    return builder;
+}
+exports.create = create;
+/** @inheritdoc */
+function fragment(p1, p2) {
+    var options = formatBuilderOptions(p1 === undefined || isXMLBuilderCreateOptions(p1) ?
+        p1 : interfaces_1.DefaultBuilderOptions);
+    var contents = isXMLBuilderCreateOptions(p1) ? p2 : p1;
+    var doc = dom_1.createDocument();
+    setOptions(doc, options, true);
+    var builder = new _1.XMLBuilderImpl(doc.createDocumentFragment());
+    if (contents !== undefined) {
+        // parse contents
+        builder.ele(contents);
+    }
+    return builder;
+}
+exports.fragment = fragment;
+/** @inheritdoc */
+function convert(p1, p2, p3) {
+    var builderOptions;
+    var contents;
+    var convertOptions;
+    if (isXMLBuilderCreateOptions(p1) && p2 !== undefined) {
+        builderOptions = p1;
+        contents = p2;
+        convertOptions = p3;
+    }
+    else {
+        builderOptions = interfaces_1.DefaultBuilderOptions;
+        contents = p1;
+        convertOptions = p2 || undefined;
+    }
+    return create(builderOptions, contents).end(convertOptions);
+}
+exports.convert = convert;
+function isXMLBuilderCreateOptions(obj) {
+    if (!util_1.isPlainObject(obj))
+        return false;
+    for (var key in obj) {
+        /* istanbul ignore else */
+        if (obj.hasOwnProperty(key)) {
+            if (!interfaces_1.XMLBuilderOptionKeys.has(key))
+                return false;
+        }
+    }
+    return true;
+}
+function formatBuilderOptions(createOptions) {
+    if (createOptions === void 0) { createOptions = {}; }
+    var options = util_1.applyDefaults(createOptions, interfaces_1.DefaultBuilderOptions);
+    if (options.convert.att.length === 0 ||
+        options.convert.ins.length === 0 ||
+        options.convert.text.length === 0 ||
+        options.convert.cdata.length === 0 ||
+        options.convert.comment.length === 0) {
+        throw new Error("JS object converter strings cannot be zero length.");
+    }
+    return options;
+}
+function setOptions(doc, options, isFragment) {
+    var docWithSettings = doc;
+    docWithSettings._xmlBuilderOptions = options;
+    docWithSettings._isFragment = isFragment;
+}
+//# sourceMappingURL=BuilderFunctions.js.map
+
+/***/ }),
+
+/***/ 10268:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var _1 = __nccwpck_require__(44260);
+/**
+ * Creates an XML builder which serializes the document in chunks.
+ *
+ * @param options - callback builder options
+ *
+ * @returns callback builder
+ */
+function createCB(options) {
+    return new _1.XMLBuilderCBImpl(options);
+}
+exports.createCB = createCB;
+/**
+ * Creates an XML builder which serializes the fragment in chunks.
+ *
+ * @param options - callback builder options
+ *
+ * @returns callback builder
+ */
+function fragmentCB(options) {
+    return new _1.XMLBuilderCBImpl(options, true);
+}
+exports.fragmentCB = fragmentCB;
+//# sourceMappingURL=BuilderFunctionsCB.js.map
+
+/***/ }),
+
+/***/ 71438:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var interfaces_1 = __nccwpck_require__(56417);
+var util_1 = __nccwpck_require__(76195);
+var BuilderFunctions_1 = __nccwpck_require__(95696);
+var algorithm_1 = __nccwpck_require__(61);
+var infra_1 = __nccwpck_require__(84251);
+var NamespacePrefixMap_1 = __nccwpck_require__(90283);
+var LocalNameSet_1 = __nccwpck_require__(19049);
+var util_2 = __nccwpck_require__(65282);
+var XMLCBWriter_1 = __nccwpck_require__(77572);
+var JSONCBWriter_1 = __nccwpck_require__(37525);
+var YAMLCBWriter_1 = __nccwpck_require__(42444);
+var events_1 = __nccwpck_require__(82361);
+/**
+ * Represents a readable XML document stream.
+ */
+var XMLBuilderCBImpl = /** @class */ (function (_super) {
+    __extends(XMLBuilderCBImpl, _super);
+    /**
+     * Initializes a new instance of `XMLStream`.
+     *
+     * @param options - stream writer options
+     * @param fragment - whether to create fragment stream or a document stream
+     *
+     * @returns XML stream
+     */
+    function XMLBuilderCBImpl(options, fragment) {
+        if (fragment === void 0) { fragment = false; }
+        var _this = _super.call(this) || this;
+        _this._hasDeclaration = false;
+        _this._docTypeName = "";
+        _this._hasDocumentElement = false;
+        _this._currentElementSerialized = false;
+        _this._openTags = [];
+        _this._ended = false;
+        _this._fragment = fragment;
+        // provide default options
+        _this._options = util_1.applyDefaults(options || {}, interfaces_1.DefaultXMLBuilderCBOptions);
+        _this._builderOptions = {
+            defaultNamespace: _this._options.defaultNamespace,
+            namespaceAlias: _this._options.namespaceAlias
+        };
+        if (_this._options.format === "json") {
+            _this._writer = new JSONCBWriter_1.JSONCBWriter(_this._options);
+        }
+        else if (_this._options.format === "yaml") {
+            _this._writer = new YAMLCBWriter_1.YAMLCBWriter(_this._options);
+        }
+        else {
+            _this._writer = new XMLCBWriter_1.XMLCBWriter(_this._options);
+        }
+        // automatically create listeners for callbacks passed via options
+        if (_this._options.data !== undefined) {
+            _this.on("data", _this._options.data);
+        }
+        if (_this._options.end !== undefined) {
+            _this.on("end", _this._options.end);
+        }
+        if (_this._options.error !== undefined) {
+            _this.on("error", _this._options.error);
+        }
+        _this._prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap();
+        _this._prefixMap.set("xml", infra_1.namespace.XML);
+        _this._prefixIndex = { value: 1 };
+        _this._push(_this._writer.frontMatter());
+        return _this;
+    }
+    /** @inheritdoc */
+    XMLBuilderCBImpl.prototype.ele = function (p1, p2, p3) {
+        var e_1, _a;
+        // parse if JS object or XML or JSON string
+        if (util_1.isObject(p1) || (util_1.isString(p1) && (/^\s*</.test(p1) || /^\s*[\{\[]/.test(p1) || /^(\s*|(#.*)|(%.*))*---/.test(p1)))) {
+            var frag = BuilderFunctions_1.fragment().set(this._options);
+            try {
+                frag.ele(p1);
+            }
+            catch (err) {
+                this.emit("error", err);
+                return this;
+            }
+            try {
+                for (var _b = __values(frag.node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var node = _c.value;
+                    this._fromNode(node);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return this;
+        }
+        this._serializeOpenTag(true);
+        if (!this._fragment && this._hasDocumentElement && this._writer.level === 0) {
+            this.emit("error", new Error("Document cannot have multiple document element nodes."));
+            return this;
+        }
+        try {
+            this._currentElement = BuilderFunctions_1.fragment(this._builderOptions).ele(p1, p2, p3);
+        }
+        catch (err) {
+            this.emit("error", err);
+            return this;
+        }
+        if (!this._fragment && !this._hasDocumentElement && this._docTypeName !== ""
+            && this._currentElement.node._qualifiedName !== this._docTypeName) {
+            this.emit("error", new Error("Document element name does not match DocType declaration name."));
+            return this;
+        }
+        this._currentElementSerialized = false;
+        if (!this._fragment) {
+            this._hasDocumentElement = true;
+        }
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderCBImpl.prototype.att = function (p1, p2, p3) {
+        if (this._currentElement === undefined) {
+            this.emit("error", new Error("Cannot insert an attribute node as child of a document node."));
+            return this;
+        }
+        try {
+            this._currentElement.att(p1, p2, p3);
+        }
+        catch (err) {
+            this.emit("error", err);
+            return this;
+        }
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderCBImpl.prototype.com = function (content) {
+        this._serializeOpenTag(true);
+        var node;
+        try {
+            node = BuilderFunctions_1.fragment(this._builderOptions).com(content).first().node;
+        }
+        catch (err) {
+            /* istanbul ignore next */
+            this.emit("error", err);
+            /* istanbul ignore next */
+            return this;
+        }
+        if (this._options.wellFormed && (!algorithm_1.xml_isLegalChar(node.data) ||
+            node.data.indexOf("--") !== -1 || node.data.endsWith("-"))) {
+            this.emit("error", new Error("Comment data contains invalid characters (well-formed required)."));
+            return this;
+        }
+        this._push(this._writer.comment(node.data));
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderCBImpl.prototype.txt = function (content) {
+        if (!this._fragment && this._currentElement === undefined) {
+            this.emit("error", new Error("Cannot insert a text node as child of a document node."));
+            return this;
+        }
+        this._serializeOpenTag(true);
+        var node;
+        try {
+            node = BuilderFunctions_1.fragment(this._builderOptions).txt(content).first().node;
+        }
+        catch (err) {
+            /* istanbul ignore next */
+            this.emit("error", err);
+            /* istanbul ignore next */
+            return this;
+        }
+        if (this._options.wellFormed && !algorithm_1.xml_isLegalChar(node.data)) {
+            this.emit("error", new Error("Text data contains invalid characters (well-formed required)."));
+            return this;
+        }
+        var markup = "";
+        if (this._options.noDoubleEncoding) {
+            markup = node.data.replace(/(?!&(lt|gt|amp|apos|quot);)&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;');
+        }
+        else {
+            for (var i = 0; i < node.data.length; i++) {
+                var c = node.data[i];
+                if (c === "&")
+                    markup += "&amp;";
+                else if (c === "<")
+                    markup += "&lt;";
+                else if (c === ">")
+                    markup += "&gt;";
+                else
+                    markup += c;
+            }
+        }
+        this._push(this._writer.text(markup));
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderCBImpl.prototype.ins = function (target, content) {
+        if (content === void 0) { content = ''; }
+        this._serializeOpenTag(true);
+        var node;
+        try {
+            node = BuilderFunctions_1.fragment(this._builderOptions).ins(target, content).first().node;
+        }
+        catch (err) {
+            /* istanbul ignore next */
+            this.emit("error", err);
+            /* istanbul ignore next */
+            return this;
+        }
+        if (this._options.wellFormed && (node.target.indexOf(":") !== -1 || (/^xml$/i).test(node.target))) {
+            this.emit("error", new Error("Processing instruction target contains invalid characters (well-formed required)."));
+            return this;
+        }
+        if (this._options.wellFormed && !algorithm_1.xml_isLegalChar(node.data)) {
+            this.emit("error", Error("Processing instruction data contains invalid characters (well-formed required)."));
+            return this;
+        }
+        this._push(this._writer.instruction(node.target, node.data));
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderCBImpl.prototype.dat = function (content) {
+        this._serializeOpenTag(true);
+        var node;
+        try {
+            node = BuilderFunctions_1.fragment(this._builderOptions).dat(content).first().node;
+        }
+        catch (err) {
+            this.emit("error", err);
+            return this;
+        }
+        this._push(this._writer.cdata(node.data));
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderCBImpl.prototype.dec = function (options) {
+        if (options === void 0) { options = { version: "1.0" }; }
+        if (this._fragment) {
+            this.emit("error", Error("Cannot insert an XML declaration into a document fragment."));
+            return this;
+        }
+        if (this._hasDeclaration) {
+            this.emit("error", Error("XML declaration is already inserted."));
+            return this;
+        }
+        this._push(this._writer.declaration(options.version || "1.0", options.encoding, options.standalone));
+        this._hasDeclaration = true;
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderCBImpl.prototype.dtd = function (options) {
+        if (this._fragment) {
+            this.emit("error", Error("Cannot insert a DocType declaration into a document fragment."));
+            return this;
+        }
+        if (this._docTypeName !== "") {
+            this.emit("error", new Error("DocType declaration is already inserted."));
+            return this;
+        }
+        if (this._hasDocumentElement) {
+            this.emit("error", new Error("Cannot insert DocType declaration after document element."));
+            return this;
+        }
+        var node;
+        try {
+            node = BuilderFunctions_1.create().dtd(options).first().node;
+        }
+        catch (err) {
+            this.emit("error", err);
+            return this;
+        }
+        if (this._options.wellFormed && !algorithm_1.xml_isPubidChar(node.publicId)) {
+            this.emit("error", new Error("DocType public identifier does not match PubidChar construct (well-formed required)."));
+            return this;
+        }
+        if (this._options.wellFormed &&
+            (!algorithm_1.xml_isLegalChar(node.systemId) ||
+                (node.systemId.indexOf('"') !== -1 && node.systemId.indexOf("'") !== -1))) {
+            this.emit("error", new Error("DocType system identifier contains invalid characters (well-formed required)."));
+            return this;
+        }
+        this._docTypeName = options.name;
+        this._push(this._writer.docType(options.name, node.publicId, node.systemId));
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderCBImpl.prototype.up = function () {
+        this._serializeOpenTag(false);
+        this._serializeCloseTag();
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderCBImpl.prototype.end = function () {
+        this._serializeOpenTag(false);
+        while (this._openTags.length > 0) {
+            this._serializeCloseTag();
+        }
+        this._push(null);
+        return this;
+    };
+    /**
+     * Serializes the opening tag of an element node.
+     *
+     * @param hasChildren - whether the element node has child nodes
+     */
+    XMLBuilderCBImpl.prototype._serializeOpenTag = function (hasChildren) {
+        if (this._currentElementSerialized)
+            return;
+        if (this._currentElement === undefined)
+            return;
+        var node = this._currentElement.node;
+        if (this._options.wellFormed && (node.localName.indexOf(":") !== -1 ||
+            !algorithm_1.xml_isName(node.localName))) {
+            this.emit("error", new Error("Node local name contains invalid characters (well-formed required)."));
+            return;
+        }
+        var qualifiedName = "";
+        var ignoreNamespaceDefinitionAttribute = false;
+        var map = this._prefixMap.copy();
+        var localPrefixesMap = {};
+        var localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap);
+        var inheritedNS = this._openTags.length === 0 ? null : this._openTags[this._openTags.length - 1][1];
+        var ns = node.namespaceURI;
+        if (ns === null)
+            ns = inheritedNS;
+        if (inheritedNS === ns) {
+            if (localDefaultNamespace !== null) {
+                ignoreNamespaceDefinitionAttribute = true;
+            }
+            if (ns === infra_1.namespace.XML) {
+                qualifiedName = "xml:" + node.localName;
+            }
+            else {
+                qualifiedName = node.localName;
+            }
+            this._writer.beginElement(qualifiedName);
+            this._push(this._writer.openTagBegin(qualifiedName));
+        }
+        else {
+            var prefix = node.prefix;
+            var candidatePrefix = null;
+            if (prefix !== null || ns !== localDefaultNamespace) {
+                candidatePrefix = map.get(prefix, ns);
+            }
+            if (prefix === "xmlns") {
+                if (this._options.wellFormed) {
+                    this.emit("error", new Error("An element cannot have the 'xmlns' prefix (well-formed required)."));
+                    return;
+                }
+                candidatePrefix = prefix;
+            }
+            if (candidatePrefix !== null) {
+                qualifiedName = candidatePrefix + ':' + node.localName;
+                if (localDefaultNamespace !== null && localDefaultNamespace !== infra_1.namespace.XML) {
+                    inheritedNS = localDefaultNamespace || null;
+                }
+                this._writer.beginElement(qualifiedName);
+                this._push(this._writer.openTagBegin(qualifiedName));
+            }
+            else if (prefix !== null) {
+                if (prefix in localPrefixesMap) {
+                    prefix = this._generatePrefix(ns, map, this._prefixIndex);
+                }
+                map.set(prefix, ns);
+                qualifiedName += prefix + ':' + node.localName;
+                this._writer.beginElement(qualifiedName);
+                this._push(this._writer.openTagBegin(qualifiedName));
+                this._push(this._writer.attribute("xmlns:" + prefix, this._serializeAttributeValue(ns, this._options.wellFormed)));
+                if (localDefaultNamespace !== null) {
+                    inheritedNS = localDefaultNamespace || null;
+                }
+            }
+            else if (localDefaultNamespace === null ||
+                (localDefaultNamespace !== null && localDefaultNamespace !== ns)) {
+                ignoreNamespaceDefinitionAttribute = true;
+                qualifiedName += node.localName;
+                inheritedNS = ns;
+                this._writer.beginElement(qualifiedName);
+                this._push(this._writer.openTagBegin(qualifiedName));
+                this._push(this._writer.attribute("xmlns", this._serializeAttributeValue(ns, this._options.wellFormed)));
+            }
+            else {
+                qualifiedName += node.localName;
+                inheritedNS = ns;
+                this._writer.beginElement(qualifiedName);
+                this._push(this._writer.openTagBegin(qualifiedName));
+            }
+        }
+        this._serializeAttributes(node, map, this._prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, this._options.wellFormed);
+        var isHTML = (ns === infra_1.namespace.HTML);
+        if (isHTML && !hasChildren &&
+            XMLBuilderCBImpl._VoidElementNames.has(node.localName)) {
+            this._push(this._writer.openTagEnd(qualifiedName, true, true));
+            this._writer.endElement(qualifiedName);
+        }
+        else if (!isHTML && !hasChildren) {
+            this._push(this._writer.openTagEnd(qualifiedName, true, false));
+            this._writer.endElement(qualifiedName);
+        }
+        else {
+            this._push(this._writer.openTagEnd(qualifiedName, false, false));
+        }
+        this._currentElementSerialized = true;
+        /**
+         * Save qualified name, original inherited ns, original prefix map, and
+         * hasChildren flag.
+         */
+        this._openTags.push([qualifiedName, inheritedNS, this._prefixMap, hasChildren]);
+        /**
+         * New values of inherited namespace and prefix map will be used while
+         * serializing child nodes. They will be returned to their original values
+         * when this node is closed using the _openTags array item we saved above.
+         */
+        if (this._isPrefixMapModified(this._prefixMap, map)) {
+            this._prefixMap = map;
+        }
+        /**
+         * Calls following this will either serialize child nodes or close this tag.
+         */
+        this._writer.level++;
+    };
+    /**
+     * Serializes the closing tag of an element node.
+     */
+    XMLBuilderCBImpl.prototype._serializeCloseTag = function () {
+        this._writer.level--;
+        var lastEle = this._openTags.pop();
+        /* istanbul ignore next */
+        if (lastEle === undefined) {
+            this.emit("error", new Error("Last element is undefined."));
+            return;
+        }
+        var _a = __read(lastEle, 4), qualifiedName = _a[0], ns = _a[1], map = _a[2], hasChildren = _a[3];
+        /**
+         * Restore original values of inherited namespace and prefix map.
+         */
+        this._prefixMap = map;
+        if (!hasChildren)
+            return;
+        this._push(this._writer.closeTag(qualifiedName));
+        this._writer.endElement(qualifiedName);
+    };
+    /**
+     * Pushes data to internal buffer.
+     *
+     * @param data - data
+     */
+    XMLBuilderCBImpl.prototype._push = function (data) {
+        if (data === null) {
+            this._ended = true;
+            this.emit("end");
+        }
+        else if (this._ended) {
+            this.emit("error", new Error("Cannot push to ended stream."));
+        }
+        else if (data.length !== 0) {
+            this._writer.hasData = true;
+            this.emit("data", data, this._writer.level);
+        }
+    };
+    /**
+     * Reads and serializes an XML tree.
+     *
+     * @param node - root node
+     */
+    XMLBuilderCBImpl.prototype._fromNode = function (node) {
+        var e_2, _a, e_3, _b;
+        if (util_2.Guard.isElementNode(node)) {
+            var name = node.prefix ? node.prefix + ":" + node.localName : node.localName;
+            if (node.namespaceURI !== null) {
+                this.ele(node.namespaceURI, name);
+            }
+            else {
+                this.ele(name);
+            }
+            try {
+                for (var _c = __values(node.attributes), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var attr = _d.value;
+                    var name_1 = attr.prefix ? attr.prefix + ":" + attr.localName : attr.localName;
+                    if (attr.namespaceURI !== null) {
+                        this.att(attr.namespaceURI, name_1, attr.value);
+                    }
+                    else {
+                        this.att(name_1, attr.value);
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            try {
+                for (var _e = __values(node.childNodes), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var child = _f.value;
+                    this._fromNode(child);
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            this.up();
+        }
+        else if (util_2.Guard.isExclusiveTextNode(node) && node.data) {
+            this.txt(node.data);
+        }
+        else if (util_2.Guard.isCommentNode(node)) {
+            this.com(node.data);
+        }
+        else if (util_2.Guard.isCDATASectionNode(node)) {
+            this.dat(node.data);
+        }
+        else if (util_2.Guard.isProcessingInstructionNode(node)) {
+            this.ins(node.target, node.data);
+        }
+    };
+    /**
+     * Produces an XML serialization of the attributes of an element node.
+     *
+     * @param node - node to serialize
+     * @param map - namespace prefix map
+     * @param prefixIndex - generated namespace prefix index
+     * @param localPrefixesMap - local prefixes map
+     * @param ignoreNamespaceDefinitionAttribute - whether to ignore namespace
+     * attributes
+     * @param requireWellFormed - whether to check conformance
+     */
+    XMLBuilderCBImpl.prototype._serializeAttributes = function (node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) {
+        var e_4, _a;
+        var localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined;
+        try {
+            for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var attr = _c.value;
+                // Optimize common case
+                if (!requireWellFormed && !ignoreNamespaceDefinitionAttribute && attr.namespaceURI === null) {
+                    this._push(this._writer.attribute(attr.localName, this._serializeAttributeValue(attr.value, this._options.wellFormed)));
+                    continue;
+                }
+                if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) {
+                    this.emit("error", new Error("Element contains duplicate attributes (well-formed required)."));
+                    return;
+                }
+                if (requireWellFormed && localNameSet)
+                    localNameSet.set(attr.namespaceURI, attr.localName);
+                var attributeNamespace = attr.namespaceURI;
+                var candidatePrefix = null;
+                if (attributeNamespace !== null) {
+                    candidatePrefix = map.get(attr.prefix, attributeNamespace);
+                    if (attributeNamespace === infra_1.namespace.XMLNS) {
+                        if (attr.value === infra_1.namespace.XML ||
+                            (attr.prefix === null && ignoreNamespaceDefinitionAttribute) ||
+                            (attr.prefix !== null && (!(attr.localName in localPrefixesMap) ||
+                                localPrefixesMap[attr.localName] !== attr.value) &&
+                                map.has(attr.localName, attr.value)))
+                            continue;
+                        if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) {
+                            this.emit("error", new Error("XMLNS namespace is reserved (well-formed required)."));
+                            return;
+                        }
+                        if (requireWellFormed && attr.value === '') {
+                            this.emit("error", new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required)."));
+                            return;
+                        }
+                        if (attr.prefix === 'xmlns')
+                            candidatePrefix = 'xmlns';
+                        /**
+                         * _Note:_ The (candidatePrefix === null) check is not in the spec.
+                         * We deviate from the spec here. Otherwise a prefix is generated for
+                         * all attributes with namespaces.
+                         */
+                    }
+                    else if (candidatePrefix === null) {
+                        if (attr.prefix !== null &&
+                            (!map.hasPrefix(attr.prefix) ||
+                                map.has(attr.prefix, attributeNamespace))) {
+                            /**
+                             * Check if we can use the attribute's own prefix.
+                             * We deviate from the spec here.
+                             * TODO: This is not an efficient way of searching for prefixes.
+                             * Follow developments to the spec.
+                             */
+                            candidatePrefix = attr.prefix;
+                        }
+                        else {
+                            candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex);
+                        }
+                        this._push(this._writer.attribute("xmlns:" + candidatePrefix, this._serializeAttributeValue(attributeNamespace, this._options.wellFormed)));
+                    }
+                }
+                if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
+                    !algorithm_1.xml_isName(attr.localName) ||
+                    (attr.localName === "xmlns" && attributeNamespace === null))) {
+                    this.emit("error", new Error("Attribute local name contains invalid characters (well-formed required)."));
+                    return;
+                }
+                this._push(this._writer.attribute((candidatePrefix !== null ? candidatePrefix + ":" : "") + attr.localName, this._serializeAttributeValue(attr.value, this._options.wellFormed)));
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    /**
+     * Produces an XML serialization of an attribute value.
+     *
+     * @param value - attribute value
+     * @param requireWellFormed - whether to check conformance
+     */
+    XMLBuilderCBImpl.prototype._serializeAttributeValue = function (value, requireWellFormed) {
+        if (requireWellFormed && value !== null && !algorithm_1.xml_isLegalChar(value)) {
+            this.emit("error", new Error("Invalid characters in attribute value."));
+            return "";
+        }
+        if (value === null)
+            return "";
+        if (this._options.noDoubleEncoding) {
+            return value.replace(/(?!&(lt|gt|amp|apos|quot);)&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;');
+        }
+        else {
+            var result = "";
+            for (var i = 0; i < value.length; i++) {
+                var c = value[i];
+                if (c === "\"")
+                    result += "&quot;";
+                else if (c === "&")
+                    result += "&amp;";
+                else if (c === "<")
+                    result += "&lt;";
+                else if (c === ">")
+                    result += "&gt;";
+                else
+                    result += c;
+            }
+            return result;
+        }
+    };
+    /**
+     * Records namespace information for the given element and returns the
+     * default namespace attribute value.
+     *
+     * @param node - element node to process
+     * @param map - namespace prefix map
+     * @param localPrefixesMap - local prefixes map
+     */
+    XMLBuilderCBImpl.prototype._recordNamespaceInformation = function (node, map, localPrefixesMap) {
+        var e_5, _a;
+        var defaultNamespaceAttrValue = null;
+        try {
+            for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var attr = _c.value;
+                var attributeNamespace = attr.namespaceURI;
+                var attributePrefix = attr.prefix;
+                if (attributeNamespace === infra_1.namespace.XMLNS) {
+                    if (attributePrefix === null) {
+                        defaultNamespaceAttrValue = attr.value;
+                        continue;
+                    }
+                    else {
+                        var prefixDefinition = attr.localName;
+                        var namespaceDefinition = attr.value;
+                        if (namespaceDefinition === infra_1.namespace.XML) {
+                            continue;
+                        }
+                        if (namespaceDefinition === '') {
+                            namespaceDefinition = null;
+                        }
+                        if (map.has(prefixDefinition, namespaceDefinition)) {
+                            continue;
+                        }
+                        map.set(prefixDefinition, namespaceDefinition);
+                        localPrefixesMap[prefixDefinition] = namespaceDefinition || '';
+                    }
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        return defaultNamespaceAttrValue;
+    };
+    /**
+     * Generates a new prefix for the given namespace.
+     *
+     * @param newNamespace - a namespace to generate prefix for
+     * @param prefixMap - namespace prefix map
+     * @param prefixIndex - generated namespace prefix index
+     */
+    XMLBuilderCBImpl.prototype._generatePrefix = function (newNamespace, prefixMap, prefixIndex) {
+        var generatedPrefix = "ns" + prefixIndex.value;
+        prefixIndex.value++;
+        prefixMap.set(generatedPrefix, newNamespace);
+        return generatedPrefix;
+    };
+    /**
+     * Determines if the namespace prefix map was modified from its original.
+     *
+     * @param originalMap - original namespace prefix map
+     * @param newMap - new namespace prefix map
+     */
+    XMLBuilderCBImpl.prototype._isPrefixMapModified = function (originalMap, newMap) {
+        var items1 = originalMap._items;
+        var items2 = newMap._items;
+        var nullItems1 = originalMap._nullItems;
+        var nullItems2 = newMap._nullItems;
+        for (var key in items2) {
+            var arr1 = items1[key];
+            if (arr1 === undefined)
+                return true;
+            var arr2 = items2[key];
+            if (arr1.length !== arr2.length)
+                return true;
+            for (var i = 0; i < arr1.length; i++) {
+                if (arr1[i] !== arr2[i])
+                    return true;
+            }
+        }
+        if (nullItems1.length !== nullItems2.length)
+            return true;
+        for (var i = 0; i < nullItems1.length; i++) {
+            if (nullItems1[i] !== nullItems2[i])
+                return true;
+        }
+        return false;
+    };
+    XMLBuilderCBImpl._VoidElementNames = new Set(['area', 'base', 'basefont',
+        'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
+        'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
+    return XMLBuilderCBImpl;
+}(events_1.EventEmitter));
+exports.XMLBuilderCBImpl = XMLBuilderCBImpl;
+//# sourceMappingURL=XMLBuilderCBImpl.js.map
+
+/***/ }),
+
+/***/ 48248:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var interfaces_1 = __nccwpck_require__(56417);
+var util_1 = __nccwpck_require__(76195);
+var writers_1 = __nccwpck_require__(17476);
+var interfaces_2 = __nccwpck_require__(27305);
+var util_2 = __nccwpck_require__(65282);
+var algorithm_1 = __nccwpck_require__(61);
+var dom_1 = __nccwpck_require__(40770);
+var infra_1 = __nccwpck_require__(84251);
+var readers_1 = __nccwpck_require__(90560);
+/**
+ * Represents a wrapper that extends XML nodes to implement easy to use and
+ * chainable document builder methods.
+ */
+var XMLBuilderImpl = /** @class */ (function () {
+    /**
+     * Initializes a new instance of `XMLBuilderNodeImpl`.
+     *
+     * @param domNode - the DOM node to wrap
+     */
+    function XMLBuilderImpl(domNode) {
+        this._domNode = domNode;
+    }
+    Object.defineProperty(XMLBuilderImpl.prototype, "node", {
+        /** @inheritdoc */
+        get: function () { return this._domNode; },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(XMLBuilderImpl.prototype, "options", {
+        /** @inheritdoc */
+        get: function () { return this._options; },
+        enumerable: true,
+        configurable: true
+    });
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.set = function (options) {
+        this._options = util_1.applyDefaults(util_1.applyDefaults(this._options, options, true), // apply user settings
+        interfaces_1.DefaultBuilderOptions); // provide defaults
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.ele = function (p1, p2, p3) {
+        var _a, _b, _c;
+        var namespace;
+        var name;
+        var attributes;
+        if (util_1.isObject(p1)) {
+            // ele(obj: ExpandObject)
+            return new readers_1.ObjectReader(this._options).parse(this, p1);
+        }
+        else if (p1 !== null && /^\s*</.test(p1)) {
+            // parse XML document string
+            return new readers_1.XMLReader(this._options).parse(this, p1);
+        }
+        else if (p1 !== null && /^\s*[\{\[]/.test(p1)) {
+            // parse JSON string
+            return new readers_1.JSONReader(this._options).parse(this, p1);
+        }
+        else if (p1 !== null && /^(\s*|(#.*)|(%.*))*---/.test(p1)) {
+            // parse YAML string
+            return new readers_1.YAMLReader(this._options).parse(this, p1);
+        }
+        if ((p1 === null || util_1.isString(p1)) && util_1.isString(p2)) {
+            // ele(namespace: string, name: string, attributes?: AttributesObject)
+            _a = __read([p1, p2, p3], 3), namespace = _a[0], name = _a[1], attributes = _a[2];
+        }
+        else if (p1 !== null) {
+            // ele(name: string, attributes?: AttributesObject)
+            _b = __read([undefined, p1, util_1.isObject(p2) ? p2 : undefined], 3), namespace = _b[0], name = _b[1], attributes = _b[2];
+        }
+        else {
+            throw new Error("Element name cannot be null. " + this._debugInfo());
+        }
+        if (attributes) {
+            attributes = util_1.getValue(attributes);
+        }
+        _c = __read(this._extractNamespace(dom_1.sanitizeInput(namespace, this._options.invalidCharReplacement), dom_1.sanitizeInput(name, this._options.invalidCharReplacement), true), 2), namespace = _c[0], name = _c[1];
+        // inherit namespace from parent
+        if (namespace === undefined) {
+            var _d = __read(algorithm_1.namespace_extractQName(name), 1), prefix = _d[0];
+            namespace = this.node.lookupNamespaceURI(prefix);
+        }
+        // create a child element node
+        var childNode = (namespace !== undefined && namespace !== null ?
+            this._doc.createElementNS(namespace, name) :
+            this._doc.createElement(name));
+        this.node.appendChild(childNode);
+        var builder = new XMLBuilderImpl(childNode);
+        // update doctype node if the new node is the document element node
+        var oldDocType = this._doc.doctype;
+        if (childNode === this._doc.documentElement && oldDocType !== null) {
+            var docType = this._doc.implementation.createDocumentType(this._doc.documentElement.tagName, oldDocType.publicId, oldDocType.systemId);
+            this._doc.replaceChild(docType, oldDocType);
+        }
+        // create attributes
+        if (attributes && !util_1.isEmpty(attributes)) {
+            builder.att(attributes);
+        }
+        return builder;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.remove = function () {
+        var parent = this.up();
+        parent.node.removeChild(this.node);
+        return parent;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.att = function (p1, p2, p3) {
+        var _a, _b, _c;
+        var _this = this;
+        if (util_1.isMap(p1) || util_1.isObject(p1)) {
+            // att(obj: AttributesObject)
+            // expand if object
+            util_1.forEachObject(p1, function (attName, attValue) { return _this.att(attName, attValue); }, this);
+            return this;
+        }
+        // get primitive values
+        if (p1 !== undefined && p1 !== null)
+            p1 = util_1.getValue(p1 + "");
+        if (p2 !== undefined && p2 !== null)
+            p2 = util_1.getValue(p2 + "");
+        if (p3 !== undefined && p3 !== null)
+            p3 = util_1.getValue(p3 + "");
+        var namespace;
+        var name;
+        var value;
+        if ((p1 === null || util_1.isString(p1)) && util_1.isString(p2) && (p3 === null || util_1.isString(p3))) {
+            // att(namespace: string, name: string, value: string)
+            _a = __read([p1, p2, p3], 3), namespace = _a[0], name = _a[1], value = _a[2];
+        }
+        else if (util_1.isString(p1) && (p2 == null || util_1.isString(p2))) {
+            // ele(name: string, value: string)
+            _b = __read([undefined, p1, p2], 3), namespace = _b[0], name = _b[1], value = _b[2];
+        }
+        else {
+            throw new Error("Attribute name and value not specified. " + this._debugInfo());
+        }
+        if (this._options.keepNullAttributes && (value == null)) {
+            // keep null attributes
+            value = "";
+        }
+        else if (value == null) {
+            // skip null|undefined attributes
+            return this;
+        }
+        if (!util_2.Guard.isElementNode(this.node)) {
+            throw new Error("An attribute can only be assigned to an element node.");
+        }
+        var ele = this.node;
+        _c = __read(this._extractNamespace(namespace, name, false), 2), namespace = _c[0], name = _c[1];
+        name = dom_1.sanitizeInput(name, this._options.invalidCharReplacement);
+        namespace = dom_1.sanitizeInput(namespace, this._options.invalidCharReplacement);
+        value = dom_1.sanitizeInput(value, this._options.invalidCharReplacement);
+        var _d = __read(algorithm_1.namespace_extractQName(name), 2), prefix = _d[0], localName = _d[1];
+        var _e = __read(algorithm_1.namespace_extractQName(ele.prefix ? ele.prefix + ':' + ele.localName : ele.localName), 1), elePrefix = _e[0];
+        // check if this is a namespace declaration attribute
+        // assign a new element namespace if it wasn't previously assigned
+        var eleNamespace = null;
+        if (prefix === "xmlns") {
+            namespace = infra_1.namespace.XMLNS;
+            if (ele.namespaceURI === null && elePrefix === localName) {
+                eleNamespace = value;
+            }
+        }
+        else if (prefix === null && localName === "xmlns" && elePrefix === null) {
+            namespace = infra_1.namespace.XMLNS;
+            eleNamespace = value;
+        }
+        // re-create the element node if its namespace changed
+        // we can't simply change the namespaceURI since its read-only
+        if (eleNamespace !== null) {
+            this._updateNamespace(eleNamespace);
+            ele = this.node;
+        }
+        if (namespace !== undefined) {
+            ele.setAttributeNS(namespace, name, value);
+        }
+        else {
+            ele.setAttribute(name, value);
+        }
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.removeAtt = function (p1, p2) {
+        var _this = this;
+        if (!util_2.Guard.isElementNode(this.node)) {
+            throw new Error("An attribute can only be removed from an element node.");
+        }
+        // get primitive values
+        p1 = util_1.getValue(p1);
+        if (p2 !== undefined) {
+            p2 = util_1.getValue(p2);
+        }
+        var namespace;
+        var name;
+        if (p1 !== null && p2 === undefined) {
+            name = p1;
+        }
+        else if ((p1 === null || util_1.isString(p1)) && p2 !== undefined) {
+            namespace = p1;
+            name = p2;
+        }
+        else {
+            throw new Error("Attribute namespace must be a string. " + this._debugInfo());
+        }
+        if (util_1.isArray(name) || util_1.isSet(name)) {
+            // removeAtt(names: string[])
+            // removeAtt(namespace: string, names: string[])
+            util_1.forEachArray(name, function (attName) {
+                return namespace === undefined ? _this.removeAtt(attName) : _this.removeAtt(namespace, attName);
+            }, this);
+        }
+        else if (namespace !== undefined) {
+            // removeAtt(namespace: string, name: string)
+            name = dom_1.sanitizeInput(name, this._options.invalidCharReplacement);
+            namespace = dom_1.sanitizeInput(namespace, this._options.invalidCharReplacement);
+            this.node.removeAttributeNS(namespace, name);
+        }
+        else {
+            // removeAtt(name: string)
+            name = dom_1.sanitizeInput(name, this._options.invalidCharReplacement);
+            this.node.removeAttribute(name);
+        }
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.txt = function (content) {
+        if (content === null || content === undefined) {
+            if (this._options.keepNullNodes) {
+                // keep null nodes
+                content = "";
+            }
+            else {
+                // skip null|undefined nodes
+                return this;
+            }
+        }
+        var child = this._doc.createTextNode(dom_1.sanitizeInput(content, this._options.invalidCharReplacement));
+        this.node.appendChild(child);
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.com = function (content) {
+        if (content === null || content === undefined) {
+            if (this._options.keepNullNodes) {
+                // keep null nodes
+                content = "";
+            }
+            else {
+                // skip null|undefined nodes
+                return this;
+            }
+        }
+        var child = this._doc.createComment(dom_1.sanitizeInput(content, this._options.invalidCharReplacement));
+        this.node.appendChild(child);
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.dat = function (content) {
+        if (content === null || content === undefined) {
+            if (this._options.keepNullNodes) {
+                // keep null nodes
+                content = "";
+            }
+            else {
+                // skip null|undefined nodes
+                return this;
+            }
+        }
+        var child = this._doc.createCDATASection(dom_1.sanitizeInput(content, this._options.invalidCharReplacement));
+        this.node.appendChild(child);
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.ins = function (target, content) {
+        var _this = this;
+        if (content === void 0) { content = ''; }
+        if (content === null || content === undefined) {
+            if (this._options.keepNullNodes) {
+                // keep null nodes
+                content = "";
+            }
+            else {
+                // skip null|undefined nodes
+                return this;
+            }
+        }
+        if (util_1.isArray(target) || util_1.isSet(target)) {
+            util_1.forEachArray(target, function (item) {
+                item += "";
+                var insIndex = item.indexOf(' ');
+                var insTarget = (insIndex === -1 ? item : item.substr(0, insIndex));
+                var insValue = (insIndex === -1 ? '' : item.substr(insIndex + 1));
+                _this.ins(insTarget, insValue);
+            }, this);
+        }
+        else if (util_1.isMap(target) || util_1.isObject(target)) {
+            util_1.forEachObject(target, function (insTarget, insValue) { return _this.ins(insTarget, insValue); }, this);
+        }
+        else {
+            var child = this._doc.createProcessingInstruction(dom_1.sanitizeInput(target, this._options.invalidCharReplacement), dom_1.sanitizeInput(content, this._options.invalidCharReplacement));
+            this.node.appendChild(child);
+        }
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.dec = function (options) {
+        this._options.version = options.version || "1.0";
+        this._options.encoding = options.encoding;
+        this._options.standalone = options.standalone;
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.dtd = function (options) {
+        var name = dom_1.sanitizeInput((options && options.name) || (this._doc.documentElement ? this._doc.documentElement.tagName : "ROOT"), this._options.invalidCharReplacement);
+        var pubID = dom_1.sanitizeInput((options && options.pubID) || "", this._options.invalidCharReplacement);
+        var sysID = dom_1.sanitizeInput((options && options.sysID) || "", this._options.invalidCharReplacement);
+        // name must match document element
+        if (this._doc.documentElement !== null && name !== this._doc.documentElement.tagName) {
+            throw new Error("DocType name does not match document element name.");
+        }
+        // create doctype node
+        var docType = this._doc.implementation.createDocumentType(name, pubID, sysID);
+        if (this._doc.doctype !== null) {
+            // replace existing doctype
+            this._doc.replaceChild(docType, this._doc.doctype);
+        }
+        else {
+            // insert before document element node or append to end
+            this._doc.insertBefore(docType, this._doc.documentElement);
+        }
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.import = function (node) {
+        var e_1, _a;
+        var hostNode = this._domNode;
+        var hostDoc = this._doc;
+        var importedNode = node.node;
+        if (util_2.Guard.isDocumentNode(importedNode)) {
+            // import document node
+            var elementNode = importedNode.documentElement;
+            if (elementNode === null) {
+                throw new Error("Imported document has no document element node. " + this._debugInfo());
+            }
+            var clone = hostDoc.importNode(elementNode, true);
+            hostNode.appendChild(clone);
+            var _b = __read(algorithm_1.namespace_extractQName(clone.prefix ? clone.prefix + ':' + clone.localName : clone.localName), 1), prefix = _b[0];
+            var namespace = hostNode.lookupNamespaceURI(prefix);
+            new XMLBuilderImpl(clone)._updateNamespace(namespace);
+        }
+        else if (util_2.Guard.isDocumentFragmentNode(importedNode)) {
+            try {
+                // import child nodes
+                for (var _c = __values(importedNode.childNodes), _d = _c.next(); !_d.done; _d = _c.next()) {
+                    var childNode = _d.value;
+                    var clone = hostDoc.importNode(childNode, true);
+                    hostNode.appendChild(clone);
+                    if (util_2.Guard.isElementNode(clone)) {
+                        var _e = __read(algorithm_1.namespace_extractQName(clone.prefix ? clone.prefix + ':' + clone.localName : clone.localName), 1), prefix = _e[0];
+                        var namespace = hostNode.lookupNamespaceURI(prefix);
+                        new XMLBuilderImpl(clone)._updateNamespace(namespace);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        else {
+            // import node
+            var clone = hostDoc.importNode(importedNode, true);
+            hostNode.appendChild(clone);
+            if (util_2.Guard.isElementNode(clone)) {
+                var _f = __read(algorithm_1.namespace_extractQName(clone.prefix ? clone.prefix + ':' + clone.localName : clone.localName), 1), prefix = _f[0];
+                var namespace = hostNode.lookupNamespaceURI(prefix);
+                new XMLBuilderImpl(clone)._updateNamespace(namespace);
+            }
+        }
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.doc = function () {
+        if (this._doc._isFragment) {
+            var node = this.node;
+            while (node && node.nodeType !== interfaces_2.NodeType.DocumentFragment) {
+                node = node.parentNode;
+            }
+            /* istanbul ignore next */
+            if (node === null) {
+                throw new Error("Node has no parent node while searching for document fragment ancestor. " + this._debugInfo());
+            }
+            return new XMLBuilderImpl(node);
+        }
+        else {
+            return new XMLBuilderImpl(this._doc);
+        }
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.root = function () {
+        var ele = this._doc.documentElement;
+        if (!ele) {
+            throw new Error("Document root element is null. " + this._debugInfo());
+        }
+        return new XMLBuilderImpl(ele);
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.up = function () {
+        var parent = this._domNode.parentNode;
+        if (!parent) {
+            throw new Error("Parent node is null. " + this._debugInfo());
+        }
+        return new XMLBuilderImpl(parent);
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.prev = function () {
+        var node = this._domNode.previousSibling;
+        if (!node) {
+            throw new Error("Previous sibling node is null. " + this._debugInfo());
+        }
+        return new XMLBuilderImpl(node);
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.next = function () {
+        var node = this._domNode.nextSibling;
+        if (!node) {
+            throw new Error("Next sibling node is null. " + this._debugInfo());
+        }
+        return new XMLBuilderImpl(node);
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.first = function () {
+        var node = this._domNode.firstChild;
+        if (!node) {
+            throw new Error("First child node is null. " + this._debugInfo());
+        }
+        return new XMLBuilderImpl(node);
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.last = function () {
+        var node = this._domNode.lastChild;
+        if (!node) {
+            throw new Error("Last child node is null. " + this._debugInfo());
+        }
+        return new XMLBuilderImpl(node);
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.each = function (callback, self, recursive, thisArg) {
+        if (self === void 0) { self = false; }
+        if (recursive === void 0) { recursive = false; }
+        var result = this._getFirstDescendantNode(this._domNode, self, recursive);
+        while (result[0]) {
+            var nextResult = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]);
+            callback.call(thisArg, new XMLBuilderImpl(result[0]), result[1], result[2]);
+            result = nextResult;
+        }
+        return this;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.map = function (callback, self, recursive, thisArg) {
+        if (self === void 0) { self = false; }
+        if (recursive === void 0) { recursive = false; }
+        var result = [];
+        this.each(function (node, index, level) {
+            return result.push(callback.call(thisArg, node, index, level));
+        }, self, recursive);
+        return result;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.reduce = function (callback, initialValue, self, recursive, thisArg) {
+        if (self === void 0) { self = false; }
+        if (recursive === void 0) { recursive = false; }
+        var value = initialValue;
+        this.each(function (node, index, level) {
+            return value = callback.call(thisArg, value, node, index, level);
+        }, self, recursive);
+        return value;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.find = function (predicate, self, recursive, thisArg) {
+        if (self === void 0) { self = false; }
+        if (recursive === void 0) { recursive = false; }
+        var result = this._getFirstDescendantNode(this._domNode, self, recursive);
+        while (result[0]) {
+            var builder = new XMLBuilderImpl(result[0]);
+            if (predicate.call(thisArg, builder, result[1], result[2])) {
+                return builder;
+            }
+            result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]);
+        }
+        return undefined;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.filter = function (predicate, self, recursive, thisArg) {
+        if (self === void 0) { self = false; }
+        if (recursive === void 0) { recursive = false; }
+        var result = [];
+        this.each(function (node, index, level) {
+            if (predicate.call(thisArg, node, index, level)) {
+                result.push(node);
+            }
+        }, self, recursive);
+        return result;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.every = function (predicate, self, recursive, thisArg) {
+        if (self === void 0) { self = false; }
+        if (recursive === void 0) { recursive = false; }
+        var result = this._getFirstDescendantNode(this._domNode, self, recursive);
+        while (result[0]) {
+            var builder = new XMLBuilderImpl(result[0]);
+            if (!predicate.call(thisArg, builder, result[1], result[2])) {
+                return false;
+            }
+            result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]);
+        }
+        return true;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.some = function (predicate, self, recursive, thisArg) {
+        if (self === void 0) { self = false; }
+        if (recursive === void 0) { recursive = false; }
+        var result = this._getFirstDescendantNode(this._domNode, self, recursive);
+        while (result[0]) {
+            var builder = new XMLBuilderImpl(result[0]);
+            if (predicate.call(thisArg, builder, result[1], result[2])) {
+                return true;
+            }
+            result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]);
+        }
+        return false;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.toArray = function (self, recursive) {
+        if (self === void 0) { self = false; }
+        if (recursive === void 0) { recursive = false; }
+        var result = [];
+        this.each(function (node) { return result.push(node); }, self, recursive);
+        return result;
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.toString = function (writerOptions) {
+        writerOptions = writerOptions || {};
+        if (writerOptions.format === undefined) {
+            writerOptions.format = "xml";
+        }
+        return this._serialize(writerOptions);
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.toObject = function (writerOptions) {
+        writerOptions = writerOptions || {};
+        if (writerOptions.format === undefined) {
+            writerOptions.format = "object";
+        }
+        return this._serialize(writerOptions);
+    };
+    /** @inheritdoc */
+    XMLBuilderImpl.prototype.end = function (writerOptions) {
+        writerOptions = writerOptions || {};
+        if (writerOptions.format === undefined) {
+            writerOptions.format = "xml";
+        }
+        return this.doc()._serialize(writerOptions);
+    };
+    /**
+     * Gets the next descendant of the given node of the tree rooted at `root`
+     * in depth-first pre-order. Returns a three-tuple with
+     * [descendant, descendant_index, descendant_level].
+     *
+     * @param root - root node of the tree
+     * @param self - whether to visit the current node along with child nodes
+     * @param recursive - whether to visit all descendant nodes in tree-order or
+     * only the immediate child nodes
+     */
+    XMLBuilderImpl.prototype._getFirstDescendantNode = function (root, self, recursive) {
+        if (self)
+            return [this._domNode, 0, 0];
+        else if (recursive)
+            return this._getNextDescendantNode(root, root, recursive, 0, 0);
+        else
+            return [this._domNode.firstChild, 0, 1];
+    };
+    /**
+     * Gets the next descendant of the given node of the tree rooted at `root`
+     * in depth-first pre-order. Returns a three-tuple with
+     * [descendant, descendant_index, descendant_level].
+     *
+     * @param root - root node of the tree
+     * @param node - current node
+     * @param recursive - whether to visit all descendant nodes in tree-order or
+     * only the immediate child nodes
+     * @param index - child node index
+     * @param level - current depth of the XML tree
+     */
+    XMLBuilderImpl.prototype._getNextDescendantNode = function (root, node, recursive, index, level) {
+        if (recursive) {
+            // traverse child nodes
+            if (node.firstChild)
+                return [node.firstChild, 0, level + 1];
+            if (node === root)
+                return [null, -1, -1];
+            // traverse siblings
+            if (node.nextSibling)
+                return [node.nextSibling, index + 1, level];
+            // traverse parent's next sibling
+            var parent = node.parentNode;
+            while (parent && parent !== root) {
+                if (parent.nextSibling)
+                    return [parent.nextSibling, algorithm_1.tree_index(parent.nextSibling), level - 1];
+                parent = parent.parentNode;
+                level--;
+            }
+        }
+        else {
+            if (root === node)
+                return [node.firstChild, 0, level + 1];
+            else
+                return [node.nextSibling, index + 1, level];
+        }
+        return [null, -1, -1];
+    };
+    /**
+     * Converts the node into its string or object representation.
+     *
+     * @param options - serialization options
+     */
+    XMLBuilderImpl.prototype._serialize = function (writerOptions) {
+        if (writerOptions.format === "xml") {
+            var writer = new writers_1.XMLWriter(this._options, writerOptions);
+            return writer.serialize(this.node);
+        }
+        else if (writerOptions.format === "map") {
+            var writer = new writers_1.MapWriter(this._options, writerOptions);
+            return writer.serialize(this.node);
+        }
+        else if (writerOptions.format === "object") {
+            var writer = new writers_1.ObjectWriter(this._options, writerOptions);
+            return writer.serialize(this.node);
+        }
+        else if (writerOptions.format === "json") {
+            var writer = new writers_1.JSONWriter(this._options, writerOptions);
+            return writer.serialize(this.node);
+        }
+        else if (writerOptions.format === "yaml") {
+            var writer = new writers_1.YAMLWriter(this._options, writerOptions);
+            return writer.serialize(this.node);
+        }
+        else {
+            throw new Error("Invalid writer format: " + writerOptions.format + ". " + this._debugInfo());
+        }
+    };
+    /**
+     * Extracts a namespace and name from the given string.
+     *
+     * @param namespace - namespace
+     * @param name - a string containing both a name and namespace separated by an
+     * `'@'` character
+     * @param ele - `true` if this is an element namespace; otherwise `false`
+     */
+    XMLBuilderImpl.prototype._extractNamespace = function (namespace, name, ele) {
+        // extract from name
+        var atIndex = name.indexOf("@");
+        if (atIndex > 0) {
+            if (namespace === undefined)
+                namespace = name.slice(atIndex + 1);
+            name = name.slice(0, atIndex);
+        }
+        if (namespace === undefined) {
+            // look-up default namespace
+            namespace = (ele ? this._options.defaultNamespace.ele : this._options.defaultNamespace.att);
+        }
+        else if (namespace !== null && namespace[0] === "@") {
+            // look-up namespace aliases
+            var alias = namespace.slice(1);
+            namespace = this._options.namespaceAlias[alias];
+            if (namespace === undefined) {
+                throw new Error("Namespace alias `" + alias + "` is not defined. " + this._debugInfo());
+            }
+        }
+        return [namespace, name];
+    };
+    /**
+     * Updates the element's namespace.
+     *
+     * @param ns - new namespace
+     */
+    XMLBuilderImpl.prototype._updateNamespace = function (ns) {
+        var e_2, _a, e_3, _b;
+        var ele = this._domNode;
+        if (util_2.Guard.isElementNode(ele) && ns !== null && ele.namespaceURI !== ns) {
+            var _c = __read(algorithm_1.namespace_extractQName(ele.prefix ? ele.prefix + ':' + ele.localName : ele.localName), 2), elePrefix = _c[0], eleLocalName = _c[1];
+            // re-create the element node if its namespace changed
+            // we can't simply change the namespaceURI since its read-only
+            var newEle = algorithm_1.create_element(this._doc, eleLocalName, ns, elePrefix);
+            try {
+                for (var _d = __values(ele.attributes), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var attr = _e.value;
+                    var attrQName = attr.prefix ? attr.prefix + ':' + attr.localName : attr.localName;
+                    var _f = __read(algorithm_1.namespace_extractQName(attrQName), 1), attrPrefix = _f[0];
+                    var newAttrNS = attr.namespaceURI;
+                    if (newAttrNS === null && attrPrefix !== null) {
+                        newAttrNS = ele.lookupNamespaceURI(attrPrefix);
+                    }
+                    if (newAttrNS === null) {
+                        newEle.setAttribute(attrQName, attr.value);
+                    }
+                    else {
+                        newEle.setAttributeNS(newAttrNS, attrQName, attr.value);
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            // replace the new node in parent node
+            var parent = ele.parentNode;
+            /* istanbul ignore next */
+            if (parent === null) {
+                throw new Error("Parent node is null." + this._debugInfo());
+            }
+            parent.replaceChild(newEle, ele);
+            this._domNode = newEle;
+            try {
+                // check child nodes
+                for (var _g = __values(ele.childNodes), _h = _g.next(); !_h.done; _h = _g.next()) {
+                    var childNode = _h.value;
+                    var newChildNode = childNode.cloneNode(true);
+                    newEle.appendChild(newChildNode);
+                    if (util_2.Guard.isElementNode(newChildNode)) {
+                        var _j = __read(algorithm_1.namespace_extractQName(newChildNode.prefix ? newChildNode.prefix + ':' + newChildNode.localName : newChildNode.localName), 1), newChildNodePrefix = _j[0];
+                        var newChildNodeNS = newEle.lookupNamespaceURI(newChildNodePrefix);
+                        new XMLBuilderImpl(newChildNode)._updateNamespace(newChildNodeNS);
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
+    };
+    Object.defineProperty(XMLBuilderImpl.prototype, "_doc", {
+        /**
+         * Returns the document owning this node.
+         */
+        get: function () {
+            var node = this.node;
+            if (util_2.Guard.isDocumentNode(node)) {
+                return node;
+            }
+            else {
+                var docNode = node.ownerDocument;
+                /* istanbul ignore next */
+                if (!docNode)
+                    throw new Error("Owner document is null. " + this._debugInfo());
+                return docNode;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    /**
+     * Returns debug information for this node.
+     *
+     * @param name - node name
+     */
+    XMLBuilderImpl.prototype._debugInfo = function (name) {
+        var node = this.node;
+        var parentNode = node.parentNode;
+        name = name || node.nodeName;
+        var parentName = parentNode ? parentNode.nodeName : '';
+        if (!parentName) {
+            return "node: <" + name + ">";
+        }
+        else {
+            return "node: <" + name + ">, parent: <" + parentName + ">";
+        }
+    };
+    Object.defineProperty(XMLBuilderImpl.prototype, "_options", {
+        /**
+         * Gets or sets builder options.
+         */
+        get: function () {
+            var doc = this._doc;
+            /* istanbul ignore next */
+            if (doc._xmlBuilderOptions === undefined) {
+                throw new Error("Builder options is not set.");
+            }
+            return doc._xmlBuilderOptions;
+        },
+        set: function (value) {
+            var doc = this._doc;
+            doc._xmlBuilderOptions = value;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return XMLBuilderImpl;
+}());
+exports.XMLBuilderImpl = XMLBuilderImpl;
+//# sourceMappingURL=XMLBuilderImpl.js.map
+
+/***/ }),
+
+/***/ 40770:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var dom_1 = __nccwpck_require__(54646);
+var dom_2 = __nccwpck_require__(50633);
+var util_1 = __nccwpck_require__(76195);
+dom_2.dom.setFeatures(false);
+/**
+ * Creates an XML document without any child nodes.
+ */
+function createDocument() {
+    var impl = new dom_1.DOMImplementation();
+    var doc = impl.createDocument(null, 'root', null);
+    /* istanbul ignore else */
+    if (doc.documentElement) {
+        doc.removeChild(doc.documentElement);
+    }
+    return doc;
+}
+exports.createDocument = createDocument;
+/**
+ * Sanitizes input strings with user supplied replacement characters.
+ *
+ * @param str - input string
+ * @param replacement - replacement character or function
+ */
+function sanitizeInput(str, replacement) {
+    if (str == null) {
+        return str;
+    }
+    else if (replacement === undefined) {
+        return str + "";
+    }
+    else {
+        var result = "";
+        str = str + "";
+        for (var i = 0; i < str.length; i++) {
+            var n = str.charCodeAt(i);
+            // #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
+            if (n === 0x9 || n === 0xA || n === 0xD ||
+                (n >= 0x20 && n <= 0xD7FF) ||
+                (n >= 0xE000 && n <= 0xFFFD)) {
+                // valid character - not surrogate pair
+                result += str.charAt(i);
+            }
+            else if (n >= 0xD800 && n <= 0xDBFF && i < str.length - 1) {
+                var n2 = str.charCodeAt(i + 1);
+                if (n2 >= 0xDC00 && n2 <= 0xDFFF) {
+                    // valid surrogate pair
+                    n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000;
+                    result += String.fromCodePoint(n);
+                    i++;
+                }
+                else {
+                    // invalid lone surrogate
+                    result += util_1.isString(replacement) ? replacement : replacement(str.charAt(i), i, str);
+                }
+            }
+            else {
+                // invalid character
+                result += util_1.isString(replacement) ? replacement : replacement(str.charAt(i), i, str);
+            }
+        }
+        return result;
+    }
+}
+exports.sanitizeInput = sanitizeInput;
+//# sourceMappingURL=dom.js.map
+
+/***/ }),
+
+/***/ 44260:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var XMLBuilderImpl_1 = __nccwpck_require__(48248);
+exports.XMLBuilderImpl = XMLBuilderImpl_1.XMLBuilderImpl;
+var XMLBuilderCBImpl_1 = __nccwpck_require__(71438);
+exports.XMLBuilderCBImpl = XMLBuilderCBImpl_1.XMLBuilderCBImpl;
+var BuilderFunctions_1 = __nccwpck_require__(95696);
+exports.builder = BuilderFunctions_1.builder;
+exports.create = BuilderFunctions_1.create;
+exports.fragment = BuilderFunctions_1.fragment;
+exports.convert = BuilderFunctions_1.convert;
+var BuilderFunctionsCB_1 = __nccwpck_require__(10268);
+exports.createCB = BuilderFunctionsCB_1.createCB;
+exports.fragmentCB = BuilderFunctionsCB_1.fragmentCB;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 70151:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var builder_1 = __nccwpck_require__(44260);
+exports.builder = builder_1.builder;
+exports.create = builder_1.create;
+exports.fragment = builder_1.fragment;
+exports.convert = builder_1.convert;
+exports.createCB = builder_1.createCB;
+exports.fragmentCB = builder_1.fragmentCB;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 56417:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+/**
+ * Defines default values for builder options.
+ */
+exports.DefaultBuilderOptions = {
+    version: "1.0",
+    encoding: undefined,
+    standalone: undefined,
+    keepNullNodes: false,
+    keepNullAttributes: false,
+    ignoreConverters: false,
+    convert: {
+        att: "@",
+        ins: "?",
+        text: "#",
+        cdata: "$",
+        comment: "!"
+    },
+    defaultNamespace: {
+        ele: undefined,
+        att: undefined
+    },
+    namespaceAlias: {
+        html: "http://www.w3.org/1999/xhtml",
+        xml: "http://www.w3.org/XML/1998/namespace",
+        xmlns: "http://www.w3.org/2000/xmlns/",
+        mathml: "http://www.w3.org/1998/Math/MathML",
+        svg: "http://www.w3.org/2000/svg",
+        xlink: "http://www.w3.org/1999/xlink"
+    },
+    invalidCharReplacement: undefined,
+    parser: undefined
+};
+/**
+ * Contains keys of `XMLBuilderOptions`.
+ */
+exports.XMLBuilderOptionKeys = new Set(Object.keys(exports.DefaultBuilderOptions));
+/**
+ * Defines default values for builder options.
+ */
+exports.DefaultXMLBuilderCBOptions = {
+    format: "xml",
+    wellFormed: false,
+    prettyPrint: false,
+    indent: "  ",
+    newline: "\n",
+    offset: 0,
+    width: 0,
+    allowEmptyTags: false,
+    spaceBeforeSlash: false,
+    keepNullNodes: false,
+    keepNullAttributes: false,
+    ignoreConverters: false,
+    convert: {
+        att: "@",
+        ins: "?",
+        text: "#",
+        cdata: "$",
+        comment: "!"
+    },
+    defaultNamespace: {
+        ele: undefined,
+        att: undefined
+    },
+    namespaceAlias: {
+        html: "http://www.w3.org/1999/xhtml",
+        xml: "http://www.w3.org/XML/1998/namespace",
+        xmlns: "http://www.w3.org/2000/xmlns/",
+        mathml: "http://www.w3.org/1998/Math/MathML",
+        svg: "http://www.w3.org/2000/svg",
+        xlink: "http://www.w3.org/1999/xlink"
+    }
+};
+//# sourceMappingURL=interfaces.js.map
+
+/***/ }),
+
+/***/ 33396:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var dom_1 = __nccwpck_require__(40770);
+/**
+ * Pre-serializes XML nodes.
+ */
+var BaseReader = /** @class */ (function () {
+    /**
+     * Initializes a new instance of `BaseReader`.
+     *
+     * @param builderOptions - XML builder options
+     */
+    function BaseReader(builderOptions) {
+        this._builderOptions = builderOptions;
+        if (builderOptions.parser) {
+            Object.assign(this, builderOptions.parser);
+        }
+    }
+    BaseReader.prototype._docType = function (parent, name, publicId, systemId) {
+        return parent.dtd({ name: name, pubID: publicId, sysID: systemId });
+    };
+    BaseReader.prototype._comment = function (parent, data) {
+        return parent.com(data);
+    };
+    BaseReader.prototype._text = function (parent, data) {
+        return parent.txt(data);
+    };
+    BaseReader.prototype._instruction = function (parent, target, data) {
+        return parent.ins(target, data);
+    };
+    BaseReader.prototype._cdata = function (parent, data) {
+        return parent.dat(data);
+    };
+    BaseReader.prototype._element = function (parent, namespace, name) {
+        return (namespace === undefined ? parent.ele(name) : parent.ele(namespace, name));
+    };
+    BaseReader.prototype._attribute = function (parent, namespace, name, value) {
+        return (namespace === undefined ? parent.att(name, value) : parent.att(namespace, name, value));
+    };
+    BaseReader.prototype._sanitize = function (str) {
+        return dom_1.sanitizeInput(str, this._builderOptions.invalidCharReplacement);
+    };
+    /**
+     * Main parser function which parses the given object and returns an XMLBuilder.
+     *
+     * @param node - node to recieve parsed content
+     * @param obj - object to parse
+     */
+    BaseReader.prototype.parse = function (node, obj) {
+        return this._parse(node, obj);
+    };
+    /**
+     * Creates a DocType node.
+     * The node will be skipped if the function returns `undefined`.
+     *
+     * @param name - node name
+     * @param publicId - public identifier
+     * @param systemId - system identifier
+     */
+    BaseReader.prototype.docType = function (parent, name, publicId, systemId) {
+        return this._docType(parent, name, publicId, systemId);
+    };
+    /**
+     * Creates a comment node.
+     * The node will be skipped if the function returns `undefined`.
+     *
+     * @param parent - parent node
+     * @param data - node data
+     */
+    BaseReader.prototype.comment = function (parent, data) {
+        return this._comment(parent, data);
+    };
+    /**
+     * Creates a text node.
+     * The node will be skipped if the function returns `undefined`.
+     *
+     * @param parent - parent node
+     * @param data - node data
+     */
+    BaseReader.prototype.text = function (parent, data) {
+        return this._text(parent, data);
+    };
+    /**
+     * Creates a processing instruction node.
+     * The node will be skipped if the function returns `undefined`.
+     *
+     * @param parent - parent node
+     * @param target - instruction target
+     * @param data - node data
+     */
+    BaseReader.prototype.instruction = function (parent, target, data) {
+        return this._instruction(parent, target, data);
+    };
+    /**
+     * Creates a CData section node.
+     * The node will be skipped if the function returns `undefined`.
+     *
+     * @param parent - parent node
+     * @param data - node data
+     */
+    BaseReader.prototype.cdata = function (parent, data) {
+        return this._cdata(parent, data);
+    };
+    /**
+     * Creates an element node.
+     * The node will be skipped if the function returns `undefined`.
+     *
+     * @param parent - parent node
+     * @param namespace - node namespace
+     * @param name - node name
+     */
+    BaseReader.prototype.element = function (parent, namespace, name) {
+        return this._element(parent, namespace, name);
+    };
+    /**
+     * Creates an attribute or namespace declaration.
+     * The node will be skipped if the function returns `undefined`.
+     *
+     * @param parent - parent node
+     * @param namespace - node namespace
+     * @param name - node name
+     * @param value - node value
+     */
+    BaseReader.prototype.attribute = function (parent, namespace, name, value) {
+        return this._attribute(parent, namespace, name, value);
+    };
+    /**
+     * Sanitizes input strings.
+     *
+     * @param str - input string
+     */
+    BaseReader.prototype.sanitize = function (str) {
+        return this._sanitize(str);
+    };
+    return BaseReader;
+}());
+exports.BaseReader = BaseReader;
+//# sourceMappingURL=BaseReader.js.map
+
+/***/ }),
+
+/***/ 43518:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var ObjectReader_1 = __nccwpck_require__(40768);
+var BaseReader_1 = __nccwpck_require__(33396);
+/**
+ * Parses XML nodes from a JSON string.
+ */
+var JSONReader = /** @class */ (function (_super) {
+    __extends(JSONReader, _super);
+    function JSONReader() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * Parses the given document representation.
+     *
+     * @param node - node receive parsed XML nodes
+     * @param str - JSON string to parse
+     */
+    JSONReader.prototype._parse = function (node, str) {
+        return new ObjectReader_1.ObjectReader(this._builderOptions).parse(node, JSON.parse(str));
+    };
+    return JSONReader;
+}(BaseReader_1.BaseReader));
+exports.JSONReader = JSONReader;
+//# sourceMappingURL=JSONReader.js.map
+
+/***/ }),
+
+/***/ 40768:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var util_1 = __nccwpck_require__(76195);
+var BaseReader_1 = __nccwpck_require__(33396);
+/**
+ * Parses XML nodes from objects and arrays.
+ * ES6 maps and sets are also supoorted.
+ */
+var ObjectReader = /** @class */ (function (_super) {
+    __extends(ObjectReader, _super);
+    function ObjectReader() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * Parses the given document representation.
+     *
+     * @param node - node receive parsed XML nodes
+     * @param obj - object to parse
+     */
+    ObjectReader.prototype._parse = function (node, obj) {
+        var _this = this;
+        var options = this._builderOptions;
+        var lastChild = null;
+        if (util_1.isFunction(obj)) {
+            // evaluate if function
+            lastChild = this.parse(node, obj.apply(this));
+        }
+        else if (util_1.isArray(obj) || util_1.isSet(obj)) {
+            util_1.forEachArray(obj, function (item) { return lastChild = _this.parse(node, item); }, this);
+        }
+        else /* if (isMap(obj) || isObject(obj)) */ {
+            // expand if object
+            util_1.forEachObject(obj, function (key, val) {
+                if (util_1.isFunction(val)) {
+                    // evaluate if function
+                    val = val.apply(_this);
+                }
+                if (!options.ignoreConverters && key.indexOf(options.convert.att) === 0) {
+                    // assign attributes
+                    if (key === options.convert.att) {
+                        if (util_1.isArray(val) || util_1.isSet(val)) {
+                            throw new Error("Invalid attribute: " + val.toString() + ". " + node._debugInfo());
+                        }
+                        else /* if (isMap(val) || isObject(val)) */ {
+                            util_1.forEachObject(val, function (attrKey, attrVal) {
+                                lastChild = _this.attribute(node, undefined, _this.sanitize(attrKey), _this.sanitize(attrVal)) || lastChild;
+                            });
+                        }
+                    }
+                    else {
+                        lastChild = _this.attribute(node, undefined, _this.sanitize(key.substr(options.convert.att.length)), _this.sanitize(val)) || lastChild;
+                    }
+                }
+                else if (!options.ignoreConverters && key.indexOf(options.convert.text) === 0) {
+                    // text node
+                    if (util_1.isMap(val) || util_1.isObject(val)) {
+                        // if the key is #text expand child nodes under this node to support mixed content
+                        lastChild = _this.parse(node, val);
+                    }
+                    else {
+                        lastChild = _this.text(node, _this.sanitize(val)) || lastChild;
+                    }
+                }
+                else if (!options.ignoreConverters && key.indexOf(options.convert.cdata) === 0) {
+                    // cdata node
+                    if (util_1.isArray(val) || util_1.isSet(val)) {
+                        util_1.forEachArray(val, function (item) { return lastChild = _this.cdata(node, _this.sanitize(item)) || lastChild; }, _this);
+                    }
+                    else {
+                        lastChild = _this.cdata(node, _this.sanitize(val)) || lastChild;
+                    }
+                }
+                else if (!options.ignoreConverters && key.indexOf(options.convert.comment) === 0) {
+                    // comment node
+                    if (util_1.isArray(val) || util_1.isSet(val)) {
+                        util_1.forEachArray(val, function (item) { return lastChild = _this.comment(node, _this.sanitize(item)) || lastChild; }, _this);
+                    }
+                    else {
+                        lastChild = _this.comment(node, _this.sanitize(val)) || lastChild;
+                    }
+                }
+                else if (!options.ignoreConverters && key.indexOf(options.convert.ins) === 0) {
+                    // processing instruction
+                    if (util_1.isString(val)) {
+                        var insIndex = val.indexOf(' ');
+                        var insTarget = (insIndex === -1 ? val : val.substr(0, insIndex));
+                        var insValue = (insIndex === -1 ? '' : val.substr(insIndex + 1));
+                        lastChild = _this.instruction(node, _this.sanitize(insTarget), _this.sanitize(insValue)) || lastChild;
+                    }
+                    else if (util_1.isArray(val) || util_1.isSet(val)) {
+                        util_1.forEachArray(val, function (item) {
+                            var insIndex = item.indexOf(' ');
+                            var insTarget = (insIndex === -1 ? item : item.substr(0, insIndex));
+                            var insValue = (insIndex === -1 ? '' : item.substr(insIndex + 1));
+                            lastChild = _this.instruction(node, _this.sanitize(insTarget), _this.sanitize(insValue)) || lastChild;
+                        }, _this);
+                    }
+                    else /* if (isMap(target) || isObject(target)) */ {
+                        util_1.forEachObject(val, function (insTarget, insValue) { return lastChild = _this.instruction(node, _this.sanitize(insTarget), _this.sanitize(insValue)) || lastChild; }, _this);
+                    }
+                }
+                else if ((util_1.isArray(val) || util_1.isSet(val)) && util_1.isEmpty(val)) {
+                    // skip empty arrays
+                }
+                else if ((util_1.isMap(val) || util_1.isObject(val)) && util_1.isEmpty(val)) {
+                    // empty objects produce one node
+                    lastChild = _this.element(node, undefined, _this.sanitize(key)) || lastChild;
+                }
+                else if (!options.keepNullNodes && (val == null)) {
+                    // skip null and undefined nodes
+                }
+                else if (util_1.isArray(val) || util_1.isSet(val)) {
+                    // expand list by creating child nodes
+                    util_1.forEachArray(val, function (item) {
+                        var childNode = {};
+                        childNode[key] = item;
+                        lastChild = _this.parse(node, childNode);
+                    }, _this);
+                }
+                else if (util_1.isMap(val) || util_1.isObject(val)) {
+                    // create a parent node
+                    var parent = _this.element(node, undefined, _this.sanitize(key));
+                    if (parent) {
+                        lastChild = parent;
+                        // expand child nodes under parent
+                        _this.parse(parent, val);
+                    }
+                }
+                else if (val != null && val !== '') {
+                    // leaf element node with a single text node
+                    var parent = _this.element(node, undefined, _this.sanitize(key));
+                    if (parent) {
+                        lastChild = parent;
+                        _this.text(parent, _this.sanitize(val));
+                    }
+                }
+                else {
+                    // leaf element node
+                    lastChild = _this.element(node, undefined, _this.sanitize(key)) || lastChild;
+                }
+            }, this);
+        }
+        return lastChild || node;
+    };
+    return ObjectReader;
+}(BaseReader_1.BaseReader));
+exports.ObjectReader = ObjectReader;
+//# sourceMappingURL=ObjectReader.js.map
+
+/***/ }),
+
+/***/ 65044:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var XMLStringLexer_1 = __nccwpck_require__(47061);
+var interfaces_1 = __nccwpck_require__(97707);
+var infra_1 = __nccwpck_require__(84251);
+var algorithm_1 = __nccwpck_require__(61);
+var BaseReader_1 = __nccwpck_require__(33396);
+/**
+ * Parses XML nodes from an XML document string.
+ */
+var XMLReader = /** @class */ (function (_super) {
+    __extends(XMLReader, _super);
+    function XMLReader() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * Parses the given document representation.
+     *
+     * @param node - node receive parsed XML nodes
+     * @param str - XML document string to parse
+     */
+    XMLReader.prototype._parse = function (node, str) {
+        var e_1, _a, e_2, _b;
+        var lexer = new XMLStringLexer_1.XMLStringLexer(str, { skipWhitespaceOnlyText: true });
+        var context = node;
+        var token = lexer.nextToken();
+        while (token.type !== interfaces_1.TokenType.EOF) {
+            switch (token.type) {
+                case interfaces_1.TokenType.Declaration:
+                    var declaration = token;
+                    var version = this.sanitize(declaration.version);
+                    if (version !== "1.0") {
+                        throw new Error("Invalid xml version: " + version);
+                    }
+                    var builderOptions = {
+                        version: version
+                    };
+                    if (declaration.encoding) {
+                        builderOptions.encoding = this.sanitize(declaration.encoding);
+                    }
+                    if (declaration.standalone) {
+                        builderOptions.standalone = (this.sanitize(declaration.standalone) === "yes");
+                    }
+                    context.set(builderOptions);
+                    break;
+                case interfaces_1.TokenType.DocType:
+                    var doctype = token;
+                    context = this.docType(context, this.sanitize(doctype.name), this.sanitize(doctype.pubId), this.sanitize(doctype.sysId)) || context;
+                    break;
+                case interfaces_1.TokenType.CDATA:
+                    var cdata = token;
+                    context = this.cdata(context, this.sanitize(cdata.data)) || context;
+                    break;
+                case interfaces_1.TokenType.Comment:
+                    var comment = token;
+                    context = this.comment(context, this.sanitize(comment.data)) || context;
+                    break;
+                case interfaces_1.TokenType.PI:
+                    var pi = token;
+                    context = this.instruction(context, this.sanitize(pi.target), this.sanitize(pi.data)) || context;
+                    break;
+                case interfaces_1.TokenType.Text:
+                    var text = token;
+                    context = this.text(context, this.sanitize(text.data)) || context;
+                    break;
+                case interfaces_1.TokenType.Element:
+                    var element = token;
+                    var elementName = this.sanitize(element.name);
+                    // inherit namespace from parent
+                    var _c = __read(algorithm_1.namespace_extractQName(elementName), 1), prefix = _c[0];
+                    var namespace = context.node.lookupNamespaceURI(prefix);
+                    // override namespace if there is a namespace declaration
+                    // attribute
+                    // also lookup namespace declaration attributes
+                    var nsDeclarations = {};
+                    try {
+                        for (var _d = (e_1 = void 0, __values(element.attributes)), _e = _d.next(); !_e.done; _e = _d.next()) {
+                            var _f = __read(_e.value, 2), attName = _f[0], attValue = _f[1];
+                            attName = this.sanitize(attName);
+                            attValue = this.sanitize(attValue);
+                            if (attName === "xmlns") {
+                                namespace = attValue;
+                            }
+                            else {
+                                var _g = __read(algorithm_1.namespace_extractQName(attName), 2), attPrefix = _g[0], attLocalName = _g[1];
+                                if (attPrefix === "xmlns") {
+                                    if (attLocalName === prefix) {
+                                        namespace = attValue;
+                                    }
+                                    nsDeclarations[attLocalName] = attValue;
+                                }
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    // create the DOM element node
+                    var elementNode = (namespace !== null ?
+                        this.element(context, namespace, elementName) :
+                        this.element(context, undefined, elementName));
+                    if (elementNode === undefined)
+                        break;
+                    try {
+                        // assign attributes
+                        for (var _h = (e_2 = void 0, __values(element.attributes)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                            var _k = __read(_j.value, 2), attName = _k[0], attValue = _k[1];
+                            attName = this.sanitize(attName);
+                            attValue = this.sanitize(attValue);
+                            var _l = __read(algorithm_1.namespace_extractQName(attName), 2), attPrefix = _l[0], attLocalName = _l[1];
+                            var attNamespace = null;
+                            if (attPrefix === "xmlns" || (attPrefix === null && attLocalName === "xmlns")) {
+                                // namespace declaration attribute
+                                attNamespace = infra_1.namespace.XMLNS;
+                            }
+                            else {
+                                attNamespace = elementNode.node.lookupNamespaceURI(attPrefix);
+                                if (attNamespace !== null && elementNode.node.isDefaultNamespace(attNamespace)) {
+                                    attNamespace = null;
+                                }
+                                else if (attNamespace === null && attPrefix !== null) {
+                                    attNamespace = nsDeclarations[attPrefix] || null;
+                                }
+                            }
+                            if (attNamespace !== null)
+                                this.attribute(elementNode, attNamespace, attName, attValue);
+                            else
+                                this.attribute(elementNode, undefined, attName, attValue);
+                        }
+                    }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                    finally {
+                        try {
+                            if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+                        }
+                        finally { if (e_2) throw e_2.error; }
+                    }
+                    if (!element.selfClosing) {
+                        context = elementNode;
+                    }
+                    break;
+                case interfaces_1.TokenType.ClosingTag:
+                    /* istanbul ignore else */
+                    if (context.node.parentNode) {
+                        context = context.up();
+                    }
+                    break;
+            }
+            token = lexer.nextToken();
+        }
+        return context;
+    };
+    return XMLReader;
+}(BaseReader_1.BaseReader));
+exports.XMLReader = XMLReader;
+//# sourceMappingURL=XMLReader.js.map
+
+/***/ }),
+
+/***/ 12475:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var ObjectReader_1 = __nccwpck_require__(40768);
+var BaseReader_1 = __nccwpck_require__(33396);
+var js_yaml_1 = __nccwpck_require__(10829);
+/**
+ * Parses XML nodes from a YAML string.
+ */
+var YAMLReader = /** @class */ (function (_super) {
+    __extends(YAMLReader, _super);
+    function YAMLReader() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * Parses the given document representation.
+     *
+     * @param node - node receive parsed XML nodes
+     * @param str - YAML string to parse
+     */
+    YAMLReader.prototype._parse = function (node, str) {
+        var result = js_yaml_1.safeLoad(str);
+        /* istanbul ignore next */
+        if (result === undefined) {
+            throw new Error("Unable to parse YAML document.");
+        }
+        return new ObjectReader_1.ObjectReader(this._builderOptions).parse(node, result);
+    };
+    return YAMLReader;
+}(BaseReader_1.BaseReader));
+exports.YAMLReader = YAMLReader;
+//# sourceMappingURL=YAMLReader.js.map
+
+/***/ }),
+
+/***/ 90560:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var XMLReader_1 = __nccwpck_require__(65044);
+exports.XMLReader = XMLReader_1.XMLReader;
+var ObjectReader_1 = __nccwpck_require__(40768);
+exports.ObjectReader = ObjectReader_1.ObjectReader;
+var JSONReader_1 = __nccwpck_require__(43518);
+exports.JSONReader = JSONReader_1.JSONReader;
+var YAMLReader_1 = __nccwpck_require__(12475);
+exports.YAMLReader = YAMLReader_1.YAMLReader;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 50708:
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+/**
+ * Pre-serializes XML nodes.
+ */
+var BaseCBWriter = /** @class */ (function () {
+    /**
+     * Initializes a new instance of `BaseCBWriter`.
+     *
+     * @param builderOptions - XML builder options
+     */
+    function BaseCBWriter(builderOptions) {
+        /**
+         * Gets the current depth of the XML tree.
+         */
+        this.level = 0;
+        this._builderOptions = builderOptions;
+        this._writerOptions = builderOptions;
+    }
+    return BaseCBWriter;
+}());
+exports.BaseCBWriter = BaseCBWriter;
+//# sourceMappingURL=BaseCBWriter.js.map
+
+/***/ }),
+
+/***/ 37644:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var interfaces_1 = __nccwpck_require__(27305);
+var LocalNameSet_1 = __nccwpck_require__(19049);
+var NamespacePrefixMap_1 = __nccwpck_require__(90283);
+var infra_1 = __nccwpck_require__(84251);
+var algorithm_1 = __nccwpck_require__(61);
+/**
+ * Pre-serializes XML nodes.
+ */
+var BaseWriter = /** @class */ (function () {
+    /**
+     * Initializes a new instance of `BaseWriter`.
+     *
+     * @param builderOptions - XML builder options
+     */
+    function BaseWriter(builderOptions) {
+        /**
+         * Gets the current depth of the XML tree.
+         */
+        this.level = 0;
+        this._builderOptions = builderOptions;
+    }
+    /**
+     * Used by derived classes to serialize the XML declaration.
+     *
+     * @param version - a version number string
+     * @param encoding - encoding declaration
+     * @param standalone - standalone document declaration
+     */
+    BaseWriter.prototype.declaration = function (version, encoding, standalone) { };
+    /**
+     * Used by derived classes to serialize a DocType node.
+     *
+     * @param name - node name
+     * @param publicId - public identifier
+     * @param systemId - system identifier
+     */
+    BaseWriter.prototype.docType = function (name, publicId, systemId) { };
+    /**
+     * Used by derived classes to serialize a comment node.
+     *
+     * @param data - node data
+     */
+    BaseWriter.prototype.comment = function (data) { };
+    /**
+     * Used by derived classes to serialize a text node.
+     *
+     * @param data - node data
+     */
+    BaseWriter.prototype.text = function (data) { };
+    /**
+     * Used by derived classes to serialize a processing instruction node.
+     *
+     * @param target - instruction target
+     * @param data - node data
+     */
+    BaseWriter.prototype.instruction = function (target, data) { };
+    /**
+     * Used by derived classes to serialize a CData section node.
+     *
+     * @param data - node data
+     */
+    BaseWriter.prototype.cdata = function (data) { };
+    /**
+     * Used by derived classes to serialize the beginning of the opening tag of an
+     * element node.
+     *
+     * @param name - node name
+     */
+    BaseWriter.prototype.openTagBegin = function (name) { };
+    /**
+     * Used by derived classes to serialize the ending of the opening tag of an
+     * element node.
+     *
+     * @param name - node name
+     * @param selfClosing - whether the element node is self closing
+     * @param voidElement - whether the element node is a HTML void element
+     */
+    BaseWriter.prototype.openTagEnd = function (name, selfClosing, voidElement) { };
+    /**
+     * Used by derived classes to serialize the closing tag of an element node.
+     *
+     * @param name - node name
+     */
+    BaseWriter.prototype.closeTag = function (name) { };
+    /**
+     * Used by derived classes to serialize attributes or namespace declarations.
+     *
+     * @param attributes - attribute array
+     */
+    BaseWriter.prototype.attributes = function (attributes) {
+        var e_1, _a;
+        try {
+            for (var attributes_1 = __values(attributes), attributes_1_1 = attributes_1.next(); !attributes_1_1.done; attributes_1_1 = attributes_1.next()) {
+                var attr = attributes_1_1.value;
+                this.attribute(attr[1] === null ? attr[2] : attr[1] + ':' + attr[2], attr[3]);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (attributes_1_1 && !attributes_1_1.done && (_a = attributes_1.return)) _a.call(attributes_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    };
+    /**
+     * Used by derived classes to serialize an attribute or namespace declaration.
+     *
+     * @param name - node name
+     * @param value - node value
+     */
+    BaseWriter.prototype.attribute = function (name, value) { };
+    /**
+     * Used by derived classes to perform any pre-processing steps before starting
+     * serializing an element node.
+     *
+     * @param name - node name
+     */
+    BaseWriter.prototype.beginElement = function (name) { };
+    /**
+     * Used by derived classes to perform any post-processing steps after
+     * completing serializing an element node.
+     *
+     * @param name - node name
+     */
+    BaseWriter.prototype.endElement = function (name) { };
+    /**
+     * Produces an XML serialization of the given node. The pre-serializer inserts
+     * namespace declarations where necessary and produces qualified names for
+     * nodes and attributes.
+     *
+     * @param node - node to serialize
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype.serializeNode = function (node, requireWellFormed, noDoubleEncoding) {
+        var hasNamespaces = (node._nodeDocument !== undefined && node._nodeDocument._hasNamespaces);
+        this.level = 0;
+        this.currentNode = node;
+        if (hasNamespaces) {
+            /** From: https://w3c.github.io/DOM-Parsing/#xml-serialization
+             *
+             * 1. Let namespace be a context namespace with value null.
+             * The context namespace tracks the XML serialization algorithm's current
+             * default namespace. The context namespace is changed when either an Element
+             * Node has a default namespace declaration, or the algorithm generates a
+             * default namespace declaration for the Element Node to match its own
+             * namespace. The algorithm assumes no namespace (null) to start.
+             * 2. Let prefix map be a new namespace prefix map.
+             * 3. Add the XML namespace with prefix value "xml" to prefix map.
+             * 4. Let prefix index be a generated namespace prefix index with value 1.
+             * The generated namespace prefix index is used to generate a new unique
+             * prefix value when no suitable existing namespace prefix is available to
+             * serialize a node's namespaceURI (or the namespaceURI of one of node's
+             * attributes). See the generate a prefix algorithm.
+             */
+            var namespace = null;
+            var prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap();
+            prefixMap.set("xml", infra_1.namespace.XML);
+            var prefixIndex = { value: 1 };
+            /**
+             * 5. Return the result of running the XML serialization algorithm on node
+             * passing the context namespace namespace, namespace prefix map prefix map,
+             * generated namespace prefix index reference to prefix index, and the
+             * flag require well-formed. If an exception occurs during the execution
+             * of the algorithm, then catch that exception and throw an
+             * "InvalidStateError" DOMException.
+             */
+            this._serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding);
+        }
+        else {
+            this._serializeNode(node, requireWellFormed, noDoubleEncoding);
+        }
+    };
+    /**
+     * Produces an XML serialization of a node.
+     *
+     * @param node - node to serialize
+     * @param namespace - context namespace
+     * @param prefixMap - namespace prefix map
+     * @param prefixIndex - generated namespace prefix index
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeNodeNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding) {
+        this.currentNode = node;
+        switch (node.nodeType) {
+            case interfaces_1.NodeType.Element:
+                this._serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.Document:
+                this._serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.Comment:
+                this._serializeComment(node, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.Text:
+                this._serializeText(node, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.DocumentFragment:
+                this._serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.DocumentType:
+                this._serializeDocumentType(node, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.ProcessingInstruction:
+                this._serializeProcessingInstruction(node, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.CData:
+                this._serializeCData(node, requireWellFormed, noDoubleEncoding);
+                break;
+            default:
+                throw new Error("Unknown node type: " + node.nodeType);
+        }
+    };
+    /**
+     * Produces an XML serialization of a node.
+     *
+     * @param node - node to serialize
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeNode = function (node, requireWellFormed, noDoubleEncoding) {
+        this.currentNode = node;
+        switch (node.nodeType) {
+            case interfaces_1.NodeType.Element:
+                this._serializeElement(node, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.Document:
+                this._serializeDocument(node, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.Comment:
+                this._serializeComment(node, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.Text:
+                this._serializeText(node, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.DocumentFragment:
+                this._serializeDocumentFragment(node, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.DocumentType:
+                this._serializeDocumentType(node, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.ProcessingInstruction:
+                this._serializeProcessingInstruction(node, requireWellFormed, noDoubleEncoding);
+                break;
+            case interfaces_1.NodeType.CData:
+                this._serializeCData(node, requireWellFormed, noDoubleEncoding);
+                break;
+            default:
+                throw new Error("Unknown node type: " + node.nodeType);
+        }
+    };
+    /**
+     * Produces an XML serialization of an element node.
+     *
+     * @param node - node to serialize
+     * @param namespace - context namespace
+     * @param prefixMap - namespace prefix map
+     * @param prefixIndex - generated namespace prefix index
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeElementNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding) {
+        var e_2, _a;
+        var attributes = [];
+        /**
+         * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node
+         *
+         * 1. If the require well-formed flag is set (its value is true), and this
+         * node's localName attribute contains the character ":" (U+003A COLON) or
+         * does not match the XML Name production, then throw an exception; the
+         * serialization of this node would not be a well-formed element.
+         */
+        if (requireWellFormed && (node.localName.indexOf(":") !== -1 ||
+            !algorithm_1.xml_isName(node.localName))) {
+            throw new Error("Node local name contains invalid characters (well-formed required).");
+        }
+        /**
+         * 2. Let markup be the string "<" (U+003C LESS-THAN SIGN).
+         * 3. Let qualified name be an empty string.
+         * 4. Let skip end tag be a boolean flag with value false.
+         * 5. Let ignore namespace definition attribute be a boolean flag with value
+         * false.
+         * 6. Given prefix map, copy a namespace prefix map and let map be the
+         * result.
+         * 7. Let local prefixes map be an empty map. The map has unique Node prefix
+         * strings as its keys, with corresponding namespaceURI Node values as the
+         * map's key values (in this map, the null namespace is represented by the
+         * empty string).
+         *
+         * _Note:_ This map is local to each element. It is used to ensure there
+         * are no conflicting prefixes should a new namespace prefix attribute need
+         * to be generated. It is also used to enable skipping of duplicate prefix
+         * definitions when writing an element's attributes: the map allows the
+         * algorithm to distinguish between a prefix in the namespace prefix map
+         * that might be locally-defined (to the current Element) and one that is
+         * not.
+         * 8. Let local default namespace be the result of recording the namespace
+         * information for node given map and local prefixes map.
+         *
+         * _Note:_ The above step will update map with any found namespace prefix
+         * definitions, add the found prefix definitions to the local prefixes map
+         * and return a local default namespace value defined by a default namespace
+         * attribute if one exists. Otherwise it returns null.
+         * 9. Let inherited ns be a copy of namespace.
+         * 10. Let ns be the value of node's namespaceURI attribute.
+         */
+        var qualifiedName = '';
+        var skipEndTag = false;
+        var ignoreNamespaceDefinitionAttribute = false;
+        var map = prefixMap.copy();
+        var localPrefixesMap = {};
+        var localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap);
+        var inheritedNS = namespace;
+        var ns = node.namespaceURI;
+        /** 11. If inherited ns is equal to ns, then: */
+        if (inheritedNS === ns) {
+            /**
+             * 11.1. If local default namespace is not null, then set ignore
+             * namespace definition attribute to true.
+             */
+            if (localDefaultNamespace !== null) {
+                ignoreNamespaceDefinitionAttribute = true;
+            }
+            /**
+             * 11.2. If ns is the XML namespace, then append to qualified name the
+             * concatenation of the string "xml:" and the value of node's localName.
+             * 11.3. Otherwise, append to qualified name the value of node's
+             * localName. The node's prefix if it exists, is dropped.
+             */
+            if (ns === infra_1.namespace.XML) {
+                qualifiedName = 'xml:' + node.localName;
+            }
+            else {
+                qualifiedName = node.localName;
+            }
+            /** 11.4. Append the value of qualified name to markup. */
+            this.beginElement(qualifiedName);
+            this.openTagBegin(qualifiedName);
+        }
+        else {
+            /**
+             * 12. Otherwise, inherited ns is not equal to ns (the node's own
+             * namespace is different from the context namespace of its parent).
+             * Run these sub-steps:
+             *
+             * 12.1. Let prefix be the value of node's prefix attribute.
+             * 12.2. Let candidate prefix be the result of retrieving a preferred
+             * prefix string prefix from map given namespace ns. The above may return
+             * null if no namespace key ns exists in map.
+             */
+            var prefix = node.prefix;
+            /**
+             * We don't need to run "retrieving a preferred prefix string" algorithm if
+             * the element has no prefix and its namespace matches to the default
+             * namespace.
+             * See: https://github.com/web-platform-tests/wpt/pull/16703
+             */
+            var candidatePrefix = null;
+            if (prefix !== null || ns !== localDefaultNamespace) {
+                candidatePrefix = map.get(prefix, ns);
+            }
+            /**
+             * 12.3. If the value of prefix matches "xmlns", then run the following
+             * steps:
+             */
+            if (prefix === "xmlns") {
+                /**
+                 * 12.3.1. If the require well-formed flag is set, then throw an error.
+                 * An Element with prefix "xmlns" will not legally round-trip in a
+                 * conforming XML parser.
+                 */
+                if (requireWellFormed) {
+                    throw new Error("An element cannot have the 'xmlns' prefix (well-formed required).");
+                }
+                /**
+                 * 12.3.2. Let candidate prefix be the value of prefix.
+                 */
+                candidatePrefix = prefix;
+            }
+            /**
+             * 12.4.Found a suitable namespace prefix: if candidate prefix is not
+             * null (a namespace prefix is defined which maps to ns), then:
+             */
+            if (candidatePrefix !== null) {
+                /**
+                 * The following may serialize a different prefix than the Element's
+                 * existing prefix if it already had one. However, the retrieving a
+                 * preferred prefix string algorithm already tried to match the
+                 * existing prefix if possible.
+                 *
+                 * 12.4.1. Append to qualified name the concatenation of candidate
+                 * prefix, ":" (U+003A COLON), and node's localName. There exists on
+                 * this node or the node's ancestry a namespace prefix definition that
+                 * defines the node's namespace.
+                 * 12.4.2. If the local default namespace is not null (there exists a
+                 * locally-defined default namespace declaration attribute) and its
+                 * value is not the XML namespace, then let inherited ns get the value
+                 * of local default namespace unless the local default namespace is the
+                 * empty string in which case let it get null (the context namespace
+                 * is changed to the declared default, rather than this node's own
+                 * namespace).
+                 *
+                 * _Note:_ Any default namespace definitions or namespace prefixes that
+                 * define the XML namespace are omitted when serializing this node's
+                 * attributes.
+                 */
+                qualifiedName = candidatePrefix + ':' + node.localName;
+                if (localDefaultNamespace !== null && localDefaultNamespace !== infra_1.namespace.XML) {
+                    inheritedNS = localDefaultNamespace || null;
+                }
+                /**
+                 * 12.4.3. Append the value of qualified name to markup.
+                 */
+                this.beginElement(qualifiedName);
+                this.openTagBegin(qualifiedName);
+                /** 12.5. Otherwise, if prefix is not null, then: */
+            }
+            else if (prefix !== null) {
+                /**
+                 * _Note:_ By this step, there is no namespace or prefix mapping
+                 * declaration in this node (or any parent node visited by this
+                 * algorithm) that defines prefix otherwise the step labelled Found
+                 * a suitable namespace prefix would have been followed. The sub-steps
+                 * that follow will create a new namespace prefix declaration for prefix
+                 * and ensure that prefix does not conflict with an existing namespace
+                 * prefix declaration of the same localName in node's attribute list.
+                 *
+                 * 12.5.1. If the local prefixes map contains a key matching prefix,
+                 * then let prefix be the result of generating a prefix providing as
+                 * input map, ns, and prefix index.
+                 */
+                if (prefix in localPrefixesMap) {
+                    prefix = this._generatePrefix(ns, map, prefixIndex);
+                }
+                /**
+                 * 12.5.2. Add prefix to map given namespace ns.
+                 * 12.5.3. Append to qualified name the concatenation of prefix, ":"
+                 * (U+003A COLON), and node's localName.
+                 * 12.5.4. Append the value of qualified name to markup.
+                 */
+                map.set(prefix, ns);
+                qualifiedName += prefix + ':' + node.localName;
+                this.beginElement(qualifiedName);
+                this.openTagBegin(qualifiedName);
+                /**
+                 * 12.5.5. Append the following to markup, in the order listed:
+                 *
+                 * _Note:_ The following serializes a namespace prefix declaration for
+                 * prefix which was just added to the map.
+                 *
+                 * 12.5.5.1. " " (U+0020 SPACE);
+                 * 12.5.5.2. The string "xmlns:";
+                 * 12.5.5.3. The value of prefix;
+                 * 12.5.5.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
+                 * 12.5.5.5. The result of serializing an attribute value given ns and
+                 * the require well-formed flag as input;
+                 * 12.5.5.6. """ (U+0022 QUOTATION MARK).
+                 */
+                attributes.push([null, 'xmlns', prefix,
+                    this._serializeAttributeValue(ns, requireWellFormed, noDoubleEncoding)]);
+                /**
+                 * 12.5.5.7. If local default namespace is not null (there exists a
+                 * locally-defined default namespace declaration attribute), then
+                 * let inherited ns get the value of local default namespace unless the
+                 * local default namespace is the empty string in which case let it get
+                 * null.
+                 */
+                if (localDefaultNamespace !== null) {
+                    inheritedNS = localDefaultNamespace || null;
+                }
+                /**
+                 * 12.6. Otherwise, if local default namespace is null, or local
+                 * default namespace is not null and its value is not equal to ns, then:
+                 */
+            }
+            else if (localDefaultNamespace === null ||
+                (localDefaultNamespace !== null && localDefaultNamespace !== ns)) {
+                /**
+                 * _Note:_ At this point, the namespace for this node still needs to be
+                 * serialized, but there's no prefix (or candidate prefix) available; the
+                 * following uses the default namespace declaration to define the
+                 * namespace--optionally replacing an existing default declaration
+                 * if present.
+                 *
+                 * 12.6.1. Set the ignore namespace definition attribute flag to true.
+                 * 12.6.2. Append to qualified name the value of node's localName.
+                 * 12.6.3. Let the value of inherited ns be ns.
+                 *
+                 * _Note:_ The new default namespace will be used in the serialization
+                 * to define this node's namespace and act as the context namespace for
+                 * its children.
+                 */
+                ignoreNamespaceDefinitionAttribute = true;
+                qualifiedName += node.localName;
+                inheritedNS = ns;
+                /**
+                 * 12.6.4. Append the value of qualified name to markup.
+                 */
+                this.beginElement(qualifiedName);
+                this.openTagBegin(qualifiedName);
+                /**
+                 * 12.6.5. Append the following to markup, in the order listed:
+                 *
+                 * _Note:_ The following serializes the new (or replacement) default
+                 * namespace definition.
+                 *
+                 * 12.6.5.1. " " (U+0020 SPACE);
+                 * 12.6.5.2. The string "xmlns";
+                 * 12.6.5.3. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
+                 * 12.6.5.4. The result of serializing an attribute value given ns
+                 * and the require well-formed flag as input;
+                 * 12.6.5.5. """ (U+0022 QUOTATION MARK).
+                 */
+                attributes.push([null, null, 'xmlns',
+                    this._serializeAttributeValue(ns, requireWellFormed, noDoubleEncoding)]);
+                /**
+                 * 12.7. Otherwise, the node has a local default namespace that matches
+                 * ns. Append to qualified name the value of node's localName, let the
+                 * value of inherited ns be ns, and append the value of qualified name
+                 * to markup.
+                 */
+            }
+            else {
+                qualifiedName += node.localName;
+                inheritedNS = ns;
+                this.beginElement(qualifiedName);
+                this.openTagBegin(qualifiedName);
+            }
+        }
+        /**
+         * 13. Append to markup the result of the XML serialization of node's
+         * attributes given map, prefix index, local prefixes map, ignore namespace
+         * definition attribute flag, and require well-formed flag.
+         */
+        attributes.push.apply(attributes, __spread(this._serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed, noDoubleEncoding)));
+        this.attributes(attributes);
+        /**
+         * 14. If ns is the HTML namespace, and the node's list of children is
+         * empty, and the node's localName matches any one of the following void
+         * elements: "area", "base", "basefont", "bgsound", "br", "col", "embed",
+         * "frame", "hr", "img", "input", "keygen", "link", "menuitem", "meta",
+         * "param", "source", "track", "wbr"; then append the following to markup,
+         * in the order listed:
+         * 14.1. " " (U+0020 SPACE);
+         * 14.2. "/" (U+002F SOLIDUS).
+         * and set the skip end tag flag to true.
+         * 15. If ns is not the HTML namespace, and the node's list of children is
+         * empty, then append "/" (U+002F SOLIDUS) to markup and set the skip end
+         * tag flag to true.
+         * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup.
+         */
+        var isHTML = (ns === infra_1.namespace.HTML);
+        if (isHTML && node.childNodes.length === 0 &&
+            BaseWriter._VoidElementNames.has(node.localName)) {
+            this.openTagEnd(qualifiedName, true, true);
+            this.endElement(qualifiedName);
+            skipEndTag = true;
+        }
+        else if (!isHTML && node.childNodes.length === 0) {
+            this.openTagEnd(qualifiedName, true, false);
+            this.endElement(qualifiedName);
+            skipEndTag = true;
+        }
+        else {
+            this.openTagEnd(qualifiedName, false, false);
+        }
+        /**
+         * 17. If the value of skip end tag is true, then return the value of markup
+         * and skip the remaining steps. The node is a leaf-node.
+         */
+        if (skipEndTag)
+            return;
+        /**
+         * 18. If ns is the HTML namespace, and the node's localName matches the
+         * string "template", then this is a template element. Append to markup the
+         * result of XML serializing a DocumentFragment node given the template
+         * element's template contents (a DocumentFragment), providing inherited
+         * ns, map, prefix index, and the require well-formed flag.
+         *
+         * _Note:_ This allows template content to round-trip, given the rules for
+         * parsing XHTML documents.
+         *
+         * 19. Otherwise, append to markup the result of running the XML
+         * serialization algorithm on each of node's children, in tree order,
+         * providing inherited ns, map, prefix index, and the require well-formed
+         * flag.
+         */
+        if (isHTML && node.localName === "template") {
+            // TODO: serialize template contents
+        }
+        else {
+            try {
+                for (var _b = __values(node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var childNode = _c.value;
+                    this.level++;
+                    this._serializeNodeNS(childNode, inheritedNS, map, prefixIndex, requireWellFormed, noDoubleEncoding);
+                    this.level--;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+        /**
+         * 20. Append the following to markup, in the order listed:
+         * 20.1. "</" (U+003C LESS-THAN SIGN, U+002F SOLIDUS);
+         * 20.2. The value of qualified name;
+         * 20.3. ">" (U+003E GREATER-THAN SIGN).
+         * 21. Return the value of markup.
+         */
+        this.closeTag(qualifiedName);
+        this.endElement(qualifiedName);
+    };
+    /**
+     * Produces an XML serialization of an element node.
+     *
+     * @param node - node to serialize
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeElement = function (node, requireWellFormed, noDoubleEncoding) {
+        var e_3, _a;
+        /**
+         * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node
+         *
+         * 1. If the require well-formed flag is set (its value is true), and this
+         * node's localName attribute contains the character ":" (U+003A COLON) or
+         * does not match the XML Name production, then throw an exception; the
+         * serialization of this node would not be a well-formed element.
+         */
+        if (requireWellFormed && (node.localName.indexOf(":") !== -1 ||
+            !algorithm_1.xml_isName(node.localName))) {
+            throw new Error("Node local name contains invalid characters (well-formed required).");
+        }
+        /**
+         * 2. Let markup be the string "<" (U+003C LESS-THAN SIGN).
+         * 3. Let qualified name be an empty string.
+         * 4. Let skip end tag be a boolean flag with value false.
+         * 5. Let ignore namespace definition attribute be a boolean flag with value
+         * false.
+         * 6. Given prefix map, copy a namespace prefix map and let map be the
+         * result.
+         * 7. Let local prefixes map be an empty map. The map has unique Node prefix
+         * strings as its keys, with corresponding namespaceURI Node values as the
+         * map's key values (in this map, the null namespace is represented by the
+         * empty string).
+         *
+         * _Note:_ This map is local to each element. It is used to ensure there
+         * are no conflicting prefixes should a new namespace prefix attribute need
+         * to be generated. It is also used to enable skipping of duplicate prefix
+         * definitions when writing an element's attributes: the map allows the
+         * algorithm to distinguish between a prefix in the namespace prefix map
+         * that might be locally-defined (to the current Element) and one that is
+         * not.
+         * 8. Let local default namespace be the result of recording the namespace
+         * information for node given map and local prefixes map.
+         *
+         * _Note:_ The above step will update map with any found namespace prefix
+         * definitions, add the found prefix definitions to the local prefixes map
+         * and return a local default namespace value defined by a default namespace
+         * attribute if one exists. Otherwise it returns null.
+         * 9. Let inherited ns be a copy of namespace.
+         * 10. Let ns be the value of node's namespaceURI attribute.
+         */
+        var skipEndTag = false;
+        /** 11. If inherited ns is equal to ns, then: */
+        /**
+         * 11.1. If local default namespace is not null, then set ignore
+         * namespace definition attribute to true.
+         */
+        /**
+         * 11.2. If ns is the XML namespace, then append to qualified name the
+         * concatenation of the string "xml:" and the value of node's localName.
+         * 11.3. Otherwise, append to qualified name the value of node's
+         * localName. The node's prefix if it exists, is dropped.
+         */
+        var qualifiedName = node.localName;
+        /** 11.4. Append the value of qualified name to markup. */
+        this.beginElement(qualifiedName);
+        this.openTagBegin(qualifiedName);
+        /**
+         * 13. Append to markup the result of the XML serialization of node's
+         * attributes given map, prefix index, local prefixes map, ignore namespace
+         * definition attribute flag, and require well-formed flag.
+         */
+        var attributes = this._serializeAttributes(node, requireWellFormed, noDoubleEncoding);
+        this.attributes(attributes);
+        /**
+         * 14. If ns is the HTML namespace, and the node's list of children is
+         * empty, and the node's localName matches any one of the following void
+         * elements: "area", "base", "basefont", "bgsound", "br", "col", "embed",
+         * "frame", "hr", "img", "input", "keygen", "link", "menuitem", "meta",
+         * "param", "source", "track", "wbr"; then append the following to markup,
+         * in the order listed:
+         * 14.1. " " (U+0020 SPACE);
+         * 14.2. "/" (U+002F SOLIDUS).
+         * and set the skip end tag flag to true.
+         * 15. If ns is not the HTML namespace, and the node's list of children is
+         * empty, then append "/" (U+002F SOLIDUS) to markup and set the skip end
+         * tag flag to true.
+         * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup.
+         */
+        if (!node.hasChildNodes()) {
+            this.openTagEnd(qualifiedName, true, false);
+            this.endElement(qualifiedName);
+            skipEndTag = true;
+        }
+        else {
+            this.openTagEnd(qualifiedName, false, false);
+        }
+        /**
+         * 17. If the value of skip end tag is true, then return the value of markup
+         * and skip the remaining steps. The node is a leaf-node.
+         */
+        if (skipEndTag)
+            return;
+        try {
+            /**
+             * 18. If ns is the HTML namespace, and the node's localName matches the
+             * string "template", then this is a template element. Append to markup the
+             * result of XML serializing a DocumentFragment node given the template
+             * element's template contents (a DocumentFragment), providing inherited
+             * ns, map, prefix index, and the require well-formed flag.
+             *
+             * _Note:_ This allows template content to round-trip, given the rules for
+             * parsing XHTML documents.
+             *
+             * 19. Otherwise, append to markup the result of running the XML
+             * serialization algorithm on each of node's children, in tree order,
+             * providing inherited ns, map, prefix index, and the require well-formed
+             * flag.
+             */
+            for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var childNode = _c.value;
+                this.level++;
+                this._serializeNode(childNode, requireWellFormed, noDoubleEncoding);
+                this.level--;
+            }
+        }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_3) throw e_3.error; }
+        }
+        /**
+         * 20. Append the following to markup, in the order listed:
+         * 20.1. "</" (U+003C LESS-THAN SIGN, U+002F SOLIDUS);
+         * 20.2. The value of qualified name;
+         * 20.3. ">" (U+003E GREATER-THAN SIGN).
+         * 21. Return the value of markup.
+         */
+        this.closeTag(qualifiedName);
+        this.endElement(qualifiedName);
+    };
+    /**
+     * Produces an XML serialization of a document node.
+     *
+     * @param node - node to serialize
+     * @param namespace - context namespace
+     * @param prefixMap - namespace prefix map
+     * @param prefixIndex - generated namespace prefix index
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeDocumentNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding) {
+        var e_4, _a;
+        /**
+         * If the require well-formed flag is set (its value is true), and this node
+         * has no documentElement (the documentElement attribute's value is null),
+         * then throw an exception; the serialization of this node would not be a
+         * well-formed document.
+         */
+        if (requireWellFormed && node.documentElement === null) {
+            throw new Error("Missing document element (well-formed required).");
+        }
+        try {
+            /**
+             * Otherwise, run the following steps:
+             * 1. Let serialized document be an empty string.
+             * 2. For each child child of node, in tree order, run the XML
+             * serialization algorithm on the child passing along the provided
+             * arguments, and append the result to serialized document.
+             *
+             * _Note:_ This will serialize any number of ProcessingInstruction and
+             * Comment nodes both before and after the Document's documentElement node,
+             * including at most one DocumentType node. (Text nodes are not allowed as
+             * children of the Document.)
+             *
+             * 3. Return the value of serialized document.
+            */
+            for (var _b = __values(node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var childNode = _c.value;
+                this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding);
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    };
+    /**
+     * Produces an XML serialization of a document node.
+     *
+     * @param node - node to serialize
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeDocument = function (node, requireWellFormed, noDoubleEncoding) {
+        var e_5, _a;
+        /**
+         * If the require well-formed flag is set (its value is true), and this node
+         * has no documentElement (the documentElement attribute's value is null),
+         * then throw an exception; the serialization of this node would not be a
+         * well-formed document.
+         */
+        if (requireWellFormed && node.documentElement === null) {
+            throw new Error("Missing document element (well-formed required).");
+        }
+        try {
+            /**
+             * Otherwise, run the following steps:
+             * 1. Let serialized document be an empty string.
+             * 2. For each child child of node, in tree order, run the XML
+             * serialization algorithm on the child passing along the provided
+             * arguments, and append the result to serialized document.
+             *
+             * _Note:_ This will serialize any number of ProcessingInstruction and
+             * Comment nodes both before and after the Document's documentElement node,
+             * including at most one DocumentType node. (Text nodes are not allowed as
+             * children of the Document.)
+             *
+             * 3. Return the value of serialized document.
+            */
+            for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var childNode = _c.value;
+                this._serializeNode(childNode, requireWellFormed, noDoubleEncoding);
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    };
+    /**
+     * Produces an XML serialization of a comment node.
+     *
+     * @param node - node to serialize
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeComment = function (node, requireWellFormed, noDoubleEncoding) {
+        /**
+         * If the require well-formed flag is set (its value is true), and node's
+         * data contains characters that are not matched by the XML Char production
+         * or contains "--" (two adjacent U+002D HYPHEN-MINUS characters) or that
+         * ends with a "-" (U+002D HYPHEN-MINUS) character, then throw an exception;
+         * the serialization of this node's data would not be well-formed.
+         */
+        if (requireWellFormed && (!algorithm_1.xml_isLegalChar(node.data) ||
+            node.data.indexOf("--") !== -1 || node.data.endsWith("-"))) {
+            throw new Error("Comment data contains invalid characters (well-formed required).");
+        }
+        /**
+         * Otherwise, return the concatenation of "<!--", node's data, and "-->".
+         */
+        this.comment(node.data);
+    };
+    /**
+     * Produces an XML serialization of a text node.
+     *
+     * @param node - node to serialize
+     * @param requireWellFormed - whether to check conformance
+     * @param level - current depth of the XML tree
+     */
+    BaseWriter.prototype._serializeText = function (node, requireWellFormed, noDoubleEncoding) {
+        /**
+         * 1. If the require well-formed flag is set (its value is true), and
+         * node's data contains characters that are not matched by the XML Char
+         * production, then throw an exception; the serialization of this node's
+         * data would not be well-formed.
+         */
+        if (requireWellFormed && !algorithm_1.xml_isLegalChar(node.data)) {
+            throw new Error("Text data contains invalid characters (well-formed required).");
+        }
+        /**
+         * 2. Let markup be the value of node's data.
+         * 3. Replace any occurrences of "&" in markup by "&amp;".
+         * 4. Replace any occurrences of "<" in markup by "&lt;".
+         * 5. Replace any occurrences of ">" in markup by "&gt;".
+         * 6. Return the value of markup.
+         */
+        var markup = "";
+        if (noDoubleEncoding) {
+            markup = node.data.replace(/(?!&(lt|gt|amp|apos|quot);)&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;');
+        }
+        else {
+            for (var i = 0; i < node.data.length; i++) {
+                var c = node.data[i];
+                if (c === "&")
+                    markup += "&amp;";
+                else if (c === "<")
+                    markup += "&lt;";
+                else if (c === ">")
+                    markup += "&gt;";
+                else
+                    markup += c;
+            }
+        }
+        this.text(markup);
+    };
+    /**
+     * Produces an XML serialization of a document fragment node.
+     *
+     * @param node - node to serialize
+     * @param namespace - context namespace
+     * @param prefixMap - namespace prefix map
+     * @param prefixIndex - generated namespace prefix index
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeDocumentFragmentNS = function (node, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding) {
+        var e_6, _a;
+        try {
+            /**
+             * 1. Let markup the empty string.
+             * 2. For each child child of node, in tree order, run the XML serialization
+             * algorithm on the child given namespace, prefix map, a reference to prefix
+             * index, and flag require well-formed. Concatenate the result to markup.
+             * 3. Return the value of markup.
+             */
+            for (var _b = __values(node.childNodes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var childNode = _c.value;
+                this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed, noDoubleEncoding);
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+    };
+    /**
+     * Produces an XML serialization of a document fragment node.
+     *
+     * @param node - node to serialize
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeDocumentFragment = function (node, requireWellFormed, noDoubleEncoding) {
+        var e_7, _a;
+        try {
+            /**
+             * 1. Let markup the empty string.
+             * 2. For each child child of node, in tree order, run the XML serialization
+             * algorithm on the child given namespace, prefix map, a reference to prefix
+             * index, and flag require well-formed. Concatenate the result to markup.
+             * 3. Return the value of markup.
+             */
+            for (var _b = __values(node._children), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var childNode = _c.value;
+                this._serializeNode(childNode, requireWellFormed, noDoubleEncoding);
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+    };
+    /**
+     * Produces an XML serialization of a document type node.
+     *
+     * @param node - node to serialize
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeDocumentType = function (node, requireWellFormed, noDoubleEncoding) {
+        /**
+         * 1. If the require well-formed flag is true and the node's publicId
+         * attribute contains characters that are not matched by the XML PubidChar
+         *  production, then throw an exception; the serialization of this node
+         * would not be a well-formed document type declaration.
+         */
+        if (requireWellFormed && !algorithm_1.xml_isPubidChar(node.publicId)) {
+            throw new Error("DocType public identifier does not match PubidChar construct (well-formed required).");
+        }
+        /**
+         * 2. If the require well-formed flag is true and the node's systemId
+         * attribute contains characters that are not matched by the XML Char
+         * production or that contains both a """ (U+0022 QUOTATION MARK) and a
+         * "'" (U+0027 APOSTROPHE), then throw an exception; the serialization
+         * of this node would not be a well-formed document type declaration.
+         */
+        if (requireWellFormed &&
+            (!algorithm_1.xml_isLegalChar(node.systemId) ||
+                (node.systemId.indexOf('"') !== -1 && node.systemId.indexOf("'") !== -1))) {
+            throw new Error("DocType system identifier contains invalid characters (well-formed required).");
+        }
+        /**
+         * 3. Let markup be an empty string.
+         * 4. Append the string "<!DOCTYPE" to markup.
+         * 5. Append " " (U+0020 SPACE) to markup.
+         * 6. Append the value of the node's name attribute to markup. For a node
+         * belonging to an HTML document, the value will be all lowercase.
+         * 7. If the node's publicId is not the empty string then append the
+         * following, in the order listed, to markup:
+         * 7.1. " " (U+0020 SPACE);
+         * 7.2. The string "PUBLIC";
+         * 7.3. " " (U+0020 SPACE);
+         * 7.4. """ (U+0022 QUOTATION MARK);
+         * 7.5. The value of the node's publicId attribute;
+         * 7.6. """ (U+0022 QUOTATION MARK).
+         * 8. If the node's systemId is not the empty string and the node's publicId
+         * is set to the empty string, then append the following, in the order
+         * listed, to markup:
+         * 8.1. " " (U+0020 SPACE);
+         * 8.2. The string "SYSTEM".
+         * 9. If the node's systemId is not the empty string then append the
+         * following, in the order listed, to markup:
+         * 9.2. " " (U+0020 SPACE);
+         * 9.3. """ (U+0022 QUOTATION MARK);
+         * 9.3. The value of the node's systemId attribute;
+         * 9.4. """ (U+0022 QUOTATION MARK).
+         * 10. Append ">" (U+003E GREATER-THAN SIGN) to markup.
+         * 11. Return the value of markup.
+         */
+        this.docType(node.name, node.publicId, node.systemId);
+    };
+    /**
+     * Produces an XML serialization of a processing instruction node.
+     *
+     * @param node - node to serialize
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeProcessingInstruction = function (node, requireWellFormed, noDoubleEncoding) {
+        /**
+         * 1. If the require well-formed flag is set (its value is true), and node's
+         * target contains a ":" (U+003A COLON) character or is an ASCII
+         * case-insensitive match for the string "xml", then throw an exception;
+         * the serialization of this node's target would not be well-formed.
+         */
+        if (requireWellFormed && (node.target.indexOf(":") !== -1 || (/^xml$/i).test(node.target))) {
+            throw new Error("Processing instruction target contains invalid characters (well-formed required).");
+        }
+        /**
+         * 2. If the require well-formed flag is set (its value is true), and node's
+         * data contains characters that are not matched by the XML Char production
+         * or contains the string "?>" (U+003F QUESTION MARK,
+         * U+003E GREATER-THAN SIGN), then throw an exception; the serialization of
+         * this node's data would not be well-formed.
+         */
+        if (requireWellFormed && (!algorithm_1.xml_isLegalChar(node.data) ||
+            node.data.indexOf("?>") !== -1)) {
+            throw new Error("Processing instruction data contains invalid characters (well-formed required).");
+        }
+        /**
+         * 3. Let markup be the concatenation of the following, in the order listed:
+         * 3.1. "<?" (U+003C LESS-THAN SIGN, U+003F QUESTION MARK);
+         * 3.2. The value of node's target;
+         * 3.3. " " (U+0020 SPACE);
+         * 3.4. The value of node's data;
+         * 3.5. "?>" (U+003F QUESTION MARK, U+003E GREATER-THAN SIGN).
+         * 4. Return the value of markup.
+         */
+        this.instruction(node.target, node.data);
+    };
+    /**
+     * Produces an XML serialization of a CDATA node.
+     *
+     * @param node - node to serialize
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeCData = function (node, requireWellFormed, noDoubleEncoding) {
+        if (requireWellFormed && (node.data.indexOf("]]>") !== -1)) {
+            throw new Error("CDATA contains invalid characters (well-formed required).");
+        }
+        this.cdata(node.data);
+    };
+    /**
+    * Produces an XML serialization of the attributes of an element node.
+    *
+     * @param node - node to serialize
+     * @param map - namespace prefix map
+     * @param prefixIndex - generated namespace prefix index
+     * @param localPrefixesMap - local prefixes map
+     * @param ignoreNamespaceDefinitionAttribute - whether to ignore namespace
+     * attributes
+     * @param requireWellFormed - whether to check conformance
+    */
+    BaseWriter.prototype._serializeAttributesNS = function (node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed, noDoubleEncoding) {
+        var e_8, _a;
+        /**
+         * 1. Let result be the empty string.
+         * 2. Let localname set be a new empty namespace localname set. This
+         * localname set will contain tuples of unique attribute namespaceURI and
+         * localName pairs, and is populated as each attr is processed. This set is
+         * used to [optionally] enforce the well-formed constraint that an element
+         * cannot have two attributes with the same namespaceURI and localName.
+         * This can occur when two otherwise identical attributes on the same
+         * element differ only by their prefix values.
+         */
+        var result = [];
+        var localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined;
+        try {
+            /**
+             * 3. Loop: For each attribute attr in element's attributes, in the order
+             * they are specified in the element's attribute list:
+             */
+            for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var attr = _c.value;
+                // Optimize common case
+                if (!requireWellFormed && !ignoreNamespaceDefinitionAttribute && attr.namespaceURI === null) {
+                    result.push([null, null, attr.localName,
+                        this._serializeAttributeValue(attr.value, requireWellFormed, noDoubleEncoding)]);
+                    continue;
+                }
+                /**
+                 * 3.1. If the require well-formed flag is set (its value is true), and the
+                 * localname set contains a tuple whose values match those of a new tuple
+                 * consisting of attr's namespaceURI attribute and localName attribute,
+                 * then throw an exception; the serialization of this attr would fail to
+                 * produce a well-formed element serialization.
+                 */
+                if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) {
+                    throw new Error("Element contains duplicate attributes (well-formed required).");
+                }
+                /**
+                 * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
+                 * localName attribute, and add it to the localname set.
+                 * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
+                 * 3.4. Let candidate prefix be null.
+                 */
+                if (requireWellFormed && localNameSet)
+                    localNameSet.set(attr.namespaceURI, attr.localName);
+                var attributeNamespace = attr.namespaceURI;
+                var candidatePrefix = null;
+                /** 3.5. If attribute namespace is not null, then run these sub-steps: */
+                if (attributeNamespace !== null) {
+                    /**
+                     * 3.5.1. Let candidate prefix be the result of retrieving a preferred
+                     * prefix string from map given namespace attribute namespace with
+                     * preferred prefix being attr's prefix value.
+                     */
+                    candidatePrefix = map.get(attr.prefix, attributeNamespace);
+                    /**
+                     * 3.5.2. If the value of attribute namespace is the XMLNS namespace,
+                     * then run these steps:
+                     */
+                    if (attributeNamespace === infra_1.namespace.XMLNS) {
+                        /**
+                         * 3.5.2.1. If any of the following are true, then stop running these
+                         * steps and goto Loop to visit the next attribute:
+                         * - the attr's value is the XML namespace;
+                         * _Note:_ The XML namespace cannot be redeclared and survive
+                         * round-tripping (unless it defines the prefix "xml"). To avoid this
+                         * problem, this algorithm always prefixes elements in the XML
+                         * namespace with "xml" and drops any related definitions as seen
+                         * in the above condition.
+                         * - the attr's prefix is null and the ignore namespace definition
+                         * attribute flag is true (the Element's default namespace attribute
+                         * should be skipped);
+                         * - the attr's prefix is not null and either
+                         *   * the attr's localName is not a key contained in the local
+                         *     prefixes map, or
+                         *   * the attr's localName is present in the local prefixes map but
+                         *     the value of the key does not match attr's value
+                         * and furthermore that the attr's localName (as the prefix to find)
+                         * is found in the namespace prefix map given the namespace consisting
+                         * of the attr's value (the current namespace prefix definition was
+                         * exactly defined previously--on an ancestor element not the current
+                         * element whose attributes are being processed).
+                         */
+                        if (attr.value === infra_1.namespace.XML ||
+                            (attr.prefix === null && ignoreNamespaceDefinitionAttribute) ||
+                            (attr.prefix !== null && (!(attr.localName in localPrefixesMap) ||
+                                localPrefixesMap[attr.localName] !== attr.value) &&
+                                map.has(attr.localName, attr.value)))
+                            continue;
+                        /**
+                         * 3.5.2.2. If the require well-formed flag is set (its value is true),
+                         * and the value of attr's value attribute matches the XMLNS
+                         * namespace, then throw an exception; the serialization of this
+                         * attribute would produce invalid XML because the XMLNS namespace
+                         * is reserved and cannot be applied as an element's namespace via
+                         * XML parsing.
+                         *
+                         * _Note:_ DOM APIs do allow creation of elements in the XMLNS
+                         * namespace but with strict qualifications.
+                         */
+                        if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) {
+                            throw new Error("XMLNS namespace is reserved (well-formed required).");
+                        }
+                        /**
+                         * 3.5.2.3. If the require well-formed flag is set (its value is true),
+                         * and the value of attr's value attribute is the empty string, then
+                         * throw an exception; namespace prefix declarations cannot be used
+                         * to undeclare a namespace (use a default namespace declaration
+                         * instead).
+                         */
+                        if (requireWellFormed && attr.value === '') {
+                            throw new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required).");
+                        }
+                        /**
+                         * 3.5.2.4. the attr's prefix matches the string "xmlns", then let
+                         * candidate prefix be the string "xmlns".
+                         */
+                        if (attr.prefix === 'xmlns')
+                            candidatePrefix = 'xmlns';
+                        /**
+                         * 3.5.3. Otherwise, the attribute namespace is not the XMLNS namespace.
+                         * Run these steps:
+                         *
+                         * _Note:_ The (candidatePrefix === null) check is not in the spec.
+                         * We deviate from the spec here. Otherwise a prefix is generated for
+                         * all attributes with namespaces.
+                         */
+                    }
+                    else if (candidatePrefix === null) {
+                        if (attr.prefix !== null &&
+                            (!map.hasPrefix(attr.prefix) ||
+                                map.has(attr.prefix, attributeNamespace))) {
+                            /**
+                             * Check if we can use the attribute's own prefix.
+                             * We deviate from the spec here.
+                             * TODO: This is not an efficient way of searching for prefixes.
+                             * Follow developments to the spec.
+                             */
+                            candidatePrefix = attr.prefix;
+                        }
+                        else {
+                            /**
+                             * 3.5.3.1. Let candidate prefix be the result of generating a prefix
+                             * providing map, attribute namespace, and prefix index as input.
+                             */
+                            candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex);
+                        }
+                        /**
+                         * 3.5.3.2. Append the following to result, in the order listed:
+                         * 3.5.3.2.1. " " (U+0020 SPACE);
+                         * 3.5.3.2.2. The string "xmlns:";
+                         * 3.5.3.2.3. The value of candidate prefix;
+                         * 3.5.3.2.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
+                         * 3.5.3.2.5. The result of serializing an attribute value given
+                         * attribute namespace and the require well-formed flag as input;
+                         * 3.5.3.2.6. """ (U+0022 QUOTATION MARK).
+                        */
+                        result.push([null, "xmlns", candidatePrefix,
+                            this._serializeAttributeValue(attributeNamespace, requireWellFormed, noDoubleEncoding)]);
+                    }
+                }
+                /**
+                 * 3.6. Append a " " (U+0020 SPACE) to result.
+                 * 3.7. If candidate prefix is not null, then append to result the
+                 * concatenation of candidate prefix with ":" (U+003A COLON).
+                 */
+                var attrName = '';
+                if (candidatePrefix !== null) {
+                    attrName = candidatePrefix;
+                }
+                /**
+                 * 3.8. If the require well-formed flag is set (its value is true), and
+                 * this attr's localName attribute contains the character
+                 * ":" (U+003A COLON) or does not match the XML Name production or
+                 * equals "xmlns" and attribute namespace is null, then throw an
+                 * exception; the serialization of this attr would not be a
+                 * well-formed attribute.
+                 */
+                if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
+                    !algorithm_1.xml_isName(attr.localName) ||
+                    (attr.localName === "xmlns" && attributeNamespace === null))) {
+                    throw new Error("Attribute local name contains invalid characters (well-formed required).");
+                }
+                /**
+                 * 3.9. Append the following strings to result, in the order listed:
+                 * 3.9.1. The value of attr's localName;
+                 * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
+                 * 3.9.3. The result of serializing an attribute value given attr's value
+                 * attribute and the require well-formed flag as input;
+                 * 3.9.4. """ (U+0022 QUOTATION MARK).
+                 */
+                result.push([attributeNamespace, candidatePrefix, attr.localName,
+                    this._serializeAttributeValue(attr.value, requireWellFormed, noDoubleEncoding)]);
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        /**
+         * 4. Return the value of result.
+         */
+        return result;
+    };
+    /**
+    * Produces an XML serialization of the attributes of an element node.
+    *
+     * @param node - node to serialize
+     * @param requireWellFormed - whether to check conformance
+    */
+    BaseWriter.prototype._serializeAttributes = function (node, requireWellFormed, noDoubleEncoding) {
+        var e_9, _a;
+        /**
+         * 1. Let result be the empty string.
+         * 2. Let localname set be a new empty namespace localname set. This
+         * localname set will contain tuples of unique attribute namespaceURI and
+         * localName pairs, and is populated as each attr is processed. This set is
+         * used to [optionally] enforce the well-formed constraint that an element
+         * cannot have two attributes with the same namespaceURI and localName.
+         * This can occur when two otherwise identical attributes on the same
+         * element differ only by their prefix values.
+         */
+        var result = [];
+        var localNameSet = requireWellFormed ? {} : undefined;
+        try {
+            /**
+             * 3. Loop: For each attribute attr in element's attributes, in the order
+             * they are specified in the element's attribute list:
+             */
+            for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var attr = _c.value;
+                // Optimize common case
+                if (!requireWellFormed) {
+                    result.push([null, null, attr.localName,
+                        this._serializeAttributeValue(attr.value, requireWellFormed, noDoubleEncoding)]);
+                    continue;
+                }
+                /**
+                 * 3.1. If the require well-formed flag is set (its value is true), and the
+                 * localname set contains a tuple whose values match those of a new tuple
+                 * consisting of attr's namespaceURI attribute and localName attribute,
+                 * then throw an exception; the serialization of this attr would fail to
+                 * produce a well-formed element serialization.
+                 */
+                if (requireWellFormed && localNameSet && (attr.localName in localNameSet)) {
+                    throw new Error("Element contains duplicate attributes (well-formed required).");
+                }
+                /**
+                 * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
+                 * localName attribute, and add it to the localname set.
+                 * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
+                 * 3.4. Let candidate prefix be null.
+                 */
+                /* istanbul ignore else */
+                if (requireWellFormed && localNameSet)
+                    localNameSet[attr.localName] = true;
+                /** 3.5. If attribute namespace is not null, then run these sub-steps: */
+                /**
+                 * 3.6. Append a " " (U+0020 SPACE) to result.
+                 * 3.7. If candidate prefix is not null, then append to result the
+                 * concatenation of candidate prefix with ":" (U+003A COLON).
+                 */
+                /**
+                 * 3.8. If the require well-formed flag is set (its value is true), and
+                 * this attr's localName attribute contains the character
+                 * ":" (U+003A COLON) or does not match the XML Name production or
+                 * equals "xmlns" and attribute namespace is null, then throw an
+                 * exception; the serialization of this attr would not be a
+                 * well-formed attribute.
+                 */
+                if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
+                    !algorithm_1.xml_isName(attr.localName))) {
+                    throw new Error("Attribute local name contains invalid characters (well-formed required).");
+                }
+                /**
+                 * 3.9. Append the following strings to result, in the order listed:
+                 * 3.9.1. The value of attr's localName;
+                 * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
+                 * 3.9.3. The result of serializing an attribute value given attr's value
+                 * attribute and the require well-formed flag as input;
+                 * 3.9.4. """ (U+0022 QUOTATION MARK).
+                 */
+                result.push([null, null, attr.localName,
+                    this._serializeAttributeValue(attr.value, requireWellFormed, noDoubleEncoding)]);
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        /**
+         * 4. Return the value of result.
+         */
+        return result;
+    };
+    /**
+    * Records namespace information for the given element and returns the
+    * default namespace attribute value.
+    *
+    * @param node - element node to process
+    * @param map - namespace prefix map
+    * @param localPrefixesMap - local prefixes map
+    */
+    BaseWriter.prototype._recordNamespaceInformation = function (node, map, localPrefixesMap) {
+        var e_10, _a;
+        /**
+         * 1. Let default namespace attr value be null.
+         */
+        var defaultNamespaceAttrValue = null;
+        try {
+            /**
+             * 2. Main: For each attribute attr in element's attributes, in the order
+             * they are specified in the element's attribute list:
+             */
+            for (var _b = __values(node.attributes), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var attr = _c.value;
+                /**
+                 * _Note:_ The following conditional steps find namespace prefixes. Only
+                 * attributes in the XMLNS namespace are considered (e.g., attributes made
+                 * to look like namespace declarations via
+                 * setAttribute("xmlns:pretend-prefix", "pretend-namespace") are not
+                 * included).
+                 */
+                /** 2.1. Let attribute namespace be the value of attr's namespaceURI value. */
+                var attributeNamespace = attr.namespaceURI;
+                /** 2.2. Let attribute prefix be the value of attr's prefix. */
+                var attributePrefix = attr.prefix;
+                /** 2.3. If the attribute namespace is the XMLNS namespace, then: */
+                if (attributeNamespace === infra_1.namespace.XMLNS) {
+                    /**
+                     * 2.3.1. If attribute prefix is null, then attr is a default namespace
+                     * declaration. Set the default namespace attr value to attr's value and
+                     * stop running these steps, returning to Main to visit the next
+                     * attribute.
+                     */
+                    if (attributePrefix === null) {
+                        defaultNamespaceAttrValue = attr.value;
+                        continue;
+                        /**
+                         * 2.3.2. Otherwise, the attribute prefix is not null and attr is a
+                         * namespace prefix definition. Run the following steps:
+                         */
+                    }
+                    else {
+                        /** 2.3.2.1. Let prefix definition be the value of attr's localName. */
+                        var prefixDefinition = attr.localName;
+                        /** 2.3.2.2. Let namespace definition be the value of attr's value. */
+                        var namespaceDefinition = attr.value;
+                        /**
+                         * 2.3.2.3. If namespace definition is the XML namespace, then stop
+                         * running these steps, and return to Main to visit the next
+                         * attribute.
+                         *
+                         * _Note:_ XML namespace definitions in prefixes are completely
+                         * ignored (in order to avoid unnecessary work when there might be
+                         * prefix conflicts). XML namespaced elements are always handled
+                         * uniformly by prefixing (and overriding if necessary) the element's
+                         * localname with the reserved "xml" prefix.
+                         */
+                        if (namespaceDefinition === infra_1.namespace.XML) {
+                            continue;
+                        }
+                        /**
+                         * 2.3.2.4. If namespace definition is the empty string (the
+                         * declarative form of having no namespace), then let namespace
+                         * definition be null instead.
+                         */
+                        if (namespaceDefinition === '') {
+                            namespaceDefinition = null;
+                        }
+                        /**
+                         * 2.3.2.5. If prefix definition is found in map given the namespace
+                         * namespace definition, then stop running these steps, and return to
+                         * Main to visit the next attribute.
+                         *
+                         * _Note:_ This step avoids adding duplicate prefix definitions for
+                         * the same namespace in the map. This has the side-effect of avoiding
+                         * later serialization of duplicate namespace prefix declarations in
+                         * any descendant nodes.
+                         */
+                        if (map.has(prefixDefinition, namespaceDefinition)) {
+                            continue;
+                        }
+                        /**
+                         * 2.3.2.6. Add the prefix prefix definition to map given namespace
+                         * namespace definition.
+                         */
+                        map.set(prefixDefinition, namespaceDefinition);
+                        /**
+                         * 2.3.2.7. Add the value of prefix definition as a new key to the
+                         * local prefixes map, with the namespace definition as the key's
+                         * value replacing the value of null with the empty string if
+                         * applicable.
+                         */
+                        localPrefixesMap[prefixDefinition] = namespaceDefinition || '';
+                    }
+                }
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        /**
+         * 3. Return the value of default namespace attr value.
+         *
+         * _Note:_ The empty string is a legitimate return value and is not
+         * converted to null.
+         */
+        return defaultNamespaceAttrValue;
+    };
+    /**
+    * Generates a new prefix for the given namespace.
+    *
+    * @param newNamespace - a namespace to generate prefix for
+    * @param prefixMap - namespace prefix map
+    * @param prefixIndex - generated namespace prefix index
+    */
+    BaseWriter.prototype._generatePrefix = function (newNamespace, prefixMap, prefixIndex) {
+        /**
+         * 1. Let generated prefix be the concatenation of the string "ns" and the
+         * current numerical value of prefix index.
+         * 2. Let the value of prefix index be incremented by one.
+         * 3. Add to map the generated prefix given the new namespace namespace.
+         * 4. Return the value of generated prefix.
+         */
+        var generatedPrefix = "ns" + prefixIndex.value.toString();
+        prefixIndex.value++;
+        prefixMap.set(generatedPrefix, newNamespace);
+        return generatedPrefix;
+    };
+    /**
+     * Produces an XML serialization of an attribute value.
+     *
+     * @param value - attribute value
+     * @param requireWellFormed - whether to check conformance
+     */
+    BaseWriter.prototype._serializeAttributeValue = function (value, requireWellFormed, noDoubleEncoding) {
+        /**
+         * From: https://w3c.github.io/DOM-Parsing/#dfn-serializing-an-attribute-value
+         *
+         * 1. If the require well-formed flag is set (its value is true), and
+         * attribute value contains characters that are not matched by the XML Char
+         * production, then throw an exception; the serialization of this attribute
+         * value would fail to produce a well-formed element serialization.
+         */
+        if (requireWellFormed && value !== null && !algorithm_1.xml_isLegalChar(value)) {
+            throw new Error("Invalid characters in attribute value.");
+        }
+        /**
+         * 2. If attribute value is null, then return the empty string.
+         */
+        if (value === null)
+            return "";
+        /**
+         * 3. Otherwise, attribute value is a string. Return the value of attribute
+         * value, first replacing any occurrences of the following:
+         * - "&" with "&amp;"
+         * - """ with "&quot;"
+         * - "<" with "&lt;"
+         * - ">" with "&gt;"
+         * NOTE
+         * This matches behavior present in browsers, and goes above and beyond the
+         * grammar requirement in the XML specification's AttValue production by
+         * also replacing ">" characters.
+         */
+        if (noDoubleEncoding) {
+            return value.replace(/(?!&(lt|gt|amp|apos|quot);)&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;')
+                .replace(/"/g, '&quot;');
+        }
+        else {
+            var result = "";
+            for (var i = 0; i < value.length; i++) {
+                var c = value[i];
+                if (c === "\"")
+                    result += "&quot;";
+                else if (c === "&")
+                    result += "&amp;";
+                else if (c === "<")
+                    result += "&lt;";
+                else if (c === ">")
+                    result += "&gt;";
+                else
+                    result += c;
+            }
+            return result;
+        }
+    };
+    BaseWriter._VoidElementNames = new Set(['area', 'base', 'basefont',
+        'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
+        'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
+    return BaseWriter;
+}());
+exports.BaseWriter = BaseWriter;
+//# sourceMappingURL=BaseWriter.js.map
+
+/***/ }),
+
+/***/ 37525:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var BaseCBWriter_1 = __nccwpck_require__(50708);
+/**
+ * Serializes XML nodes.
+ */
+var JSONCBWriter = /** @class */ (function (_super) {
+    __extends(JSONCBWriter, _super);
+    /**
+     * Initializes a new instance of `JSONCBWriter`.
+     *
+     * @param builderOptions - XML builder options
+     */
+    function JSONCBWriter(builderOptions) {
+        var _this = _super.call(this, builderOptions) || this;
+        _this._hasChildren = [];
+        _this._additionalLevel = 0;
+        return _this;
+    }
+    /** @inheritdoc */
+    JSONCBWriter.prototype.frontMatter = function () {
+        return "";
+    };
+    /** @inheritdoc */
+    JSONCBWriter.prototype.declaration = function (version, encoding, standalone) {
+        return "";
+    };
+    /** @inheritdoc */
+    JSONCBWriter.prototype.docType = function (name, publicId, systemId) {
+        return "";
+    };
+    /** @inheritdoc */
+    JSONCBWriter.prototype.comment = function (data) {
+        // { "!": "hello" }
+        return this._comma() + this._beginLine() + "{" + this._sep() +
+            this._key(this._builderOptions.convert.comment) + this._sep() +
+            this._val(data) + this._sep() + "}";
+    };
+    /** @inheritdoc */
+    JSONCBWriter.prototype.text = function (data) {
+        // { "#": "hello" }
+        return this._comma() + this._beginLine() + "{" + this._sep() +
+            this._key(this._builderOptions.convert.text) + this._sep() +
+            this._val(data) + this._sep() + "}";
+    };
+    /** @inheritdoc */
+    JSONCBWriter.prototype.instruction = function (target, data) {
+        // { "?": "target hello" }
+        return this._comma() + this._beginLine() + "{" + this._sep() +
+            this._key(this._builderOptions.convert.ins) + this._sep() +
+            this._val(data ? target + " " + data : target) + this._sep() + "}";
+    };
+    /** @inheritdoc */
+    JSONCBWriter.prototype.cdata = function (data) {
+        // { "$": "hello" }
+        return this._comma() + this._beginLine() + "{" + this._sep() +
+            this._key(this._builderOptions.convert.cdata) + this._sep() +
+            this._val(data) + this._sep() + "}";
+    };
+    /** @inheritdoc */
+    JSONCBWriter.prototype.attribute = function (name, value) {
+        // { "@name": "val" }
+        return this._comma() + this._beginLine(1) + "{" + this._sep() +
+            this._key(this._builderOptions.convert.att + name) + this._sep() +
+            this._val(value) + this._sep() + "}";
+    };
+    /** @inheritdoc */
+    JSONCBWriter.prototype.openTagBegin = function (name) {
+        // { "node": { "#": [
+        var str = this._comma() + this._beginLine() + "{" + this._sep() + this._key(name) + this._sep() + "{";
+        this._additionalLevel++;
+        this.hasData = true;
+        str += this._beginLine() + this._key(this._builderOptions.convert.text) + this._sep() + "[";
+        this._hasChildren.push(false);
+        return str;
+    };
+    /** @inheritdoc */
+    JSONCBWriter.prototype.openTagEnd = function (name, selfClosing, voidElement) {
+        if (selfClosing) {
+            var str = this._sep() + "]";
+            this._additionalLevel--;
+            str += this._beginLine() + "}" + this._sep() + "}";
+            return str;
+        }
+        else {
+            return "";
+        }
+    };
+    /** @inheritdoc */
+    JSONCBWriter.prototype.closeTag = function (name) {
+        // ] } }
+        var str = this._beginLine() + "]";
+        this._additionalLevel--;
+        str += this._beginLine() + "}" + this._sep() + "}";
+        return str;
+    };
+    /** @inheritdoc */
+    JSONCBWriter.prototype.beginElement = function (name) { };
+    /** @inheritdoc */
+    JSONCBWriter.prototype.endElement = function (name) { this._hasChildren.pop(); };
+    /**
+     * Produces characters to be prepended to a line of string in pretty-print
+     * mode.
+     */
+    JSONCBWriter.prototype._beginLine = function (additionalOffset) {
+        if (additionalOffset === void 0) { additionalOffset = 0; }
+        if (this._writerOptions.prettyPrint) {
+            return (this.hasData ? this._writerOptions.newline : "") +
+                this._indent(this._writerOptions.offset + this.level + additionalOffset);
+        }
+        else {
+            return "";
+        }
+    };
+    /**
+     * Produces an indentation string.
+     *
+     * @param level - depth of the tree
+     */
+    JSONCBWriter.prototype._indent = function (level) {
+        if (level + this._additionalLevel <= 0) {
+            return "";
+        }
+        else {
+            return this._writerOptions.indent.repeat(level + this._additionalLevel);
+        }
+    };
+    /**
+     * Produces a comma before a child node if it has previous siblings.
+     */
+    JSONCBWriter.prototype._comma = function () {
+        var str = (this._hasChildren[this._hasChildren.length - 1] ? "," : "");
+        if (this._hasChildren.length > 0) {
+            this._hasChildren[this._hasChildren.length - 1] = true;
+        }
+        return str;
+    };
+    /**
+     * Produces a separator string.
+     */
+    JSONCBWriter.prototype._sep = function () {
+        return (this._writerOptions.prettyPrint ? " " : "");
+    };
+    /**
+     * Produces a JSON key string delimited with double quotes.
+     */
+    JSONCBWriter.prototype._key = function (key) {
+        return "\"" + key + "\":";
+    };
+    /**
+     * Produces a JSON value string delimited with double quotes.
+     */
+    JSONCBWriter.prototype._val = function (val) {
+        return JSON.stringify(val);
+    };
+    return JSONCBWriter;
+}(BaseCBWriter_1.BaseCBWriter));
+exports.JSONCBWriter = JSONCBWriter;
+//# sourceMappingURL=JSONCBWriter.js.map
+
+/***/ }),
+
+/***/ 37510:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var ObjectWriter_1 = __nccwpck_require__(50243);
+var util_1 = __nccwpck_require__(76195);
+var BaseWriter_1 = __nccwpck_require__(37644);
+/**
+ * Serializes XML nodes into a JSON string.
+ */
+var JSONWriter = /** @class */ (function (_super) {
+    __extends(JSONWriter, _super);
+    /**
+     * Initializes a new instance of `JSONWriter`.
+     *
+     * @param builderOptions - XML builder options
+     * @param writerOptions - serialization options
+     */
+    function JSONWriter(builderOptions, writerOptions) {
+        var _this = _super.call(this, builderOptions) || this;
+        // provide default options
+        _this._writerOptions = util_1.applyDefaults(writerOptions, {
+            wellFormed: false,
+            noDoubleEncoding: false,
+            prettyPrint: false,
+            indent: '  ',
+            newline: '\n',
+            offset: 0,
+            group: false,
+            verbose: false
+        });
+        return _this;
+    }
+    /**
+     * Produces an XML serialization of the given node.
+     *
+     * @param node - node to serialize
+     * @param writerOptions - serialization options
+     */
+    JSONWriter.prototype.serialize = function (node) {
+        // convert to object
+        var objectWriterOptions = util_1.applyDefaults(this._writerOptions, {
+            format: "object",
+            wellFormed: false,
+            noDoubleEncoding: false,
+        });
+        var objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions, objectWriterOptions);
+        var val = objectWriter.serialize(node);
+        // recursively convert object into JSON string
+        return this._beginLine(this._writerOptions, 0) + this._convertObject(val, this._writerOptions);
+    };
+    /**
+     * Produces an XML serialization of the given object.
+     *
+     * @param obj - object to serialize
+     * @param options - serialization options
+     * @param level - depth of the XML tree
+     */
+    JSONWriter.prototype._convertObject = function (obj, options, level) {
+        var e_1, _a;
+        var _this = this;
+        if (level === void 0) { level = 0; }
+        var markup = '';
+        var isLeaf = this._isLeafNode(obj);
+        if (util_1.isArray(obj)) {
+            markup += '[';
+            var len = obj.length;
+            var i = 0;
+            try {
+                for (var obj_1 = __values(obj), obj_1_1 = obj_1.next(); !obj_1_1.done; obj_1_1 = obj_1.next()) {
+                    var val = obj_1_1.value;
+                    markup += this._endLine(options, level + 1) +
+                        this._beginLine(options, level + 1) +
+                        this._convertObject(val, options, level + 1);
+                    if (i < len - 1) {
+                        markup += ',';
+                    }
+                    i++;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (obj_1_1 && !obj_1_1.done && (_a = obj_1.return)) _a.call(obj_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            markup += this._endLine(options, level) + this._beginLine(options, level);
+            markup += ']';
+        }
+        else if (util_1.isObject(obj)) {
+            markup += '{';
+            var len_1 = util_1.objectLength(obj);
+            var i_1 = 0;
+            util_1.forEachObject(obj, function (key, val) {
+                if (isLeaf && options.prettyPrint) {
+                    markup += ' ';
+                }
+                else {
+                    markup += _this._endLine(options, level + 1) + _this._beginLine(options, level + 1);
+                }
+                markup += _this._key(key);
+                if (options.prettyPrint) {
+                    markup += ' ';
+                }
+                markup += _this._convertObject(val, options, level + 1);
+                if (i_1 < len_1 - 1) {
+                    markup += ',';
+                }
+                i_1++;
+            }, this);
+            if (isLeaf && options.prettyPrint) {
+                markup += ' ';
+            }
+            else {
+                markup += this._endLine(options, level) + this._beginLine(options, level);
+            }
+            markup += '}';
+        }
+        else {
+            markup += this._val(obj);
+        }
+        return markup;
+    };
+    /**
+     * Produces characters to be prepended to a line of string in pretty-print
+     * mode.
+     *
+     * @param options - serialization options
+     * @param level - current depth of the XML tree
+     */
+    JSONWriter.prototype._beginLine = function (options, level) {
+        if (!options.prettyPrint) {
+            return '';
+        }
+        else {
+            var indentLevel = options.offset + level + 1;
+            if (indentLevel > 0) {
+                return new Array(indentLevel).join(options.indent);
+            }
+        }
+        return '';
+    };
+    /**
+     * Produces characters to be appended to a line of string in pretty-print
+     * mode.
+     *
+     * @param options - serialization options
+     * @param level - current depth of the XML tree
+     */
+    JSONWriter.prototype._endLine = function (options, level) {
+        if (!options.prettyPrint) {
+            return '';
+        }
+        else {
+            return options.newline;
+        }
+    };
+    /**
+     * Produces a JSON key string delimited with double quotes.
+     */
+    JSONWriter.prototype._key = function (key) {
+        return "\"" + key + "\":";
+    };
+    /**
+     * Produces a JSON value string delimited with double quotes.
+     */
+    JSONWriter.prototype._val = function (val) {
+        return JSON.stringify(val);
+    };
+    /**
+     * Determines if an object is a leaf node.
+     *
+     * @param obj
+     */
+    JSONWriter.prototype._isLeafNode = function (obj) {
+        return this._descendantCount(obj) <= 1;
+    };
+    /**
+     * Counts the number of descendants of the given object.
+     *
+     * @param obj
+     * @param count
+     */
+    JSONWriter.prototype._descendantCount = function (obj, count) {
+        var _this = this;
+        if (count === void 0) { count = 0; }
+        if (util_1.isArray(obj)) {
+            util_1.forEachArray(obj, function (val) { return count += _this._descendantCount(val, count); }, this);
+        }
+        else if (util_1.isObject(obj)) {
+            util_1.forEachObject(obj, function (key, val) { return count += _this._descendantCount(val, count); }, this);
+        }
+        else {
+            count++;
+        }
+        return count;
+    };
+    return JSONWriter;
+}(BaseWriter_1.BaseWriter));
+exports.JSONWriter = JSONWriter;
+//# sourceMappingURL=JSONWriter.js.map
+
+/***/ }),
+
+/***/ 41397:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var util_1 = __nccwpck_require__(76195);
+var ObjectWriter_1 = __nccwpck_require__(50243);
+var BaseWriter_1 = __nccwpck_require__(37644);
+/**
+ * Serializes XML nodes into ES6 maps and arrays.
+ */
+var MapWriter = /** @class */ (function (_super) {
+    __extends(MapWriter, _super);
+    /**
+     * Initializes a new instance of `MapWriter`.
+     *
+     * @param builderOptions - XML builder options
+     * @param writerOptions - serialization options
+     */
+    function MapWriter(builderOptions, writerOptions) {
+        var _this = _super.call(this, builderOptions) || this;
+        // provide default options
+        _this._writerOptions = util_1.applyDefaults(writerOptions, {
+            format: "map",
+            wellFormed: false,
+            noDoubleEncoding: false,
+            group: false,
+            verbose: false
+        });
+        return _this;
+    }
+    /**
+     * Produces an XML serialization of the given node.
+     *
+     * @param node - node to serialize
+     */
+    MapWriter.prototype.serialize = function (node) {
+        // convert to object
+        var objectWriterOptions = util_1.applyDefaults(this._writerOptions, {
+            format: "object",
+            wellFormed: false,
+            noDoubleEncoding: false,
+            verbose: false
+        });
+        var objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions, objectWriterOptions);
+        var val = objectWriter.serialize(node);
+        // recursively convert object into Map
+        return this._convertObject(val);
+    };
+    /**
+     * Recursively converts a JS object into an ES5 map.
+     *
+     * @param obj - a JS object
+     */
+    MapWriter.prototype._convertObject = function (obj) {
+        if (util_1.isArray(obj)) {
+            for (var i = 0; i < obj.length; i++) {
+                obj[i] = this._convertObject(obj[i]);
+            }
+            return obj;
+        }
+        else if (util_1.isObject(obj)) {
+            var map = new Map();
+            for (var key in obj) {
+                map.set(key, this._convertObject(obj[key]));
+            }
+            return map;
+        }
+        else {
+            return obj;
+        }
+    };
+    return MapWriter;
+}(BaseWriter_1.BaseWriter));
+exports.MapWriter = MapWriter;
+//# sourceMappingURL=MapWriter.js.map
+
+/***/ }),
+
+/***/ 50243:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var util_1 = __nccwpck_require__(76195);
+var interfaces_1 = __nccwpck_require__(27305);
+var BaseWriter_1 = __nccwpck_require__(37644);
+/**
+ * Serializes XML nodes into objects and arrays.
+ */
+var ObjectWriter = /** @class */ (function (_super) {
+    __extends(ObjectWriter, _super);
+    /**
+     * Initializes a new instance of `ObjectWriter`.
+     *
+     * @param builderOptions - XML builder options
+     * @param writerOptions - serialization options
+     */
+    function ObjectWriter(builderOptions, writerOptions) {
+        var _this = _super.call(this, builderOptions) || this;
+        _this._writerOptions = util_1.applyDefaults(writerOptions, {
+            format: "object",
+            wellFormed: false,
+            noDoubleEncoding: false,
+            group: false,
+            verbose: false
+        });
+        return _this;
+    }
+    /**
+     * Produces an XML serialization of the given node.
+     *
+     * @param node - node to serialize
+     */
+    ObjectWriter.prototype.serialize = function (node) {
+        this._currentList = [];
+        this._currentIndex = 0;
+        this._listRegister = [this._currentList];
+        /**
+         * First pass, serialize nodes
+         * This creates a list of nodes grouped under node types while preserving
+         * insertion order. For example:
+         * [
+         *   root: [
+         *     node: [
+         *       { "@" : { "att1": "val1", "att2": "val2" }
+         *       { "#": "node text" }
+         *       { childNode: [] }
+         *       { "#": "more text" }
+         *     ],
+         *     node: [
+         *       { "@" : { "att": "val" }
+         *       { "#": [ "text line1", "text line2" ] }
+         *     ]
+         *   ]
+         * ]
+         */
+        this.serializeNode(node, this._writerOptions.wellFormed, this._writerOptions.noDoubleEncoding);
+        /**
+         * Second pass, process node lists. Above example becomes:
+         * {
+         *   root: {
+         *     node: [
+         *       {
+         *         "@att1": "val1",
+         *         "@att2": "val2",
+         *         "#1": "node text",
+         *         childNode: {},
+         *         "#2": "more text"
+         *       },
+         *       {
+         *         "@att": "val",
+         *         "#": [ "text line1", "text line2" ]
+         *       }
+         *     ]
+         *   }
+         * }
+         */
+        return this._process(this._currentList, this._writerOptions);
+    };
+    ObjectWriter.prototype._process = function (items, options) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        if (items.length === 0)
+            return {};
+        // determine if there are non-unique element names
+        var namesSeen = {};
+        var hasNonUniqueNames = false;
+        var textCount = 0;
+        var commentCount = 0;
+        var instructionCount = 0;
+        var cdataCount = 0;
+        for (var i = 0; i < items.length; i++) {
+            var item = items[i];
+            var key = Object.keys(item)[0];
+            switch (key) {
+                case "@":
+                    continue;
+                case "#":
+                    textCount++;
+                    break;
+                case "!":
+                    commentCount++;
+                    break;
+                case "?":
+                    instructionCount++;
+                    break;
+                case "$":
+                    cdataCount++;
+                    break;
+                default:
+                    if (namesSeen[key]) {
+                        hasNonUniqueNames = true;
+                    }
+                    else {
+                        namesSeen[key] = true;
+                    }
+                    break;
+            }
+        }
+        var defAttrKey = this._getAttrKey();
+        var defTextKey = this._getNodeKey(interfaces_1.NodeType.Text);
+        var defCommentKey = this._getNodeKey(interfaces_1.NodeType.Comment);
+        var defInstructionKey = this._getNodeKey(interfaces_1.NodeType.ProcessingInstruction);
+        var defCdataKey = this._getNodeKey(interfaces_1.NodeType.CData);
+        if (textCount === 1 && items.length === 1 && util_1.isString(items[0]["#"])) {
+            // special case of an element node with a single text node
+            return items[0]["#"];
+        }
+        else if (hasNonUniqueNames) {
+            var obj = {};
+            // process attributes first
+            for (var i = 0; i < items.length; i++) {
+                var item = items[i];
+                var key = Object.keys(item)[0];
+                if (key === "@") {
+                    var attrs = item["@"];
+                    var attrKeys = Object.keys(attrs);
+                    if (attrKeys.length === 1) {
+                        obj[defAttrKey + attrKeys[0]] = attrs[attrKeys[0]];
+                    }
+                    else {
+                        obj[defAttrKey] = item["@"];
+                    }
+                }
+            }
+            // list contains element nodes with non-unique names
+            // return an array with mixed content notation
+            var result = [];
+            for (var i = 0; i < items.length; i++) {
+                var item = items[i];
+                var key = Object.keys(item)[0];
+                switch (key) {
+                    case "@":
+                        // attributes were processed above
+                        break;
+                    case "#":
+                        result.push((_a = {}, _a[defTextKey] = item["#"], _a));
+                        break;
+                    case "!":
+                        result.push((_b = {}, _b[defCommentKey] = item["!"], _b));
+                        break;
+                    case "?":
+                        result.push((_c = {}, _c[defInstructionKey] = item["?"], _c));
+                        break;
+                    case "$":
+                        result.push((_d = {}, _d[defCdataKey] = item["$"], _d));
+                        break;
+                    default:
+                        // element node
+                        var ele = item;
+                        if (ele[key].length !== 0 && util_1.isArray(ele[key][0])) {
+                            // group of element nodes
+                            var eleGroup = [];
+                            var listOfLists = ele[key];
+                            for (var i_1 = 0; i_1 < listOfLists.length; i_1++) {
+                                eleGroup.push(this._process(listOfLists[i_1], options));
+                            }
+                            result.push((_e = {}, _e[key] = eleGroup, _e));
+                        }
+                        else {
+                            // single element node
+                            if (options.verbose) {
+                                result.push((_f = {}, _f[key] = [this._process(ele[key], options)], _f));
+                            }
+                            else {
+                                result.push((_g = {}, _g[key] = this._process(ele[key], options), _g));
+                            }
+                        }
+                        break;
+                }
+            }
+            obj[defTextKey] = result;
+            return obj;
+        }
+        else {
+            // all element nodes have unique names
+            // return an object while prefixing data node keys
+            var textId = 1;
+            var commentId = 1;
+            var instructionId = 1;
+            var cdataId = 1;
+            var obj = {};
+            for (var i = 0; i < items.length; i++) {
+                var item = items[i];
+                var key = Object.keys(item)[0];
+                switch (key) {
+                    case "@":
+                        var attrs = item["@"];
+                        var attrKeys = Object.keys(attrs);
+                        if (!options.group || attrKeys.length === 1) {
+                            for (var attrName in attrs) {
+                                obj[defAttrKey + attrName] = attrs[attrName];
+                            }
+                        }
+                        else {
+                            obj[defAttrKey] = attrs;
+                        }
+                        break;
+                    case "#":
+                        textId = this._processSpecItem(item["#"], obj, options.group, defTextKey, textCount, textId);
+                        break;
+                    case "!":
+                        commentId = this._processSpecItem(item["!"], obj, options.group, defCommentKey, commentCount, commentId);
+                        break;
+                    case "?":
+                        instructionId = this._processSpecItem(item["?"], obj, options.group, defInstructionKey, instructionCount, instructionId);
+                        break;
+                    case "$":
+                        cdataId = this._processSpecItem(item["$"], obj, options.group, defCdataKey, cdataCount, cdataId);
+                        break;
+                    default:
+                        // element node
+                        var ele = item;
+                        if (ele[key].length !== 0 && util_1.isArray(ele[key][0])) {
+                            // group of element nodes
+                            var eleGroup = [];
+                            var listOfLists = ele[key];
+                            for (var i_2 = 0; i_2 < listOfLists.length; i_2++) {
+                                eleGroup.push(this._process(listOfLists[i_2], options));
+                            }
+                            obj[key] = eleGroup;
+                        }
+                        else {
+                            // single element node
+                            if (options.verbose) {
+                                obj[key] = [this._process(ele[key], options)];
+                            }
+                            else {
+                                obj[key] = this._process(ele[key], options);
+                            }
+                        }
+                        break;
+                }
+            }
+            return obj;
+        }
+    };
+    ObjectWriter.prototype._processSpecItem = function (item, obj, group, defKey, count, id) {
+        var e_1, _a;
+        if (!group && util_1.isArray(item) && count + item.length > 2) {
+            try {
+                for (var item_1 = __values(item), item_1_1 = item_1.next(); !item_1_1.done; item_1_1 = item_1.next()) {
+                    var subItem = item_1_1.value;
+                    var key = defKey + (id++).toString();
+                    obj[key] = subItem;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (item_1_1 && !item_1_1.done && (_a = item_1.return)) _a.call(item_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        else {
+            var key = count > 1 ? defKey + (id++).toString() : defKey;
+            obj[key] = item;
+        }
+        return id;
+    };
+    /** @inheritdoc */
+    ObjectWriter.prototype.beginElement = function (name) {
+        var _a, _b;
+        var childItems = [];
+        if (this._currentList.length === 0) {
+            this._currentList.push((_a = {}, _a[name] = childItems, _a));
+        }
+        else {
+            var lastItem = this._currentList[this._currentList.length - 1];
+            if (this._isElementNode(lastItem, name)) {
+                if (lastItem[name].length !== 0 && util_1.isArray(lastItem[name][0])) {
+                    var listOfLists = lastItem[name];
+                    listOfLists.push(childItems);
+                }
+                else {
+                    lastItem[name] = [lastItem[name], childItems];
+                }
+            }
+            else {
+                this._currentList.push((_b = {}, _b[name] = childItems, _b));
+            }
+        }
+        this._currentIndex++;
+        if (this._listRegister.length > this._currentIndex) {
+            this._listRegister[this._currentIndex] = childItems;
+        }
+        else {
+            this._listRegister.push(childItems);
+        }
+        this._currentList = childItems;
+    };
+    /** @inheritdoc */
+    ObjectWriter.prototype.endElement = function () {
+        this._currentList = this._listRegister[--this._currentIndex];
+    };
+    /** @inheritdoc */
+    ObjectWriter.prototype.attribute = function (name, value) {
+        var _a, _b;
+        if (this._currentList.length === 0) {
+            this._currentList.push({ "@": (_a = {}, _a[name] = value, _a) });
+        }
+        else {
+            var lastItem = this._currentList[this._currentList.length - 1];
+            /* istanbul ignore else */
+            if (this._isAttrNode(lastItem)) {
+                lastItem["@"][name] = value;
+            }
+            else {
+                this._currentList.push({ "@": (_b = {}, _b[name] = value, _b) });
+            }
+        }
+    };
+    /** @inheritdoc */
+    ObjectWriter.prototype.comment = function (data) {
+        if (this._currentList.length === 0) {
+            this._currentList.push({ "!": data });
+        }
+        else {
+            var lastItem = this._currentList[this._currentList.length - 1];
+            if (this._isCommentNode(lastItem)) {
+                if (util_1.isArray(lastItem["!"])) {
+                    lastItem["!"].push(data);
+                }
+                else {
+                    lastItem["!"] = [lastItem["!"], data];
+                }
+            }
+            else {
+                this._currentList.push({ "!": data });
+            }
+        }
+    };
+    /** @inheritdoc */
+    ObjectWriter.prototype.text = function (data) {
+        if (this._currentList.length === 0) {
+            this._currentList.push({ "#": data });
+        }
+        else {
+            var lastItem = this._currentList[this._currentList.length - 1];
+            if (this._isTextNode(lastItem)) {
+                if (util_1.isArray(lastItem["#"])) {
+                    lastItem["#"].push(data);
+                }
+                else {
+                    lastItem["#"] = [lastItem["#"], data];
+                }
+            }
+            else {
+                this._currentList.push({ "#": data });
+            }
+        }
+    };
+    /** @inheritdoc */
+    ObjectWriter.prototype.instruction = function (target, data) {
+        var value = (data === "" ? target : target + " " + data);
+        if (this._currentList.length === 0) {
+            this._currentList.push({ "?": value });
+        }
+        else {
+            var lastItem = this._currentList[this._currentList.length - 1];
+            if (this._isInstructionNode(lastItem)) {
+                if (util_1.isArray(lastItem["?"])) {
+                    lastItem["?"].push(value);
+                }
+                else {
+                    lastItem["?"] = [lastItem["?"], value];
+                }
+            }
+            else {
+                this._currentList.push({ "?": value });
+            }
+        }
+    };
+    /** @inheritdoc */
+    ObjectWriter.prototype.cdata = function (data) {
+        if (this._currentList.length === 0) {
+            this._currentList.push({ "$": data });
+        }
+        else {
+            var lastItem = this._currentList[this._currentList.length - 1];
+            if (this._isCDATANode(lastItem)) {
+                if (util_1.isArray(lastItem["$"])) {
+                    lastItem["$"].push(data);
+                }
+                else {
+                    lastItem["$"] = [lastItem["$"], data];
+                }
+            }
+            else {
+                this._currentList.push({ "$": data });
+            }
+        }
+    };
+    ObjectWriter.prototype._isAttrNode = function (x) {
+        return "@" in x;
+    };
+    ObjectWriter.prototype._isTextNode = function (x) {
+        return "#" in x;
+    };
+    ObjectWriter.prototype._isCommentNode = function (x) {
+        return "!" in x;
+    };
+    ObjectWriter.prototype._isInstructionNode = function (x) {
+        return "?" in x;
+    };
+    ObjectWriter.prototype._isCDATANode = function (x) {
+        return "$" in x;
+    };
+    ObjectWriter.prototype._isElementNode = function (x, name) {
+        return name in x;
+    };
+    /**
+     * Returns an object key for an attribute or namespace declaration.
+     */
+    ObjectWriter.prototype._getAttrKey = function () {
+        return this._builderOptions.convert.att;
+    };
+    /**
+     * Returns an object key for the given node type.
+     *
+     * @param nodeType - node type to get a key for
+     */
+    ObjectWriter.prototype._getNodeKey = function (nodeType) {
+        switch (nodeType) {
+            case interfaces_1.NodeType.Comment:
+                return this._builderOptions.convert.comment;
+            case interfaces_1.NodeType.Text:
+                return this._builderOptions.convert.text;
+            case interfaces_1.NodeType.ProcessingInstruction:
+                return this._builderOptions.convert.ins;
+            case interfaces_1.NodeType.CData:
+                return this._builderOptions.convert.cdata;
+            /* istanbul ignore next */
+            default:
+                throw new Error("Invalid node type.");
+        }
+    };
+    return ObjectWriter;
+}(BaseWriter_1.BaseWriter));
+exports.ObjectWriter = ObjectWriter;
+//# sourceMappingURL=ObjectWriter.js.map
+
+/***/ }),
+
+/***/ 77572:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var BaseCBWriter_1 = __nccwpck_require__(50708);
+/**
+ * Serializes XML nodes.
+ */
+var XMLCBWriter = /** @class */ (function (_super) {
+    __extends(XMLCBWriter, _super);
+    /**
+     * Initializes a new instance of `XMLCBWriter`.
+     *
+     * @param builderOptions - XML builder options
+     */
+    function XMLCBWriter(builderOptions) {
+        var _this = _super.call(this, builderOptions) || this;
+        _this._lineLength = 0;
+        return _this;
+    }
+    /** @inheritdoc */
+    XMLCBWriter.prototype.frontMatter = function () {
+        return "";
+    };
+    /** @inheritdoc */
+    XMLCBWriter.prototype.declaration = function (version, encoding, standalone) {
+        var markup = this._beginLine() + "<?xml";
+        markup += " version=\"" + version + "\"";
+        if (encoding !== undefined) {
+            markup += " encoding=\"" + encoding + "\"";
+        }
+        if (standalone !== undefined) {
+            markup += " standalone=\"" + (standalone ? "yes" : "no") + "\"";
+        }
+        markup += "?>";
+        return markup;
+    };
+    /** @inheritdoc */
+    XMLCBWriter.prototype.docType = function (name, publicId, systemId) {
+        var markup = this._beginLine();
+        if (publicId && systemId) {
+            markup += "<!DOCTYPE " + name + " PUBLIC \"" + publicId + "\" \"" + systemId + "\">";
+        }
+        else if (publicId) {
+            markup += "<!DOCTYPE " + name + " PUBLIC \"" + publicId + "\">";
+        }
+        else if (systemId) {
+            markup += "<!DOCTYPE " + name + " SYSTEM \"" + systemId + "\">";
+        }
+        else {
+            markup += "<!DOCTYPE " + name + ">";
+        }
+        return markup;
+    };
+    /** @inheritdoc */
+    XMLCBWriter.prototype.comment = function (data) {
+        return this._beginLine() + "<!--" + data + "-->";
+    };
+    /** @inheritdoc */
+    XMLCBWriter.prototype.text = function (data) {
+        return this._beginLine() + data;
+    };
+    /** @inheritdoc */
+    XMLCBWriter.prototype.instruction = function (target, data) {
+        if (data) {
+            return this._beginLine() + "<?" + target + " " + data + "?>";
+        }
+        else {
+            return this._beginLine() + "<?" + target + "?>";
+        }
+    };
+    /** @inheritdoc */
+    XMLCBWriter.prototype.cdata = function (data) {
+        return this._beginLine() + "<![CDATA[" + data + "]]>";
+    };
+    /** @inheritdoc */
+    XMLCBWriter.prototype.openTagBegin = function (name) {
+        this._lineLength += 1 + name.length;
+        return this._beginLine() + "<" + name;
+    };
+    /** @inheritdoc */
+    XMLCBWriter.prototype.openTagEnd = function (name, selfClosing, voidElement) {
+        if (voidElement) {
+            return " />";
+        }
+        else if (selfClosing) {
+            if (this._writerOptions.allowEmptyTags) {
+                return "></" + name + ">";
+            }
+            else if (this._writerOptions.spaceBeforeSlash) {
+                return " />";
+            }
+            else {
+                return "/>";
+            }
+        }
+        else {
+            return ">";
+        }
+    };
+    /** @inheritdoc */
+    XMLCBWriter.prototype.closeTag = function (name) {
+        return this._beginLine() + "</" + name + ">";
+    };
+    /** @inheritdoc */
+    XMLCBWriter.prototype.attribute = function (name, value) {
+        var str = name + "=\"" + value + "\"";
+        if (this._writerOptions.prettyPrint && this._writerOptions.width > 0 &&
+            this._lineLength + 1 + str.length > this._writerOptions.width) {
+            str = this._beginLine() + this._indent(1) + str;
+            this._lineLength = str.length;
+            return str;
+        }
+        else {
+            this._lineLength += 1 + str.length;
+            return " " + str;
+        }
+    };
+    /** @inheritdoc */
+    XMLCBWriter.prototype.beginElement = function (name) { };
+    /** @inheritdoc */
+    XMLCBWriter.prototype.endElement = function (name) { };
+    /**
+     * Produces characters to be prepended to a line of string in pretty-print
+     * mode.
+     */
+    XMLCBWriter.prototype._beginLine = function () {
+        if (this._writerOptions.prettyPrint) {
+            var str = (this.hasData ? this._writerOptions.newline : "") +
+                this._indent(this._writerOptions.offset + this.level);
+            this._lineLength = str.length;
+            return str;
+        }
+        else {
+            return "";
+        }
+    };
+    /**
+     * Produces an indentation string.
+     *
+     * @param level - depth of the tree
+     */
+    XMLCBWriter.prototype._indent = function (level) {
+        if (level <= 0) {
+            return "";
+        }
+        else {
+            return this._writerOptions.indent.repeat(level);
+        }
+    };
+    return XMLCBWriter;
+}(BaseCBWriter_1.BaseCBWriter));
+exports.XMLCBWriter = XMLCBWriter;
+//# sourceMappingURL=XMLCBWriter.js.map
+
+/***/ }),
+
+/***/ 59606:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var util_1 = __nccwpck_require__(76195);
+var interfaces_1 = __nccwpck_require__(27305);
+var BaseWriter_1 = __nccwpck_require__(37644);
+var util_2 = __nccwpck_require__(65282);
+/**
+ * Serializes XML nodes into strings.
+ */
+var XMLWriter = /** @class */ (function (_super) {
+    __extends(XMLWriter, _super);
+    /**
+     * Initializes a new instance of `XMLWriter`.
+     *
+     * @param builderOptions - XML builder options
+     * @param writerOptions - serialization options
+     */
+    function XMLWriter(builderOptions, writerOptions) {
+        var _this = _super.call(this, builderOptions) || this;
+        _this._indentation = {};
+        _this._lengthToLastNewline = 0;
+        // provide default options
+        _this._writerOptions = util_1.applyDefaults(writerOptions, {
+            wellFormed: false,
+            noDoubleEncoding: false,
+            headless: false,
+            prettyPrint: false,
+            indent: "  ",
+            newline: "\n",
+            offset: 0,
+            width: 0,
+            allowEmptyTags: false,
+            indentTextOnlyNodes: false,
+            spaceBeforeSlash: false
+        });
+        return _this;
+    }
+    /**
+     * Produces an XML serialization of the given node.
+     *
+     * @param node - node to serialize
+     */
+    XMLWriter.prototype.serialize = function (node) {
+        this._refs = { suppressPretty: false, emptyNode: false, markup: "" };
+        // Serialize XML declaration
+        if (node.nodeType === interfaces_1.NodeType.Document && !this._writerOptions.headless) {
+            this.declaration(this._builderOptions.version, this._builderOptions.encoding, this._builderOptions.standalone);
+        }
+        // recursively serialize node
+        this.serializeNode(node, this._writerOptions.wellFormed, this._writerOptions.noDoubleEncoding);
+        // remove trailing newline
+        if (this._writerOptions.prettyPrint &&
+            this._refs.markup.slice(-this._writerOptions.newline.length) === this._writerOptions.newline) {
+            this._refs.markup = this._refs.markup.slice(0, -this._writerOptions.newline.length);
+        }
+        return this._refs.markup;
+    };
+    /** @inheritdoc */
+    XMLWriter.prototype.declaration = function (version, encoding, standalone) {
+        this._beginLine();
+        this._refs.markup += "<?xml version=\"" + version + "\"";
+        if (encoding !== undefined) {
+            this._refs.markup += " encoding=\"" + encoding + "\"";
+        }
+        if (standalone !== undefined) {
+            this._refs.markup += " standalone=\"" + (standalone ? "yes" : "no") + "\"";
+        }
+        this._refs.markup += "?>";
+        this._endLine();
+    };
+    /** @inheritdoc */
+    XMLWriter.prototype.docType = function (name, publicId, systemId) {
+        this._beginLine();
+        if (publicId && systemId) {
+            this._refs.markup += "<!DOCTYPE " + name + " PUBLIC \"" + publicId + "\" \"" + systemId + "\">";
+        }
+        else if (publicId) {
+            this._refs.markup += "<!DOCTYPE " + name + " PUBLIC \"" + publicId + "\">";
+        }
+        else if (systemId) {
+            this._refs.markup += "<!DOCTYPE " + name + " SYSTEM \"" + systemId + "\">";
+        }
+        else {
+            this._refs.markup += "<!DOCTYPE " + name + ">";
+        }
+        this._endLine();
+    };
+    /** @inheritdoc */
+    XMLWriter.prototype.openTagBegin = function (name) {
+        this._beginLine();
+        this._refs.markup += "<" + name;
+    };
+    /** @inheritdoc */
+    XMLWriter.prototype.openTagEnd = function (name, selfClosing, voidElement) {
+        // do not indent text only elements or elements with empty text nodes
+        this._refs.suppressPretty = false;
+        this._refs.emptyNode = false;
+        if (this._writerOptions.prettyPrint && !selfClosing && !voidElement) {
+            var textOnlyNode = true;
+            var emptyNode = true;
+            var childNode = this.currentNode.firstChild;
+            var cdataCount = 0;
+            var textCount = 0;
+            while (childNode) {
+                if (util_2.Guard.isExclusiveTextNode(childNode)) {
+                    textCount++;
+                }
+                else if (util_2.Guard.isCDATASectionNode(childNode)) {
+                    cdataCount++;
+                }
+                else {
+                    textOnlyNode = false;
+                    emptyNode = false;
+                    break;
+                }
+                if (childNode.data !== '') {
+                    emptyNode = false;
+                }
+                childNode = childNode.nextSibling;
+            }
+            this._refs.suppressPretty = !this._writerOptions.indentTextOnlyNodes && textOnlyNode && ((cdataCount <= 1 && textCount === 0) || cdataCount === 0);
+            this._refs.emptyNode = emptyNode;
+        }
+        if ((voidElement || selfClosing || this._refs.emptyNode) && this._writerOptions.allowEmptyTags) {
+            this._refs.markup += "></" + name + ">";
+        }
+        else {
+            this._refs.markup += voidElement ? " />" :
+                (selfClosing || this._refs.emptyNode) ? (this._writerOptions.spaceBeforeSlash ? " />" : "/>") : ">";
+        }
+        this._endLine();
+    };
+    /** @inheritdoc */
+    XMLWriter.prototype.closeTag = function (name) {
+        if (!this._refs.emptyNode) {
+            this._beginLine();
+            this._refs.markup += "</" + name + ">";
+        }
+        this._refs.suppressPretty = false;
+        this._refs.emptyNode = false;
+        this._endLine();
+    };
+    /** @inheritdoc */
+    XMLWriter.prototype.attribute = function (name, value) {
+        var str = name + "=\"" + value + "\"";
+        if (this._writerOptions.prettyPrint && this._writerOptions.width > 0 &&
+            this._refs.markup.length - this._lengthToLastNewline + 1 + str.length > this._writerOptions.width) {
+            this._endLine();
+            this._beginLine();
+            this._refs.markup += this._indent(1) + str;
+        }
+        else {
+            this._refs.markup += " " + str;
+        }
+    };
+    /** @inheritdoc */
+    XMLWriter.prototype.text = function (data) {
+        if (data !== '') {
+            this._beginLine();
+            this._refs.markup += data;
+            this._endLine();
+        }
+    };
+    /** @inheritdoc */
+    XMLWriter.prototype.cdata = function (data) {
+        if (data !== '') {
+            this._beginLine();
+            this._refs.markup += "<![CDATA[" + data + "]]>";
+            this._endLine();
+        }
+    };
+    /** @inheritdoc */
+    XMLWriter.prototype.comment = function (data) {
+        this._beginLine();
+        this._refs.markup += "<!--" + data + "-->";
+        this._endLine();
+    };
+    /** @inheritdoc */
+    XMLWriter.prototype.instruction = function (target, data) {
+        this._beginLine();
+        this._refs.markup += "<?" + (data === "" ? target : target + " " + data) + "?>";
+        this._endLine();
+    };
+    /**
+     * Produces characters to be prepended to a line of string in pretty-print
+     * mode.
+     */
+    XMLWriter.prototype._beginLine = function () {
+        if (this._writerOptions.prettyPrint && !this._refs.suppressPretty) {
+            this._refs.markup += this._indent(this._writerOptions.offset + this.level);
+        }
+    };
+    /**
+     * Produces characters to be appended to a line of string in pretty-print
+     * mode.
+     */
+    XMLWriter.prototype._endLine = function () {
+        if (this._writerOptions.prettyPrint && !this._refs.suppressPretty) {
+            this._refs.markup += this._writerOptions.newline;
+            this._lengthToLastNewline = this._refs.markup.length;
+        }
+    };
+    /**
+     * Produces an indentation string.
+     *
+     * @param level - depth of the tree
+     */
+    XMLWriter.prototype._indent = function (level) {
+        if (level <= 0) {
+            return "";
+        }
+        else if (this._indentation[level] !== undefined) {
+            return this._indentation[level];
+        }
+        else {
+            var str = this._writerOptions.indent.repeat(level);
+            this._indentation[level] = str;
+            return str;
+        }
+    };
+    return XMLWriter;
+}(BaseWriter_1.BaseWriter));
+exports.XMLWriter = XMLWriter;
+//# sourceMappingURL=XMLWriter.js.map
+
+/***/ }),
+
+/***/ 42444:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var BaseCBWriter_1 = __nccwpck_require__(50708);
+/**
+ * Serializes XML nodes.
+ */
+var YAMLCBWriter = /** @class */ (function (_super) {
+    __extends(YAMLCBWriter, _super);
+    /**
+     * Initializes a new instance of `BaseCBWriter`.
+     *
+     * @param builderOptions - XML builder options
+     */
+    function YAMLCBWriter(builderOptions) {
+        var _this = _super.call(this, builderOptions) || this;
+        _this._rootWritten = false;
+        _this._additionalLevel = 0;
+        if (builderOptions.indent.length < 2) {
+            throw new Error("YAML indententation string must be at least two characters long.");
+        }
+        if (builderOptions.offset < 0) {
+            throw new Error("YAML offset should be zero or a positive number.");
+        }
+        return _this;
+    }
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.frontMatter = function () {
+        return this._beginLine() + "---";
+    };
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.declaration = function (version, encoding, standalone) {
+        return "";
+    };
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.docType = function (name, publicId, systemId) {
+        return "";
+    };
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.comment = function (data) {
+        // "!": "hello"
+        return this._beginLine() +
+            this._key(this._builderOptions.convert.comment) + " " +
+            this._val(data);
+    };
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.text = function (data) {
+        // "#": "hello"
+        return this._beginLine() +
+            this._key(this._builderOptions.convert.text) + " " +
+            this._val(data);
+    };
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.instruction = function (target, data) {
+        // "?": "target hello"
+        return this._beginLine() +
+            this._key(this._builderOptions.convert.ins) + " " +
+            this._val(data ? target + " " + data : target);
+    };
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.cdata = function (data) {
+        // "$": "hello"
+        return this._beginLine() +
+            this._key(this._builderOptions.convert.cdata) + " " +
+            this._val(data);
+    };
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.attribute = function (name, value) {
+        // "@name": "val"
+        this._additionalLevel++;
+        var str = this._beginLine() +
+            this._key(this._builderOptions.convert.att + name) + " " +
+            this._val(value);
+        this._additionalLevel--;
+        return str;
+    };
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.openTagBegin = function (name) {
+        // "node":
+        //   "#":
+        //   -
+        var str = this._beginLine() + this._key(name);
+        if (!this._rootWritten) {
+            this._rootWritten = true;
+        }
+        this.hasData = true;
+        this._additionalLevel++;
+        str += this._beginLine(true) + this._key(this._builderOptions.convert.text);
+        return str;
+    };
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.openTagEnd = function (name, selfClosing, voidElement) {
+        if (selfClosing) {
+            return " " + this._val("");
+        }
+        return "";
+    };
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.closeTag = function (name) {
+        this._additionalLevel--;
+        return "";
+    };
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.beginElement = function (name) { };
+    /** @inheritdoc */
+    YAMLCBWriter.prototype.endElement = function (name) { };
+    /**
+     * Produces characters to be prepended to a line of string in pretty-print
+     * mode.
+     */
+    YAMLCBWriter.prototype._beginLine = function (suppressArray) {
+        if (suppressArray === void 0) { suppressArray = false; }
+        return (this.hasData ? this._writerOptions.newline : "") +
+            this._indent(this._writerOptions.offset + this.level, suppressArray);
+    };
+    /**
+     * Produces an indentation string.
+     *
+     * @param level - depth of the tree
+     * @param suppressArray - whether the suppress array marker
+     */
+    YAMLCBWriter.prototype._indent = function (level, suppressArray) {
+        if (level + this._additionalLevel <= 0) {
+            return "";
+        }
+        else {
+            var chars = this._writerOptions.indent.repeat(level + this._additionalLevel);
+            if (!suppressArray && this._rootWritten) {
+                return chars.substr(0, chars.length - 2) + '-' + chars.substr(-1, 1);
+            }
+            return chars;
+        }
+    };
+    /**
+     * Produces a YAML key string delimited with double quotes.
+     */
+    YAMLCBWriter.prototype._key = function (key) {
+        return "\"" + key + "\":";
+    };
+    /**
+     * Produces a YAML value string delimited with double quotes.
+     */
+    YAMLCBWriter.prototype._val = function (val) {
+        return JSON.stringify(val);
+    };
+    return YAMLCBWriter;
+}(BaseCBWriter_1.BaseCBWriter));
+exports.YAMLCBWriter = YAMLCBWriter;
+//# sourceMappingURL=YAMLCBWriter.js.map
+
+/***/ }),
+
+/***/ 96517:
+/***/ (function(__unused_webpack_module, exports, __nccwpck_require__) {
+
+"use strict";
+
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var ObjectWriter_1 = __nccwpck_require__(50243);
+var util_1 = __nccwpck_require__(76195);
+var BaseWriter_1 = __nccwpck_require__(37644);
+/**
+ * Serializes XML nodes into a YAML string.
+ */
+var YAMLWriter = /** @class */ (function (_super) {
+    __extends(YAMLWriter, _super);
+    /**
+     * Initializes a new instance of `YAMLWriter`.
+     *
+     * @param builderOptions - XML builder options
+     * @param writerOptions - serialization options
+     */
+    function YAMLWriter(builderOptions, writerOptions) {
+        var _this = _super.call(this, builderOptions) || this;
+        // provide default options
+        _this._writerOptions = util_1.applyDefaults(writerOptions, {
+            wellFormed: false,
+            noDoubleEncoding: false,
+            indent: '  ',
+            newline: '\n',
+            offset: 0,
+            group: false,
+            verbose: false
+        });
+        if (_this._writerOptions.indent.length < 2) {
+            throw new Error("YAML indententation string must be at least two characters long.");
+        }
+        if (_this._writerOptions.offset < 0) {
+            throw new Error("YAML offset should be zero or a positive number.");
+        }
+        return _this;
+    }
+    /**
+     * Produces an XML serialization of the given node.
+     *
+     * @param node - node to serialize
+     * @param writerOptions - serialization options
+     */
+    YAMLWriter.prototype.serialize = function (node) {
+        // convert to object
+        var objectWriterOptions = util_1.applyDefaults(this._writerOptions, {
+            format: "object",
+            wellFormed: false,
+            noDoubleEncoding: false,
+        });
+        var objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions, objectWriterOptions);
+        var val = objectWriter.serialize(node);
+        var markup = this._beginLine(this._writerOptions, 0) + '---' + this._endLine(this._writerOptions) +
+            this._convertObject(val, this._writerOptions, 0);
+        // remove trailing newline
+        /* istanbul ignore else */
+        if (markup.slice(-this._writerOptions.newline.length) === this._writerOptions.newline) {
+            markup = markup.slice(0, -this._writerOptions.newline.length);
+        }
+        return markup;
+    };
+    /**
+     * Produces an XML serialization of the given object.
+     *
+     * @param obj - object to serialize
+     * @param options - serialization options
+     * @param level - depth of the XML tree
+     * @param indentLeaf - indents leaf nodes
+     */
+    YAMLWriter.prototype._convertObject = function (obj, options, level, suppressIndent) {
+        var e_1, _a;
+        var _this = this;
+        if (suppressIndent === void 0) { suppressIndent = false; }
+        var markup = '';
+        if (util_1.isArray(obj)) {
+            try {
+                for (var obj_1 = __values(obj), obj_1_1 = obj_1.next(); !obj_1_1.done; obj_1_1 = obj_1.next()) {
+                    var val = obj_1_1.value;
+                    markup += this._beginLine(options, level, true);
+                    if (!util_1.isObject(val)) {
+                        markup += this._val(val) + this._endLine(options);
+                    }
+                    else if (util_1.isEmpty(val)) {
+                        markup += '""' + this._endLine(options);
+                    }
+                    else {
+                        markup += this._convertObject(val, options, level, true);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (obj_1_1 && !obj_1_1.done && (_a = obj_1.return)) _a.call(obj_1);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        else /* if (isObject(obj)) */ {
+            util_1.forEachObject(obj, function (key, val) {
+                if (suppressIndent) {
+                    markup += _this._key(key);
+                    suppressIndent = false;
+                }
+                else {
+                    markup += _this._beginLine(options, level) + _this._key(key);
+                }
+                if (!util_1.isObject(val)) {
+                    markup += ' ' + _this._val(val) + _this._endLine(options);
+                }
+                else if (util_1.isEmpty(val)) {
+                    markup += ' ""' + _this._endLine(options);
+                }
+                else {
+                    markup += _this._endLine(options) +
+                        _this._convertObject(val, options, level + 1);
+                }
+            }, this);
+        }
+        return markup;
+    };
+    /**
+     * Produces characters to be prepended to a line of string in pretty-print
+     * mode.
+     *
+     * @param options - serialization options
+     * @param level - current depth of the XML tree
+     * @param isArray - whether this line is an array item
+     */
+    YAMLWriter.prototype._beginLine = function (options, level, isArray) {
+        if (isArray === void 0) { isArray = false; }
+        var indentLevel = options.offset + level + 1;
+        var chars = new Array(indentLevel).join(options.indent);
+        if (isArray) {
+            return chars.substr(0, chars.length - 2) + '-' + chars.substr(-1, 1);
+        }
+        else {
+            return chars;
+        }
+    };
+    /**
+     * Produces characters to be appended to a line of string in pretty-print
+     * mode.
+     *
+     * @param options - serialization options
+     */
+    YAMLWriter.prototype._endLine = function (options) {
+        return options.newline;
+    };
+    /**
+     * Produces a YAML key string delimited with double quotes.
+     */
+    YAMLWriter.prototype._key = function (key) {
+        return "\"" + key + "\":";
+    };
+    /**
+     * Produces a YAML value string delimited with double quotes.
+     */
+    YAMLWriter.prototype._val = function (val) {
+        return JSON.stringify(val);
+    };
+    return YAMLWriter;
+}(BaseWriter_1.BaseWriter));
+exports.YAMLWriter = YAMLWriter;
+//# sourceMappingURL=YAMLWriter.js.map
+
+/***/ }),
+
+/***/ 17476:
+/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+var MapWriter_1 = __nccwpck_require__(41397);
+exports.MapWriter = MapWriter_1.MapWriter;
+var XMLWriter_1 = __nccwpck_require__(59606);
+exports.XMLWriter = XMLWriter_1.XMLWriter;
+var ObjectWriter_1 = __nccwpck_require__(50243);
+exports.ObjectWriter = ObjectWriter_1.ObjectWriter;
+var JSONWriter_1 = __nccwpck_require__(37510);
+exports.JSONWriter = JSONWriter_1.JSONWriter;
+var YAMLWriter_1 = __nccwpck_require__(96517);
+exports.YAMLWriter = YAMLWriter_1.YAMLWriter;
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 10829:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+
+var yaml = __nccwpck_require__(59625);
+
+
+module.exports = yaml;
+
+
+/***/ }),
+
+/***/ 59625:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+
+var loader = __nccwpck_require__(40342);
+var dumper = __nccwpck_require__(98069);
+
+
+function deprecated(name) {
+  return function () {
+    throw new Error('Function ' + name + ' is deprecated and cannot be used.');
+  };
+}
+
+
+module.exports.Type = __nccwpck_require__(90256);
+module.exports.Schema = __nccwpck_require__(66280);
+module.exports.FAILSAFE_SCHEMA = __nccwpck_require__(70026);
+module.exports.JSON_SCHEMA = __nccwpck_require__(2168);
+module.exports.CORE_SCHEMA = __nccwpck_require__(11950);
+module.exports.DEFAULT_SAFE_SCHEMA = __nccwpck_require__(42881);
+module.exports.DEFAULT_FULL_SCHEMA = __nccwpck_require__(145);
+module.exports.load                = loader.load;
+module.exports.loadAll             = loader.loadAll;
+module.exports.safeLoad            = loader.safeLoad;
+module.exports.safeLoadAll         = loader.safeLoadAll;
+module.exports.dump                = dumper.dump;
+module.exports.safeDump            = dumper.safeDump;
+module.exports.YAMLException = __nccwpck_require__(29291);
+
+// Deprecated schema names from JS-YAML 2.0.x
+module.exports.MINIMAL_SCHEMA = __nccwpck_require__(70026);
+module.exports.SAFE_SCHEMA = __nccwpck_require__(42881);
+module.exports.DEFAULT_SCHEMA = __nccwpck_require__(145);
+
+// Deprecated functions from JS-YAML 1.x.x
+module.exports.scan           = deprecated('scan');
+module.exports.parse          = deprecated('parse');
+module.exports.compose        = deprecated('compose');
+module.exports.addConstructor = deprecated('addConstructor');
+
+
+/***/ }),
+
+/***/ 59941:
+/***/ ((module) => {
+
+"use strict";
+
+
+
+function isNothing(subject) {
+  return (typeof subject === 'undefined') || (subject === null);
+}
+
+
+function isObject(subject) {
+  return (typeof subject === 'object') && (subject !== null);
+}
+
+
+function toArray(sequence) {
+  if (Array.isArray(sequence)) return sequence;
+  else if (isNothing(sequence)) return [];
+
+  return [ sequence ];
+}
+
+
+function extend(target, source) {
+  var index, length, key, sourceKeys;
+
+  if (source) {
+    sourceKeys = Object.keys(source);
+
+    for (index = 0, length = sourceKeys.length; index < length; index += 1) {
+      key = sourceKeys[index];
+      target[key] = source[key];
+    }
+  }
+
+  return target;
+}
+
+
+function repeat(string, count) {
+  var result = '', cycle;
+
+  for (cycle = 0; cycle < count; cycle += 1) {
+    result += string;
+  }
+
+  return result;
+}
+
+
+function isNegativeZero(number) {
+  return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number);
+}
+
+
+module.exports.isNothing      = isNothing;
+module.exports.isObject       = isObject;
+module.exports.toArray        = toArray;
+module.exports.repeat         = repeat;
+module.exports.isNegativeZero = isNegativeZero;
+module.exports.extend         = extend;
+
+
+/***/ }),
+
+/***/ 98069:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+/*eslint-disable no-use-before-define*/
+
+var common              = __nccwpck_require__(59941);
+var YAMLException       = __nccwpck_require__(29291);
+var DEFAULT_FULL_SCHEMA = __nccwpck_require__(145);
+var DEFAULT_SAFE_SCHEMA = __nccwpck_require__(42881);
+
+var _toString       = Object.prototype.toString;
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+var CHAR_TAB                  = 0x09; /* Tab */
+var CHAR_LINE_FEED            = 0x0A; /* LF */
+var CHAR_CARRIAGE_RETURN      = 0x0D; /* CR */
+var CHAR_SPACE                = 0x20; /* Space */
+var CHAR_EXCLAMATION          = 0x21; /* ! */
+var CHAR_DOUBLE_QUOTE         = 0x22; /* " */
+var CHAR_SHARP                = 0x23; /* # */
+var CHAR_PERCENT              = 0x25; /* % */
+var CHAR_AMPERSAND            = 0x26; /* & */
+var CHAR_SINGLE_QUOTE         = 0x27; /* ' */
+var CHAR_ASTERISK             = 0x2A; /* * */
+var CHAR_COMMA                = 0x2C; /* , */
+var CHAR_MINUS                = 0x2D; /* - */
+var CHAR_COLON                = 0x3A; /* : */
+var CHAR_EQUALS               = 0x3D; /* = */
+var CHAR_GREATER_THAN         = 0x3E; /* > */
+var CHAR_QUESTION             = 0x3F; /* ? */
+var CHAR_COMMERCIAL_AT        = 0x40; /* @ */
+var CHAR_LEFT_SQUARE_BRACKET  = 0x5B; /* [ */
+var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */
+var CHAR_GRAVE_ACCENT         = 0x60; /* ` */
+var CHAR_LEFT_CURLY_BRACKET   = 0x7B; /* { */
+var CHAR_VERTICAL_LINE        = 0x7C; /* | */
+var CHAR_RIGHT_CURLY_BRACKET  = 0x7D; /* } */
+
+var ESCAPE_SEQUENCES = {};
+
+ESCAPE_SEQUENCES[0x00]   = '\\0';
+ESCAPE_SEQUENCES[0x07]   = '\\a';
+ESCAPE_SEQUENCES[0x08]   = '\\b';
+ESCAPE_SEQUENCES[0x09]   = '\\t';
+ESCAPE_SEQUENCES[0x0A]   = '\\n';
+ESCAPE_SEQUENCES[0x0B]   = '\\v';
+ESCAPE_SEQUENCES[0x0C]   = '\\f';
+ESCAPE_SEQUENCES[0x0D]   = '\\r';
+ESCAPE_SEQUENCES[0x1B]   = '\\e';
+ESCAPE_SEQUENCES[0x22]   = '\\"';
+ESCAPE_SEQUENCES[0x5C]   = '\\\\';
+ESCAPE_SEQUENCES[0x85]   = '\\N';
+ESCAPE_SEQUENCES[0xA0]   = '\\_';
+ESCAPE_SEQUENCES[0x2028] = '\\L';
+ESCAPE_SEQUENCES[0x2029] = '\\P';
+
+var DEPRECATED_BOOLEANS_SYNTAX = [
+  'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON',
+  'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF'
+];
+
+function compileStyleMap(schema, map) {
+  var result, keys, index, length, tag, style, type;
+
+  if (map === null) return {};
+
+  result = {};
+  keys = Object.keys(map);
+
+  for (index = 0, length = keys.length; index < length; index += 1) {
+    tag = keys[index];
+    style = String(map[tag]);
+
+    if (tag.slice(0, 2) === '!!') {
+      tag = 'tag:yaml.org,2002:' + tag.slice(2);
+    }
+    type = schema.compiledTypeMap['fallback'][tag];
+
+    if (type && _hasOwnProperty.call(type.styleAliases, style)) {
+      style = type.styleAliases[style];
+    }
+
+    result[tag] = style;
+  }
+
+  return result;
+}
+
+function encodeHex(character) {
+  var string, handle, length;
+
+  string = character.toString(16).toUpperCase();
+
+  if (character <= 0xFF) {
+    handle = 'x';
+    length = 2;
+  } else if (character <= 0xFFFF) {
+    handle = 'u';
+    length = 4;
+  } else if (character <= 0xFFFFFFFF) {
+    handle = 'U';
+    length = 8;
+  } else {
+    throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF');
+  }
+
+  return '\\' + handle + common.repeat('0', length - string.length) + string;
+}
+
+function State(options) {
+  this.schema        = options['schema'] || DEFAULT_FULL_SCHEMA;
+  this.indent        = Math.max(1, (options['indent'] || 2));
+  this.noArrayIndent = options['noArrayIndent'] || false;
+  this.skipInvalid   = options['skipInvalid'] || false;
+  this.flowLevel     = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']);
+  this.styleMap      = compileStyleMap(this.schema, options['styles'] || null);
+  this.sortKeys      = options['sortKeys'] || false;
+  this.lineWidth     = options['lineWidth'] || 80;
+  this.noRefs        = options['noRefs'] || false;
+  this.noCompatMode  = options['noCompatMode'] || false;
+  this.condenseFlow  = options['condenseFlow'] || false;
+
+  this.implicitTypes = this.schema.compiledImplicit;
+  this.explicitTypes = this.schema.compiledExplicit;
+
+  this.tag = null;
+  this.result = '';
+
+  this.duplicates = [];
+  this.usedDuplicates = null;
+}
+
+// Indents every line in a string. Empty lines (\n only) are not indented.
+function indentString(string, spaces) {
+  var ind = common.repeat(' ', spaces),
+      position = 0,
+      next = -1,
+      result = '',
+      line,
+      length = string.length;
+
+  while (position < length) {
+    next = string.indexOf('\n', position);
+    if (next === -1) {
+      line = string.slice(position);
+      position = length;
+    } else {
+      line = string.slice(position, next + 1);
+      position = next + 1;
+    }
+
+    if (line.length && line !== '\n') result += ind;
+
+    result += line;
+  }
+
+  return result;
+}
+
+function generateNextLine(state, level) {
+  return '\n' + common.repeat(' ', state.indent * level);
+}
+
+function testImplicitResolving(state, str) {
+  var index, length, type;
+
+  for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
+    type = state.implicitTypes[index];
+
+    if (type.resolve(str)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// [33] s-white ::= s-space | s-tab
+function isWhitespace(c) {
+  return c === CHAR_SPACE || c === CHAR_TAB;
+}
+
+// Returns true if the character can be printed without escaping.
+// From YAML 1.2: "any allowed characters known to be non-printable
+// should also be escaped. [However,] This isn’t mandatory"
+// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029.
+function isPrintable(c) {
+  return  (0x00020 <= c && c <= 0x00007E)
+      || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029)
+      || ((0x0E000 <= c && c <= 0x00FFFD) && c !== 0xFEFF /* BOM */)
+      ||  (0x10000 <= c && c <= 0x10FFFF);
+}
+
+// [34] ns-char ::= nb-char - s-white
+// [27] nb-char ::= c-printable - b-char - c-byte-order-mark
+// [26] b-char  ::= b-line-feed | b-carriage-return
+// [24] b-line-feed       ::=     #xA    /* LF */
+// [25] b-carriage-return ::=     #xD    /* CR */
+// [3]  c-byte-order-mark ::=     #xFEFF
+function isNsChar(c) {
+  return isPrintable(c) && !isWhitespace(c)
+    // byte-order-mark
+    && c !== 0xFEFF
+    // b-char
+    && c !== CHAR_CARRIAGE_RETURN
+    && c !== CHAR_LINE_FEED;
+}
+
+// Simplified test for values allowed after the first character in plain style.
+function isPlainSafe(c, prev) {
+  // Uses a subset of nb-char - c-flow-indicator - ":" - "#"
+  // where nb-char ::= c-printable - b-char - c-byte-order-mark.
+  return isPrintable(c) && c !== 0xFEFF
+    // - c-flow-indicator
+    && c !== CHAR_COMMA
+    && c !== CHAR_LEFT_SQUARE_BRACKET
+    && c !== CHAR_RIGHT_SQUARE_BRACKET
+    && c !== CHAR_LEFT_CURLY_BRACKET
+    && c !== CHAR_RIGHT_CURLY_BRACKET
+    // - ":" - "#"
+    // /* An ns-char preceding */ "#"
+    && c !== CHAR_COLON
+    && ((c !== CHAR_SHARP) || (prev && isNsChar(prev)));
+}
+
+// Simplified test for values allowed as the first character in plain style.
+function isPlainSafeFirst(c) {
+  // Uses a subset of ns-char - c-indicator
+  // where ns-char = nb-char - s-white.
+  return isPrintable(c) && c !== 0xFEFF
+    && !isWhitespace(c) // - s-white
+    // - (c-indicator ::=
+    // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}”
+    && c !== CHAR_MINUS
+    && c !== CHAR_QUESTION
+    && c !== CHAR_COLON
+    && c !== CHAR_COMMA
+    && c !== CHAR_LEFT_SQUARE_BRACKET
+    && c !== CHAR_RIGHT_SQUARE_BRACKET
+    && c !== CHAR_LEFT_CURLY_BRACKET
+    && c !== CHAR_RIGHT_CURLY_BRACKET
+    // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"”
+    && c !== CHAR_SHARP
+    && c !== CHAR_AMPERSAND
+    && c !== CHAR_ASTERISK
+    && c !== CHAR_EXCLAMATION
+    && c !== CHAR_VERTICAL_LINE
+    && c !== CHAR_EQUALS
+    && c !== CHAR_GREATER_THAN
+    && c !== CHAR_SINGLE_QUOTE
+    && c !== CHAR_DOUBLE_QUOTE
+    // | “%” | “@” | “`”)
+    && c !== CHAR_PERCENT
+    && c !== CHAR_COMMERCIAL_AT
+    && c !== CHAR_GRAVE_ACCENT;
+}
+
+// Determines whether block indentation indicator is required.
+function needIndentIndicator(string) {
+  var leadingSpaceRe = /^\n* /;
+  return leadingSpaceRe.test(string);
+}
+
+var STYLE_PLAIN   = 1,
+    STYLE_SINGLE  = 2,
+    STYLE_LITERAL = 3,
+    STYLE_FOLDED  = 4,
+    STYLE_DOUBLE  = 5;
+
+// Determines which scalar styles are possible and returns the preferred style.
+// lineWidth = -1 => no limit.
+// Pre-conditions: str.length > 0.
+// Post-conditions:
+//    STYLE_PLAIN or STYLE_SINGLE => no \n are in the string.
+//    STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1).
+//    STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1).
+function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType) {
+  var i;
+  var char, prev_char;
+  var hasLineBreak = false;
+  var hasFoldableLine = false; // only checked if shouldTrackWidth
+  var shouldTrackWidth = lineWidth !== -1;
+  var previousLineBreak = -1; // count the first line correctly
+  var plain = isPlainSafeFirst(string.charCodeAt(0))
+          && !isWhitespace(string.charCodeAt(string.length - 1));
+
+  if (singleLineOnly) {
+    // Case: no block styles.
+    // Check for disallowed characters to rule out plain and single.
+    for (i = 0; i < string.length; i++) {
+      char = string.charCodeAt(i);
+      if (!isPrintable(char)) {
+        return STYLE_DOUBLE;
+      }
+      prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
+      plain = plain && isPlainSafe(char, prev_char);
+    }
+  } else {
+    // Case: block styles permitted.
+    for (i = 0; i < string.length; i++) {
+      char = string.charCodeAt(i);
+      if (char === CHAR_LINE_FEED) {
+        hasLineBreak = true;
+        // Check if any line can be folded.
+        if (shouldTrackWidth) {
+          hasFoldableLine = hasFoldableLine ||
+            // Foldable line = too long, and not more-indented.
+            (i - previousLineBreak - 1 > lineWidth &&
+             string[previousLineBreak + 1] !== ' ');
+          previousLineBreak = i;
+        }
+      } else if (!isPrintable(char)) {
+        return STYLE_DOUBLE;
+      }
+      prev_char = i > 0 ? string.charCodeAt(i - 1) : null;
+      plain = plain && isPlainSafe(char, prev_char);
+    }
+    // in case the end is missing a \n
+    hasFoldableLine = hasFoldableLine || (shouldTrackWidth &&
+      (i - previousLineBreak - 1 > lineWidth &&
+       string[previousLineBreak + 1] !== ' '));
+  }
+  // Although every style can represent \n without escaping, prefer block styles
+  // for multiline, since they're more readable and they don't add empty lines.
+  // Also prefer folding a super-long line.
+  if (!hasLineBreak && !hasFoldableLine) {
+    // Strings interpretable as another type have to be quoted;
+    // e.g. the string 'true' vs. the boolean true.
+    return plain && !testAmbiguousType(string)
+      ? STYLE_PLAIN : STYLE_SINGLE;
+  }
+  // Edge case: block indentation indicator can only have one digit.
+  if (indentPerLevel > 9 && needIndentIndicator(string)) {
+    return STYLE_DOUBLE;
+  }
+  // At this point we know block styles are valid.
+  // Prefer literal style unless we want to fold.
+  return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
+}
+
+// Note: line breaking/folding is implemented for only the folded style.
+// NB. We drop the last trailing newline (if any) of a returned block scalar
+//  since the dumper adds its own newline. This always works:
+//    • No ending newline => unaffected; already using strip "-" chomping.
+//    • Ending newline    => removed then restored.
+//  Importantly, this keeps the "+" chomp indicator from gaining an extra line.
+function writeScalar(state, string, level, iskey) {
+  state.dump = (function () {
+    if (string.length === 0) {
+      return "''";
+    }
+    if (!state.noCompatMode &&
+        DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1) {
+      return "'" + string + "'";
+    }
+
+    var indent = state.indent * Math.max(1, level); // no 0-indent scalars
+    // As indentation gets deeper, let the width decrease monotonically
+    // to the lower bound min(state.lineWidth, 40).
+    // Note that this implies
+    //  state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound.
+    //  state.lineWidth > 40 + state.indent: width decreases until the lower bound.
+    // This behaves better than a constant minimum width which disallows narrower options,
+    // or an indent threshold which causes the width to suddenly increase.
+    var lineWidth = state.lineWidth === -1
+      ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
+
+    // Without knowing if keys are implicit/explicit, assume implicit for safety.
+    var singleLineOnly = iskey
+      // No block styles in flow mode.
+      || (state.flowLevel > -1 && level >= state.flowLevel);
+    function testAmbiguity(string) {
+      return testImplicitResolving(state, string);
+    }
+
+    switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, testAmbiguity)) {
+      case STYLE_PLAIN:
+        return string;
+      case STYLE_SINGLE:
+        return "'" + string.replace(/'/g, "''") + "'";
+      case STYLE_LITERAL:
+        return '|' + blockHeader(string, state.indent)
+          + dropEndingNewline(indentString(string, indent));
+      case STYLE_FOLDED:
+        return '>' + blockHeader(string, state.indent)
+          + dropEndingNewline(indentString(foldString(string, lineWidth), indent));
+      case STYLE_DOUBLE:
+        return '"' + escapeString(string, lineWidth) + '"';
+      default:
+        throw new YAMLException('impossible error: invalid scalar style');
+    }
+  }());
+}
+
+// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9.
+function blockHeader(string, indentPerLevel) {
+  var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : '';
+
+  // note the special case: the string '\n' counts as a "trailing" empty line.
+  var clip =          string[string.length - 1] === '\n';
+  var keep = clip && (string[string.length - 2] === '\n' || string === '\n');
+  var chomp = keep ? '+' : (clip ? '' : '-');
+
+  return indentIndicator + chomp + '\n';
+}
+
+// (See the note for writeScalar.)
+function dropEndingNewline(string) {
+  return string[string.length - 1] === '\n' ? string.slice(0, -1) : string;
+}
+
+// Note: a long line without a suitable break point will exceed the width limit.
+// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0.
+function foldString(string, width) {
+  // In folded style, $k$ consecutive newlines output as $k+1$ newlines—
+  // unless they're before or after a more-indented line, or at the very
+  // beginning or end, in which case $k$ maps to $k$.
+  // Therefore, parse each chunk as newline(s) followed by a content line.
+  var lineRe = /(\n+)([^\n]*)/g;
+
+  // first line (possibly an empty line)
+  var result = (function () {
+    var nextLF = string.indexOf('\n');
+    nextLF = nextLF !== -1 ? nextLF : string.length;
+    lineRe.lastIndex = nextLF;
+    return foldLine(string.slice(0, nextLF), width);
+  }());
+  // If we haven't reached the first content line yet, don't add an extra \n.
+  var prevMoreIndented = string[0] === '\n' || string[0] === ' ';
+  var moreIndented;
+
+  // rest of the lines
+  var match;
+  while ((match = lineRe.exec(string))) {
+    var prefix = match[1], line = match[2];
+    moreIndented = (line[0] === ' ');
+    result += prefix
+      + (!prevMoreIndented && !moreIndented && line !== ''
+        ? '\n' : '')
+      + foldLine(line, width);
+    prevMoreIndented = moreIndented;
+  }
+
+  return result;
+}
+
+// Greedy line breaking.
+// Picks the longest line under the limit each time,
+// otherwise settles for the shortest line over the limit.
+// NB. More-indented lines *cannot* be folded, as that would add an extra \n.
+function foldLine(line, width) {
+  if (line === '' || line[0] === ' ') return line;
+
+  // Since a more-indented line adds a \n, breaks can't be followed by a space.
+  var breakRe = / [^ ]/g; // note: the match index will always be <= length-2.
+  var match;
+  // start is an inclusive index. end, curr, and next are exclusive.
+  var start = 0, end, curr = 0, next = 0;
+  var result = '';
+
+  // Invariants: 0 <= start <= length-1.
+  //   0 <= curr <= next <= max(0, length-2). curr - start <= width.
+  // Inside the loop:
+  //   A match implies length >= 2, so curr and next are <= length-2.
+  while ((match = breakRe.exec(line))) {
+    next = match.index;
+    // maintain invariant: curr - start <= width
+    if (next - start > width) {
+      end = (curr > start) ? curr : next; // derive end <= length-2
+      result += '\n' + line.slice(start, end);
+      // skip the space that was output as \n
+      start = end + 1;                    // derive start <= length-1
+    }
+    curr = next;
+  }
+
+  // By the invariants, start <= length-1, so there is something left over.
+  // It is either the whole string or a part starting from non-whitespace.
+  result += '\n';
+  // Insert a break if the remainder is too long and there is a break available.
+  if (line.length - start > width && curr > start) {
+    result += line.slice(start, curr) + '\n' + line.slice(curr + 1);
+  } else {
+    result += line.slice(start);
+  }
+
+  return result.slice(1); // drop extra \n joiner
+}
+
+// Escapes a double-quoted string.
+function escapeString(string) {
+  var result = '';
+  var char, nextChar;
+  var escapeSeq;
+
+  for (var i = 0; i < string.length; i++) {
+    char = string.charCodeAt(i);
+    // Check for surrogate pairs (reference Unicode 3.0 section "3.7 Surrogates").
+    if (char >= 0xD800 && char <= 0xDBFF/* high surrogate */) {
+      nextChar = string.charCodeAt(i + 1);
+      if (nextChar >= 0xDC00 && nextChar <= 0xDFFF/* low surrogate */) {
+        // Combine the surrogate pair and store it escaped.
+        result += encodeHex((char - 0xD800) * 0x400 + nextChar - 0xDC00 + 0x10000);
+        // Advance index one extra since we already used that char here.
+        i++; continue;
+      }
+    }
+    escapeSeq = ESCAPE_SEQUENCES[char];
+    result += !escapeSeq && isPrintable(char)
+      ? string[i]
+      : escapeSeq || encodeHex(char);
+  }
+
+  return result;
+}
+
+function writeFlowSequence(state, level, object) {
+  var _result = '',
+      _tag    = state.tag,
+      index,
+      length;
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    // Write only valid elements.
+    if (writeNode(state, level, object[index], false, false)) {
+      if (index !== 0) _result += ',' + (!state.condenseFlow ? ' ' : '');
+      _result += state.dump;
+    }
+  }
+
+  state.tag = _tag;
+  state.dump = '[' + _result + ']';
+}
+
+function writeBlockSequence(state, level, object, compact) {
+  var _result = '',
+      _tag    = state.tag,
+      index,
+      length;
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    // Write only valid elements.
+    if (writeNode(state, level + 1, object[index], true, true)) {
+      if (!compact || index !== 0) {
+        _result += generateNextLine(state, level);
+      }
+
+      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+        _result += '-';
+      } else {
+        _result += '- ';
+      }
+
+      _result += state.dump;
+    }
+  }
+
+  state.tag = _tag;
+  state.dump = _result || '[]'; // Empty sequence if no valid values.
+}
+
+function writeFlowMapping(state, level, object) {
+  var _result       = '',
+      _tag          = state.tag,
+      objectKeyList = Object.keys(object),
+      index,
+      length,
+      objectKey,
+      objectValue,
+      pairBuffer;
+
+  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+
+    pairBuffer = '';
+    if (index !== 0) pairBuffer += ', ';
+
+    if (state.condenseFlow) pairBuffer += '"';
+
+    objectKey = objectKeyList[index];
+    objectValue = object[objectKey];
+
+    if (!writeNode(state, level, objectKey, false, false)) {
+      continue; // Skip this pair because of invalid key;
+    }
+
+    if (state.dump.length > 1024) pairBuffer += '? ';
+
+    pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' ');
+
+    if (!writeNode(state, level, objectValue, false, false)) {
+      continue; // Skip this pair because of invalid value.
+    }
+
+    pairBuffer += state.dump;
+
+    // Both key and value are valid.
+    _result += pairBuffer;
+  }
+
+  state.tag = _tag;
+  state.dump = '{' + _result + '}';
+}
+
+function writeBlockMapping(state, level, object, compact) {
+  var _result       = '',
+      _tag          = state.tag,
+      objectKeyList = Object.keys(object),
+      index,
+      length,
+      objectKey,
+      objectValue,
+      explicitPair,
+      pairBuffer;
+
+  // Allow sorting keys so that the output file is deterministic
+  if (state.sortKeys === true) {
+    // Default sorting
+    objectKeyList.sort();
+  } else if (typeof state.sortKeys === 'function') {
+    // Custom sort function
+    objectKeyList.sort(state.sortKeys);
+  } else if (state.sortKeys) {
+    // Something is wrong
+    throw new YAMLException('sortKeys must be a boolean or a function');
+  }
+
+  for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+    pairBuffer = '';
+
+    if (!compact || index !== 0) {
+      pairBuffer += generateNextLine(state, level);
+    }
+
+    objectKey = objectKeyList[index];
+    objectValue = object[objectKey];
+
+    if (!writeNode(state, level + 1, objectKey, true, true, true)) {
+      continue; // Skip this pair because of invalid key.
+    }
+
+    explicitPair = (state.tag !== null && state.tag !== '?') ||
+                   (state.dump && state.dump.length > 1024);
+
+    if (explicitPair) {
+      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+        pairBuffer += '?';
+      } else {
+        pairBuffer += '? ';
+      }
+    }
+
+    pairBuffer += state.dump;
+
+    if (explicitPair) {
+      pairBuffer += generateNextLine(state, level);
+    }
+
+    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
+      continue; // Skip this pair because of invalid value.
+    }
+
+    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
+      pairBuffer += ':';
+    } else {
+      pairBuffer += ': ';
+    }
+
+    pairBuffer += state.dump;
+
+    // Both key and value are valid.
+    _result += pairBuffer;
+  }
+
+  state.tag = _tag;
+  state.dump = _result || '{}'; // Empty mapping if no valid pairs.
+}
+
+function detectType(state, object, explicit) {
+  var _result, typeList, index, length, type, style;
+
+  typeList = explicit ? state.explicitTypes : state.implicitTypes;
+
+  for (index = 0, length = typeList.length; index < length; index += 1) {
+    type = typeList[index];
+
+    if ((type.instanceOf  || type.predicate) &&
+        (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) &&
+        (!type.predicate  || type.predicate(object))) {
+
+      state.tag = explicit ? type.tag : '?';
+
+      if (type.represent) {
+        style = state.styleMap[type.tag] || type.defaultStyle;
+
+        if (_toString.call(type.represent) === '[object Function]') {
+          _result = type.represent(object, style);
+        } else if (_hasOwnProperty.call(type.represent, style)) {
+          _result = type.represent[style](object, style);
+        } else {
+          throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style');
+        }
+
+        state.dump = _result;
+      }
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+// Serializes `object` and writes it to global `result`.
+// Returns true on success, or false on invalid object.
+//
+function writeNode(state, level, object, block, compact, iskey) {
+  state.tag = null;
+  state.dump = object;
+
+  if (!detectType(state, object, false)) {
+    detectType(state, object, true);
+  }
+
+  var type = _toString.call(state.dump);
+
+  if (block) {
+    block = (state.flowLevel < 0 || state.flowLevel > level);
+  }
+
+  var objectOrArray = type === '[object Object]' || type === '[object Array]',
+      duplicateIndex,
+      duplicate;
+
+  if (objectOrArray) {
+    duplicateIndex = state.duplicates.indexOf(object);
+    duplicate = duplicateIndex !== -1;
+  }
+
+  if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) {
+    compact = false;
+  }
+
+  if (duplicate && state.usedDuplicates[duplicateIndex]) {
+    state.dump = '*ref_' + duplicateIndex;
+  } else {
+    if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) {
+      state.usedDuplicates[duplicateIndex] = true;
+    }
+    if (type === '[object Object]') {
+      if (block && (Object.keys(state.dump).length !== 0)) {
+        writeBlockMapping(state, level, state.dump, compact);
+        if (duplicate) {
+          state.dump = '&ref_' + duplicateIndex + state.dump;
+        }
+      } else {
+        writeFlowMapping(state, level, state.dump);
+        if (duplicate) {
+          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
+        }
+      }
+    } else if (type === '[object Array]') {
+      var arrayLevel = (state.noArrayIndent && (level > 0)) ? level - 1 : level;
+      if (block && (state.dump.length !== 0)) {
+        writeBlockSequence(state, arrayLevel, state.dump, compact);
+        if (duplicate) {
+          state.dump = '&ref_' + duplicateIndex + state.dump;
+        }
+      } else {
+        writeFlowSequence(state, arrayLevel, state.dump);
+        if (duplicate) {
+          state.dump = '&ref_' + duplicateIndex + ' ' + state.dump;
+        }
+      }
+    } else if (type === '[object String]') {
+      if (state.tag !== '?') {
+        writeScalar(state, state.dump, level, iskey);
+      }
+    } else {
+      if (state.skipInvalid) return false;
+      throw new YAMLException('unacceptable kind of an object to dump ' + type);
+    }
+
+    if (state.tag !== null && state.tag !== '?') {
+      state.dump = '!<' + state.tag + '> ' + state.dump;
+    }
+  }
+
+  return true;
+}
+
+function getDuplicateReferences(object, state) {
+  var objects = [],
+      duplicatesIndexes = [],
+      index,
+      length;
+
+  inspectNode(object, objects, duplicatesIndexes);
+
+  for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) {
+    state.duplicates.push(objects[duplicatesIndexes[index]]);
+  }
+  state.usedDuplicates = new Array(length);
+}
+
+function inspectNode(object, objects, duplicatesIndexes) {
+  var objectKeyList,
+      index,
+      length;
+
+  if (object !== null && typeof object === 'object') {
+    index = objects.indexOf(object);
+    if (index !== -1) {
+      if (duplicatesIndexes.indexOf(index) === -1) {
+        duplicatesIndexes.push(index);
+      }
+    } else {
+      objects.push(object);
+
+      if (Array.isArray(object)) {
+        for (index = 0, length = object.length; index < length; index += 1) {
+          inspectNode(object[index], objects, duplicatesIndexes);
+        }
+      } else {
+        objectKeyList = Object.keys(object);
+
+        for (index = 0, length = objectKeyList.length; index < length; index += 1) {
+          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
+        }
+      }
+    }
+  }
+}
+
+function dump(input, options) {
+  options = options || {};
+
+  var state = new State(options);
+
+  if (!state.noRefs) getDuplicateReferences(input, state);
+
+  if (writeNode(state, 0, input, true, true)) return state.dump + '\n';
+
+  return '';
+}
+
+function safeDump(input, options) {
+  return dump(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
+}
+
+module.exports.dump     = dump;
+module.exports.safeDump = safeDump;
+
+
+/***/ }),
+
+/***/ 29291:
+/***/ ((module) => {
+
+"use strict";
+// YAML error class. http://stackoverflow.com/questions/8458984
+//
+
+
+function YAMLException(reason, mark) {
+  // Super constructor
+  Error.call(this);
+
+  this.name = 'YAMLException';
+  this.reason = reason;
+  this.mark = mark;
+  this.message = (this.reason || '(unknown reason)') + (this.mark ? ' ' + this.mark.toString() : '');
+
+  // Include stack trace in error object
+  if (Error.captureStackTrace) {
+    // Chrome and NodeJS
+    Error.captureStackTrace(this, this.constructor);
+  } else {
+    // FF, IE 10+ and Safari 6+. Fallback for others
+    this.stack = (new Error()).stack || '';
+  }
+}
+
+
+// Inherit from Error
+YAMLException.prototype = Object.create(Error.prototype);
+YAMLException.prototype.constructor = YAMLException;
+
+
+YAMLException.prototype.toString = function toString(compact) {
+  var result = this.name + ': ';
+
+  result += this.reason || '(unknown reason)';
+
+  if (!compact && this.mark) {
+    result += ' ' + this.mark.toString();
+  }
+
+  return result;
+};
+
+
+module.exports = YAMLException;
+
+
+/***/ }),
+
+/***/ 40342:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+/*eslint-disable max-len,no-use-before-define*/
+
+var common              = __nccwpck_require__(59941);
+var YAMLException       = __nccwpck_require__(29291);
+var Mark                = __nccwpck_require__(77262);
+var DEFAULT_SAFE_SCHEMA = __nccwpck_require__(42881);
+var DEFAULT_FULL_SCHEMA = __nccwpck_require__(145);
+
+
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+
+var CONTEXT_FLOW_IN   = 1;
+var CONTEXT_FLOW_OUT  = 2;
+var CONTEXT_BLOCK_IN  = 3;
+var CONTEXT_BLOCK_OUT = 4;
+
+
+var CHOMPING_CLIP  = 1;
+var CHOMPING_STRIP = 2;
+var CHOMPING_KEEP  = 3;
+
+
+var PATTERN_NON_PRINTABLE         = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+var PATTERN_FLOW_INDICATORS       = /[,\[\]\{\}]/;
+var PATTERN_TAG_HANDLE            = /^(?:!|!!|![a-z\-]+!)$/i;
+var PATTERN_TAG_URI               = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+
+
+function _class(obj) { return Object.prototype.toString.call(obj); }
+
+function is_EOL(c) {
+  return (c === 0x0A/* LF */) || (c === 0x0D/* CR */);
+}
+
+function is_WHITE_SPACE(c) {
+  return (c === 0x09/* Tab */) || (c === 0x20/* Space */);
+}
+
+function is_WS_OR_EOL(c) {
+  return (c === 0x09/* Tab */) ||
+         (c === 0x20/* Space */) ||
+         (c === 0x0A/* LF */) ||
+         (c === 0x0D/* CR */);
+}
+
+function is_FLOW_INDICATOR(c) {
+  return c === 0x2C/* , */ ||
+         c === 0x5B/* [ */ ||
+         c === 0x5D/* ] */ ||
+         c === 0x7B/* { */ ||
+         c === 0x7D/* } */;
+}
+
+function fromHexCode(c) {
+  var lc;
+
+  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
+    return c - 0x30;
+  }
+
+  /*eslint-disable no-bitwise*/
+  lc = c | 0x20;
+
+  if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) {
+    return lc - 0x61 + 10;
+  }
+
+  return -1;
+}
+
+function escapedHexLen(c) {
+  if (c === 0x78/* x */) { return 2; }
+  if (c === 0x75/* u */) { return 4; }
+  if (c === 0x55/* U */) { return 8; }
+  return 0;
+}
+
+function fromDecimalCode(c) {
+  if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) {
+    return c - 0x30;
+  }
+
+  return -1;
+}
+
+function simpleEscapeSequence(c) {
+  /* eslint-disable indent */
+  return (c === 0x30/* 0 */) ? '\x00' :
+        (c === 0x61/* a */) ? '\x07' :
+        (c === 0x62/* b */) ? '\x08' :
+        (c === 0x74/* t */) ? '\x09' :
+        (c === 0x09/* Tab */) ? '\x09' :
+        (c === 0x6E/* n */) ? '\x0A' :
+        (c === 0x76/* v */) ? '\x0B' :
+        (c === 0x66/* f */) ? '\x0C' :
+        (c === 0x72/* r */) ? '\x0D' :
+        (c === 0x65/* e */) ? '\x1B' :
+        (c === 0x20/* Space */) ? ' ' :
+        (c === 0x22/* " */) ? '\x22' :
+        (c === 0x2F/* / */) ? '/' :
+        (c === 0x5C/* \ */) ? '\x5C' :
+        (c === 0x4E/* N */) ? '\x85' :
+        (c === 0x5F/* _ */) ? '\xA0' :
+        (c === 0x4C/* L */) ? '\u2028' :
+        (c === 0x50/* P */) ? '\u2029' : '';
+}
+
+function charFromCodepoint(c) {
+  if (c <= 0xFFFF) {
+    return String.fromCharCode(c);
+  }
+  // Encode UTF-16 surrogate pair
+  // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF
+  return String.fromCharCode(
+    ((c - 0x010000) >> 10) + 0xD800,
+    ((c - 0x010000) & 0x03FF) + 0xDC00
+  );
+}
+
+var simpleEscapeCheck = new Array(256); // integer, for fast access
+var simpleEscapeMap = new Array(256);
+for (var i = 0; i < 256; i++) {
+  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
+  simpleEscapeMap[i] = simpleEscapeSequence(i);
+}
+
+
+function State(input, options) {
+  this.input = input;
+
+  this.filename  = options['filename']  || null;
+  this.schema    = options['schema']    || DEFAULT_FULL_SCHEMA;
+  this.onWarning = options['onWarning'] || null;
+  this.legacy    = options['legacy']    || false;
+  this.json      = options['json']      || false;
+  this.listener  = options['listener']  || null;
+
+  this.implicitTypes = this.schema.compiledImplicit;
+  this.typeMap       = this.schema.compiledTypeMap;
+
+  this.length     = input.length;
+  this.position   = 0;
+  this.line       = 0;
+  this.lineStart  = 0;
+  this.lineIndent = 0;
+
+  this.documents = [];
+
+  /*
+  this.version;
+  this.checkLineBreaks;
+  this.tagMap;
+  this.anchorMap;
+  this.tag;
+  this.anchor;
+  this.kind;
+  this.result;*/
+
+}
+
+
+function generateError(state, message) {
+  return new YAMLException(
+    message,
+    new Mark(state.filename, state.input, state.position, state.line, (state.position - state.lineStart)));
+}
+
+function throwError(state, message) {
+  throw generateError(state, message);
+}
+
+function throwWarning(state, message) {
+  if (state.onWarning) {
+    state.onWarning.call(null, generateError(state, message));
+  }
+}
+
+
+var directiveHandlers = {
+
+  YAML: function handleYamlDirective(state, name, args) {
+
+    var match, major, minor;
+
+    if (state.version !== null) {
+      throwError(state, 'duplication of %YAML directive');
+    }
+
+    if (args.length !== 1) {
+      throwError(state, 'YAML directive accepts exactly one argument');
+    }
+
+    match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+
+    if (match === null) {
+      throwError(state, 'ill-formed argument of the YAML directive');
+    }
+
+    major = parseInt(match[1], 10);
+    minor = parseInt(match[2], 10);
+
+    if (major !== 1) {
+      throwError(state, 'unacceptable YAML version of the document');
+    }
+
+    state.version = args[0];
+    state.checkLineBreaks = (minor < 2);
+
+    if (minor !== 1 && minor !== 2) {
+      throwWarning(state, 'unsupported YAML version of the document');
+    }
+  },
+
+  TAG: function handleTagDirective(state, name, args) {
+
+    var handle, prefix;
+
+    if (args.length !== 2) {
+      throwError(state, 'TAG directive accepts exactly two arguments');
+    }
+
+    handle = args[0];
+    prefix = args[1];
+
+    if (!PATTERN_TAG_HANDLE.test(handle)) {
+      throwError(state, 'ill-formed tag handle (first argument) of the TAG directive');
+    }
+
+    if (_hasOwnProperty.call(state.tagMap, handle)) {
+      throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle');
+    }
+
+    if (!PATTERN_TAG_URI.test(prefix)) {
+      throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive');
+    }
+
+    state.tagMap[handle] = prefix;
+  }
+};
+
+
+function captureSegment(state, start, end, checkJson) {
+  var _position, _length, _character, _result;
+
+  if (start < end) {
+    _result = state.input.slice(start, end);
+
+    if (checkJson) {
+      for (_position = 0, _length = _result.length; _position < _length; _position += 1) {
+        _character = _result.charCodeAt(_position);
+        if (!(_character === 0x09 ||
+              (0x20 <= _character && _character <= 0x10FFFF))) {
+          throwError(state, 'expected valid JSON character');
+        }
+      }
+    } else if (PATTERN_NON_PRINTABLE.test(_result)) {
+      throwError(state, 'the stream contains non-printable characters');
+    }
+
+    state.result += _result;
+  }
+}
+
+function mergeMappings(state, destination, source, overridableKeys) {
+  var sourceKeys, key, index, quantity;
+
+  if (!common.isObject(source)) {
+    throwError(state, 'cannot merge mappings; the provided source object is unacceptable');
+  }
+
+  sourceKeys = Object.keys(source);
+
+  for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
+    key = sourceKeys[index];
+
+    if (!_hasOwnProperty.call(destination, key)) {
+      destination[key] = source[key];
+      overridableKeys[key] = true;
+    }
+  }
+}
+
+function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
+  var index, quantity;
+
+  // The output is a plain object here, so keys can only be strings.
+  // We need to convert keyNode to a string, but doing so can hang the process
+  // (deeply nested arrays that explode exponentially using aliases).
+  if (Array.isArray(keyNode)) {
+    keyNode = Array.prototype.slice.call(keyNode);
+
+    for (index = 0, quantity = keyNode.length; index < quantity; index += 1) {
+      if (Array.isArray(keyNode[index])) {
+        throwError(state, 'nested arrays are not supported inside keys');
+      }
+
+      if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') {
+        keyNode[index] = '[object Object]';
+      }
+    }
+  }
+
+  // Avoid code execution in load() via toString property
+  // (still use its own toString for arrays, timestamps,
+  // and whatever user schema extensions happen to have @@toStringTag)
+  if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') {
+    keyNode = '[object Object]';
+  }
+
+
+  keyNode = String(keyNode);
+
+  if (_result === null) {
+    _result = {};
+  }
+
+  if (keyTag === 'tag:yaml.org,2002:merge') {
+    if (Array.isArray(valueNode)) {
+      for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
+        mergeMappings(state, _result, valueNode[index], overridableKeys);
+      }
+    } else {
+      mergeMappings(state, _result, valueNode, overridableKeys);
+    }
+  } else {
+    if (!state.json &&
+        !_hasOwnProperty.call(overridableKeys, keyNode) &&
+        _hasOwnProperty.call(_result, keyNode)) {
+      state.line = startLine || state.line;
+      state.position = startPos || state.position;
+      throwError(state, 'duplicated mapping key');
+    }
+    _result[keyNode] = valueNode;
+    delete overridableKeys[keyNode];
+  }
+
+  return _result;
+}
+
+function readLineBreak(state) {
+  var ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch === 0x0A/* LF */) {
+    state.position++;
+  } else if (ch === 0x0D/* CR */) {
+    state.position++;
+    if (state.input.charCodeAt(state.position) === 0x0A/* LF */) {
+      state.position++;
+    }
+  } else {
+    throwError(state, 'a line break is expected');
+  }
+
+  state.line += 1;
+  state.lineStart = state.position;
+}
+
+function skipSeparationSpace(state, allowComments, checkIndent) {
+  var lineBreaks = 0,
+      ch = state.input.charCodeAt(state.position);
+
+  while (ch !== 0) {
+    while (is_WHITE_SPACE(ch)) {
+      ch = state.input.charCodeAt(++state.position);
+    }
+
+    if (allowComments && ch === 0x23/* # */) {
+      do {
+        ch = state.input.charCodeAt(++state.position);
+      } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0);
+    }
+
+    if (is_EOL(ch)) {
+      readLineBreak(state);
+
+      ch = state.input.charCodeAt(state.position);
+      lineBreaks++;
+      state.lineIndent = 0;
+
+      while (ch === 0x20/* Space */) {
+        state.lineIndent++;
+        ch = state.input.charCodeAt(++state.position);
+      }
+    } else {
+      break;
+    }
+  }
+
+  if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) {
+    throwWarning(state, 'deficient indentation');
+  }
+
+  return lineBreaks;
+}
+
+function testDocumentSeparator(state) {
+  var _position = state.position,
+      ch;
+
+  ch = state.input.charCodeAt(_position);
+
+  // Condition state.position === state.lineStart is tested
+  // in parent on each call, for efficiency. No needs to test here again.
+  if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) &&
+      ch === state.input.charCodeAt(_position + 1) &&
+      ch === state.input.charCodeAt(_position + 2)) {
+
+    _position += 3;
+
+    ch = state.input.charCodeAt(_position);
+
+    if (ch === 0 || is_WS_OR_EOL(ch)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function writeFoldedLines(state, count) {
+  if (count === 1) {
+    state.result += ' ';
+  } else if (count > 1) {
+    state.result += common.repeat('\n', count - 1);
+  }
+}
+
+
+function readPlainScalar(state, nodeIndent, withinFlowCollection) {
+  var preceding,
+      following,
+      captureStart,
+      captureEnd,
+      hasPendingContent,
+      _line,
+      _lineStart,
+      _lineIndent,
+      _kind = state.kind,
+      _result = state.result,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (is_WS_OR_EOL(ch)      ||
+      is_FLOW_INDICATOR(ch) ||
+      ch === 0x23/* # */    ||
+      ch === 0x26/* & */    ||
+      ch === 0x2A/* * */    ||
+      ch === 0x21/* ! */    ||
+      ch === 0x7C/* | */    ||
+      ch === 0x3E/* > */    ||
+      ch === 0x27/* ' */    ||
+      ch === 0x22/* " */    ||
+      ch === 0x25/* % */    ||
+      ch === 0x40/* @ */    ||
+      ch === 0x60/* ` */) {
+    return false;
+  }
+
+  if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) {
+    following = state.input.charCodeAt(state.position + 1);
+
+    if (is_WS_OR_EOL(following) ||
+        withinFlowCollection && is_FLOW_INDICATOR(following)) {
+      return false;
+    }
+  }
+
+  state.kind = 'scalar';
+  state.result = '';
+  captureStart = captureEnd = state.position;
+  hasPendingContent = false;
+
+  while (ch !== 0) {
+    if (ch === 0x3A/* : */) {
+      following = state.input.charCodeAt(state.position + 1);
+
+      if (is_WS_OR_EOL(following) ||
+          withinFlowCollection && is_FLOW_INDICATOR(following)) {
+        break;
+      }
+
+    } else if (ch === 0x23/* # */) {
+      preceding = state.input.charCodeAt(state.position - 1);
+
+      if (is_WS_OR_EOL(preceding)) {
+        break;
+      }
+
+    } else if ((state.position === state.lineStart && testDocumentSeparator(state)) ||
+               withinFlowCollection && is_FLOW_INDICATOR(ch)) {
+      break;
+
+    } else if (is_EOL(ch)) {
+      _line = state.line;
+      _lineStart = state.lineStart;
+      _lineIndent = state.lineIndent;
+      skipSeparationSpace(state, false, -1);
+
+      if (state.lineIndent >= nodeIndent) {
+        hasPendingContent = true;
+        ch = state.input.charCodeAt(state.position);
+        continue;
+      } else {
+        state.position = captureEnd;
+        state.line = _line;
+        state.lineStart = _lineStart;
+        state.lineIndent = _lineIndent;
+        break;
+      }
+    }
+
+    if (hasPendingContent) {
+      captureSegment(state, captureStart, captureEnd, false);
+      writeFoldedLines(state, state.line - _line);
+      captureStart = captureEnd = state.position;
+      hasPendingContent = false;
+    }
+
+    if (!is_WHITE_SPACE(ch)) {
+      captureEnd = state.position + 1;
+    }
+
+    ch = state.input.charCodeAt(++state.position);
+  }
+
+  captureSegment(state, captureStart, captureEnd, false);
+
+  if (state.result) {
+    return true;
+  }
+
+  state.kind = _kind;
+  state.result = _result;
+  return false;
+}
+
+function readSingleQuotedScalar(state, nodeIndent) {
+  var ch,
+      captureStart, captureEnd;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch !== 0x27/* ' */) {
+    return false;
+  }
+
+  state.kind = 'scalar';
+  state.result = '';
+  state.position++;
+  captureStart = captureEnd = state.position;
+
+  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+    if (ch === 0x27/* ' */) {
+      captureSegment(state, captureStart, state.position, true);
+      ch = state.input.charCodeAt(++state.position);
+
+      if (ch === 0x27/* ' */) {
+        captureStart = state.position;
+        state.position++;
+        captureEnd = state.position;
+      } else {
+        return true;
+      }
+
+    } else if (is_EOL(ch)) {
+      captureSegment(state, captureStart, captureEnd, true);
+      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+      captureStart = captureEnd = state.position;
+
+    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
+      throwError(state, 'unexpected end of the document within a single quoted scalar');
+
+    } else {
+      state.position++;
+      captureEnd = state.position;
+    }
+  }
+
+  throwError(state, 'unexpected end of the stream within a single quoted scalar');
+}
+
+function readDoubleQuotedScalar(state, nodeIndent) {
+  var captureStart,
+      captureEnd,
+      hexLength,
+      hexResult,
+      tmp,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch !== 0x22/* " */) {
+    return false;
+  }
+
+  state.kind = 'scalar';
+  state.result = '';
+  state.position++;
+  captureStart = captureEnd = state.position;
+
+  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+    if (ch === 0x22/* " */) {
+      captureSegment(state, captureStart, state.position, true);
+      state.position++;
+      return true;
+
+    } else if (ch === 0x5C/* \ */) {
+      captureSegment(state, captureStart, state.position, true);
+      ch = state.input.charCodeAt(++state.position);
+
+      if (is_EOL(ch)) {
+        skipSeparationSpace(state, false, nodeIndent);
+
+        // TODO: rework to inline fn with no type cast?
+      } else if (ch < 256 && simpleEscapeCheck[ch]) {
+        state.result += simpleEscapeMap[ch];
+        state.position++;
+
+      } else if ((tmp = escapedHexLen(ch)) > 0) {
+        hexLength = tmp;
+        hexResult = 0;
+
+        for (; hexLength > 0; hexLength--) {
+          ch = state.input.charCodeAt(++state.position);
+
+          if ((tmp = fromHexCode(ch)) >= 0) {
+            hexResult = (hexResult << 4) + tmp;
+
+          } else {
+            throwError(state, 'expected hexadecimal character');
+          }
+        }
+
+        state.result += charFromCodepoint(hexResult);
+
+        state.position++;
+
+      } else {
+        throwError(state, 'unknown escape sequence');
+      }
+
+      captureStart = captureEnd = state.position;
+
+    } else if (is_EOL(ch)) {
+      captureSegment(state, captureStart, captureEnd, true);
+      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
+      captureStart = captureEnd = state.position;
+
+    } else if (state.position === state.lineStart && testDocumentSeparator(state)) {
+      throwError(state, 'unexpected end of the document within a double quoted scalar');
+
+    } else {
+      state.position++;
+      captureEnd = state.position;
+    }
+  }
+
+  throwError(state, 'unexpected end of the stream within a double quoted scalar');
+}
+
+function readFlowCollection(state, nodeIndent) {
+  var readNext = true,
+      _line,
+      _tag     = state.tag,
+      _result,
+      _anchor  = state.anchor,
+      following,
+      terminator,
+      isPair,
+      isExplicitPair,
+      isMapping,
+      overridableKeys = {},
+      keyNode,
+      keyTag,
+      valueNode,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch === 0x5B/* [ */) {
+    terminator = 0x5D;/* ] */
+    isMapping = false;
+    _result = [];
+  } else if (ch === 0x7B/* { */) {
+    terminator = 0x7D;/* } */
+    isMapping = true;
+    _result = {};
+  } else {
+    return false;
+  }
+
+  if (state.anchor !== null) {
+    state.anchorMap[state.anchor] = _result;
+  }
+
+  ch = state.input.charCodeAt(++state.position);
+
+  while (ch !== 0) {
+    skipSeparationSpace(state, true, nodeIndent);
+
+    ch = state.input.charCodeAt(state.position);
+
+    if (ch === terminator) {
+      state.position++;
+      state.tag = _tag;
+      state.anchor = _anchor;
+      state.kind = isMapping ? 'mapping' : 'sequence';
+      state.result = _result;
+      return true;
+    } else if (!readNext) {
+      throwError(state, 'missed comma between flow collection entries');
+    }
+
+    keyTag = keyNode = valueNode = null;
+    isPair = isExplicitPair = false;
+
+    if (ch === 0x3F/* ? */) {
+      following = state.input.charCodeAt(state.position + 1);
+
+      if (is_WS_OR_EOL(following)) {
+        isPair = isExplicitPair = true;
+        state.position++;
+        skipSeparationSpace(state, true, nodeIndent);
+      }
+    }
+
+    _line = state.line;
+    composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+    keyTag = state.tag;
+    keyNode = state.result;
+    skipSeparationSpace(state, true, nodeIndent);
+
+    ch = state.input.charCodeAt(state.position);
+
+    if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) {
+      isPair = true;
+      ch = state.input.charCodeAt(++state.position);
+      skipSeparationSpace(state, true, nodeIndent);
+      composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+      valueNode = state.result;
+    }
+
+    if (isMapping) {
+      storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode);
+    } else if (isPair) {
+      _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode));
+    } else {
+      _result.push(keyNode);
+    }
+
+    skipSeparationSpace(state, true, nodeIndent);
+
+    ch = state.input.charCodeAt(state.position);
+
+    if (ch === 0x2C/* , */) {
+      readNext = true;
+      ch = state.input.charCodeAt(++state.position);
+    } else {
+      readNext = false;
+    }
+  }
+
+  throwError(state, 'unexpected end of the stream within a flow collection');
+}
+
+function readBlockScalar(state, nodeIndent) {
+  var captureStart,
+      folding,
+      chomping       = CHOMPING_CLIP,
+      didReadContent = false,
+      detectedIndent = false,
+      textIndent     = nodeIndent,
+      emptyLines     = 0,
+      atMoreIndented = false,
+      tmp,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch === 0x7C/* | */) {
+    folding = false;
+  } else if (ch === 0x3E/* > */) {
+    folding = true;
+  } else {
+    return false;
+  }
+
+  state.kind = 'scalar';
+  state.result = '';
+
+  while (ch !== 0) {
+    ch = state.input.charCodeAt(++state.position);
+
+    if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
+      if (CHOMPING_CLIP === chomping) {
+        chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP;
+      } else {
+        throwError(state, 'repeat of a chomping mode identifier');
+      }
+
+    } else if ((tmp = fromDecimalCode(ch)) >= 0) {
+      if (tmp === 0) {
+        throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one');
+      } else if (!detectedIndent) {
+        textIndent = nodeIndent + tmp - 1;
+        detectedIndent = true;
+      } else {
+        throwError(state, 'repeat of an indentation width identifier');
+      }
+
+    } else {
+      break;
+    }
+  }
+
+  if (is_WHITE_SPACE(ch)) {
+    do { ch = state.input.charCodeAt(++state.position); }
+    while (is_WHITE_SPACE(ch));
+
+    if (ch === 0x23/* # */) {
+      do { ch = state.input.charCodeAt(++state.position); }
+      while (!is_EOL(ch) && (ch !== 0));
+    }
+  }
+
+  while (ch !== 0) {
+    readLineBreak(state);
+    state.lineIndent = 0;
+
+    ch = state.input.charCodeAt(state.position);
+
+    while ((!detectedIndent || state.lineIndent < textIndent) &&
+           (ch === 0x20/* Space */)) {
+      state.lineIndent++;
+      ch = state.input.charCodeAt(++state.position);
+    }
+
+    if (!detectedIndent && state.lineIndent > textIndent) {
+      textIndent = state.lineIndent;
+    }
+
+    if (is_EOL(ch)) {
+      emptyLines++;
+      continue;
+    }
+
+    // End of the scalar.
+    if (state.lineIndent < textIndent) {
+
+      // Perform the chomping.
+      if (chomping === CHOMPING_KEEP) {
+        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
+      } else if (chomping === CHOMPING_CLIP) {
+        if (didReadContent) { // i.e. only if the scalar is not empty.
+          state.result += '\n';
+        }
+      }
+
+      // Break this `while` cycle and go to the funciton's epilogue.
+      break;
+    }
+
+    // Folded style: use fancy rules to handle line breaks.
+    if (folding) {
+
+      // Lines starting with white space characters (more-indented lines) are not folded.
+      if (is_WHITE_SPACE(ch)) {
+        atMoreIndented = true;
+        // except for the first content line (cf. Example 8.1)
+        state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
+
+      // End of more-indented block.
+      } else if (atMoreIndented) {
+        atMoreIndented = false;
+        state.result += common.repeat('\n', emptyLines + 1);
+
+      // Just one line break - perceive as the same line.
+      } else if (emptyLines === 0) {
+        if (didReadContent) { // i.e. only if we have already read some scalar content.
+          state.result += ' ';
+        }
+
+      // Several line breaks - perceive as different lines.
+      } else {
+        state.result += common.repeat('\n', emptyLines);
+      }
+
+    // Literal style: just add exact number of line breaks between content lines.
+    } else {
+      // Keep all line breaks except the header line break.
+      state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines);
+    }
+
+    didReadContent = true;
+    detectedIndent = true;
+    emptyLines = 0;
+    captureStart = state.position;
+
+    while (!is_EOL(ch) && (ch !== 0)) {
+      ch = state.input.charCodeAt(++state.position);
+    }
+
+    captureSegment(state, captureStart, state.position, false);
+  }
+
+  return true;
+}
+
+function readBlockSequence(state, nodeIndent) {
+  var _line,
+      _tag      = state.tag,
+      _anchor   = state.anchor,
+      _result   = [],
+      following,
+      detected  = false,
+      ch;
+
+  if (state.anchor !== null) {
+    state.anchorMap[state.anchor] = _result;
+  }
+
+  ch = state.input.charCodeAt(state.position);
+
+  while (ch !== 0) {
+
+    if (ch !== 0x2D/* - */) {
+      break;
+    }
+
+    following = state.input.charCodeAt(state.position + 1);
+
+    if (!is_WS_OR_EOL(following)) {
+      break;
+    }
+
+    detected = true;
+    state.position++;
+
+    if (skipSeparationSpace(state, true, -1)) {
+      if (state.lineIndent <= nodeIndent) {
+        _result.push(null);
+        ch = state.input.charCodeAt(state.position);
+        continue;
+      }
+    }
+
+    _line = state.line;
+    composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
+    _result.push(state.result);
+    skipSeparationSpace(state, true, -1);
+
+    ch = state.input.charCodeAt(state.position);
+
+    if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) {
+      throwError(state, 'bad indentation of a sequence entry');
+    } else if (state.lineIndent < nodeIndent) {
+      break;
+    }
+  }
+
+  if (detected) {
+    state.tag = _tag;
+    state.anchor = _anchor;
+    state.kind = 'sequence';
+    state.result = _result;
+    return true;
+  }
+  return false;
+}
+
+function readBlockMapping(state, nodeIndent, flowIndent) {
+  var following,
+      allowCompact,
+      _line,
+      _pos,
+      _tag          = state.tag,
+      _anchor       = state.anchor,
+      _result       = {},
+      overridableKeys = {},
+      keyTag        = null,
+      keyNode       = null,
+      valueNode     = null,
+      atExplicitKey = false,
+      detected      = false,
+      ch;
+
+  if (state.anchor !== null) {
+    state.anchorMap[state.anchor] = _result;
+  }
+
+  ch = state.input.charCodeAt(state.position);
+
+  while (ch !== 0) {
+    following = state.input.charCodeAt(state.position + 1);
+    _line = state.line; // Save the current line.
+    _pos = state.position;
+
+    //
+    // Explicit notation case. There are two separate blocks:
+    // first for the key (denoted by "?") and second for the value (denoted by ":")
+    //
+    if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) {
+
+      if (ch === 0x3F/* ? */) {
+        if (atExplicitKey) {
+          storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
+          keyTag = keyNode = valueNode = null;
+        }
+
+        detected = true;
+        atExplicitKey = true;
+        allowCompact = true;
+
+      } else if (atExplicitKey) {
+        // i.e. 0x3A/* : */ === character after the explicit key.
+        atExplicitKey = false;
+        allowCompact = true;
+
+      } else {
+        throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line');
+      }
+
+      state.position += 1;
+      ch = following;
+
+    //
+    // Implicit notation case. Flow-style node as the key first, then ":", and the value.
+    //
+    } else if (composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
+
+      if (state.line === _line) {
+        ch = state.input.charCodeAt(state.position);
+
+        while (is_WHITE_SPACE(ch)) {
+          ch = state.input.charCodeAt(++state.position);
+        }
+
+        if (ch === 0x3A/* : */) {
+          ch = state.input.charCodeAt(++state.position);
+
+          if (!is_WS_OR_EOL(ch)) {
+            throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping');
+          }
+
+          if (atExplicitKey) {
+            storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
+            keyTag = keyNode = valueNode = null;
+          }
+
+          detected = true;
+          atExplicitKey = false;
+          allowCompact = false;
+          keyTag = state.tag;
+          keyNode = state.result;
+
+        } else if (detected) {
+          throwError(state, 'can not read an implicit mapping pair; a colon is missed');
+
+        } else {
+          state.tag = _tag;
+          state.anchor = _anchor;
+          return true; // Keep the result of `composeNode`.
+        }
+
+      } else if (detected) {
+        throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key');
+
+      } else {
+        state.tag = _tag;
+        state.anchor = _anchor;
+        return true; // Keep the result of `composeNode`.
+      }
+
+    } else {
+      break; // Reading is done. Go to the epilogue.
+    }
+
+    //
+    // Common reading code for both explicit and implicit notations.
+    //
+    if (state.line === _line || state.lineIndent > nodeIndent) {
+      if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
+        if (atExplicitKey) {
+          keyNode = state.result;
+        } else {
+          valueNode = state.result;
+        }
+      }
+
+      if (!atExplicitKey) {
+        storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _pos);
+        keyTag = keyNode = valueNode = null;
+      }
+
+      skipSeparationSpace(state, true, -1);
+      ch = state.input.charCodeAt(state.position);
+    }
+
+    if (state.lineIndent > nodeIndent && (ch !== 0)) {
+      throwError(state, 'bad indentation of a mapping entry');
+    } else if (state.lineIndent < nodeIndent) {
+      break;
+    }
+  }
+
+  //
+  // Epilogue.
+  //
+
+  // Special case: last mapping's node contains only the key in explicit notation.
+  if (atExplicitKey) {
+    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null);
+  }
+
+  // Expose the resulting mapping.
+  if (detected) {
+    state.tag = _tag;
+    state.anchor = _anchor;
+    state.kind = 'mapping';
+    state.result = _result;
+  }
+
+  return detected;
+}
+
+function readTagProperty(state) {
+  var _position,
+      isVerbatim = false,
+      isNamed    = false,
+      tagHandle,
+      tagName,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch !== 0x21/* ! */) return false;
+
+  if (state.tag !== null) {
+    throwError(state, 'duplication of a tag property');
+  }
+
+  ch = state.input.charCodeAt(++state.position);
+
+  if (ch === 0x3C/* < */) {
+    isVerbatim = true;
+    ch = state.input.charCodeAt(++state.position);
+
+  } else if (ch === 0x21/* ! */) {
+    isNamed = true;
+    tagHandle = '!!';
+    ch = state.input.charCodeAt(++state.position);
+
+  } else {
+    tagHandle = '!';
+  }
+
+  _position = state.position;
+
+  if (isVerbatim) {
+    do { ch = state.input.charCodeAt(++state.position); }
+    while (ch !== 0 && ch !== 0x3E/* > */);
+
+    if (state.position < state.length) {
+      tagName = state.input.slice(_position, state.position);
+      ch = state.input.charCodeAt(++state.position);
+    } else {
+      throwError(state, 'unexpected end of the stream within a verbatim tag');
+    }
+  } else {
+    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
+
+      if (ch === 0x21/* ! */) {
+        if (!isNamed) {
+          tagHandle = state.input.slice(_position - 1, state.position + 1);
+
+          if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
+            throwError(state, 'named tag handle cannot contain such characters');
+          }
+
+          isNamed = true;
+          _position = state.position + 1;
+        } else {
+          throwError(state, 'tag suffix cannot contain exclamation marks');
+        }
+      }
+
+      ch = state.input.charCodeAt(++state.position);
+    }
+
+    tagName = state.input.slice(_position, state.position);
+
+    if (PATTERN_FLOW_INDICATORS.test(tagName)) {
+      throwError(state, 'tag suffix cannot contain flow indicator characters');
+    }
+  }
+
+  if (tagName && !PATTERN_TAG_URI.test(tagName)) {
+    throwError(state, 'tag name cannot contain such characters: ' + tagName);
+  }
+
+  if (isVerbatim) {
+    state.tag = tagName;
+
+  } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) {
+    state.tag = state.tagMap[tagHandle] + tagName;
+
+  } else if (tagHandle === '!') {
+    state.tag = '!' + tagName;
+
+  } else if (tagHandle === '!!') {
+    state.tag = 'tag:yaml.org,2002:' + tagName;
+
+  } else {
+    throwError(state, 'undeclared tag handle "' + tagHandle + '"');
+  }
+
+  return true;
+}
+
+function readAnchorProperty(state) {
+  var _position,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch !== 0x26/* & */) return false;
+
+  if (state.anchor !== null) {
+    throwError(state, 'duplication of an anchor property');
+  }
+
+  ch = state.input.charCodeAt(++state.position);
+  _position = state.position;
+
+  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
+    ch = state.input.charCodeAt(++state.position);
+  }
+
+  if (state.position === _position) {
+    throwError(state, 'name of an anchor node must contain at least one character');
+  }
+
+  state.anchor = state.input.slice(_position, state.position);
+  return true;
+}
+
+function readAlias(state) {
+  var _position, alias,
+      ch;
+
+  ch = state.input.charCodeAt(state.position);
+
+  if (ch !== 0x2A/* * */) return false;
+
+  ch = state.input.charCodeAt(++state.position);
+  _position = state.position;
+
+  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
+    ch = state.input.charCodeAt(++state.position);
+  }
+
+  if (state.position === _position) {
+    throwError(state, 'name of an alias node must contain at least one character');
+  }
+
+  alias = state.input.slice(_position, state.position);
+
+  if (!state.anchorMap.hasOwnProperty(alias)) {
+    throwError(state, 'unidentified alias "' + alias + '"');
+  }
+
+  state.result = state.anchorMap[alias];
+  skipSeparationSpace(state, true, -1);
+  return true;
+}
+
+function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
+  var allowBlockStyles,
+      allowBlockScalars,
+      allowBlockCollections,
+      indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this<parent
+      atNewLine  = false,
+      hasContent = false,
+      typeIndex,
+      typeQuantity,
+      type,
+      flowIndent,
+      blockIndent;
+
+  if (state.listener !== null) {
+    state.listener('open', state);
+  }
+
+  state.tag    = null;
+  state.anchor = null;
+  state.kind   = null;
+  state.result = null;
+
+  allowBlockStyles = allowBlockScalars = allowBlockCollections =
+    CONTEXT_BLOCK_OUT === nodeContext ||
+    CONTEXT_BLOCK_IN  === nodeContext;
+
+  if (allowToSeek) {
+    if (skipSeparationSpace(state, true, -1)) {
+      atNewLine = true;
+
+      if (state.lineIndent > parentIndent) {
+        indentStatus = 1;
+      } else if (state.lineIndent === parentIndent) {
+        indentStatus = 0;
+      } else if (state.lineIndent < parentIndent) {
+        indentStatus = -1;
+      }
+    }
+  }
+
+  if (indentStatus === 1) {
+    while (readTagProperty(state) || readAnchorProperty(state)) {
+      if (skipSeparationSpace(state, true, -1)) {
+        atNewLine = true;
+        allowBlockCollections = allowBlockStyles;
+
+        if (state.lineIndent > parentIndent) {
+          indentStatus = 1;
+        } else if (state.lineIndent === parentIndent) {
+          indentStatus = 0;
+        } else if (state.lineIndent < parentIndent) {
+          indentStatus = -1;
+        }
+      } else {
+        allowBlockCollections = false;
+      }
+    }
+  }
+
+  if (allowBlockCollections) {
+    allowBlockCollections = atNewLine || allowCompact;
+  }
+
+  if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
+    if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
+      flowIndent = parentIndent;
+    } else {
+      flowIndent = parentIndent + 1;
+    }
+
+    blockIndent = state.position - state.lineStart;
+
+    if (indentStatus === 1) {
+      if (allowBlockCollections &&
+          (readBlockSequence(state, blockIndent) ||
+           readBlockMapping(state, blockIndent, flowIndent)) ||
+          readFlowCollection(state, flowIndent)) {
+        hasContent = true;
+      } else {
+        if ((allowBlockScalars && readBlockScalar(state, flowIndent)) ||
+            readSingleQuotedScalar(state, flowIndent) ||
+            readDoubleQuotedScalar(state, flowIndent)) {
+          hasContent = true;
+
+        } else if (readAlias(state)) {
+          hasContent = true;
+
+          if (state.tag !== null || state.anchor !== null) {
+            throwError(state, 'alias node should not have any properties');
+          }
+
+        } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
+          hasContent = true;
+
+          if (state.tag === null) {
+            state.tag = '?';
+          }
+        }
+
+        if (state.anchor !== null) {
+          state.anchorMap[state.anchor] = state.result;
+        }
+      }
+    } else if (indentStatus === 0) {
+      // Special case: block sequences are allowed to have same indentation level as the parent.
+      // http://www.yaml.org/spec/1.2/spec.html#id2799784
+      hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
+    }
+  }
+
+  if (state.tag !== null && state.tag !== '!') {
+    if (state.tag === '?') {
+      // Implicit resolving is not allowed for non-scalar types, and '?'
+      // non-specific tag is only automatically assigned to plain scalars.
+      //
+      // We only need to check kind conformity in case user explicitly assigns '?'
+      // tag, for example like this: "!<?> [0]"
+      //
+      if (state.result !== null && state.kind !== 'scalar') {
+        throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
+      }
+
+      for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
+        type = state.implicitTypes[typeIndex];
+
+        if (type.resolve(state.result)) { // `state.result` updated in resolver if matched
+          state.result = type.construct(state.result);
+          state.tag = type.tag;
+          if (state.anchor !== null) {
+            state.anchorMap[state.anchor] = state.result;
+          }
+          break;
+        }
+      }
+    } else if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) {
+      type = state.typeMap[state.kind || 'fallback'][state.tag];
+
+      if (state.result !== null && type.kind !== state.kind) {
+        throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"');
+      }
+
+      if (!type.resolve(state.result)) { // `state.result` updated in resolver if matched
+        throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag');
+      } else {
+        state.result = type.construct(state.result);
+        if (state.anchor !== null) {
+          state.anchorMap[state.anchor] = state.result;
+        }
+      }
+    } else {
+      throwError(state, 'unknown tag !<' + state.tag + '>');
+    }
+  }
+
+  if (state.listener !== null) {
+    state.listener('close', state);
+  }
+  return state.tag !== null ||  state.anchor !== null || hasContent;
+}
+
+function readDocument(state) {
+  var documentStart = state.position,
+      _position,
+      directiveName,
+      directiveArgs,
+      hasDirectives = false,
+      ch;
+
+  state.version = null;
+  state.checkLineBreaks = state.legacy;
+  state.tagMap = {};
+  state.anchorMap = {};
+
+  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
+    skipSeparationSpace(state, true, -1);
+
+    ch = state.input.charCodeAt(state.position);
+
+    if (state.lineIndent > 0 || ch !== 0x25/* % */) {
+      break;
+    }
+
+    hasDirectives = true;
+    ch = state.input.charCodeAt(++state.position);
+    _position = state.position;
+
+    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
+      ch = state.input.charCodeAt(++state.position);
+    }
+
+    directiveName = state.input.slice(_position, state.position);
+    directiveArgs = [];
+
+    if (directiveName.length < 1) {
+      throwError(state, 'directive name must not be less than one character in length');
+    }
+
+    while (ch !== 0) {
+      while (is_WHITE_SPACE(ch)) {
+        ch = state.input.charCodeAt(++state.position);
+      }
+
+      if (ch === 0x23/* # */) {
+        do { ch = state.input.charCodeAt(++state.position); }
+        while (ch !== 0 && !is_EOL(ch));
+        break;
+      }
+
+      if (is_EOL(ch)) break;
+
+      _position = state.position;
+
+      while (ch !== 0 && !is_WS_OR_EOL(ch)) {
+        ch = state.input.charCodeAt(++state.position);
+      }
+
+      directiveArgs.push(state.input.slice(_position, state.position));
+    }
+
+    if (ch !== 0) readLineBreak(state);
+
+    if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
+      directiveHandlers[directiveName](state, directiveName, directiveArgs);
+    } else {
+      throwWarning(state, 'unknown document directive "' + directiveName + '"');
+    }
+  }
+
+  skipSeparationSpace(state, true, -1);
+
+  if (state.lineIndent === 0 &&
+      state.input.charCodeAt(state.position)     === 0x2D/* - */ &&
+      state.input.charCodeAt(state.position + 1) === 0x2D/* - */ &&
+      state.input.charCodeAt(state.position + 2) === 0x2D/* - */) {
+    state.position += 3;
+    skipSeparationSpace(state, true, -1);
+
+  } else if (hasDirectives) {
+    throwError(state, 'directives end mark is expected');
+  }
+
+  composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
+  skipSeparationSpace(state, true, -1);
+
+  if (state.checkLineBreaks &&
+      PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) {
+    throwWarning(state, 'non-ASCII line breaks are interpreted as content');
+  }
+
+  state.documents.push(state.result);
+
+  if (state.position === state.lineStart && testDocumentSeparator(state)) {
+
+    if (state.input.charCodeAt(state.position) === 0x2E/* . */) {
+      state.position += 3;
+      skipSeparationSpace(state, true, -1);
+    }
+    return;
+  }
+
+  if (state.position < (state.length - 1)) {
+    throwError(state, 'end of the stream or a document separator is expected');
+  } else {
+    return;
+  }
+}
+
+
+function loadDocuments(input, options) {
+  input = String(input);
+  options = options || {};
+
+  if (input.length !== 0) {
+
+    // Add tailing `\n` if not exists
+    if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ &&
+        input.charCodeAt(input.length - 1) !== 0x0D/* CR */) {
+      input += '\n';
+    }
+
+    // Strip BOM
+    if (input.charCodeAt(0) === 0xFEFF) {
+      input = input.slice(1);
+    }
+  }
+
+  var state = new State(input, options);
+
+  var nullpos = input.indexOf('\0');
+
+  if (nullpos !== -1) {
+    state.position = nullpos;
+    throwError(state, 'null byte is not allowed in input');
+  }
+
+  // Use 0 as string terminator. That significantly simplifies bounds check.
+  state.input += '\0';
+
+  while (state.input.charCodeAt(state.position) === 0x20/* Space */) {
+    state.lineIndent += 1;
+    state.position += 1;
+  }
+
+  while (state.position < (state.length - 1)) {
+    readDocument(state);
+  }
+
+  return state.documents;
+}
+
+
+function loadAll(input, iterator, options) {
+  if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') {
+    options = iterator;
+    iterator = null;
+  }
+
+  var documents = loadDocuments(input, options);
+
+  if (typeof iterator !== 'function') {
+    return documents;
+  }
+
+  for (var index = 0, length = documents.length; index < length; index += 1) {
+    iterator(documents[index]);
+  }
+}
+
+
+function load(input, options) {
+  var documents = loadDocuments(input, options);
+
+  if (documents.length === 0) {
+    /*eslint-disable no-undefined*/
+    return undefined;
+  } else if (documents.length === 1) {
+    return documents[0];
+  }
+  throw new YAMLException('expected a single document in the stream, but found more');
+}
+
+
+function safeLoadAll(input, iterator, options) {
+  if (typeof iterator === 'object' && iterator !== null && typeof options === 'undefined') {
+    options = iterator;
+    iterator = null;
+  }
+
+  return loadAll(input, iterator, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
+}
+
+
+function safeLoad(input, options) {
+  return load(input, common.extend({ schema: DEFAULT_SAFE_SCHEMA }, options));
+}
+
+
+module.exports.loadAll     = loadAll;
+module.exports.load        = load;
+module.exports.safeLoadAll = safeLoadAll;
+module.exports.safeLoad    = safeLoad;
+
+
+/***/ }),
+
+/***/ 77262:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+
+var common = __nccwpck_require__(59941);
+
+
+function Mark(name, buffer, position, line, column) {
+  this.name     = name;
+  this.buffer   = buffer;
+  this.position = position;
+  this.line     = line;
+  this.column   = column;
+}
+
+
+Mark.prototype.getSnippet = function getSnippet(indent, maxLength) {
+  var head, start, tail, end, snippet;
+
+  if (!this.buffer) return null;
+
+  indent = indent || 4;
+  maxLength = maxLength || 75;
+
+  head = '';
+  start = this.position;
+
+  while (start > 0 && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(start - 1)) === -1) {
+    start -= 1;
+    if (this.position - start > (maxLength / 2 - 1)) {
+      head = ' ... ';
+      start += 5;
+      break;
+    }
+  }
+
+  tail = '';
+  end = this.position;
+
+  while (end < this.buffer.length && '\x00\r\n\x85\u2028\u2029'.indexOf(this.buffer.charAt(end)) === -1) {
+    end += 1;
+    if (end - this.position > (maxLength / 2 - 1)) {
+      tail = ' ... ';
+      end -= 5;
+      break;
+    }
+  }
+
+  snippet = this.buffer.slice(start, end);
+
+  return common.repeat(' ', indent) + head + snippet + tail + '\n' +
+         common.repeat(' ', indent + this.position - start + head.length) + '^';
+};
+
+
+Mark.prototype.toString = function toString(compact) {
+  var snippet, where = '';
+
+  if (this.name) {
+    where += 'in "' + this.name + '" ';
+  }
+
+  where += 'at line ' + (this.line + 1) + ', column ' + (this.column + 1);
+
+  if (!compact) {
+    snippet = this.getSnippet();
+
+    if (snippet) {
+      where += ':\n' + snippet;
+    }
+  }
+
+  return where;
+};
+
+
+module.exports = Mark;
+
+
+/***/ }),
+
+/***/ 66280:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+/*eslint-disable max-len*/
+
+var common        = __nccwpck_require__(59941);
+var YAMLException = __nccwpck_require__(29291);
+var Type          = __nccwpck_require__(90256);
+
+
+function compileList(schema, name, result) {
+  var exclude = [];
+
+  schema.include.forEach(function (includedSchema) {
+    result = compileList(includedSchema, name, result);
+  });
+
+  schema[name].forEach(function (currentType) {
+    result.forEach(function (previousType, previousIndex) {
+      if (previousType.tag === currentType.tag && previousType.kind === currentType.kind) {
+        exclude.push(previousIndex);
+      }
+    });
+
+    result.push(currentType);
+  });
+
+  return result.filter(function (type, index) {
+    return exclude.indexOf(index) === -1;
+  });
+}
+
+
+function compileMap(/* lists... */) {
+  var result = {
+        scalar: {},
+        sequence: {},
+        mapping: {},
+        fallback: {}
+      }, index, length;
+
+  function collectType(type) {
+    result[type.kind][type.tag] = result['fallback'][type.tag] = type;
+  }
+
+  for (index = 0, length = arguments.length; index < length; index += 1) {
+    arguments[index].forEach(collectType);
+  }
+  return result;
+}
+
+
+function Schema(definition) {
+  this.include  = definition.include  || [];
+  this.implicit = definition.implicit || [];
+  this.explicit = definition.explicit || [];
+
+  this.implicit.forEach(function (type) {
+    if (type.loadKind && type.loadKind !== 'scalar') {
+      throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.');
+    }
+  });
+
+  this.compiledImplicit = compileList(this, 'implicit', []);
+  this.compiledExplicit = compileList(this, 'explicit', []);
+  this.compiledTypeMap  = compileMap(this.compiledImplicit, this.compiledExplicit);
+}
+
+
+Schema.DEFAULT = null;
+
+
+Schema.create = function createSchema() {
+  var schemas, types;
+
+  switch (arguments.length) {
+    case 1:
+      schemas = Schema.DEFAULT;
+      types = arguments[0];
+      break;
+
+    case 2:
+      schemas = arguments[0];
+      types = arguments[1];
+      break;
+
+    default:
+      throw new YAMLException('Wrong number of arguments for Schema.create function');
+  }
+
+  schemas = common.toArray(schemas);
+  types = common.toArray(types);
+
+  if (!schemas.every(function (schema) { return schema instanceof Schema; })) {
+    throw new YAMLException('Specified list of super schemas (or a single Schema object) contains a non-Schema object.');
+  }
+
+  if (!types.every(function (type) { return type instanceof Type; })) {
+    throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.');
+  }
+
+  return new Schema({
+    include: schemas,
+    explicit: types
+  });
+};
+
+
+module.exports = Schema;
+
+
+/***/ }),
+
+/***/ 11950:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// Standard YAML's Core schema.
+// http://www.yaml.org/spec/1.2/spec.html#id2804923
+//
+// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
+// So, Core schema has no distinctions from JSON schema is JS-YAML.
+
+
+
+
+
+var Schema = __nccwpck_require__(66280);
+
+
+module.exports = new Schema({
+  include: [
+    __nccwpck_require__(2168)
+  ]
+});
+
+
+/***/ }),
+
+/***/ 145:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// JS-YAML's default schema for `load` function.
+// It is not described in the YAML specification.
+//
+// This schema is based on JS-YAML's default safe schema and includes
+// JavaScript-specific types: !!js/undefined, !!js/regexp and !!js/function.
+//
+// Also this schema is used as default base schema at `Schema.create` function.
+
+
+
+
+
+var Schema = __nccwpck_require__(66280);
+
+
+module.exports = Schema.DEFAULT = new Schema({
+  include: [
+    __nccwpck_require__(42881)
+  ],
+  explicit: [
+    __nccwpck_require__(34801),
+    __nccwpck_require__(77234),
+    __nccwpck_require__(35361)
+  ]
+});
+
+
+/***/ }),
+
+/***/ 42881:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// JS-YAML's default schema for `safeLoad` function.
+// It is not described in the YAML specification.
+//
+// This schema is based on standard YAML's Core schema and includes most of
+// extra types described at YAML tag repository. (http://yaml.org/type/)
+
+
+
+
+
+var Schema = __nccwpck_require__(66280);
+
+
+module.exports = new Schema({
+  include: [
+    __nccwpck_require__(11950)
+  ],
+  implicit: [
+    __nccwpck_require__(82018),
+    __nccwpck_require__(60194)
+  ],
+  explicit: [
+    __nccwpck_require__(21716),
+    __nccwpck_require__(96439),
+    __nccwpck_require__(33730),
+    __nccwpck_require__(9047)
+  ]
+});
+
+
+/***/ }),
+
+/***/ 70026:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// Standard YAML's Failsafe schema.
+// http://www.yaml.org/spec/1.2/spec.html#id2802346
+
+
+
+
+
+var Schema = __nccwpck_require__(66280);
+
+
+module.exports = new Schema({
+  explicit: [
+    __nccwpck_require__(24649),
+    __nccwpck_require__(65629),
+    __nccwpck_require__(15938)
+  ]
+});
+
+
+/***/ }),
+
+/***/ 2168:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+// Standard YAML's JSON schema.
+// http://www.yaml.org/spec/1.2/spec.html#id2803231
+//
+// NOTE: JS-YAML does not support schema-specific tag resolution restrictions.
+// So, this schema is not such strict as defined in the YAML specification.
+// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc.
+
+
+
+
+
+var Schema = __nccwpck_require__(66280);
+
+
+module.exports = new Schema({
+  include: [
+    __nccwpck_require__(70026)
+  ],
+  implicit: [
+    __nccwpck_require__(26058),
+    __nccwpck_require__(93195),
+    __nccwpck_require__(76865),
+    __nccwpck_require__(16480)
+  ]
+});
+
+
+/***/ }),
+
+/***/ 90256:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var YAMLException = __nccwpck_require__(29291);
+
+var TYPE_CONSTRUCTOR_OPTIONS = [
+  'kind',
+  'resolve',
+  'construct',
+  'instanceOf',
+  'predicate',
+  'represent',
+  'defaultStyle',
+  'styleAliases'
+];
+
+var YAML_NODE_KINDS = [
+  'scalar',
+  'sequence',
+  'mapping'
+];
+
+function compileStyleAliases(map) {
+  var result = {};
+
+  if (map !== null) {
+    Object.keys(map).forEach(function (style) {
+      map[style].forEach(function (alias) {
+        result[String(alias)] = style;
+      });
+    });
+  }
+
+  return result;
+}
+
+function Type(tag, options) {
+  options = options || {};
+
+  Object.keys(options).forEach(function (name) {
+    if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
+      throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
+    }
+  });
+
+  // TODO: Add tag format check.
+  this.tag          = tag;
+  this.kind         = options['kind']         || null;
+  this.resolve      = options['resolve']      || function () { return true; };
+  this.construct    = options['construct']    || function (data) { return data; };
+  this.instanceOf   = options['instanceOf']   || null;
+  this.predicate    = options['predicate']    || null;
+  this.represent    = options['represent']    || null;
+  this.defaultStyle = options['defaultStyle'] || null;
+  this.styleAliases = compileStyleAliases(options['styleAliases'] || null);
+
+  if (YAML_NODE_KINDS.indexOf(this.kind) === -1) {
+    throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+  }
+}
+
+module.exports = Type;
+
+
+/***/ }),
+
+/***/ 21716:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+/*eslint-disable no-bitwise*/
+
+var NodeBuffer;
+
+try {
+  // A trick for browserified version, to not include `Buffer` shim
+  var _require = require;
+  NodeBuffer = _require('buffer').Buffer;
+} catch (__) {}
+
+var Type       = __nccwpck_require__(90256);
+
+
+// [ 64, 65, 66 ] -> [ padding, CR, LF ]
+var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r';
+
+
+function resolveYamlBinary(data) {
+  if (data === null) return false;
+
+  var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP;
+
+  // Convert one by one.
+  for (idx = 0; idx < max; idx++) {
+    code = map.indexOf(data.charAt(idx));
+
+    // Skip CR/LF
+    if (code > 64) continue;
+
+    // Fail on illegal characters
+    if (code < 0) return false;
+
+    bitlen += 6;
+  }
+
+  // If there are any bits left, source was corrupted
+  return (bitlen % 8) === 0;
+}
+
+function constructYamlBinary(data) {
+  var idx, tailbits,
+      input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan
+      max = input.length,
+      map = BASE64_MAP,
+      bits = 0,
+      result = [];
+
+  // Collect by 6*4 bits (3 bytes)
+
+  for (idx = 0; idx < max; idx++) {
+    if ((idx % 4 === 0) && idx) {
+      result.push((bits >> 16) & 0xFF);
+      result.push((bits >> 8) & 0xFF);
+      result.push(bits & 0xFF);
+    }
+
+    bits = (bits << 6) | map.indexOf(input.charAt(idx));
+  }
+
+  // Dump tail
+
+  tailbits = (max % 4) * 6;
+
+  if (tailbits === 0) {
+    result.push((bits >> 16) & 0xFF);
+    result.push((bits >> 8) & 0xFF);
+    result.push(bits & 0xFF);
+  } else if (tailbits === 18) {
+    result.push((bits >> 10) & 0xFF);
+    result.push((bits >> 2) & 0xFF);
+  } else if (tailbits === 12) {
+    result.push((bits >> 4) & 0xFF);
+  }
+
+  // Wrap into Buffer for NodeJS and leave Array for browser
+  if (NodeBuffer) {
+    // Support node 6.+ Buffer API when available
+    return NodeBuffer.from ? NodeBuffer.from(result) : new NodeBuffer(result);
+  }
+
+  return result;
+}
+
+function representYamlBinary(object /*, style*/) {
+  var result = '', bits = 0, idx, tail,
+      max = object.length,
+      map = BASE64_MAP;
+
+  // Convert every three bytes to 4 ASCII characters.
+
+  for (idx = 0; idx < max; idx++) {
+    if ((idx % 3 === 0) && idx) {
+      result += map[(bits >> 18) & 0x3F];
+      result += map[(bits >> 12) & 0x3F];
+      result += map[(bits >> 6) & 0x3F];
+      result += map[bits & 0x3F];
+    }
+
+    bits = (bits << 8) + object[idx];
+  }
+
+  // Dump tail
+
+  tail = max % 3;
+
+  if (tail === 0) {
+    result += map[(bits >> 18) & 0x3F];
+    result += map[(bits >> 12) & 0x3F];
+    result += map[(bits >> 6) & 0x3F];
+    result += map[bits & 0x3F];
+  } else if (tail === 2) {
+    result += map[(bits >> 10) & 0x3F];
+    result += map[(bits >> 4) & 0x3F];
+    result += map[(bits << 2) & 0x3F];
+    result += map[64];
+  } else if (tail === 1) {
+    result += map[(bits >> 2) & 0x3F];
+    result += map[(bits << 4) & 0x3F];
+    result += map[64];
+    result += map[64];
+  }
+
+  return result;
+}
+
+function isBinary(object) {
+  return NodeBuffer && NodeBuffer.isBuffer(object);
+}
+
+module.exports = new Type('tag:yaml.org,2002:binary', {
+  kind: 'scalar',
+  resolve: resolveYamlBinary,
+  construct: constructYamlBinary,
+  predicate: isBinary,
+  represent: representYamlBinary
+});
+
+
+/***/ }),
+
+/***/ 93195:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var Type = __nccwpck_require__(90256);
+
+function resolveYamlBoolean(data) {
+  if (data === null) return false;
+
+  var max = data.length;
+
+  return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) ||
+         (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE'));
+}
+
+function constructYamlBoolean(data) {
+  return data === 'true' ||
+         data === 'True' ||
+         data === 'TRUE';
+}
+
+function isBoolean(object) {
+  return Object.prototype.toString.call(object) === '[object Boolean]';
+}
+
+module.exports = new Type('tag:yaml.org,2002:bool', {
+  kind: 'scalar',
+  resolve: resolveYamlBoolean,
+  construct: constructYamlBoolean,
+  predicate: isBoolean,
+  represent: {
+    lowercase: function (object) { return object ? 'true' : 'false'; },
+    uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; },
+    camelcase: function (object) { return object ? 'True' : 'False'; }
+  },
+  defaultStyle: 'lowercase'
+});
+
+
+/***/ }),
+
+/***/ 16480:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var common = __nccwpck_require__(59941);
+var Type   = __nccwpck_require__(90256);
+
+var YAML_FLOAT_PATTERN = new RegExp(
+  // 2.5e4, 2.5 and integers
+  '^(?:[-+]?(?:0|[1-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' +
+  // .2e4, .2
+  // special case, seems not from spec
+  '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' +
+  // 20:59
+  '|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*' +
+  // .inf
+  '|[-+]?\\.(?:inf|Inf|INF)' +
+  // .nan
+  '|\\.(?:nan|NaN|NAN))$');
+
+function resolveYamlFloat(data) {
+  if (data === null) return false;
+
+  if (!YAML_FLOAT_PATTERN.test(data) ||
+      // Quick hack to not allow integers end with `_`
+      // Probably should update regexp & check speed
+      data[data.length - 1] === '_') {
+    return false;
+  }
+
+  return true;
+}
+
+function constructYamlFloat(data) {
+  var value, sign, base, digits;
+
+  value  = data.replace(/_/g, '').toLowerCase();
+  sign   = value[0] === '-' ? -1 : 1;
+  digits = [];
+
+  if ('+-'.indexOf(value[0]) >= 0) {
+    value = value.slice(1);
+  }
+
+  if (value === '.inf') {
+    return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+
+  } else if (value === '.nan') {
+    return NaN;
+
+  } else if (value.indexOf(':') >= 0) {
+    value.split(':').forEach(function (v) {
+      digits.unshift(parseFloat(v, 10));
+    });
+
+    value = 0.0;
+    base = 1;
+
+    digits.forEach(function (d) {
+      value += d * base;
+      base *= 60;
+    });
+
+    return sign * value;
+
+  }
+  return sign * parseFloat(value, 10);
+}
+
+
+var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/;
+
+function representYamlFloat(object, style) {
+  var res;
+
+  if (isNaN(object)) {
+    switch (style) {
+      case 'lowercase': return '.nan';
+      case 'uppercase': return '.NAN';
+      case 'camelcase': return '.NaN';
+    }
+  } else if (Number.POSITIVE_INFINITY === object) {
+    switch (style) {
+      case 'lowercase': return '.inf';
+      case 'uppercase': return '.INF';
+      case 'camelcase': return '.Inf';
+    }
+  } else if (Number.NEGATIVE_INFINITY === object) {
+    switch (style) {
+      case 'lowercase': return '-.inf';
+      case 'uppercase': return '-.INF';
+      case 'camelcase': return '-.Inf';
+    }
+  } else if (common.isNegativeZero(object)) {
+    return '-0.0';
+  }
+
+  res = object.toString(10);
+
+  // JS stringifier can build scientific format without dots: 5e-100,
+  // while YAML requres dot: 5.e-100. Fix it with simple hack
+
+  return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res;
+}
+
+function isFloat(object) {
+  return (Object.prototype.toString.call(object) === '[object Number]') &&
+         (object % 1 !== 0 || common.isNegativeZero(object));
+}
+
+module.exports = new Type('tag:yaml.org,2002:float', {
+  kind: 'scalar',
+  resolve: resolveYamlFloat,
+  construct: constructYamlFloat,
+  predicate: isFloat,
+  represent: representYamlFloat,
+  defaultStyle: 'lowercase'
+});
+
+
+/***/ }),
+
+/***/ 76865:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var common = __nccwpck_require__(59941);
+var Type   = __nccwpck_require__(90256);
+
+function isHexCode(c) {
+  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) ||
+         ((0x41/* A */ <= c) && (c <= 0x46/* F */)) ||
+         ((0x61/* a */ <= c) && (c <= 0x66/* f */));
+}
+
+function isOctCode(c) {
+  return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */));
+}
+
+function isDecCode(c) {
+  return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */));
+}
+
+function resolveYamlInteger(data) {
+  if (data === null) return false;
+
+  var max = data.length,
+      index = 0,
+      hasDigits = false,
+      ch;
+
+  if (!max) return false;
+
+  ch = data[index];
+
+  // sign
+  if (ch === '-' || ch === '+') {
+    ch = data[++index];
+  }
+
+  if (ch === '0') {
+    // 0
+    if (index + 1 === max) return true;
+    ch = data[++index];
+
+    // base 2, base 8, base 16
+
+    if (ch === 'b') {
+      // base 2
+      index++;
+
+      for (; index < max; index++) {
+        ch = data[index];
+        if (ch === '_') continue;
+        if (ch !== '0' && ch !== '1') return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== '_';
+    }
+
+
+    if (ch === 'x') {
+      // base 16
+      index++;
+
+      for (; index < max; index++) {
+        ch = data[index];
+        if (ch === '_') continue;
+        if (!isHexCode(data.charCodeAt(index))) return false;
+        hasDigits = true;
+      }
+      return hasDigits && ch !== '_';
+    }
+
+    // base 8
+    for (; index < max; index++) {
+      ch = data[index];
+      if (ch === '_') continue;
+      if (!isOctCode(data.charCodeAt(index))) return false;
+      hasDigits = true;
+    }
+    return hasDigits && ch !== '_';
+  }
+
+  // base 10 (except 0) or base 60
+
+  // value should not start with `_`;
+  if (ch === '_') return false;
+
+  for (; index < max; index++) {
+    ch = data[index];
+    if (ch === '_') continue;
+    if (ch === ':') break;
+    if (!isDecCode(data.charCodeAt(index))) {
+      return false;
+    }
+    hasDigits = true;
+  }
+
+  // Should have digits and should not end with `_`
+  if (!hasDigits || ch === '_') return false;
+
+  // if !base60 - done;
+  if (ch !== ':') return true;
+
+  // base60 almost not used, no needs to optimize
+  return /^(:[0-5]?[0-9])+$/.test(data.slice(index));
+}
+
+function constructYamlInteger(data) {
+  var value = data, sign = 1, ch, base, digits = [];
+
+  if (value.indexOf('_') !== -1) {
+    value = value.replace(/_/g, '');
+  }
+
+  ch = value[0];
+
+  if (ch === '-' || ch === '+') {
+    if (ch === '-') sign = -1;
+    value = value.slice(1);
+    ch = value[0];
+  }
+
+  if (value === '0') return 0;
+
+  if (ch === '0') {
+    if (value[1] === 'b') return sign * parseInt(value.slice(2), 2);
+    if (value[1] === 'x') return sign * parseInt(value, 16);
+    return sign * parseInt(value, 8);
+  }
+
+  if (value.indexOf(':') !== -1) {
+    value.split(':').forEach(function (v) {
+      digits.unshift(parseInt(v, 10));
+    });
+
+    value = 0;
+    base = 1;
+
+    digits.forEach(function (d) {
+      value += (d * base);
+      base *= 60;
+    });
+
+    return sign * value;
+
+  }
+
+  return sign * parseInt(value, 10);
+}
+
+function isInteger(object) {
+  return (Object.prototype.toString.call(object)) === '[object Number]' &&
+         (object % 1 === 0 && !common.isNegativeZero(object));
+}
+
+module.exports = new Type('tag:yaml.org,2002:int', {
+  kind: 'scalar',
+  resolve: resolveYamlInteger,
+  construct: constructYamlInteger,
+  predicate: isInteger,
+  represent: {
+    binary:      function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); },
+    octal:       function (obj) { return obj >= 0 ? '0'  + obj.toString(8) : '-0'  + obj.toString(8).slice(1); },
+    decimal:     function (obj) { return obj.toString(10); },
+    /* eslint-disable max-len */
+    hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() :  '-0x' + obj.toString(16).toUpperCase().slice(1); }
+  },
+  defaultStyle: 'decimal',
+  styleAliases: {
+    binary:      [ 2,  'bin' ],
+    octal:       [ 8,  'oct' ],
+    decimal:     [ 10, 'dec' ],
+    hexadecimal: [ 16, 'hex' ]
+  }
+});
+
+
+/***/ }),
+
+/***/ 35361:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var esprima;
+
+// Browserified version does not have esprima
+//
+// 1. For node.js just require module as deps
+// 2. For browser try to require mudule via external AMD system.
+//    If not found - try to fallback to window.esprima. If not
+//    found too - then fail to parse.
+//
+try {
+  // workaround to exclude package from browserify list.
+  var _require = require;
+  esprima = _require('esprima');
+} catch (_) {
+  /* eslint-disable no-redeclare */
+  /* global window */
+  if (typeof window !== 'undefined') esprima = window.esprima;
+}
+
+var Type = __nccwpck_require__(90256);
+
+function resolveJavascriptFunction(data) {
+  if (data === null) return false;
+
+  try {
+    var source = '(' + data + ')',
+        ast    = esprima.parse(source, { range: true });
+
+    if (ast.type                    !== 'Program'             ||
+        ast.body.length             !== 1                     ||
+        ast.body[0].type            !== 'ExpressionStatement' ||
+        (ast.body[0].expression.type !== 'ArrowFunctionExpression' &&
+          ast.body[0].expression.type !== 'FunctionExpression')) {
+      return false;
+    }
+
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+function constructJavascriptFunction(data) {
+  /*jslint evil:true*/
+
+  var source = '(' + data + ')',
+      ast    = esprima.parse(source, { range: true }),
+      params = [],
+      body;
+
+  if (ast.type                    !== 'Program'             ||
+      ast.body.length             !== 1                     ||
+      ast.body[0].type            !== 'ExpressionStatement' ||
+      (ast.body[0].expression.type !== 'ArrowFunctionExpression' &&
+        ast.body[0].expression.type !== 'FunctionExpression')) {
+    throw new Error('Failed to resolve function');
+  }
+
+  ast.body[0].expression.params.forEach(function (param) {
+    params.push(param.name);
+  });
+
+  body = ast.body[0].expression.body.range;
+
+  // Esprima's ranges include the first '{' and the last '}' characters on
+  // function expressions. So cut them out.
+  if (ast.body[0].expression.body.type === 'BlockStatement') {
+    /*eslint-disable no-new-func*/
+    return new Function(params, source.slice(body[0] + 1, body[1] - 1));
+  }
+  // ES6 arrow functions can omit the BlockStatement. In that case, just return
+  // the body.
+  /*eslint-disable no-new-func*/
+  return new Function(params, 'return ' + source.slice(body[0], body[1]));
+}
+
+function representJavascriptFunction(object /*, style*/) {
+  return object.toString();
+}
+
+function isFunction(object) {
+  return Object.prototype.toString.call(object) === '[object Function]';
+}
+
+module.exports = new Type('tag:yaml.org,2002:js/function', {
+  kind: 'scalar',
+  resolve: resolveJavascriptFunction,
+  construct: constructJavascriptFunction,
+  predicate: isFunction,
+  represent: representJavascriptFunction
+});
+
+
+/***/ }),
+
+/***/ 77234:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var Type = __nccwpck_require__(90256);
+
+function resolveJavascriptRegExp(data) {
+  if (data === null) return false;
+  if (data.length === 0) return false;
+
+  var regexp = data,
+      tail   = /\/([gim]*)$/.exec(data),
+      modifiers = '';
+
+  // if regexp starts with '/' it can have modifiers and must be properly closed
+  // `/foo/gim` - modifiers tail can be maximum 3 chars
+  if (regexp[0] === '/') {
+    if (tail) modifiers = tail[1];
+
+    if (modifiers.length > 3) return false;
+    // if expression starts with /, is should be properly terminated
+    if (regexp[regexp.length - modifiers.length - 1] !== '/') return false;
+  }
+
+  return true;
+}
+
+function constructJavascriptRegExp(data) {
+  var regexp = data,
+      tail   = /\/([gim]*)$/.exec(data),
+      modifiers = '';
+
+  // `/foo/gim` - tail can be maximum 4 chars
+  if (regexp[0] === '/') {
+    if (tail) modifiers = tail[1];
+    regexp = regexp.slice(1, regexp.length - modifiers.length - 1);
+  }
+
+  return new RegExp(regexp, modifiers);
+}
+
+function representJavascriptRegExp(object /*, style*/) {
+  var result = '/' + object.source + '/';
+
+  if (object.global) result += 'g';
+  if (object.multiline) result += 'm';
+  if (object.ignoreCase) result += 'i';
+
+  return result;
+}
+
+function isRegExp(object) {
+  return Object.prototype.toString.call(object) === '[object RegExp]';
+}
+
+module.exports = new Type('tag:yaml.org,2002:js/regexp', {
+  kind: 'scalar',
+  resolve: resolveJavascriptRegExp,
+  construct: constructJavascriptRegExp,
+  predicate: isRegExp,
+  represent: representJavascriptRegExp
+});
+
+
+/***/ }),
+
+/***/ 34801:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var Type = __nccwpck_require__(90256);
+
+function resolveJavascriptUndefined() {
+  return true;
+}
+
+function constructJavascriptUndefined() {
+  /*eslint-disable no-undefined*/
+  return undefined;
+}
+
+function representJavascriptUndefined() {
+  return '';
+}
+
+function isUndefined(object) {
+  return typeof object === 'undefined';
+}
+
+module.exports = new Type('tag:yaml.org,2002:js/undefined', {
+  kind: 'scalar',
+  resolve: resolveJavascriptUndefined,
+  construct: constructJavascriptUndefined,
+  predicate: isUndefined,
+  represent: representJavascriptUndefined
+});
+
+
+/***/ }),
+
+/***/ 15938:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var Type = __nccwpck_require__(90256);
+
+module.exports = new Type('tag:yaml.org,2002:map', {
+  kind: 'mapping',
+  construct: function (data) { return data !== null ? data : {}; }
+});
+
+
+/***/ }),
+
+/***/ 60194:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var Type = __nccwpck_require__(90256);
+
+function resolveYamlMerge(data) {
+  return data === '<<' || data === null;
+}
+
+module.exports = new Type('tag:yaml.org,2002:merge', {
+  kind: 'scalar',
+  resolve: resolveYamlMerge
+});
+
+
+/***/ }),
+
+/***/ 26058:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var Type = __nccwpck_require__(90256);
+
+function resolveYamlNull(data) {
+  if (data === null) return true;
+
+  var max = data.length;
+
+  return (max === 1 && data === '~') ||
+         (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL'));
+}
+
+function constructYamlNull() {
+  return null;
+}
+
+function isNull(object) {
+  return object === null;
+}
+
+module.exports = new Type('tag:yaml.org,2002:null', {
+  kind: 'scalar',
+  resolve: resolveYamlNull,
+  construct: constructYamlNull,
+  predicate: isNull,
+  represent: {
+    canonical: function () { return '~';    },
+    lowercase: function () { return 'null'; },
+    uppercase: function () { return 'NULL'; },
+    camelcase: function () { return 'Null'; }
+  },
+  defaultStyle: 'lowercase'
+});
+
+
+/***/ }),
+
+/***/ 96439:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var Type = __nccwpck_require__(90256);
+
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+var _toString       = Object.prototype.toString;
+
+function resolveYamlOmap(data) {
+  if (data === null) return true;
+
+  var objectKeys = [], index, length, pair, pairKey, pairHasKey,
+      object = data;
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    pair = object[index];
+    pairHasKey = false;
+
+    if (_toString.call(pair) !== '[object Object]') return false;
+
+    for (pairKey in pair) {
+      if (_hasOwnProperty.call(pair, pairKey)) {
+        if (!pairHasKey) pairHasKey = true;
+        else return false;
+      }
+    }
+
+    if (!pairHasKey) return false;
+
+    if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey);
+    else return false;
+  }
+
+  return true;
+}
+
+function constructYamlOmap(data) {
+  return data !== null ? data : [];
+}
+
+module.exports = new Type('tag:yaml.org,2002:omap', {
+  kind: 'sequence',
+  resolve: resolveYamlOmap,
+  construct: constructYamlOmap
+});
+
+
+/***/ }),
+
+/***/ 33730:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var Type = __nccwpck_require__(90256);
+
+var _toString = Object.prototype.toString;
+
+function resolveYamlPairs(data) {
+  if (data === null) return true;
+
+  var index, length, pair, keys, result,
+      object = data;
+
+  result = new Array(object.length);
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    pair = object[index];
+
+    if (_toString.call(pair) !== '[object Object]') return false;
+
+    keys = Object.keys(pair);
+
+    if (keys.length !== 1) return false;
+
+    result[index] = [ keys[0], pair[keys[0]] ];
+  }
+
+  return true;
+}
+
+function constructYamlPairs(data) {
+  if (data === null) return [];
+
+  var index, length, pair, keys, result,
+      object = data;
+
+  result = new Array(object.length);
+
+  for (index = 0, length = object.length; index < length; index += 1) {
+    pair = object[index];
+
+    keys = Object.keys(pair);
+
+    result[index] = [ keys[0], pair[keys[0]] ];
+  }
+
+  return result;
+}
+
+module.exports = new Type('tag:yaml.org,2002:pairs', {
+  kind: 'sequence',
+  resolve: resolveYamlPairs,
+  construct: constructYamlPairs
+});
+
+
+/***/ }),
+
+/***/ 65629:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var Type = __nccwpck_require__(90256);
+
+module.exports = new Type('tag:yaml.org,2002:seq', {
+  kind: 'sequence',
+  construct: function (data) { return data !== null ? data : []; }
+});
+
+
+/***/ }),
+
+/***/ 9047:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var Type = __nccwpck_require__(90256);
+
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+function resolveYamlSet(data) {
+  if (data === null) return true;
+
+  var key, object = data;
+
+  for (key in object) {
+    if (_hasOwnProperty.call(object, key)) {
+      if (object[key] !== null) return false;
+    }
+  }
+
+  return true;
+}
+
+function constructYamlSet(data) {
+  return data !== null ? data : {};
+}
+
+module.exports = new Type('tag:yaml.org,2002:set', {
+  kind: 'mapping',
+  resolve: resolveYamlSet,
+  construct: constructYamlSet
+});
+
+
+/***/ }),
+
+/***/ 24649:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var Type = __nccwpck_require__(90256);
+
+module.exports = new Type('tag:yaml.org,2002:str', {
+  kind: 'scalar',
+  construct: function (data) { return data !== null ? data : ''; }
+});
+
+
+/***/ }),
+
+/***/ 82018:
+/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
+
+"use strict";
+
+
+var Type = __nccwpck_require__(90256);
+
+var YAML_DATE_REGEXP = new RegExp(
+  '^([0-9][0-9][0-9][0-9])'          + // [1] year
+  '-([0-9][0-9])'                    + // [2] month
+  '-([0-9][0-9])$');                   // [3] day
+
+var YAML_TIMESTAMP_REGEXP = new RegExp(
+  '^([0-9][0-9][0-9][0-9])'          + // [1] year
+  '-([0-9][0-9]?)'                   + // [2] month
+  '-([0-9][0-9]?)'                   + // [3] day
+  '(?:[Tt]|[ \\t]+)'                 + // ...
+  '([0-9][0-9]?)'                    + // [4] hour
+  ':([0-9][0-9])'                    + // [5] minute
+  ':([0-9][0-9])'                    + // [6] second
+  '(?:\\.([0-9]*))?'                 + // [7] fraction
+  '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour
+  '(?::([0-9][0-9]))?))?$');           // [11] tz_minute
+
+function resolveYamlTimestamp(data) {
+  if (data === null) return false;
+  if (YAML_DATE_REGEXP.exec(data) !== null) return true;
+  if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true;
+  return false;
+}
+
+function constructYamlTimestamp(data) {
+  var match, year, month, day, hour, minute, second, fraction = 0,
+      delta = null, tz_hour, tz_minute, date;
+
+  match = YAML_DATE_REGEXP.exec(data);
+  if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+
+  if (match === null) throw new Error('Date resolve error');
+
+  // match: [1] year [2] month [3] day
+
+  year = +(match[1]);
+  month = +(match[2]) - 1; // JS month starts with 0
+  day = +(match[3]);
+
+  if (!match[4]) { // no hour
+    return new Date(Date.UTC(year, month, day));
+  }
+
+  // match: [4] hour [5] minute [6] second [7] fraction
+
+  hour = +(match[4]);
+  minute = +(match[5]);
+  second = +(match[6]);
+
+  if (match[7]) {
+    fraction = match[7].slice(0, 3);
+    while (fraction.length < 3) { // milli-seconds
+      fraction += '0';
+    }
+    fraction = +fraction;
+  }
+
+  // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute
+
+  if (match[9]) {
+    tz_hour = +(match[10]);
+    tz_minute = +(match[11] || 0);
+    delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds
+    if (match[9] === '-') delta = -delta;
+  }
+
+  date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+
+  if (delta) date.setTime(date.getTime() - delta);
+
+  return date;
+}
+
+function representYamlTimestamp(object /*, style*/) {
+  return object.toISOString();
+}
+
+module.exports = new Type('tag:yaml.org,2002:timestamp', {
+  kind: 'scalar',
+  resolve: resolveYamlTimestamp,
+  construct: constructYamlTimestamp,
+  instanceOf: Date,
+  represent: representYamlTimestamp
+});
+
+
 /***/ }),
 
 /***/ 53497:
@@ -74946,7 +111803,7 @@ const core = __importStar(__nccwpck_require__(42186));
 const io = __importStar(__nccwpck_require__(47351));
 const fs = __importStar(__nccwpck_require__(57147));
 const os = __importStar(__nccwpck_require__(22037));
-const xmlbuilder2_1 = __nccwpck_require__(69075);
+const xmlbuilder2_1 = __nccwpck_require__(70151);
 const constants = __importStar(__nccwpck_require__(69042));
 const gpg = __importStar(__nccwpck_require__(23759));
 const util_1 = __nccwpck_require__(92629);
@@ -75328,7 +112185,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.AdoptDistribution = exports.AdoptImplementation = void 0;
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const path_1 = __importDefault(__nccwpck_require__(71017));
 const semver_1 = __importDefault(__nccwpck_require__(11383));
@@ -75508,7 +112365,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.JavaBase = void 0;
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const core = __importStar(__nccwpck_require__(42186));
 const fs = __importStar(__nccwpck_require__(57147));
 const semver_1 = __importDefault(__nccwpck_require__(11383));
@@ -75793,7 +112650,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.CorrettoDistribution = void 0;
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const path_1 = __importDefault(__nccwpck_require__(71017));
 const util_1 = __nccwpck_require__(92629);
@@ -76048,7 +112905,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.DragonwellDistribution = void 0;
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const semver_1 = __importDefault(__nccwpck_require__(11383));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const path_1 = __importDefault(__nccwpck_require__(71017));
@@ -76262,7 +113119,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.GraalVMDistribution = void 0;
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const path_1 = __importDefault(__nccwpck_require__(71017));
 const base_installer_1 = __nccwpck_require__(59741);
@@ -76473,7 +113330,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.JetBrainsDistribution = void 0;
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const path_1 = __importDefault(__nccwpck_require__(71017));
 const semver_1 = __importDefault(__nccwpck_require__(11383));
@@ -76708,7 +113565,7 @@ const base_installer_1 = __nccwpck_require__(59741);
 const semver_1 = __importDefault(__nccwpck_require__(11383));
 const util_1 = __nccwpck_require__(92629);
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const path_1 = __importDefault(__nccwpck_require__(71017));
 const supportedPlatform = `'linux', 'linux-musl', 'macos', 'solaris', 'windows'`;
@@ -76883,7 +113740,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.LocalDistribution = void 0;
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const core = __importStar(__nccwpck_require__(42186));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const path_1 = __importDefault(__nccwpck_require__(71017));
@@ -76995,7 +113852,7 @@ exports.MicrosoftDistributions = void 0;
 const base_installer_1 = __nccwpck_require__(59741);
 const util_1 = __nccwpck_require__(92629);
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const path_1 = __importDefault(__nccwpck_require__(71017));
 class MicrosoftDistributions extends base_installer_1.JavaBase {
@@ -77133,7 +113990,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.OracleDistribution = void 0;
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const path_1 = __importDefault(__nccwpck_require__(71017));
 const base_installer_1 = __nccwpck_require__(59741);
@@ -77265,7 +114122,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.SapMachineDistribution = void 0;
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const semver_1 = __importDefault(__nccwpck_require__(11383));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const path_1 = __importDefault(__nccwpck_require__(71017));
@@ -77485,7 +114342,7 @@ const base_installer_1 = __nccwpck_require__(59741);
 const semver_1 = __importDefault(__nccwpck_require__(11383));
 const util_1 = __nccwpck_require__(92629);
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const path_1 = __importDefault(__nccwpck_require__(71017));
 const supportedArchitectures = [
@@ -77674,7 +114531,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.TemurinDistribution = exports.TemurinImplementation = void 0;
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const path_1 = __importDefault(__nccwpck_require__(71017));
 const semver_1 = __importDefault(__nccwpck_require__(11383));
@@ -77853,7 +114710,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.ZuluDistribution = void 0;
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const path_1 = __importDefault(__nccwpck_require__(71017));
 const fs_1 = __importDefault(__nccwpck_require__(57147));
 const semver_1 = __importDefault(__nccwpck_require__(11383));
@@ -78252,7 +115109,7 @@ const core = __importStar(__nccwpck_require__(42186));
 const io = __importStar(__nccwpck_require__(47351));
 const constants = __importStar(__nccwpck_require__(69042));
 const util_1 = __nccwpck_require__(92629);
-const xmlbuilder2_1 = __nccwpck_require__(69075);
+const xmlbuilder2_1 = __nccwpck_require__(70151);
 function configureToolchains(version, distributionName, jdkHome, toolchainId) {
     return __awaiter(this, void 0, void 0, function* () {
         const vendor = core.getInput(constants.INPUT_MVN_TOOLCHAIN_VENDOR) || distributionName;
@@ -78419,7 +115276,7 @@ const fs = __importStar(__nccwpck_require__(57147));
 const semver = __importStar(__nccwpck_require__(11383));
 const cache = __importStar(__nccwpck_require__(27799));
 const core = __importStar(__nccwpck_require__(42186));
-const tc = __importStar(__nccwpck_require__(27784));
+const tc = __importStar(__nccwpck_require__(54188));
 const constants_1 = __nccwpck_require__(69042);
 function getTempDir() {
     const tempDirectory = process.env['RUNNER_TEMP'] || os_1.default.tmpdir();
@@ -78698,6 +115555,22 @@ module.exports = require("net");
 
 /***/ }),
 
+/***/ 98061:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:assert");
+
+/***/ }),
+
+/***/ 92761:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:async_hooks");
+
+/***/ }),
+
 /***/ 72254:
 /***/ ((module) => {
 
@@ -78706,6 +115579,14 @@ module.exports = require("node:buffer");
 
 /***/ }),
 
+/***/ 40027:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:console");
+
+/***/ }),
+
 /***/ 6005:
 /***/ ((module) => {
 
@@ -78714,6 +115595,22 @@ module.exports = require("node:crypto");
 
 /***/ }),
 
+/***/ 65714:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:diagnostics_channel");
+
+/***/ }),
+
+/***/ 30604:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:dns");
+
+/***/ }),
+
 /***/ 15673:
 /***/ ((module) => {
 
@@ -78738,6 +115635,14 @@ module.exports = require("node:http");
 
 /***/ }),
 
+/***/ 42725:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:http2");
+
+/***/ }),
+
 /***/ 22286:
 /***/ ((module) => {
 
@@ -78746,6 +115651,14 @@ module.exports = require("node:https");
 
 /***/ }),
 
+/***/ 87503:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:net");
+
+/***/ }),
+
 /***/ 70612:
 /***/ ((module) => {
 
@@ -78754,6 +115667,14 @@ module.exports = require("node:os");
 
 /***/ }),
 
+/***/ 38846:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:perf_hooks");
+
+/***/ }),
+
 /***/ 97742:
 /***/ ((module) => {
 
@@ -78762,6 +115683,14 @@ module.exports = require("node:process");
 
 /***/ }),
 
+/***/ 39630:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:querystring");
+
+/***/ }),
+
 /***/ 84492:
 /***/ ((module) => {
 
@@ -78770,6 +115699,22 @@ module.exports = require("node:stream");
 
 /***/ }),
 
+/***/ 31764:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:tls");
+
+/***/ }),
+
+/***/ 41041:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:url");
+
+/***/ }),
+
 /***/ 47261:
 /***/ ((module) => {
 
@@ -78778,6 +115723,22 @@ module.exports = require("node:util");
 
 /***/ }),
 
+/***/ 93746:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:util/types");
+
+/***/ }),
+
+/***/ 24086:
+/***/ ((module) => {
+
+"use strict";
+module.exports = require("node:worker_threads");
+
+/***/ }),
+
 /***/ 65628:
 /***/ ((module) => {
 
@@ -121601,5470 +158562,10 @@ function randomUUID() {
 
 /***/ }),
 
-/***/ 13810:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.builder = builder;
-exports.create = create;
-exports.fragment = fragment;
-exports.convert = convert;
-const interfaces_1 = __nccwpck_require__(81348);
-const util_1 = __nccwpck_require__(76195);
-const util_2 = __nccwpck_require__(65282);
-const _1 = __nccwpck_require__(2106);
-const dom_1 = __nccwpck_require__(1256);
-/** @inheritdoc */
-function builder(p1, p2) {
-    const options = formatBuilderOptions(isXMLBuilderCreateOptions(p1) ? p1 : interfaces_1.DefaultBuilderOptions);
-    const nodes = util_2.Guard.isNode(p1) || (0, util_1.isArray)(p1) ? p1 : p2;
-    if (nodes === undefined) {
-        throw new Error("Invalid arguments.");
-    }
-    if ((0, util_1.isArray)(nodes)) {
-        const builders = [];
-        for (let i = 0; i < nodes.length; i++) {
-            const builder = new _1.XMLBuilderImpl(nodes[i]);
-            builder.set(options);
-            builders.push(builder);
-        }
-        return builders;
-    }
-    else {
-        const builder = new _1.XMLBuilderImpl(nodes);
-        builder.set(options);
-        return builder;
-    }
-}
-/** @inheritdoc */
-function create(p1, p2) {
-    const options = formatBuilderOptions(p1 === undefined || isXMLBuilderCreateOptions(p1) ?
-        p1 : interfaces_1.DefaultBuilderOptions);
-    const contents = isXMLBuilderCreateOptions(p1) ? p2 : p1;
-    const doc = (0, dom_1.createDocument)();
-    setOptions(doc, options);
-    const builder = new _1.XMLBuilderImpl(doc);
-    if (contents !== undefined) {
-        // parse contents
-        builder.ele(contents);
-    }
-    return builder;
-}
-/** @inheritdoc */
-function fragment(p1, p2) {
-    const options = formatBuilderOptions(p1 === undefined || isXMLBuilderCreateOptions(p1) ?
-        p1 : interfaces_1.DefaultBuilderOptions);
-    const contents = isXMLBuilderCreateOptions(p1) ? p2 : p1;
-    const doc = (0, dom_1.createDocument)();
-    setOptions(doc, options, true);
-    const builder = new _1.XMLBuilderImpl(doc.createDocumentFragment());
-    if (contents !== undefined) {
-        // parse contents
-        builder.ele(contents);
-    }
-    return builder;
-}
-/** @inheritdoc */
-function convert(p1, p2, p3) {
-    let builderOptions;
-    let contents;
-    let convertOptions;
-    if (isXMLBuilderCreateOptions(p1) && p2 !== undefined) {
-        builderOptions = p1;
-        contents = p2;
-        convertOptions = p3;
-    }
-    else {
-        builderOptions = interfaces_1.DefaultBuilderOptions;
-        contents = p1;
-        convertOptions = p2 || undefined;
-    }
-    return create(builderOptions, contents).end(convertOptions);
-}
-function isXMLBuilderCreateOptions(obj) {
-    if (!(0, util_1.isPlainObject)(obj))
-        return false;
-    for (const key in obj) {
-        /* istanbul ignore else */
-        if (obj.hasOwnProperty(key)) {
-            if (!interfaces_1.XMLBuilderOptionKeys.has(key))
-                return false;
-        }
-    }
-    return true;
-}
-function formatBuilderOptions(createOptions = {}) {
-    const options = (0, util_1.applyDefaults)(createOptions, interfaces_1.DefaultBuilderOptions);
-    if (options.convert.att.length === 0 ||
-        options.convert.ins.length === 0 ||
-        options.convert.text.length === 0 ||
-        options.convert.cdata.length === 0 ||
-        options.convert.comment.length === 0) {
-        throw new Error("JS object converter strings cannot be zero length.");
-    }
-    return options;
-}
-function setOptions(doc, options, isFragment) {
-    const docWithSettings = doc;
-    docWithSettings._xmlBuilderOptions = options;
-    docWithSettings._isFragment = isFragment;
-}
-//# sourceMappingURL=BuilderFunctions.js.map
-
-/***/ }),
-
-/***/ 47059:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.createCB = createCB;
-exports.fragmentCB = fragmentCB;
-const _1 = __nccwpck_require__(2106);
-/**
- * Creates an XML builder which serializes the document in chunks.
- *
- * @param options - callback builder options
- *
- * @returns callback builder
- */
-function createCB(options) {
-    return new _1.XMLBuilderCBImpl(options);
-}
-/**
- * Creates an XML builder which serializes the fragment in chunks.
- *
- * @param options - callback builder options
- *
- * @returns callback builder
- */
-function fragmentCB(options) {
-    return new _1.XMLBuilderCBImpl(options, true);
-}
-//# sourceMappingURL=BuilderFunctionsCB.js.map
-
-/***/ }),
-
-/***/ 20282:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLBuilderCBImpl = void 0;
-const interfaces_1 = __nccwpck_require__(81348);
-const util_1 = __nccwpck_require__(76195);
-const BuilderFunctions_1 = __nccwpck_require__(13810);
-const algorithm_1 = __nccwpck_require__(61);
-const infra_1 = __nccwpck_require__(84251);
-const NamespacePrefixMap_1 = __nccwpck_require__(90283);
-const LocalNameSet_1 = __nccwpck_require__(19049);
-const util_2 = __nccwpck_require__(65282);
-const XMLCBWriter_1 = __nccwpck_require__(7299);
-const JSONCBWriter_1 = __nccwpck_require__(3198);
-const YAMLCBWriter_1 = __nccwpck_require__(32770);
-const events_1 = __nccwpck_require__(82361);
-/**
- * Represents a readable XML document stream.
- */
-class XMLBuilderCBImpl extends events_1.EventEmitter {
-    static _VoidElementNames = new Set(['area', 'base', 'basefont',
-        'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
-        'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
-    _options;
-    _builderOptions;
-    _writer;
-    _fragment;
-    _hasDeclaration = false;
-    _docTypeName = "";
-    _hasDocumentElement = false;
-    _currentElement;
-    _currentElementSerialized = false;
-    _openTags = [];
-    _prefixMap;
-    _prefixIndex;
-    _ended = false;
-    /**
-     * Initializes a new instance of `XMLStream`.
-     *
-     * @param options - stream writer options
-     * @param fragment - whether to create fragment stream or a document stream
-     *
-     * @returns XML stream
-     */
-    constructor(options, fragment = false) {
-        super();
-        this._fragment = fragment;
-        // provide default options
-        this._options = (0, util_1.applyDefaults)(options || {}, interfaces_1.DefaultXMLBuilderCBOptions);
-        this._builderOptions = {
-            defaultNamespace: this._options.defaultNamespace,
-            namespaceAlias: this._options.namespaceAlias
-        };
-        if (this._options.format === "json") {
-            this._writer = new JSONCBWriter_1.JSONCBWriter(this._options);
-        }
-        else if (this._options.format === "yaml") {
-            this._writer = new YAMLCBWriter_1.YAMLCBWriter(this._options);
-        }
-        else {
-            this._writer = new XMLCBWriter_1.XMLCBWriter(this._options);
-        }
-        // automatically create listeners for callbacks passed via options
-        if (this._options.data !== undefined) {
-            this.on("data", this._options.data);
-        }
-        if (this._options.end !== undefined) {
-            this.on("end", this._options.end);
-        }
-        if (this._options.error !== undefined) {
-            this.on("error", this._options.error);
-        }
-        this._prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap();
-        this._prefixMap.set("xml", infra_1.namespace.XML);
-        this._prefixIndex = { value: 1 };
-        this._push(this._writer.frontMatter());
-    }
-    /** @inheritdoc */
-    ele(p1, p2, p3) {
-        // parse if JS object or XML or JSON string
-        if ((0, util_1.isObject)(p1) || ((0, util_1.isString)(p1) && (/^\s*</.test(p1) || /^\s*[\{\[]/.test(p1) || /^(\s*|(#.*)|(%.*))*---/.test(p1)))) {
-            const frag = (0, BuilderFunctions_1.fragment)().set(this._options);
-            try {
-                frag.ele(p1);
-            }
-            catch (err) {
-                this.emit("error", err);
-                return this;
-            }
-            for (const node of frag.node.childNodes) {
-                this._fromNode(node);
-            }
-            return this;
-        }
-        this._serializeOpenTag(true);
-        if (!this._fragment && this._hasDocumentElement && this._writer.level === 0) {
-            this.emit("error", new Error("Document cannot have multiple document element nodes."));
-            return this;
-        }
-        try {
-            this._currentElement = (0, BuilderFunctions_1.fragment)(this._builderOptions).ele(p1, p2, p3);
-        }
-        catch (err) {
-            this.emit("error", err);
-            return this;
-        }
-        if (!this._fragment && !this._hasDocumentElement && this._docTypeName !== ""
-            && this._currentElement.node._qualifiedName !== this._docTypeName) {
-            this.emit("error", new Error("Document element name does not match DocType declaration name."));
-            return this;
-        }
-        this._currentElementSerialized = false;
-        if (!this._fragment) {
-            this._hasDocumentElement = true;
-        }
-        return this;
-    }
-    /** @inheritdoc */
-    att(p1, p2, p3) {
-        if (this._currentElement === undefined) {
-            this.emit("error", new Error("Cannot insert an attribute node as child of a document node."));
-            return this;
-        }
-        try {
-            this._currentElement.att(p1, p2, p3);
-        }
-        catch (err) {
-            this.emit("error", err);
-            return this;
-        }
-        return this;
-    }
-    /** @inheritdoc */
-    com(content) {
-        this._serializeOpenTag(true);
-        let node;
-        try {
-            node = (0, BuilderFunctions_1.fragment)(this._builderOptions).com(content).first().node;
-        }
-        catch (err) {
-            /* istanbul ignore next */
-            this.emit("error", err);
-            /* istanbul ignore next */
-            return this;
-        }
-        if (this._options.wellFormed && (!(0, algorithm_1.xml_isLegalChar)(node.data) ||
-            node.data.indexOf("--") !== -1 || node.data.endsWith("-"))) {
-            this.emit("error", new Error("Comment data contains invalid characters (well-formed required)."));
-            return this;
-        }
-        this._push(this._writer.comment(node.data));
-        return this;
-    }
-    /** @inheritdoc */
-    txt(content) {
-        if (!this._fragment && this._currentElement === undefined) {
-            this.emit("error", new Error("Cannot insert a text node as child of a document node."));
-            return this;
-        }
-        this._serializeOpenTag(true);
-        let node;
-        try {
-            node = (0, BuilderFunctions_1.fragment)(this._builderOptions).txt(content).first().node;
-        }
-        catch (err) {
-            /* istanbul ignore next */
-            this.emit("error", err);
-            /* istanbul ignore next */
-            return this;
-        }
-        if (this._options.wellFormed && !(0, algorithm_1.xml_isLegalChar)(node.data)) {
-            this.emit("error", new Error("Text data contains invalid characters (well-formed required)."));
-            return this;
-        }
-        const markup = node.data.replace(/(?!&(lt|gt|amp|apos|quot);)&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;');
-        this._push(this._writer.text(markup));
-        const lastEl = this._openTags[this._openTags.length - 1];
-        // edge case: text on top level.
-        if (lastEl) {
-            lastEl[lastEl.length - 1] = true;
-        }
-        return this;
-    }
-    /** @inheritdoc */
-    ins(target, content = '') {
-        this._serializeOpenTag(true);
-        let node;
-        try {
-            node = (0, BuilderFunctions_1.fragment)(this._builderOptions).ins(target, content).first().node;
-        }
-        catch (err) {
-            /* istanbul ignore next */
-            this.emit("error", err);
-            /* istanbul ignore next */
-            return this;
-        }
-        if (this._options.wellFormed && (node.target.indexOf(":") !== -1 || (/^xml$/i).test(node.target))) {
-            this.emit("error", new Error("Processing instruction target contains invalid characters (well-formed required)."));
-            return this;
-        }
-        if (this._options.wellFormed && !(0, algorithm_1.xml_isLegalChar)(node.data)) {
-            this.emit("error", Error("Processing instruction data contains invalid characters (well-formed required)."));
-            return this;
-        }
-        this._push(this._writer.instruction(node.target, node.data));
-        return this;
-    }
-    /** @inheritdoc */
-    dat(content) {
-        this._serializeOpenTag(true);
-        let node;
-        try {
-            node = (0, BuilderFunctions_1.fragment)(this._builderOptions).dat(content).first().node;
-        }
-        catch (err) {
-            this.emit("error", err);
-            return this;
-        }
-        this._push(this._writer.cdata(node.data));
-        return this;
-    }
-    /** @inheritdoc */
-    dec(options = { version: "1.0" }) {
-        if (this._fragment) {
-            this.emit("error", Error("Cannot insert an XML declaration into a document fragment."));
-            return this;
-        }
-        if (this._hasDeclaration) {
-            this.emit("error", Error("XML declaration is already inserted."));
-            return this;
-        }
-        this._push(this._writer.declaration(options.version || "1.0", options.encoding, options.standalone));
-        this._hasDeclaration = true;
-        return this;
-    }
-    /** @inheritdoc */
-    dtd(options) {
-        if (this._fragment) {
-            this.emit("error", Error("Cannot insert a DocType declaration into a document fragment."));
-            return this;
-        }
-        if (this._docTypeName !== "") {
-            this.emit("error", new Error("DocType declaration is already inserted."));
-            return this;
-        }
-        if (this._hasDocumentElement) {
-            this.emit("error", new Error("Cannot insert DocType declaration after document element."));
-            return this;
-        }
-        let node;
-        try {
-            node = (0, BuilderFunctions_1.create)().dtd(options).first().node;
-        }
-        catch (err) {
-            this.emit("error", err);
-            return this;
-        }
-        if (this._options.wellFormed && !(0, algorithm_1.xml_isPubidChar)(node.publicId)) {
-            this.emit("error", new Error("DocType public identifier does not match PubidChar construct (well-formed required)."));
-            return this;
-        }
-        if (this._options.wellFormed &&
-            (!(0, algorithm_1.xml_isLegalChar)(node.systemId) ||
-                (node.systemId.indexOf('"') !== -1 && node.systemId.indexOf("'") !== -1))) {
-            this.emit("error", new Error("DocType system identifier contains invalid characters (well-formed required)."));
-            return this;
-        }
-        this._docTypeName = options.name;
-        this._push(this._writer.docType(options.name, node.publicId, node.systemId));
-        return this;
-    }
-    /** @inheritdoc */
-    import(node) {
-        const frag = (0, BuilderFunctions_1.fragment)().set(this._options);
-        try {
-            frag.import(node);
-        }
-        catch (err) {
-            this.emit("error", err);
-            return this;
-        }
-        for (const node of frag.node.childNodes) {
-            this._fromNode(node);
-        }
-        return this;
-    }
-    /** @inheritdoc */
-    up() {
-        this._serializeOpenTag(false);
-        this._serializeCloseTag();
-        return this;
-    }
-    /** @inheritdoc */
-    end() {
-        this._serializeOpenTag(false);
-        while (this._openTags.length > 0) {
-            this._serializeCloseTag();
-        }
-        this._push(null);
-        return this;
-    }
-    /**
-     * Serializes the opening tag of an element node.
-     *
-     * @param hasChildren - whether the element node has child nodes
-     */
-    _serializeOpenTag(hasChildren) {
-        if (this._currentElementSerialized)
-            return;
-        if (this._currentElement === undefined)
-            return;
-        const node = this._currentElement.node;
-        if (this._options.wellFormed && (node.localName.indexOf(":") !== -1 ||
-            !(0, algorithm_1.xml_isName)(node.localName))) {
-            this.emit("error", new Error("Node local name contains invalid characters (well-formed required)."));
-            return;
-        }
-        let qualifiedName = "";
-        let ignoreNamespaceDefinitionAttribute = false;
-        let map = this._prefixMap.copy();
-        let localPrefixesMap = {};
-        let localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap);
-        let inheritedNS = this._openTags.length === 0 ? null : this._openTags[this._openTags.length - 1][1];
-        let ns = node.namespaceURI;
-        if (ns === null)
-            ns = inheritedNS;
-        if (inheritedNS === ns) {
-            if (localDefaultNamespace !== null) {
-                ignoreNamespaceDefinitionAttribute = true;
-            }
-            if (ns === infra_1.namespace.XML) {
-                qualifiedName = "xml:" + node.localName;
-            }
-            else {
-                qualifiedName = node.localName;
-            }
-            this._writer.beginElement(qualifiedName);
-            this._push(this._writer.openTagBegin(qualifiedName));
-        }
-        else {
-            let prefix = node.prefix;
-            let candidatePrefix = null;
-            if (prefix !== null || ns !== localDefaultNamespace) {
-                candidatePrefix = map.get(prefix, ns);
-            }
-            if (prefix === "xmlns") {
-                if (this._options.wellFormed) {
-                    this.emit("error", new Error("An element cannot have the 'xmlns' prefix (well-formed required)."));
-                    return;
-                }
-                candidatePrefix = prefix;
-            }
-            if (candidatePrefix !== null) {
-                qualifiedName = candidatePrefix + ':' + node.localName;
-                if (localDefaultNamespace !== null && localDefaultNamespace !== infra_1.namespace.XML) {
-                    inheritedNS = localDefaultNamespace || null;
-                }
-                this._writer.beginElement(qualifiedName);
-                this._push(this._writer.openTagBegin(qualifiedName));
-            }
-            else if (prefix !== null) {
-                if (prefix in localPrefixesMap) {
-                    prefix = this._generatePrefix(ns, map, this._prefixIndex);
-                }
-                map.set(prefix, ns);
-                qualifiedName += prefix + ':' + node.localName;
-                this._writer.beginElement(qualifiedName);
-                this._push(this._writer.openTagBegin(qualifiedName));
-                this._push(this._writer.attribute("xmlns:" + prefix, this._serializeAttributeValue(ns, this._options.wellFormed)));
-                if (localDefaultNamespace !== null) {
-                    inheritedNS = localDefaultNamespace || null;
-                }
-            }
-            else if (localDefaultNamespace === null ||
-                (localDefaultNamespace !== null && localDefaultNamespace !== ns)) {
-                ignoreNamespaceDefinitionAttribute = true;
-                qualifiedName += node.localName;
-                inheritedNS = ns;
-                this._writer.beginElement(qualifiedName);
-                this._push(this._writer.openTagBegin(qualifiedName));
-                this._push(this._writer.attribute("xmlns", this._serializeAttributeValue(ns, this._options.wellFormed)));
-            }
-            else {
-                qualifiedName += node.localName;
-                inheritedNS = ns;
-                this._writer.beginElement(qualifiedName);
-                this._push(this._writer.openTagBegin(qualifiedName));
-            }
-        }
-        this._serializeAttributes(node, map, this._prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, this._options.wellFormed);
-        const isHTML = (ns === infra_1.namespace.HTML);
-        if (isHTML && !hasChildren &&
-            XMLBuilderCBImpl._VoidElementNames.has(node.localName)) {
-            this._push(this._writer.openTagEnd(qualifiedName, true, true));
-            this._writer.endElement(qualifiedName);
-        }
-        else if (!isHTML && !hasChildren) {
-            this._push(this._writer.openTagEnd(qualifiedName, true, false));
-            this._writer.endElement(qualifiedName);
-        }
-        else {
-            this._push(this._writer.openTagEnd(qualifiedName, false, false));
-        }
-        this._currentElementSerialized = true;
-        /**
-         * Save qualified name, original inherited ns, original prefix map, and
-         * hasChildren flag.
-         */
-        this._openTags.push([qualifiedName, inheritedNS, this._prefixMap, hasChildren, undefined]);
-        /**
-         * New values of inherited namespace and prefix map will be used while
-         * serializing child nodes. They will be returned to their original values
-         * when this node is closed using the _openTags array item we saved above.
-         */
-        if (this._isPrefixMapModified(this._prefixMap, map)) {
-            this._prefixMap = map;
-        }
-        /**
-         * Calls following this will either serialize child nodes or close this tag.
-         */
-        this._writer.level++;
-    }
-    /**
-     * Serializes the closing tag of an element node.
-     */
-    _serializeCloseTag() {
-        this._writer.level--;
-        const lastEle = this._openTags.pop();
-        /* istanbul ignore next */
-        if (lastEle === undefined) {
-            this.emit("error", new Error("Last element is undefined."));
-            return;
-        }
-        const [qualifiedName, ns, map, hasChildren, hasTextPayload] = lastEle;
-        /**
-         * Restore original values of inherited namespace and prefix map.
-         */
-        this._prefixMap = map;
-        if (!hasChildren)
-            return;
-        this._push(this._writer.closeTag(qualifiedName, hasTextPayload));
-        this._writer.endElement(qualifiedName);
-    }
-    /**
-     * Pushes data to internal buffer.
-     *
-     * @param data - data
-     */
-    _push(data) {
-        if (data === null) {
-            this._ended = true;
-            this.emit("end");
-        }
-        else if (this._ended) {
-            this.emit("error", new Error("Cannot push to ended stream."));
-        }
-        else if (data.length !== 0) {
-            this._writer.hasData = true;
-            this.emit("data", data, this._writer.level);
-        }
-    }
-    /**
-     * Reads and serializes an XML tree.
-     *
-     * @param node - root node
-     */
-    _fromNode(node) {
-        if (util_2.Guard.isElementNode(node)) {
-            const name = node.prefix ? node.prefix + ":" + node.localName : node.localName;
-            if (node.namespaceURI !== null) {
-                this.ele(node.namespaceURI, name);
-            }
-            else {
-                this.ele(name);
-            }
-            for (const attr of node.attributes) {
-                const name = attr.prefix ? attr.prefix + ":" + attr.localName : attr.localName;
-                if (attr.namespaceURI !== null) {
-                    this.att(attr.namespaceURI, name, attr.value);
-                }
-                else {
-                    this.att(name, attr.value);
-                }
-            }
-            for (const child of node.childNodes) {
-                this._fromNode(child);
-            }
-            this.up();
-        }
-        else if (util_2.Guard.isExclusiveTextNode(node) && node.data) {
-            this.txt(node.data);
-        }
-        else if (util_2.Guard.isCommentNode(node)) {
-            this.com(node.data);
-        }
-        else if (util_2.Guard.isCDATASectionNode(node)) {
-            this.dat(node.data);
-        }
-        else if (util_2.Guard.isProcessingInstructionNode(node)) {
-            this.ins(node.target, node.data);
-        }
-    }
-    /**
-     * Produces an XML serialization of the attributes of an element node.
-     *
-     * @param node - node to serialize
-     * @param map - namespace prefix map
-     * @param prefixIndex - generated namespace prefix index
-     * @param localPrefixesMap - local prefixes map
-     * @param ignoreNamespaceDefinitionAttribute - whether to ignore namespace
-     * attributes
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeAttributes(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) {
-        const localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined;
-        for (const attr of node.attributes) {
-            // Optimize common case
-            if (!requireWellFormed && !ignoreNamespaceDefinitionAttribute && attr.namespaceURI === null) {
-                this._push(this._writer.attribute(attr.localName, this._serializeAttributeValue(attr.value, this._options.wellFormed)));
-                continue;
-            }
-            if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) {
-                this.emit("error", new Error("Element contains duplicate attributes (well-formed required)."));
-                return;
-            }
-            if (requireWellFormed && localNameSet)
-                localNameSet.set(attr.namespaceURI, attr.localName);
-            let attributeNamespace = attr.namespaceURI;
-            let candidatePrefix = null;
-            if (attributeNamespace !== null) {
-                candidatePrefix = map.get(attr.prefix, attributeNamespace);
-                if (attributeNamespace === infra_1.namespace.XMLNS) {
-                    if (attr.value === infra_1.namespace.XML ||
-                        (attr.prefix === null && ignoreNamespaceDefinitionAttribute) ||
-                        (attr.prefix !== null && (!(attr.localName in localPrefixesMap) ||
-                            localPrefixesMap[attr.localName] !== attr.value) &&
-                            map.has(attr.localName, attr.value)))
-                        continue;
-                    if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) {
-                        this.emit("error", new Error("XMLNS namespace is reserved (well-formed required)."));
-                        return;
-                    }
-                    if (requireWellFormed && attr.value === '') {
-                        this.emit("error", new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required)."));
-                        return;
-                    }
-                    if (attr.prefix === 'xmlns')
-                        candidatePrefix = 'xmlns';
-                    /**
-                     * _Note:_ The (candidatePrefix === null) check is not in the spec.
-                     * We deviate from the spec here. Otherwise a prefix is generated for
-                     * all attributes with namespaces.
-                     */
-                }
-                else if (candidatePrefix === null) {
-                    if (attr.prefix !== null &&
-                        (!map.hasPrefix(attr.prefix) ||
-                            map.has(attr.prefix, attributeNamespace))) {
-                        /**
-                         * Check if we can use the attribute's own prefix.
-                         * We deviate from the spec here.
-                         * TODO: This is not an efficient way of searching for prefixes.
-                         * Follow developments to the spec.
-                         */
-                        candidatePrefix = attr.prefix;
-                    }
-                    else {
-                        candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex);
-                    }
-                    this._push(this._writer.attribute("xmlns:" + candidatePrefix, this._serializeAttributeValue(attributeNamespace, this._options.wellFormed)));
-                }
-            }
-            if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
-                !(0, algorithm_1.xml_isName)(attr.localName) ||
-                (attr.localName === "xmlns" && attributeNamespace === null))) {
-                this.emit("error", new Error("Attribute local name contains invalid characters (well-formed required)."));
-                return;
-            }
-            this._push(this._writer.attribute((candidatePrefix !== null ? candidatePrefix + ":" : "") + attr.localName, this._serializeAttributeValue(attr.value, this._options.wellFormed)));
-        }
-    }
-    /**
-     * Produces an XML serialization of an attribute value.
-     *
-     * @param value - attribute value
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeAttributeValue(value, requireWellFormed) {
-        if (requireWellFormed && value !== null && !(0, algorithm_1.xml_isLegalChar)(value)) {
-            this.emit("error", new Error("Invalid characters in attribute value."));
-            return "";
-        }
-        if (value === null)
-            return "";
-        return value.replace(/(?!&(lt|gt|amp|apos|quot);)&/g, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-            .replace(/"/g, '&quot;');
-    }
-    /**
-     * Records namespace information for the given element and returns the
-     * default namespace attribute value.
-     *
-     * @param node - element node to process
-     * @param map - namespace prefix map
-     * @param localPrefixesMap - local prefixes map
-     */
-    _recordNamespaceInformation(node, map, localPrefixesMap) {
-        let defaultNamespaceAttrValue = null;
-        for (const attr of node.attributes) {
-            let attributeNamespace = attr.namespaceURI;
-            let attributePrefix = attr.prefix;
-            if (attributeNamespace === infra_1.namespace.XMLNS) {
-                if (attributePrefix === null) {
-                    defaultNamespaceAttrValue = attr.value;
-                    continue;
-                }
-                else {
-                    let prefixDefinition = attr.localName;
-                    let namespaceDefinition = attr.value;
-                    if (namespaceDefinition === infra_1.namespace.XML) {
-                        continue;
-                    }
-                    if (namespaceDefinition === '') {
-                        namespaceDefinition = null;
-                    }
-                    if (map.has(prefixDefinition, namespaceDefinition)) {
-                        continue;
-                    }
-                    map.set(prefixDefinition, namespaceDefinition);
-                    localPrefixesMap[prefixDefinition] = namespaceDefinition || '';
-                }
-            }
-        }
-        return defaultNamespaceAttrValue;
-    }
-    /**
-     * Generates a new prefix for the given namespace.
-     *
-     * @param newNamespace - a namespace to generate prefix for
-     * @param prefixMap - namespace prefix map
-     * @param prefixIndex - generated namespace prefix index
-     */
-    _generatePrefix(newNamespace, prefixMap, prefixIndex) {
-        let generatedPrefix = "ns" + prefixIndex.value;
-        prefixIndex.value++;
-        prefixMap.set(generatedPrefix, newNamespace);
-        return generatedPrefix;
-    }
-    /**
-     * Determines if the namespace prefix map was modified from its original.
-     *
-     * @param originalMap - original namespace prefix map
-     * @param newMap - new namespace prefix map
-     */
-    _isPrefixMapModified(originalMap, newMap) {
-        const items1 = originalMap._items;
-        const items2 = newMap._items;
-        const nullItems1 = originalMap._nullItems;
-        const nullItems2 = newMap._nullItems;
-        for (const key in items2) {
-            const arr1 = items1[key];
-            if (arr1 === undefined)
-                return true;
-            const arr2 = items2[key];
-            if (arr1.length !== arr2.length)
-                return true;
-            for (let i = 0; i < arr1.length; i++) {
-                if (arr1[i] !== arr2[i])
-                    return true;
-            }
-        }
-        if (nullItems1.length !== nullItems2.length)
-            return true;
-        for (let i = 0; i < nullItems1.length; i++) {
-            if (nullItems1[i] !== nullItems2[i])
-                return true;
-        }
-        return false;
-    }
-}
-exports.XMLBuilderCBImpl = XMLBuilderCBImpl;
-//# sourceMappingURL=XMLBuilderCBImpl.js.map
-
-/***/ }),
-
-/***/ 10584:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLBuilderImpl = void 0;
-const interfaces_1 = __nccwpck_require__(81348);
-const util_1 = __nccwpck_require__(76195);
-const writers_1 = __nccwpck_require__(70469);
-const interfaces_2 = __nccwpck_require__(27305);
-const util_2 = __nccwpck_require__(65282);
-const algorithm_1 = __nccwpck_require__(61);
-const dom_1 = __nccwpck_require__(1256);
-const infra_1 = __nccwpck_require__(84251);
-const readers_1 = __nccwpck_require__(90241);
-/**
- * Represents a wrapper that extends XML nodes to implement easy to use and
- * chainable document builder methods.
- */
-class XMLBuilderImpl {
-    _domNode;
-    /**
-     * Initializes a new instance of `XMLBuilderNodeImpl`.
-     *
-     * @param domNode - the DOM node to wrap
-     */
-    constructor(domNode) {
-        this._domNode = domNode;
-    }
-    /** @inheritdoc */
-    get node() { return this._domNode; }
-    /** @inheritdoc */
-    get options() { return this._options; }
-    /** @inheritdoc */
-    set(options) {
-        this._options = (0, util_1.applyDefaults)((0, util_1.applyDefaults)(this._options, options, true), // apply user settings
-        interfaces_1.DefaultBuilderOptions); // provide defaults
-        return this;
-    }
-    /** @inheritdoc */
-    ele(p1, p2, p3) {
-        let namespace;
-        let name;
-        let attributes;
-        if ((0, util_1.isObject)(p1)) {
-            // ele(obj: ExpandObject)
-            return new readers_1.ObjectReader(this._options).parse(this, p1);
-        }
-        else if ((0, util_1.isString)(p1) && p1 !== null && /^\s*</.test(p1)) {
-            // parse XML document string
-            return new readers_1.XMLReader(this._options).parse(this, p1);
-        }
-        else if ((0, util_1.isString)(p1) && p1 !== null && /^\s*[\{\[]/.test(p1)) {
-            // parse JSON string
-            return new readers_1.JSONReader(this._options).parse(this, p1);
-        }
-        else if ((0, util_1.isString)(p1) && p1 !== null && /^(\s*|(#.*)|(%.*))*---/.test(p1)) {
-            // parse YAML string
-            return new readers_1.YAMLReader(this._options).parse(this, p1);
-        }
-        if ((p1 === null || (0, util_1.isString)(p1)) && (0, util_1.isString)(p2)) {
-            // ele(namespace: string, name: string, attributes?: AttributesObject)
-            [namespace, name, attributes] = [p1, p2, p3];
-        }
-        else if (p1 !== null) {
-            // ele(name: string, attributes?: AttributesObject)
-            [namespace, name, attributes] = [undefined, p1, (0, util_1.isObject)(p2) ? p2 : undefined];
-        }
-        else {
-            throw new Error("Element name cannot be null. " + this._debugInfo());
-        }
-        if (attributes) {
-            attributes = (0, util_1.getValue)(attributes);
-        }
-        [namespace, name] = this._extractNamespace((0, dom_1.sanitizeInput)(namespace, this._options.invalidCharReplacement), (0, dom_1.sanitizeInput)(name, this._options.invalidCharReplacement), true);
-        // inherit namespace from parent
-        if (namespace === undefined) {
-            const [prefix] = (0, algorithm_1.namespace_extractQName)(name);
-            namespace = this.node.lookupNamespaceURI(prefix);
-        }
-        // create a child element node
-        const childNode = (namespace !== undefined && namespace !== null ?
-            this._doc.createElementNS(namespace, name) :
-            this._doc.createElement(name));
-        this.node.appendChild(childNode);
-        const builder = new XMLBuilderImpl(childNode);
-        // update doctype node if the new node is the document element node
-        const oldDocType = this._doc.doctype;
-        if (childNode === this._doc.documentElement && oldDocType !== null) {
-            const docType = this._doc.implementation.createDocumentType(this._doc.documentElement.tagName, oldDocType.publicId, oldDocType.systemId);
-            this._doc.replaceChild(docType, oldDocType);
-        }
-        // create attributes
-        if (attributes && !(0, util_1.isEmpty)(attributes)) {
-            builder.att(attributes);
-        }
-        return builder;
-    }
-    /** @inheritdoc */
-    remove() {
-        const parent = this.up();
-        parent.node.removeChild(this.node);
-        return parent;
-    }
-    /** @inheritdoc */
-    att(p1, p2, p3) {
-        if ((0, util_1.isMap)(p1) || (0, util_1.isObject)(p1)) {
-            // att(obj: AttributesObject)
-            // expand if object
-            (0, util_1.forEachObject)(p1, (attName, attValue) => this.att(attName, attValue), this);
-            return this;
-        }
-        // get primitive values
-        if (p1 !== undefined && p1 !== null)
-            p1 = (0, util_1.getValue)(p1 + "");
-        if (p2 !== undefined && p2 !== null)
-            p2 = (0, util_1.getValue)(p2 + "");
-        if (p3 !== undefined && p3 !== null)
-            p3 = (0, util_1.getValue)(p3 + "");
-        let namespace;
-        let name;
-        let value;
-        if ((p1 === null || (0, util_1.isString)(p1)) && (0, util_1.isString)(p2) && (p3 === null || (0, util_1.isString)(p3))) {
-            // att(namespace: string, name: string, value: string)
-            [namespace, name, value] = [p1, p2, p3];
-        }
-        else if ((0, util_1.isString)(p1) && (p2 == null || (0, util_1.isString)(p2))) {
-            // ele(name: string, value: string)
-            [namespace, name, value] = [undefined, p1, p2];
-        }
-        else {
-            throw new Error("Attribute name and value not specified. " + this._debugInfo());
-        }
-        if (this._options.keepNullAttributes && (value == null)) {
-            // keep null attributes
-            value = "";
-        }
-        else if (value == null) {
-            // skip null|undefined attributes
-            return this;
-        }
-        if (!util_2.Guard.isElementNode(this.node)) {
-            throw new Error("An attribute can only be assigned to an element node.");
-        }
-        let ele = this.node;
-        [namespace, name] = this._extractNamespace(namespace, name, false);
-        name = (0, dom_1.sanitizeInput)(name, this._options.invalidCharReplacement);
-        namespace = (0, dom_1.sanitizeInput)(namespace, this._options.invalidCharReplacement);
-        value = (0, dom_1.sanitizeInput)(value, this._options.invalidCharReplacement);
-        const [prefix, localName] = (0, algorithm_1.namespace_extractQName)(name);
-        const [elePrefix] = (0, algorithm_1.namespace_extractQName)(ele.prefix ? ele.prefix + ':' + ele.localName : ele.localName);
-        // check if this is a namespace declaration attribute
-        // assign a new element namespace if it wasn't previously assigned
-        let eleNamespace = null;
-        if (prefix === "xmlns") {
-            namespace = infra_1.namespace.XMLNS;
-            if (ele.namespaceURI === null && elePrefix === localName) {
-                eleNamespace = value;
-            }
-        }
-        else if (prefix === null && localName === "xmlns" && elePrefix === null) {
-            namespace = infra_1.namespace.XMLNS;
-            eleNamespace = value;
-        }
-        // re-create the element node if its namespace changed
-        // we can't simply change the namespaceURI since its read-only
-        if (eleNamespace !== null) {
-            this._updateNamespace(eleNamespace);
-            ele = this.node;
-        }
-        if (namespace !== undefined) {
-            ele.setAttributeNS(namespace, name, value);
-        }
-        else {
-            ele.setAttribute(name, value);
-        }
-        return this;
-    }
-    /** @inheritdoc */
-    removeAtt(p1, p2) {
-        if (!util_2.Guard.isElementNode(this.node)) {
-            throw new Error("An attribute can only be removed from an element node.");
-        }
-        // get primitive values
-        p1 = (0, util_1.getValue)(p1);
-        if (p2 !== undefined) {
-            p2 = (0, util_1.getValue)(p2);
-        }
-        let namespace;
-        let name;
-        if (p1 !== null && p2 === undefined) {
-            name = p1;
-        }
-        else if ((p1 === null || (0, util_1.isString)(p1)) && p2 !== undefined) {
-            namespace = p1;
-            name = p2;
-        }
-        else {
-            throw new Error("Attribute namespace must be a string. " + this._debugInfo());
-        }
-        if ((0, util_1.isArray)(name) || (0, util_1.isSet)(name)) {
-            // removeAtt(names: string[])
-            // removeAtt(namespace: string, names: string[])
-            (0, util_1.forEachArray)(name, attName => namespace === undefined ? this.removeAtt(attName) : this.removeAtt(namespace, attName), this);
-        }
-        else if (namespace !== undefined) {
-            // removeAtt(namespace: string, name: string)
-            name = (0, dom_1.sanitizeInput)(name, this._options.invalidCharReplacement);
-            namespace = (0, dom_1.sanitizeInput)(namespace, this._options.invalidCharReplacement);
-            this.node.removeAttributeNS(namespace, name);
-        }
-        else {
-            // removeAtt(name: string)
-            name = (0, dom_1.sanitizeInput)(name, this._options.invalidCharReplacement);
-            this.node.removeAttribute(name);
-        }
-        return this;
-    }
-    /** @inheritdoc */
-    txt(content) {
-        if (content === null || content === undefined) {
-            if (this._options.keepNullNodes) {
-                // keep null nodes
-                content = "";
-            }
-            else {
-                // skip null|undefined nodes
-                return this;
-            }
-        }
-        const child = this._doc.createTextNode((0, dom_1.sanitizeInput)(content, this._options.invalidCharReplacement));
-        this.node.appendChild(child);
-        return this;
-    }
-    /** @inheritdoc */
-    com(content) {
-        if (content === null || content === undefined) {
-            if (this._options.keepNullNodes) {
-                // keep null nodes
-                content = "";
-            }
-            else {
-                // skip null|undefined nodes
-                return this;
-            }
-        }
-        const child = this._doc.createComment((0, dom_1.sanitizeInput)(content, this._options.invalidCharReplacement));
-        this.node.appendChild(child);
-        return this;
-    }
-    /** @inheritdoc */
-    dat(content) {
-        if (content === null || content === undefined) {
-            if (this._options.keepNullNodes) {
-                // keep null nodes
-                content = "";
-            }
-            else {
-                // skip null|undefined nodes
-                return this;
-            }
-        }
-        const child = this._doc.createCDATASection((0, dom_1.sanitizeInput)(content, this._options.invalidCharReplacement));
-        this.node.appendChild(child);
-        return this;
-    }
-    /** @inheritdoc */
-    ins(target, content = '') {
-        if (content === null || content === undefined) {
-            if (this._options.keepNullNodes) {
-                // keep null nodes
-                content = "";
-            }
-            else {
-                // skip null|undefined nodes
-                return this;
-            }
-        }
-        if ((0, util_1.isArray)(target) || (0, util_1.isSet)(target)) {
-            (0, util_1.forEachArray)(target, item => {
-                item += "";
-                const insIndex = item.indexOf(' ');
-                const insTarget = (insIndex === -1 ? item : item.substr(0, insIndex));
-                const insValue = (insIndex === -1 ? '' : item.substr(insIndex + 1));
-                this.ins(insTarget, insValue);
-            }, this);
-        }
-        else if ((0, util_1.isMap)(target) || (0, util_1.isObject)(target)) {
-            (0, util_1.forEachObject)(target, (insTarget, insValue) => this.ins(insTarget, insValue), this);
-        }
-        else {
-            const child = this._doc.createProcessingInstruction((0, dom_1.sanitizeInput)(target, this._options.invalidCharReplacement), (0, dom_1.sanitizeInput)(content, this._options.invalidCharReplacement));
-            this.node.appendChild(child);
-        }
-        return this;
-    }
-    /** @inheritdoc */
-    dec(options) {
-        this._options.version = options.version || "1.0";
-        this._options.encoding = options.encoding;
-        this._options.standalone = options.standalone;
-        return this;
-    }
-    /** @inheritdoc */
-    dtd(options) {
-        const name = (0, dom_1.sanitizeInput)((options && options.name) || (this._doc.documentElement ? this._doc.documentElement.tagName : "ROOT"), this._options.invalidCharReplacement);
-        const pubID = (0, dom_1.sanitizeInput)((options && options.pubID) || "", this._options.invalidCharReplacement);
-        const sysID = (0, dom_1.sanitizeInput)((options && options.sysID) || "", this._options.invalidCharReplacement);
-        // name must match document element
-        if (this._doc.documentElement !== null && name !== this._doc.documentElement.tagName) {
-            throw new Error("DocType name does not match document element name.");
-        }
-        // create doctype node
-        const docType = this._doc.implementation.createDocumentType(name, pubID, sysID);
-        if (this._doc.doctype !== null) {
-            // replace existing doctype
-            this._doc.replaceChild(docType, this._doc.doctype);
-        }
-        else {
-            // insert before document element node or append to end
-            this._doc.insertBefore(docType, this._doc.documentElement);
-        }
-        return this;
-    }
-    /** @inheritdoc */
-    import(node) {
-        const hostNode = this._domNode;
-        const hostDoc = this._doc;
-        const importedNode = node.node;
-        const updateImportedNodeNs = (clone) => {
-            // update namespace of imported node only when not specified
-            if (!clone._namespace) {
-                const [prefix] = (0, algorithm_1.namespace_extractQName)(clone.prefix ? clone.prefix + ':' + clone.localName : clone.localName);
-                const namespace = hostNode.lookupNamespaceURI(prefix);
-                new XMLBuilderImpl(clone)._updateNamespace(namespace);
-            }
-        };
-        if (util_2.Guard.isDocumentNode(importedNode)) {
-            // import document node
-            const elementNode = importedNode.documentElement;
-            if (elementNode === null) {
-                throw new Error("Imported document has no document element node. " + this._debugInfo());
-            }
-            const clone = hostDoc.importNode(elementNode, true);
-            hostNode.appendChild(clone);
-            updateImportedNodeNs(clone);
-        }
-        else if (util_2.Guard.isDocumentFragmentNode(importedNode)) {
-            // import child nodes
-            for (const childNode of importedNode.childNodes) {
-                const clone = hostDoc.importNode(childNode, true);
-                hostNode.appendChild(clone);
-                if (util_2.Guard.isElementNode(clone)) {
-                    updateImportedNodeNs(clone);
-                }
-            }
-        }
-        else {
-            // import node
-            const clone = hostDoc.importNode(importedNode, true);
-            hostNode.appendChild(clone);
-            if (util_2.Guard.isElementNode(clone)) {
-                updateImportedNodeNs(clone);
-            }
-        }
-        return this;
-    }
-    /** @inheritdoc */
-    doc() {
-        if (this._doc._isFragment) {
-            let node = this.node;
-            while (node && node.nodeType !== interfaces_2.NodeType.DocumentFragment) {
-                node = node.parentNode;
-            }
-            /* istanbul ignore next */
-            if (node === null) {
-                throw new Error("Node has no parent node while searching for document fragment ancestor. " + this._debugInfo());
-            }
-            return new XMLBuilderImpl(node);
-        }
-        else {
-            return new XMLBuilderImpl(this._doc);
-        }
-    }
-    /** @inheritdoc */
-    root() {
-        const ele = this._doc.documentElement;
-        if (!ele) {
-            throw new Error("Document root element is null. " + this._debugInfo());
-        }
-        return new XMLBuilderImpl(ele);
-    }
-    /** @inheritdoc */
-    up() {
-        const parent = this._domNode.parentNode;
-        if (!parent) {
-            throw new Error("Parent node is null. " + this._debugInfo());
-        }
-        return new XMLBuilderImpl(parent);
-    }
-    /** @inheritdoc */
-    prev() {
-        const node = this._domNode.previousSibling;
-        if (!node) {
-            throw new Error("Previous sibling node is null. " + this._debugInfo());
-        }
-        return new XMLBuilderImpl(node);
-    }
-    /** @inheritdoc */
-    next() {
-        const node = this._domNode.nextSibling;
-        if (!node) {
-            throw new Error("Next sibling node is null. " + this._debugInfo());
-        }
-        return new XMLBuilderImpl(node);
-    }
-    /** @inheritdoc */
-    first() {
-        const node = this._domNode.firstChild;
-        if (!node) {
-            throw new Error("First child node is null. " + this._debugInfo());
-        }
-        return new XMLBuilderImpl(node);
-    }
-    /** @inheritdoc */
-    last() {
-        const node = this._domNode.lastChild;
-        if (!node) {
-            throw new Error("Last child node is null. " + this._debugInfo());
-        }
-        return new XMLBuilderImpl(node);
-    }
-    /** @inheritdoc */
-    each(callback, self = false, recursive = false, thisArg) {
-        let result = this._getFirstDescendantNode(this._domNode, self, recursive);
-        while (result[0]) {
-            const nextResult = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]);
-            callback.call(thisArg, new XMLBuilderImpl(result[0]), result[1], result[2]);
-            result = nextResult;
-        }
-        return this;
-    }
-    /** @inheritdoc */
-    map(callback, self = false, recursive = false, thisArg) {
-        let result = [];
-        this.each((node, index, level) => result.push(callback.call(thisArg, node, index, level)), self, recursive);
-        return result;
-    }
-    /** @inheritdoc */
-    reduce(callback, initialValue, self = false, recursive = false, thisArg) {
-        let value = initialValue;
-        this.each((node, index, level) => value = callback.call(thisArg, value, node, index, level), self, recursive);
-        return value;
-    }
-    /** @inheritdoc */
-    find(predicate, self = false, recursive = false, thisArg) {
-        let result = this._getFirstDescendantNode(this._domNode, self, recursive);
-        while (result[0]) {
-            const builder = new XMLBuilderImpl(result[0]);
-            if (predicate.call(thisArg, builder, result[1], result[2])) {
-                return builder;
-            }
-            result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]);
-        }
-        return undefined;
-    }
-    /** @inheritdoc */
-    filter(predicate, self = false, recursive = false, thisArg) {
-        let result = [];
-        this.each((node, index, level) => {
-            if (predicate.call(thisArg, node, index, level)) {
-                result.push(node);
-            }
-        }, self, recursive);
-        return result;
-    }
-    /** @inheritdoc */
-    every(predicate, self = false, recursive = false, thisArg) {
-        let result = this._getFirstDescendantNode(this._domNode, self, recursive);
-        while (result[0]) {
-            const builder = new XMLBuilderImpl(result[0]);
-            if (!predicate.call(thisArg, builder, result[1], result[2])) {
-                return false;
-            }
-            result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]);
-        }
-        return true;
-    }
-    /** @inheritdoc */
-    some(predicate, self = false, recursive = false, thisArg) {
-        let result = this._getFirstDescendantNode(this._domNode, self, recursive);
-        while (result[0]) {
-            const builder = new XMLBuilderImpl(result[0]);
-            if (predicate.call(thisArg, builder, result[1], result[2])) {
-                return true;
-            }
-            result = this._getNextDescendantNode(this._domNode, result[0], recursive, result[1], result[2]);
-        }
-        return false;
-    }
-    /** @inheritdoc */
-    toArray(self = false, recursive = false) {
-        let result = [];
-        this.each(node => result.push(node), self, recursive);
-        return result;
-    }
-    /** @inheritdoc */
-    toString(writerOptions) {
-        writerOptions = writerOptions || {};
-        if (writerOptions.format === undefined) {
-            writerOptions.format = "xml";
-        }
-        return this._serialize(writerOptions);
-    }
-    /** @inheritdoc */
-    toObject(writerOptions) {
-        writerOptions = writerOptions || {};
-        if (writerOptions.format === undefined) {
-            writerOptions.format = "object";
-        }
-        return this._serialize(writerOptions);
-    }
-    /** @inheritdoc */
-    end(writerOptions) {
-        writerOptions = writerOptions || {};
-        if (writerOptions.format === undefined) {
-            writerOptions.format = "xml";
-        }
-        return this.doc()._serialize(writerOptions);
-    }
-    /**
-     * Gets the next descendant of the given node of the tree rooted at `root`
-     * in depth-first pre-order. Returns a three-tuple with
-     * [descendant, descendant_index, descendant_level].
-     *
-     * @param root - root node of the tree
-     * @param self - whether to visit the current node along with child nodes
-     * @param recursive - whether to visit all descendant nodes in tree-order or
-     * only the immediate child nodes
-     */
-    _getFirstDescendantNode(root, self, recursive) {
-        if (self)
-            return [this._domNode, 0, 0];
-        else if (recursive)
-            return this._getNextDescendantNode(root, root, recursive, 0, 0);
-        else
-            return [this._domNode.firstChild, 0, 1];
-    }
-    /**
-     * Gets the next descendant of the given node of the tree rooted at `root`
-     * in depth-first pre-order. Returns a three-tuple with
-     * [descendant, descendant_index, descendant_level].
-     *
-     * @param root - root node of the tree
-     * @param node - current node
-     * @param recursive - whether to visit all descendant nodes in tree-order or
-     * only the immediate child nodes
-     * @param index - child node index
-     * @param level - current depth of the XML tree
-     */
-    _getNextDescendantNode(root, node, recursive, index, level) {
-        if (recursive) {
-            // traverse child nodes
-            if (node.firstChild)
-                return [node.firstChild, 0, level + 1];
-            if (node === root)
-                return [null, -1, -1];
-            // traverse siblings
-            if (node.nextSibling)
-                return [node.nextSibling, index + 1, level];
-            // traverse parent's next sibling
-            let parent = node.parentNode;
-            while (parent && parent !== root) {
-                if (parent.nextSibling)
-                    return [parent.nextSibling, (0, algorithm_1.tree_index)(parent.nextSibling), level - 1];
-                parent = parent.parentNode;
-                level--;
-            }
-        }
-        else {
-            if (root === node)
-                return [node.firstChild, 0, level + 1];
-            else
-                return [node.nextSibling, index + 1, level];
-        }
-        return [null, -1, -1];
-    }
-    /**
-     * Converts the node into its string or object representation.
-     *
-     * @param options - serialization options
-     */
-    _serialize(writerOptions) {
-        if (writerOptions.format === "xml") {
-            const writer = new writers_1.XMLWriter(this._options, writerOptions);
-            return writer.serialize(this.node);
-        }
-        else if (writerOptions.format === "map") {
-            const writer = new writers_1.MapWriter(this._options, writerOptions);
-            return writer.serialize(this.node);
-        }
-        else if (writerOptions.format === "object") {
-            const writer = new writers_1.ObjectWriter(this._options, writerOptions);
-            return writer.serialize(this.node);
-        }
-        else if (writerOptions.format === "json") {
-            const writer = new writers_1.JSONWriter(this._options, writerOptions);
-            return writer.serialize(this.node);
-        }
-        else if (writerOptions.format === "yaml") {
-            const writer = new writers_1.YAMLWriter(this._options, writerOptions);
-            return writer.serialize(this.node);
-        }
-        else {
-            throw new Error("Invalid writer format: " + writerOptions.format + ". " + this._debugInfo());
-        }
-    }
-    /**
-     * Extracts a namespace and name from the given string.
-     *
-     * @param namespace - namespace
-     * @param name - a string containing both a name and namespace separated by an
-     * `'@'` character
-     * @param ele - `true` if this is an element namespace; otherwise `false`
-     */
-    _extractNamespace(namespace, name, ele) {
-        // extract from name
-        const atIndex = name.indexOf("@");
-        if (atIndex > 0) {
-            if (namespace === undefined)
-                namespace = name.slice(atIndex + 1);
-            name = name.slice(0, atIndex);
-        }
-        if (namespace === undefined) {
-            // look-up default namespace
-            namespace = (ele ? this._options.defaultNamespace.ele : this._options.defaultNamespace.att);
-        }
-        else if (namespace !== null && namespace[0] === "@") {
-            // look-up namespace aliases
-            const alias = namespace.slice(1);
-            namespace = this._options.namespaceAlias[alias];
-            if (namespace === undefined) {
-                throw new Error("Namespace alias `" + alias + "` is not defined. " + this._debugInfo());
-            }
-        }
-        return [namespace, name];
-    }
-    /**
-     * Updates the element's namespace.
-     *
-     * @param ns - new namespace
-     */
-    _updateNamespace(ns) {
-        const ele = this._domNode;
-        if (util_2.Guard.isElementNode(ele) && ns !== null && ele.namespaceURI !== ns) {
-            const [elePrefix, eleLocalName] = (0, algorithm_1.namespace_extractQName)(ele.prefix ? ele.prefix + ':' + ele.localName : ele.localName);
-            // re-create the element node if its namespace changed
-            // we can't simply change the namespaceURI since its read-only
-            const newEle = (0, algorithm_1.create_element)(this._doc, eleLocalName, ns, elePrefix);
-            for (const attr of ele.attributes) {
-                const attrQName = attr.prefix ? attr.prefix + ':' + attr.localName : attr.localName;
-                const [attrPrefix] = (0, algorithm_1.namespace_extractQName)(attrQName);
-                let newAttrNS = attr.namespaceURI;
-                if (newAttrNS === null && attrPrefix !== null) {
-                    newAttrNS = ele.lookupNamespaceURI(attrPrefix);
-                }
-                if (newAttrNS === null) {
-                    newEle.setAttribute(attrQName, attr.value);
-                }
-                else {
-                    newEle.setAttributeNS(newAttrNS, attrQName, attr.value);
-                }
-            }
-            // replace the new node in parent node
-            const parent = ele.parentNode;
-            /* istanbul ignore next */
-            if (parent === null) {
-                throw new Error("Parent node is null." + this._debugInfo());
-            }
-            parent.replaceChild(newEle, ele);
-            this._domNode = newEle;
-            // check child nodes
-            for (const childNode of ele.childNodes) {
-                const newChildNode = childNode.cloneNode(true);
-                newEle.appendChild(newChildNode);
-                if (util_2.Guard.isElementNode(newChildNode) && !newChildNode._namespace) {
-                    const [newChildNodePrefix] = (0, algorithm_1.namespace_extractQName)(newChildNode.prefix ? newChildNode.prefix + ':' + newChildNode.localName : newChildNode.localName);
-                    const newChildNodeNS = newEle.lookupNamespaceURI(newChildNodePrefix);
-                    new XMLBuilderImpl(newChildNode)._updateNamespace(newChildNodeNS);
-                }
-            }
-        }
-    }
-    /**
-     * Returns the document owning this node.
-     */
-    get _doc() {
-        const node = this.node;
-        if (util_2.Guard.isDocumentNode(node)) {
-            return node;
-        }
-        else {
-            const docNode = node.ownerDocument;
-            /* istanbul ignore next */
-            if (!docNode)
-                throw new Error("Owner document is null. " + this._debugInfo());
-            return docNode;
-        }
-    }
-    /**
-     * Returns debug information for this node.
-     *
-     * @param name - node name
-     */
-    _debugInfo(name) {
-        const node = this.node;
-        const parentNode = node.parentNode;
-        name = name || node.nodeName;
-        const parentName = parentNode ? parentNode.nodeName : '';
-        if (!parentName) {
-            return "node: <" + name + ">";
-        }
-        else {
-            return "node: <" + name + ">, parent: <" + parentName + ">";
-        }
-    }
-    /**
-     * Gets or sets builder options.
-     */
-    get _options() {
-        const doc = this._doc;
-        /* istanbul ignore next */
-        if (doc._xmlBuilderOptions === undefined) {
-            throw new Error("Builder options is not set.");
-        }
-        return doc._xmlBuilderOptions;
-    }
-    set _options(value) {
-        const doc = this._doc;
-        doc._xmlBuilderOptions = value;
-    }
-}
-exports.XMLBuilderImpl = XMLBuilderImpl;
-//# sourceMappingURL=XMLBuilderImpl.js.map
-
-/***/ }),
-
-/***/ 1256:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.createDocument = createDocument;
-exports.sanitizeInput = sanitizeInput;
-const dom_1 = __nccwpck_require__(54646);
-const dom_2 = __nccwpck_require__(50633);
-const util_1 = __nccwpck_require__(76195);
-dom_2.dom.setFeatures(false);
-/**
- * Creates an XML document without any child nodes.
- */
-function createDocument() {
-    const impl = new dom_1.DOMImplementation();
-    const doc = impl.createDocument(null, 'root', null);
-    /* istanbul ignore else */
-    if (doc.documentElement) {
-        doc.removeChild(doc.documentElement);
-    }
-    return doc;
-}
-/**
- * Sanitizes input strings with user supplied replacement characters.
- *
- * @param str - input string
- * @param replacement - replacement character or function
- */
-function sanitizeInput(str, replacement) {
-    if (str == null) {
-        return str;
-    }
-    else if (replacement === undefined) {
-        return str + "";
-    }
-    else {
-        let result = "";
-        str = str + "";
-        for (let i = 0; i < str.length; i++) {
-            let n = str.charCodeAt(i);
-            // #x9 | #xA | #xD | [#x20-#xD7FF] | [#xE000-#xFFFD] | [#x10000-#x10FFFF]
-            if (n === 0x9 || n === 0xA || n === 0xD ||
-                (n >= 0x20 && n <= 0xD7FF) ||
-                (n >= 0xE000 && n <= 0xFFFD)) {
-                // valid character - not surrogate pair
-                result += str.charAt(i);
-            }
-            else if (n >= 0xD800 && n <= 0xDBFF && i < str.length - 1) {
-                const n2 = str.charCodeAt(i + 1);
-                if (n2 >= 0xDC00 && n2 <= 0xDFFF) {
-                    // valid surrogate pair
-                    n = (n - 0xD800) * 0x400 + n2 - 0xDC00 + 0x10000;
-                    result += String.fromCodePoint(n);
-                    i++;
-                }
-                else {
-                    // invalid lone surrogate
-                    result += (0, util_1.isString)(replacement) ? replacement : replacement(str.charAt(i), i, str);
-                }
-            }
-            else {
-                // invalid character
-                result += (0, util_1.isString)(replacement) ? replacement : replacement(str.charAt(i), i, str);
-            }
-        }
-        return result;
-    }
-}
-//# sourceMappingURL=dom.js.map
-
-/***/ }),
-
-/***/ 2106:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.fragmentCB = exports.createCB = exports.convert = exports.fragment = exports.create = exports.builder = exports.XMLBuilderCBImpl = exports.XMLBuilderImpl = void 0;
-var XMLBuilderImpl_1 = __nccwpck_require__(10584);
-Object.defineProperty(exports, "XMLBuilderImpl", ({ enumerable: true, get: function () { return XMLBuilderImpl_1.XMLBuilderImpl; } }));
-var XMLBuilderCBImpl_1 = __nccwpck_require__(20282);
-Object.defineProperty(exports, "XMLBuilderCBImpl", ({ enumerable: true, get: function () { return XMLBuilderCBImpl_1.XMLBuilderCBImpl; } }));
-var BuilderFunctions_1 = __nccwpck_require__(13810);
-Object.defineProperty(exports, "builder", ({ enumerable: true, get: function () { return BuilderFunctions_1.builder; } }));
-Object.defineProperty(exports, "create", ({ enumerable: true, get: function () { return BuilderFunctions_1.create; } }));
-Object.defineProperty(exports, "fragment", ({ enumerable: true, get: function () { return BuilderFunctions_1.fragment; } }));
-Object.defineProperty(exports, "convert", ({ enumerable: true, get: function () { return BuilderFunctions_1.convert; } }));
-var BuilderFunctionsCB_1 = __nccwpck_require__(47059);
-Object.defineProperty(exports, "createCB", ({ enumerable: true, get: function () { return BuilderFunctionsCB_1.createCB; } }));
-Object.defineProperty(exports, "fragmentCB", ({ enumerable: true, get: function () { return BuilderFunctionsCB_1.fragmentCB; } }));
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 9311:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.nonEntityAmpersandRegex = void 0;
-exports.nonEntityAmpersandRegex = /&(?![A-Za-z]+;|#\d+;)/g;
-//# sourceMappingURL=constants.js.map
-
-/***/ }),
-
-/***/ 69075:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.fragmentCB = exports.createCB = exports.convert = exports.fragment = exports.create = exports.builder = void 0;
-var builder_1 = __nccwpck_require__(2106);
-Object.defineProperty(exports, "builder", ({ enumerable: true, get: function () { return builder_1.builder; } }));
-Object.defineProperty(exports, "create", ({ enumerable: true, get: function () { return builder_1.create; } }));
-Object.defineProperty(exports, "fragment", ({ enumerable: true, get: function () { return builder_1.fragment; } }));
-Object.defineProperty(exports, "convert", ({ enumerable: true, get: function () { return builder_1.convert; } }));
-Object.defineProperty(exports, "createCB", ({ enumerable: true, get: function () { return builder_1.createCB; } }));
-Object.defineProperty(exports, "fragmentCB", ({ enumerable: true, get: function () { return builder_1.fragmentCB; } }));
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 81348:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.DefaultXMLBuilderCBOptions = exports.XMLBuilderOptionKeys = exports.DefaultBuilderOptions = void 0;
-/**
- * Defines default values for builder options.
- */
-exports.DefaultBuilderOptions = {
-    version: "1.0",
-    encoding: undefined,
-    standalone: undefined,
-    keepNullNodes: false,
-    keepNullAttributes: false,
-    ignoreConverters: false,
-    skipWhitespaceOnlyText: true,
-    convert: {
-        att: "@",
-        ins: "?",
-        text: "#",
-        cdata: "$",
-        comment: "!"
-    },
-    defaultNamespace: {
-        ele: undefined,
-        att: undefined
-    },
-    namespaceAlias: {
-        html: "http://www.w3.org/1999/xhtml",
-        xml: "http://www.w3.org/XML/1998/namespace",
-        xmlns: "http://www.w3.org/2000/xmlns/",
-        mathml: "http://www.w3.org/1998/Math/MathML",
-        svg: "http://www.w3.org/2000/svg",
-        xlink: "http://www.w3.org/1999/xlink"
-    },
-    invalidCharReplacement: undefined,
-    parser: undefined
-};
-/**
- * Contains keys of `XMLBuilderOptions`.
- */
-exports.XMLBuilderOptionKeys = new Set(Object.keys(exports.DefaultBuilderOptions));
-/**
- * Defines default values for builder options.
- */
-exports.DefaultXMLBuilderCBOptions = {
-    format: "xml",
-    wellFormed: false,
-    prettyPrint: false,
-    indent: "  ",
-    newline: "\n",
-    offset: 0,
-    width: 0,
-    allowEmptyTags: false,
-    spaceBeforeSlash: false,
-    keepNullNodes: false,
-    keepNullAttributes: false,
-    ignoreConverters: false,
-    convert: {
-        att: "@",
-        ins: "?",
-        text: "#",
-        cdata: "$",
-        comment: "!"
-    },
-    defaultNamespace: {
-        ele: undefined,
-        att: undefined
-    },
-    namespaceAlias: {
-        html: "http://www.w3.org/1999/xhtml",
-        xml: "http://www.w3.org/XML/1998/namespace",
-        xmlns: "http://www.w3.org/2000/xmlns/",
-        mathml: "http://www.w3.org/1998/Math/MathML",
-        svg: "http://www.w3.org/2000/svg",
-        xlink: "http://www.w3.org/1999/xlink"
-    }
-};
-//# sourceMappingURL=interfaces.js.map
-
-/***/ }),
-
-/***/ 87825:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.BaseReader = void 0;
-const dom_1 = __nccwpck_require__(1256);
-/**
- * Parses XML nodes.
- */
-class BaseReader {
-    _builderOptions;
-    static _entityTable = {
-        "lt": "<",
-        "gt": ">",
-        "amp": "&",
-        "quot": '"',
-        "apos": "'",
-    };
-    /**
-     * Initializes a new instance of `BaseReader`.
-     *
-     * @param builderOptions - XML builder options
-     */
-    constructor(builderOptions) {
-        this._builderOptions = builderOptions;
-        if (builderOptions.parser) {
-            Object.assign(this, builderOptions.parser);
-        }
-    }
-    _docType(parent, name, publicId, systemId) {
-        return parent.dtd({ name: name, pubID: publicId, sysID: systemId });
-    }
-    _comment(parent, data) {
-        return parent.com(data);
-    }
-    _text(parent, data) {
-        return parent.txt(data);
-    }
-    _instruction(parent, target, data) {
-        return parent.ins(target, data);
-    }
-    _cdata(parent, data) {
-        return parent.dat(data);
-    }
-    _element(parent, namespace, name) {
-        return (namespace === undefined ? parent.ele(name) : parent.ele(namespace, name));
-    }
-    _attribute(parent, namespace, name, value) {
-        return (namespace === undefined ? parent.att(name, value) : parent.att(namespace, name, value));
-    }
-    _sanitize(str) {
-        return (0, dom_1.sanitizeInput)(str, this._builderOptions.invalidCharReplacement);
-    }
-    /**
-     * Decodes serialized text.
-     *
-     * @param text - text value to serialize
-     */
-    _decodeText(text) {
-        if (text == null)
-            return text;
-        return text.replace(/&(quot|amp|apos|lt|gt);/g, (_match, tag) => BaseReader._entityTable[tag]).replace(/&#(?:x([a-fA-F0-9]+)|([0-9]+));/g, (_match, hexStr, numStr) => String.fromCodePoint(parseInt(hexStr || numStr, hexStr ? 16 : 10)));
-    }
-    /**
-     * Decodes serialized attribute value.
-     *
-     * @param text - attribute value to serialize
-     */
-    _decodeAttributeValue(text) {
-        return this._decodeText(text);
-    }
-    /**
-     * Main parser function which parses the given object and returns an XMLBuilder.
-     *
-     * @param node - node to recieve parsed content
-     * @param obj - object to parse
-     */
-    parse(node, obj) {
-        return this._parse(node, obj);
-    }
-    /**
-     * Creates a DocType node.
-     * The node will be skipped if the function returns `undefined`.
-     *
-     * @param name - node name
-     * @param publicId - public identifier
-     * @param systemId - system identifier
-     */
-    docType(parent, name, publicId, systemId) {
-        return this._docType(parent, name, publicId, systemId);
-    }
-    /**
-     * Creates a comment node.
-     * The node will be skipped if the function returns `undefined`.
-     *
-     * @param parent - parent node
-     * @param data - node data
-     */
-    comment(parent, data) {
-        return this._comment(parent, data);
-    }
-    /**
-     * Creates a text node.
-     * The node will be skipped if the function returns `undefined`.
-     *
-     * @param parent - parent node
-     * @param data - node data
-     */
-    text(parent, data) {
-        return this._text(parent, data);
-    }
-    /**
-     * Creates a processing instruction node.
-     * The node will be skipped if the function returns `undefined`.
-     *
-     * @param parent - parent node
-     * @param target - instruction target
-     * @param data - node data
-     */
-    instruction(parent, target, data) {
-        return this._instruction(parent, target, data);
-    }
-    /**
-     * Creates a CData section node.
-     * The node will be skipped if the function returns `undefined`.
-     *
-     * @param parent - parent node
-     * @param data - node data
-     */
-    cdata(parent, data) {
-        return this._cdata(parent, data);
-    }
-    /**
-     * Creates an element node.
-     * The node will be skipped if the function returns `undefined`.
-     *
-     * @param parent - parent node
-     * @param namespace - node namespace
-     * @param name - node name
-     */
-    element(parent, namespace, name) {
-        return this._element(parent, namespace, name);
-    }
-    /**
-     * Creates an attribute or namespace declaration.
-     * The node will be skipped if the function returns `undefined`.
-     *
-     * @param parent - parent node
-     * @param namespace - node namespace
-     * @param name - node name
-     * @param value - node value
-     */
-    attribute(parent, namespace, name, value) {
-        return this._attribute(parent, namespace, name, value);
-    }
-    /**
-     * Sanitizes input strings.
-     *
-     * @param str - input string
-     */
-    sanitize(str) {
-        return this._sanitize(str);
-    }
-}
-exports.BaseReader = BaseReader;
-//# sourceMappingURL=BaseReader.js.map
-
-/***/ }),
-
-/***/ 24520:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.JSONReader = void 0;
-const ObjectReader_1 = __nccwpck_require__(74573);
-const BaseReader_1 = __nccwpck_require__(87825);
-/**
- * Parses XML nodes from a JSON string.
- */
-class JSONReader extends BaseReader_1.BaseReader {
-    /**
-     * Parses the given document representation.
-     *
-     * @param node - node receive parsed XML nodes
-     * @param str - JSON string to parse
-     */
-    _parse(node, str) {
-        return new ObjectReader_1.ObjectReader(this._builderOptions).parse(node, JSON.parse(str));
-    }
-}
-exports.JSONReader = JSONReader;
-//# sourceMappingURL=JSONReader.js.map
-
-/***/ }),
-
-/***/ 74573:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ObjectReader = void 0;
-const util_1 = __nccwpck_require__(76195);
-const BaseReader_1 = __nccwpck_require__(87825);
-/**
- * Parses XML nodes from objects and arrays.
- * ES6 maps and sets are also supoorted.
- */
-class ObjectReader extends BaseReader_1.BaseReader {
-    /**
-     * Parses the given document representation.
-     *
-     * @param node - node receive parsed XML nodes
-     * @param obj - object to parse
-     */
-    _parse(node, obj) {
-        const options = this._builderOptions;
-        let lastChild = null;
-        if ((0, util_1.isFunction)(obj)) {
-            // evaluate if function
-            lastChild = this.parse(node, obj.call(this));
-        }
-        else if ((0, util_1.isArray)(obj) || (0, util_1.isSet)(obj)) {
-            (0, util_1.forEachArray)(obj, item => lastChild = this.parse(node, item), this);
-        }
-        else if ((0, util_1.isMap)(obj) || (0, util_1.isObject)(obj)) {
-            // expand if object
-            (0, util_1.forEachObject)(obj, (key, val) => {
-                if ((0, util_1.isFunction)(val)) {
-                    // evaluate if function
-                    val = val.call(this);
-                }
-                if (!options.ignoreConverters && key.indexOf(options.convert.att) === 0) {
-                    // assign attributes
-                    if (key === options.convert.att) {
-                        if ((0, util_1.isArray)(val) || (0, util_1.isSet)(val)) {
-                            throw new Error("Invalid attribute: " + val.toString() + ". " + node._debugInfo());
-                        }
-                        else /* if (isMap(val) || isObject(val)) */ {
-                            (0, util_1.forEachObject)(val, (attrKey, attrVal) => {
-                                lastChild = this.attribute(node, undefined, this.sanitize(attrKey), this._decodeAttributeValue(this.sanitize(attrVal))) || lastChild;
-                            });
-                        }
-                    }
-                    else {
-                        lastChild = this.attribute(node, undefined, this.sanitize(key.substring(options.convert.att.length)), this._decodeAttributeValue(this.sanitize(val?.toString()))) || lastChild;
-                    }
-                }
-                else if (!options.ignoreConverters && key.indexOf(options.convert.text) === 0) {
-                    // text node
-                    if ((0, util_1.isMap)(val) || (0, util_1.isObject)(val)) {
-                        // if the key is #text expand child nodes under this node to support mixed content
-                        lastChild = this.parse(node, val);
-                    }
-                    else {
-                        lastChild = this.text(node, this._decodeText(this.sanitize(val?.toString()))) || lastChild;
-                    }
-                }
-                else if (!options.ignoreConverters && key.indexOf(options.convert.cdata) === 0) {
-                    // cdata node
-                    if ((0, util_1.isArray)(val) || (0, util_1.isSet)(val)) {
-                        (0, util_1.forEachArray)(val, item => lastChild = this.cdata(node, this.sanitize(item)) || lastChild, this);
-                    }
-                    else {
-                        lastChild = this.cdata(node, this.sanitize(val?.toString())) || lastChild;
-                    }
-                }
-                else if (!options.ignoreConverters && key.indexOf(options.convert.comment) === 0) {
-                    // comment node
-                    if ((0, util_1.isArray)(val) || (0, util_1.isSet)(val)) {
-                        (0, util_1.forEachArray)(val, item => lastChild = this.comment(node, this.sanitize(item)) || lastChild, this);
-                    }
-                    else {
-                        lastChild = this.comment(node, this.sanitize(val?.toString())) || lastChild;
-                    }
-                }
-                else if (!options.ignoreConverters && key.indexOf(options.convert.ins) === 0) {
-                    // processing instruction
-                    if ((0, util_1.isString)(val)) {
-                        const insIndex = val.indexOf(' ');
-                        const insTarget = (insIndex === -1 ? val : val.substr(0, insIndex));
-                        const insValue = (insIndex === -1 ? '' : val.substr(insIndex + 1));
-                        lastChild = this.instruction(node, this.sanitize(insTarget), this.sanitize(insValue)) || lastChild;
-                    }
-                    else if ((0, util_1.isArray)(val) || (0, util_1.isSet)(val)) {
-                        (0, util_1.forEachArray)(val, item => {
-                            const insIndex = item.indexOf(' ');
-                            const insTarget = (insIndex === -1 ? item : item.substr(0, insIndex));
-                            const insValue = (insIndex === -1 ? '' : item.substr(insIndex + 1));
-                            lastChild = this.instruction(node, this.sanitize(insTarget), this.sanitize(insValue)) || lastChild;
-                        }, this);
-                    }
-                    else /* if (isMap(target) || isObject(target)) */ {
-                        (0, util_1.forEachObject)(val, (insTarget, insValue) => lastChild = this.instruction(node, this.sanitize(insTarget), this.sanitize(insValue)) || lastChild, this);
-                    }
-                }
-                else if (((0, util_1.isArray)(val) || (0, util_1.isSet)(val)) && (0, util_1.isEmpty)(val)) {
-                    // skip empty arrays
-                }
-                else if (((0, util_1.isMap)(val) || (0, util_1.isObject)(val)) && (0, util_1.isEmpty)(val)) {
-                    // empty objects produce one node
-                    lastChild = this.element(node, undefined, this.sanitize(key)) || lastChild;
-                }
-                else if (!options.keepNullNodes && (val == null)) {
-                    // skip null and undefined nodes
-                }
-                else if ((0, util_1.isArray)(val) || (0, util_1.isSet)(val)) {
-                    // expand list by creating child nodes
-                    (0, util_1.forEachArray)(val, item => {
-                        const childNode = {};
-                        childNode[key] = item;
-                        lastChild = this.parse(node, childNode);
-                    }, this);
-                }
-                else if ((0, util_1.isMap)(val) || (0, util_1.isObject)(val)) {
-                    // create a parent node
-                    const parent = this.element(node, undefined, this.sanitize(key));
-                    if (parent) {
-                        lastChild = parent;
-                        // expand child nodes under parent
-                        this.parse(parent, val);
-                    }
-                }
-                else if (val != null && (!(0, util_1.isString)(val) || val !== '')) {
-                    // leaf element node with a single text node
-                    const parent = this.element(node, undefined, this.sanitize(key));
-                    if (parent) {
-                        lastChild = parent;
-                        this.text(parent, this._decodeText(this.sanitize(val?.toString())));
-                    }
-                }
-                else {
-                    // leaf element node
-                    lastChild = this.element(node, undefined, this.sanitize(key)) || lastChild;
-                }
-            }, this);
-        }
-        else if (!options.keepNullNodes && (obj == null)) {
-            // skip null and undefined nodes
-        }
-        else {
-            // text node
-            lastChild = this.text(node, this._decodeText(this.sanitize(obj?.toString()))) || lastChild;
-        }
-        return lastChild || node;
-    }
-}
-exports.ObjectReader = ObjectReader;
-//# sourceMappingURL=ObjectReader.js.map
-
-/***/ }),
-
-/***/ 21190:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLReader = void 0;
-const XMLStringLexer_1 = __nccwpck_require__(47061);
-const interfaces_1 = __nccwpck_require__(97707);
-const interfaces_2 = __nccwpck_require__(27305);
-const infra_1 = __nccwpck_require__(84251);
-const algorithm_1 = __nccwpck_require__(61);
-const BaseReader_1 = __nccwpck_require__(87825);
-/**
- * Parses XML nodes from an XML document string.
- */
-class XMLReader extends BaseReader_1.BaseReader {
-    /**
-     * Parses the given document representation.
-     *
-     * @param node - node receive parsed XML nodes
-     * @param str - XML document string to parse
-     */
-    _parse(node, str) {
-        const lexer = new XMLStringLexer_1.XMLStringLexer(str, { skipWhitespaceOnlyText: this._builderOptions.skipWhitespaceOnlyText });
-        let lastChild = node;
-        let context = node;
-        let token = lexer.nextToken();
-        while (token.type !== interfaces_1.TokenType.EOF) {
-            switch (token.type) {
-                case interfaces_1.TokenType.Declaration:
-                    const declaration = token;
-                    const version = this.sanitize(declaration.version);
-                    if (version !== "1.0") {
-                        throw new Error("Invalid xml version: " + version);
-                    }
-                    const builderOptions = {
-                        version: version
-                    };
-                    if (declaration.encoding) {
-                        builderOptions.encoding = this.sanitize(declaration.encoding);
-                    }
-                    if (declaration.standalone) {
-                        builderOptions.standalone = (this.sanitize(declaration.standalone) === "yes");
-                    }
-                    context.set(builderOptions);
-                    break;
-                case interfaces_1.TokenType.DocType:
-                    const doctype = token;
-                    context = this.docType(context, this.sanitize(doctype.name), this.sanitize(doctype.pubId), this.sanitize(doctype.sysId)) || context;
-                    break;
-                case interfaces_1.TokenType.CDATA:
-                    const cdata = token;
-                    context = this.cdata(context, this.sanitize(cdata.data)) || context;
-                    break;
-                case interfaces_1.TokenType.Comment:
-                    const comment = token;
-                    context = this.comment(context, this.sanitize(comment.data)) || context;
-                    break;
-                case interfaces_1.TokenType.PI:
-                    const pi = token;
-                    context = this.instruction(context, this.sanitize(pi.target), this.sanitize(pi.data)) || context;
-                    break;
-                case interfaces_1.TokenType.Text:
-                    if (context.node.nodeType === interfaces_2.NodeType.Document)
-                        break;
-                    const text = token;
-                    context = this.text(context, this._decodeText(this.sanitize(text.data))) || context;
-                    break;
-                case interfaces_1.TokenType.Element:
-                    const element = token;
-                    const elementName = this.sanitize(element.name);
-                    // inherit namespace from parent
-                    const [prefix] = (0, algorithm_1.namespace_extractQName)(elementName);
-                    let namespace = context.node.lookupNamespaceURI(prefix);
-                    // override namespace if there is a namespace declaration
-                    // attribute
-                    // also lookup namespace declaration attributes
-                    const nsDeclarations = {};
-                    for (let [attName, attValue] of element.attributes) {
-                        attName = this.sanitize(attName);
-                        attValue = this.sanitize(attValue);
-                        if (attName === "xmlns") {
-                            namespace = attValue;
-                        }
-                        else {
-                            const [attPrefix, attLocalName] = (0, algorithm_1.namespace_extractQName)(attName);
-                            if (attPrefix === "xmlns") {
-                                if (attLocalName === prefix) {
-                                    namespace = attValue;
-                                }
-                                nsDeclarations[attLocalName] = attValue;
-                            }
-                        }
-                    }
-                    // create the DOM element node
-                    const elementNode = (namespace !== null ?
-                        this.element(context, namespace, elementName) :
-                        this.element(context, undefined, elementName));
-                    if (elementNode === undefined)
-                        break;
-                    if (context.node === node.node)
-                        lastChild = elementNode;
-                    // assign attributes
-                    for (let [attName, attValue] of element.attributes) {
-                        attName = this.sanitize(attName);
-                        attValue = this.sanitize(attValue);
-                        const [attPrefix, attLocalName] = (0, algorithm_1.namespace_extractQName)(attName);
-                        let attNamespace = null;
-                        if (attPrefix === "xmlns" || (attPrefix === null && attLocalName === "xmlns")) {
-                            // namespace declaration attribute
-                            attNamespace = infra_1.namespace.XMLNS;
-                        }
-                        else {
-                            attNamespace = elementNode.node.lookupNamespaceURI(attPrefix);
-                            if (attNamespace !== null && elementNode.node.isDefaultNamespace(attNamespace)) {
-                                attNamespace = null;
-                            }
-                            else if (attNamespace === null && attPrefix !== null) {
-                                attNamespace = nsDeclarations[attPrefix] || null;
-                            }
-                        }
-                        if (attNamespace !== null)
-                            this.attribute(elementNode, attNamespace, attName, this._decodeAttributeValue(attValue));
-                        else
-                            this.attribute(elementNode, undefined, attName, this._decodeAttributeValue(attValue));
-                    }
-                    if (!element.selfClosing) {
-                        context = elementNode;
-                    }
-                    break;
-                case interfaces_1.TokenType.ClosingTag:
-                    /* istanbul ignore else */
-                    if (context.node.parentNode) {
-                        context = context.up();
-                    }
-                    break;
-            }
-            token = lexer.nextToken();
-        }
-        return lastChild;
-    }
-}
-exports.XMLReader = XMLReader;
-//# sourceMappingURL=XMLReader.js.map
-
-/***/ }),
-
-/***/ 3905:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.YAMLReader = void 0;
-const ObjectReader_1 = __nccwpck_require__(74573);
-const BaseReader_1 = __nccwpck_require__(87825);
-const js_yaml_1 = __nccwpck_require__(21917);
-/**
- * Parses XML nodes from a YAML string.
- */
-class YAMLReader extends BaseReader_1.BaseReader {
-    /**
-     * Parses the given document representation.
-     *
-     * @param node - node receive parsed XML nodes
-     * @param str - YAML string to parse
-     */
-    _parse(node, str) {
-        const result = (0, js_yaml_1.load)(str);
-        /* istanbul ignore next */
-        if (result === undefined) {
-            throw new Error("Unable to parse YAML document.");
-        }
-        return new ObjectReader_1.ObjectReader(this._builderOptions).parse(node, result);
-    }
-}
-exports.YAMLReader = YAMLReader;
-//# sourceMappingURL=YAMLReader.js.map
-
-/***/ }),
-
-/***/ 90241:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.YAMLReader = exports.JSONReader = exports.ObjectReader = exports.XMLReader = void 0;
-var XMLReader_1 = __nccwpck_require__(21190);
-Object.defineProperty(exports, "XMLReader", ({ enumerable: true, get: function () { return XMLReader_1.XMLReader; } }));
-var ObjectReader_1 = __nccwpck_require__(74573);
-Object.defineProperty(exports, "ObjectReader", ({ enumerable: true, get: function () { return ObjectReader_1.ObjectReader; } }));
-var JSONReader_1 = __nccwpck_require__(24520);
-Object.defineProperty(exports, "JSONReader", ({ enumerable: true, get: function () { return JSONReader_1.JSONReader; } }));
-var YAMLReader_1 = __nccwpck_require__(3905);
-Object.defineProperty(exports, "YAMLReader", ({ enumerable: true, get: function () { return YAMLReader_1.YAMLReader; } }));
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
-/***/ 63210:
-/***/ ((__unused_webpack_module, exports) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.BaseCBWriter = void 0;
-/**
- * Pre-serializes XML nodes.
- */
-class BaseCBWriter {
-    _builderOptions;
-    _writerOptions;
-    /**
-     * Gets the current depth of the XML tree.
-     */
-    level = 0;
-    /**
-     * Determines whether any data has been written.
-     */
-    hasData;
-    /**
-     * Initializes a new instance of `BaseCBWriter`.
-     *
-     * @param builderOptions - XML builder options
-     */
-    constructor(builderOptions) {
-        this._builderOptions = builderOptions;
-        this._writerOptions = builderOptions;
-    }
-}
-exports.BaseCBWriter = BaseCBWriter;
-//# sourceMappingURL=BaseCBWriter.js.map
-
-/***/ }),
-
-/***/ 24189:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.BaseWriter = void 0;
-const interfaces_1 = __nccwpck_require__(27305);
-const LocalNameSet_1 = __nccwpck_require__(19049);
-const NamespacePrefixMap_1 = __nccwpck_require__(90283);
-const infra_1 = __nccwpck_require__(84251);
-const algorithm_1 = __nccwpck_require__(61);
-const constants_1 = __nccwpck_require__(9311);
-/**
- * Pre-serializes XML nodes.
- */
-class BaseWriter {
-    static _VoidElementNames = new Set(['area', 'base', 'basefont',
-        'bgsound', 'br', 'col', 'embed', 'frame', 'hr', 'img', 'input', 'keygen',
-        'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr']);
-    _builderOptions;
-    _writerOptions;
-    /**
-     * Initializes a new instance of `BaseWriter`.
-     *
-     * @param builderOptions - XML builder options
-     */
-    constructor(builderOptions) {
-        this._builderOptions = builderOptions;
-    }
-    /**
-     * Used by derived classes to serialize the XML declaration.
-     *
-     * @param version - a version number string
-     * @param encoding - encoding declaration
-     * @param standalone - standalone document declaration
-     */
-    declaration(version, encoding, standalone) { }
-    /**
-     * Used by derived classes to serialize a DocType node.
-     *
-     * @param name - node name
-     * @param publicId - public identifier
-     * @param systemId - system identifier
-     */
-    docType(name, publicId, systemId) { }
-    /**
-     * Used by derived classes to serialize a comment node.
-     *
-     * @param data - node data
-     */
-    comment(data) { }
-    /**
-     * Used by derived classes to serialize a text node.
-     *
-     * @param data - node data
-     */
-    text(data) { }
-    /**
-     * Used by derived classes to serialize a processing instruction node.
-     *
-     * @param target - instruction target
-     * @param data - node data
-     */
-    instruction(target, data) { }
-    /**
-     * Used by derived classes to serialize a CData section node.
-     *
-     * @param data - node data
-     */
-    cdata(data) { }
-    /**
-     * Used by derived classes to serialize the beginning of the opening tag of an
-     * element node.
-     *
-     * @param name - node name
-     */
-    openTagBegin(name) { }
-    /**
-     * Used by derived classes to serialize the ending of the opening tag of an
-     * element node.
-     *
-     * @param name - node name
-     * @param selfClosing - whether the element node is self closing
-     * @param voidElement - whether the element node is a HTML void element
-     */
-    openTagEnd(name, selfClosing, voidElement) { }
-    /**
-     * Used by derived classes to serialize the closing tag of an element node.
-     *
-     * @param name - node name
-     */
-    closeTag(name) { }
-    /**
-     * Used by derived classes to serialize attributes or namespace declarations.
-     *
-     * @param attributes - attribute array
-     */
-    attributes(attributes) {
-        for (const attr of attributes) {
-            this.attribute(attr[1] === null ? attr[2] : attr[1] + ':' + attr[2], attr[3]);
-        }
-    }
-    /**
-     * Used by derived classes to serialize an attribute or namespace declaration.
-     *
-     * @param name - node name
-     * @param value - node value
-     */
-    attribute(name, value) { }
-    /**
-     * Used by derived classes to perform any pre-processing steps before starting
-     * serializing an element node.
-     *
-     * @param name - node name
-     */
-    beginElement(name) { }
-    /**
-     * Used by derived classes to perform any post-processing steps after
-     * completing serializing an element node.
-     *
-     * @param name - node name
-     */
-    endElement(name) { }
-    /**
-     * Gets the current depth of the XML tree.
-     */
-    level = 0;
-    /**
-     * Gets the current XML node.
-     */
-    currentNode;
-    /**
-     * Produces an XML serialization of the given node. The pre-serializer inserts
-     * namespace declarations where necessary and produces qualified names for
-     * nodes and attributes.
-     *
-     * @param node - node to serialize
-     * @param requireWellFormed - whether to check conformance
-     */
-    serializeNode(node, requireWellFormed) {
-        const hasNamespaces = (node._nodeDocument !== undefined && node._nodeDocument._hasNamespaces);
-        this.level = 0;
-        this.currentNode = node;
-        if (hasNamespaces) {
-            /** From: https://w3c.github.io/DOM-Parsing/#xml-serialization
-             *
-             * 1. Let namespace be a context namespace with value null.
-             * The context namespace tracks the XML serialization algorithm's current
-             * default namespace. The context namespace is changed when either an Element
-             * Node has a default namespace declaration, or the algorithm generates a
-             * default namespace declaration for the Element Node to match its own
-             * namespace. The algorithm assumes no namespace (null) to start.
-             * 2. Let prefix map be a new namespace prefix map.
-             * 3. Add the XML namespace with prefix value "xml" to prefix map.
-             * 4. Let prefix index be a generated namespace prefix index with value 1.
-             * The generated namespace prefix index is used to generate a new unique
-             * prefix value when no suitable existing namespace prefix is available to
-             * serialize a node's namespaceURI (or the namespaceURI of one of node's
-             * attributes). See the generate a prefix algorithm.
-             */
-            let namespace = null;
-            const prefixMap = new NamespacePrefixMap_1.NamespacePrefixMap();
-            prefixMap.set("xml", infra_1.namespace.XML);
-            const prefixIndex = { value: 1 };
-            /**
-             * 5. Return the result of running the XML serialization algorithm on node
-             * passing the context namespace namespace, namespace prefix map prefix map,
-             * generated namespace prefix index reference to prefix index, and the
-             * flag require well-formed. If an exception occurs during the execution
-             * of the algorithm, then catch that exception and throw an
-             * "InvalidStateError" DOMException.
-             */
-            this._serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
-        }
-        else {
-            this._serializeNode(node, requireWellFormed);
-        }
-    }
-    /**
-     * Produces an XML serialization of a node.
-     *
-     * @param node - node to serialize
-     * @param namespace - context namespace
-     * @param prefixMap - namespace prefix map
-     * @param prefixIndex - generated namespace prefix index
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeNodeNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
-        this.currentNode = node;
-        switch (node.nodeType) {
-            case interfaces_1.NodeType.Element:
-                this._serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.Document:
-                this._serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.Comment:
-                this._serializeComment(node, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.Text:
-                this._serializeText(node, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.DocumentFragment:
-                this._serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.DocumentType:
-                this._serializeDocumentType(node, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.ProcessingInstruction:
-                this._serializeProcessingInstruction(node, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.CData:
-                this._serializeCData(node, requireWellFormed);
-                break;
-            default:
-                throw new Error(`Unknown node type: ${node.nodeType}`);
-        }
-    }
-    /**
-     * Produces an XML serialization of a node.
-     *
-     * @param node - node to serialize
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeNode(node, requireWellFormed) {
-        this.currentNode = node;
-        switch (node.nodeType) {
-            case interfaces_1.NodeType.Element:
-                this._serializeElement(node, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.Document:
-                this._serializeDocument(node, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.Comment:
-                this._serializeComment(node, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.Text:
-                this._serializeText(node, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.DocumentFragment:
-                this._serializeDocumentFragment(node, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.DocumentType:
-                this._serializeDocumentType(node, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.ProcessingInstruction:
-                this._serializeProcessingInstruction(node, requireWellFormed);
-                break;
-            case interfaces_1.NodeType.CData:
-                this._serializeCData(node, requireWellFormed);
-                break;
-            default:
-                throw new Error(`Unknown node type: ${node.nodeType}`);
-        }
-    }
-    /**
-     * Produces an XML serialization of an element node.
-     *
-     * @param node - node to serialize
-     * @param namespace - context namespace
-     * @param prefixMap - namespace prefix map
-     * @param prefixIndex - generated namespace prefix index
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeElementNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
-        const attributes = [];
-        /**
-         * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node
-         *
-         * 1. If the require well-formed flag is set (its value is true), and this
-         * node's localName attribute contains the character ":" (U+003A COLON) or
-         * does not match the XML Name production, then throw an exception; the
-         * serialization of this node would not be a well-formed element.
-         */
-        if (requireWellFormed && (node.localName.indexOf(":") !== -1 ||
-            !(0, algorithm_1.xml_isName)(node.localName))) {
-            throw new Error("Node local name contains invalid characters (well-formed required).");
-        }
-        /**
-         * 2. Let markup be the string "<" (U+003C LESS-THAN SIGN).
-         * 3. Let qualified name be an empty string.
-         * 4. Let skip end tag be a boolean flag with value false.
-         * 5. Let ignore namespace definition attribute be a boolean flag with value
-         * false.
-         * 6. Given prefix map, copy a namespace prefix map and let map be the
-         * result.
-         * 7. Let local prefixes map be an empty map. The map has unique Node prefix
-         * strings as its keys, with corresponding namespaceURI Node values as the
-         * map's key values (in this map, the null namespace is represented by the
-         * empty string).
-         *
-         * _Note:_ This map is local to each element. It is used to ensure there
-         * are no conflicting prefixes should a new namespace prefix attribute need
-         * to be generated. It is also used to enable skipping of duplicate prefix
-         * definitions when writing an element's attributes: the map allows the
-         * algorithm to distinguish between a prefix in the namespace prefix map
-         * that might be locally-defined (to the current Element) and one that is
-         * not.
-         * 8. Let local default namespace be the result of recording the namespace
-         * information for node given map and local prefixes map.
-         *
-         * _Note:_ The above step will update map with any found namespace prefix
-         * definitions, add the found prefix definitions to the local prefixes map
-         * and return a local default namespace value defined by a default namespace
-         * attribute if one exists. Otherwise it returns null.
-         * 9. Let inherited ns be a copy of namespace.
-         * 10. Let ns be the value of node's namespaceURI attribute.
-         */
-        let qualifiedName = '';
-        let skipEndTag = false;
-        let ignoreNamespaceDefinitionAttribute = false;
-        let map = prefixMap.copy();
-        let localPrefixesMap = {};
-        let localDefaultNamespace = this._recordNamespaceInformation(node, map, localPrefixesMap);
-        let inheritedNS = namespace;
-        let ns = node.namespaceURI;
-        /** 11. If inherited ns is equal to ns, then: */
-        if (inheritedNS === ns) {
-            /**
-             * 11.1. If local default namespace is not null, then set ignore
-             * namespace definition attribute to true.
-             */
-            if (localDefaultNamespace !== null) {
-                ignoreNamespaceDefinitionAttribute = true;
-            }
-            /**
-             * 11.2. If ns is the XML namespace, then append to qualified name the
-             * concatenation of the string "xml:" and the value of node's localName.
-             * 11.3. Otherwise, append to qualified name the value of node's
-             * localName. The node's prefix if it exists, is dropped.
-             */
-            if (ns === infra_1.namespace.XML) {
-                qualifiedName = 'xml:' + node.localName;
-            }
-            else {
-                qualifiedName = node.localName;
-            }
-            /** 11.4. Append the value of qualified name to markup. */
-            this.beginElement(qualifiedName);
-            this.openTagBegin(qualifiedName);
-        }
-        else {
-            /**
-             * 12. Otherwise, inherited ns is not equal to ns (the node's own
-             * namespace is different from the context namespace of its parent).
-             * Run these sub-steps:
-             *
-             * 12.1. Let prefix be the value of node's prefix attribute.
-             * 12.2. Let candidate prefix be the result of retrieving a preferred
-             * prefix string prefix from map given namespace ns. The above may return
-             * null if no namespace key ns exists in map.
-             */
-            let prefix = node.prefix;
-            /**
-             * We don't need to run "retrieving a preferred prefix string" algorithm if
-             * the element has no prefix and its namespace matches to the default
-             * namespace.
-             * See: https://github.com/web-platform-tests/wpt/pull/16703
-             */
-            let candidatePrefix = null;
-            if (prefix !== null || ns !== localDefaultNamespace) {
-                candidatePrefix = map.get(prefix, ns);
-            }
-            /**
-             * 12.3. If the value of prefix matches "xmlns", then run the following
-             * steps:
-             */
-            if (prefix === "xmlns") {
-                /**
-                 * 12.3.1. If the require well-formed flag is set, then throw an error.
-                 * An Element with prefix "xmlns" will not legally round-trip in a
-                 * conforming XML parser.
-                 */
-                if (requireWellFormed) {
-                    throw new Error("An element cannot have the 'xmlns' prefix (well-formed required).");
-                }
-                /**
-                 * 12.3.2. Let candidate prefix be the value of prefix.
-                 */
-                candidatePrefix = prefix;
-            }
-            /**
-             * 12.4.Found a suitable namespace prefix: if candidate prefix is not
-             * null (a namespace prefix is defined which maps to ns), then:
-             */
-            if (candidatePrefix !== null) {
-                /**
-                 * The following may serialize a different prefix than the Element's
-                 * existing prefix if it already had one. However, the retrieving a
-                 * preferred prefix string algorithm already tried to match the
-                 * existing prefix if possible.
-                 *
-                 * 12.4.1. Append to qualified name the concatenation of candidate
-                 * prefix, ":" (U+003A COLON), and node's localName. There exists on
-                 * this node or the node's ancestry a namespace prefix definition that
-                 * defines the node's namespace.
-                 * 12.4.2. If the local default namespace is not null (there exists a
-                 * locally-defined default namespace declaration attribute) and its
-                 * value is not the XML namespace, then let inherited ns get the value
-                 * of local default namespace unless the local default namespace is the
-                 * empty string in which case let it get null (the context namespace
-                 * is changed to the declared default, rather than this node's own
-                 * namespace).
-                 *
-                 * _Note:_ Any default namespace definitions or namespace prefixes that
-                 * define the XML namespace are omitted when serializing this node's
-                 * attributes.
-                 */
-                qualifiedName = candidatePrefix + ':' + node.localName;
-                if (localDefaultNamespace !== null && localDefaultNamespace !== infra_1.namespace.XML) {
-                    inheritedNS = localDefaultNamespace || null;
-                }
-                /**
-                 * 12.4.3. Append the value of qualified name to markup.
-                 */
-                this.beginElement(qualifiedName);
-                this.openTagBegin(qualifiedName);
-                /** 12.5. Otherwise, if prefix is not null, then: */
-            }
-            else if (prefix !== null) {
-                /**
-                 * _Note:_ By this step, there is no namespace or prefix mapping
-                 * declaration in this node (or any parent node visited by this
-                 * algorithm) that defines prefix otherwise the step labelled Found
-                 * a suitable namespace prefix would have been followed. The sub-steps
-                 * that follow will create a new namespace prefix declaration for prefix
-                 * and ensure that prefix does not conflict with an existing namespace
-                 * prefix declaration of the same localName in node's attribute list.
-                 *
-                 * 12.5.1. If the local prefixes map contains a key matching prefix,
-                 * then let prefix be the result of generating a prefix providing as
-                 * input map, ns, and prefix index.
-                 */
-                if (prefix in localPrefixesMap) {
-                    prefix = this._generatePrefix(ns, map, prefixIndex);
-                }
-                /**
-                 * 12.5.2. Add prefix to map given namespace ns.
-                 * 12.5.3. Append to qualified name the concatenation of prefix, ":"
-                 * (U+003A COLON), and node's localName.
-                 * 12.5.4. Append the value of qualified name to markup.
-                 */
-                map.set(prefix, ns);
-                qualifiedName += prefix + ':' + node.localName;
-                this.beginElement(qualifiedName);
-                this.openTagBegin(qualifiedName);
-                /**
-                 * 12.5.5. Append the following to markup, in the order listed:
-                 *
-                 * _Note:_ The following serializes a namespace prefix declaration for
-                 * prefix which was just added to the map.
-                 *
-                 * 12.5.5.1. " " (U+0020 SPACE);
-                 * 12.5.5.2. The string "xmlns:";
-                 * 12.5.5.3. The value of prefix;
-                 * 12.5.5.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
-                 * 12.5.5.5. The result of serializing an attribute value given ns and
-                 * the require well-formed flag as input;
-                 * 12.5.5.6. """ (U+0022 QUOTATION MARK).
-                 */
-                attributes.push([null, 'xmlns', prefix,
-                    this._serializeAttributeValue(ns, requireWellFormed)]);
-                /**
-                 * 12.5.5.7. If local default namespace is not null (there exists a
-                 * locally-defined default namespace declaration attribute), then
-                 * let inherited ns get the value of local default namespace unless the
-                 * local default namespace is the empty string in which case let it get
-                 * null.
-                 */
-                if (localDefaultNamespace !== null) {
-                    inheritedNS = localDefaultNamespace || null;
-                }
-                /**
-                 * 12.6. Otherwise, if local default namespace is null, or local
-                 * default namespace is not null and its value is not equal to ns, then:
-                 */
-            }
-            else if (localDefaultNamespace === null ||
-                (localDefaultNamespace !== null && localDefaultNamespace !== ns)) {
-                /**
-                 * _Note:_ At this point, the namespace for this node still needs to be
-                 * serialized, but there's no prefix (or candidate prefix) available; the
-                 * following uses the default namespace declaration to define the
-                 * namespace--optionally replacing an existing default declaration
-                 * if present.
-                 *
-                 * 12.6.1. Set the ignore namespace definition attribute flag to true.
-                 * 12.6.2. Append to qualified name the value of node's localName.
-                 * 12.6.3. Let the value of inherited ns be ns.
-                 *
-                 * _Note:_ The new default namespace will be used in the serialization
-                 * to define this node's namespace and act as the context namespace for
-                 * its children.
-                 */
-                ignoreNamespaceDefinitionAttribute = true;
-                qualifiedName += node.localName;
-                inheritedNS = ns;
-                /**
-                 * 12.6.4. Append the value of qualified name to markup.
-                 */
-                this.beginElement(qualifiedName);
-                this.openTagBegin(qualifiedName);
-                /**
-                 * 12.6.5. Append the following to markup, in the order listed:
-                 *
-                 * _Note:_ The following serializes the new (or replacement) default
-                 * namespace definition.
-                 *
-                 * 12.6.5.1. " " (U+0020 SPACE);
-                 * 12.6.5.2. The string "xmlns";
-                 * 12.6.5.3. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
-                 * 12.6.5.4. The result of serializing an attribute value given ns
-                 * and the require well-formed flag as input;
-                 * 12.6.5.5. """ (U+0022 QUOTATION MARK).
-                 */
-                attributes.push([null, null, 'xmlns',
-                    this._serializeAttributeValue(ns, requireWellFormed)]);
-                /**
-                 * 12.7. Otherwise, the node has a local default namespace that matches
-                 * ns. Append to qualified name the value of node's localName, let the
-                 * value of inherited ns be ns, and append the value of qualified name
-                 * to markup.
-                 */
-            }
-            else {
-                qualifiedName += node.localName;
-                inheritedNS = ns;
-                this.beginElement(qualifiedName);
-                this.openTagBegin(qualifiedName);
-            }
-        }
-        /**
-         * 13. Append to markup the result of the XML serialization of node's
-         * attributes given map, prefix index, local prefixes map, ignore namespace
-         * definition attribute flag, and require well-formed flag.
-         */
-        attributes.push(...this._serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed));
-        this.attributes(attributes);
-        /**
-         * 14. If ns is the HTML namespace, and the node's list of children is
-         * empty, and the node's localName matches any one of the following void
-         * elements: "area", "base", "basefont", "bgsound", "br", "col", "embed",
-         * "frame", "hr", "img", "input", "keygen", "link", "menuitem", "meta",
-         * "param", "source", "track", "wbr"; then append the following to markup,
-         * in the order listed:
-         * 14.1. " " (U+0020 SPACE);
-         * 14.2. "/" (U+002F SOLIDUS).
-         * and set the skip end tag flag to true.
-         * 15. If ns is not the HTML namespace, and the node's list of children is
-         * empty, then append "/" (U+002F SOLIDUS) to markup and set the skip end
-         * tag flag to true.
-         * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup.
-         */
-        const isHTML = (ns === infra_1.namespace.HTML);
-        if (isHTML && node.childNodes.length === 0 &&
-            BaseWriter._VoidElementNames.has(node.localName)) {
-            this.openTagEnd(qualifiedName, true, true);
-            this.endElement(qualifiedName);
-            skipEndTag = true;
-        }
-        else if (!isHTML && node.childNodes.length === 0) {
-            this.openTagEnd(qualifiedName, true, false);
-            this.endElement(qualifiedName);
-            skipEndTag = true;
-        }
-        else {
-            this.openTagEnd(qualifiedName, false, false);
-        }
-        /**
-         * 17. If the value of skip end tag is true, then return the value of markup
-         * and skip the remaining steps. The node is a leaf-node.
-         */
-        if (skipEndTag)
-            return;
-        /**
-         * 18. If ns is the HTML namespace, and the node's localName matches the
-         * string "template", then this is a template element. Append to markup the
-         * result of XML serializing a DocumentFragment node given the template
-         * element's template contents (a DocumentFragment), providing inherited
-         * ns, map, prefix index, and the require well-formed flag.
-         *
-         * _Note:_ This allows template content to round-trip, given the rules for
-         * parsing XHTML documents.
-         *
-         * 19. Otherwise, append to markup the result of running the XML
-         * serialization algorithm on each of node's children, in tree order,
-         * providing inherited ns, map, prefix index, and the require well-formed
-         * flag.
-         */
-        if (isHTML && node.localName === "template") {
-            // TODO: serialize template contents
-        }
-        else {
-            for (const childNode of node.childNodes) {
-                this.level++;
-                this._serializeNodeNS(childNode, inheritedNS, map, prefixIndex, requireWellFormed);
-                this.level--;
-            }
-        }
-        /**
-         * 20. Append the following to markup, in the order listed:
-         * 20.1. "</" (U+003C LESS-THAN SIGN, U+002F SOLIDUS);
-         * 20.2. The value of qualified name;
-         * 20.3. ">" (U+003E GREATER-THAN SIGN).
-         * 21. Return the value of markup.
-         */
-        this.closeTag(qualifiedName);
-        this.endElement(qualifiedName);
-    }
-    /**
-     * Produces an XML serialization of an element node.
-     *
-     * @param node - node to serialize
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeElement(node, requireWellFormed) {
-        /**
-         * From: https://w3c.github.io/DOM-Parsing/#xml-serializing-an-element-node
-         *
-         * 1. If the require well-formed flag is set (its value is true), and this
-         * node's localName attribute contains the character ":" (U+003A COLON) or
-         * does not match the XML Name production, then throw an exception; the
-         * serialization of this node would not be a well-formed element.
-         */
-        if (requireWellFormed && (node.localName.indexOf(":") !== -1 ||
-            !(0, algorithm_1.xml_isName)(node.localName))) {
-            throw new Error("Node local name contains invalid characters (well-formed required).");
-        }
-        /**
-         * 2. Let markup be the string "<" (U+003C LESS-THAN SIGN).
-         * 3. Let qualified name be an empty string.
-         * 4. Let skip end tag be a boolean flag with value false.
-         * 5. Let ignore namespace definition attribute be a boolean flag with value
-         * false.
-         * 6. Given prefix map, copy a namespace prefix map and let map be the
-         * result.
-         * 7. Let local prefixes map be an empty map. The map has unique Node prefix
-         * strings as its keys, with corresponding namespaceURI Node values as the
-         * map's key values (in this map, the null namespace is represented by the
-         * empty string).
-         *
-         * _Note:_ This map is local to each element. It is used to ensure there
-         * are no conflicting prefixes should a new namespace prefix attribute need
-         * to be generated. It is also used to enable skipping of duplicate prefix
-         * definitions when writing an element's attributes: the map allows the
-         * algorithm to distinguish between a prefix in the namespace prefix map
-         * that might be locally-defined (to the current Element) and one that is
-         * not.
-         * 8. Let local default namespace be the result of recording the namespace
-         * information for node given map and local prefixes map.
-         *
-         * _Note:_ The above step will update map with any found namespace prefix
-         * definitions, add the found prefix definitions to the local prefixes map
-         * and return a local default namespace value defined by a default namespace
-         * attribute if one exists. Otherwise it returns null.
-         * 9. Let inherited ns be a copy of namespace.
-         * 10. Let ns be the value of node's namespaceURI attribute.
-         */
-        let skipEndTag = false;
-        /** 11. If inherited ns is equal to ns, then: */
-        /**
-         * 11.1. If local default namespace is not null, then set ignore
-         * namespace definition attribute to true.
-         */
-        /**
-         * 11.2. If ns is the XML namespace, then append to qualified name the
-         * concatenation of the string "xml:" and the value of node's localName.
-         * 11.3. Otherwise, append to qualified name the value of node's
-         * localName. The node's prefix if it exists, is dropped.
-         */
-        const qualifiedName = node.localName;
-        /** 11.4. Append the value of qualified name to markup. */
-        this.beginElement(qualifiedName);
-        this.openTagBegin(qualifiedName);
-        /**
-         * 13. Append to markup the result of the XML serialization of node's
-         * attributes given map, prefix index, local prefixes map, ignore namespace
-         * definition attribute flag, and require well-formed flag.
-         */
-        const attributes = this._serializeAttributes(node, requireWellFormed);
-        this.attributes(attributes);
-        /**
-         * 14. If ns is the HTML namespace, and the node's list of children is
-         * empty, and the node's localName matches any one of the following void
-         * elements: "area", "base", "basefont", "bgsound", "br", "col", "embed",
-         * "frame", "hr", "img", "input", "keygen", "link", "menuitem", "meta",
-         * "param", "source", "track", "wbr"; then append the following to markup,
-         * in the order listed:
-         * 14.1. " " (U+0020 SPACE);
-         * 14.2. "/" (U+002F SOLIDUS).
-         * and set the skip end tag flag to true.
-         * 15. If ns is not the HTML namespace, and the node's list of children is
-         * empty, then append "/" (U+002F SOLIDUS) to markup and set the skip end
-         * tag flag to true.
-         * 16. Append ">" (U+003E GREATER-THAN SIGN) to markup.
-         */
-        if (!node.hasChildNodes()) {
-            this.openTagEnd(qualifiedName, true, false);
-            this.endElement(qualifiedName);
-            skipEndTag = true;
-        }
-        else {
-            this.openTagEnd(qualifiedName, false, false);
-        }
-        /**
-         * 17. If the value of skip end tag is true, then return the value of markup
-         * and skip the remaining steps. The node is a leaf-node.
-         */
-        if (skipEndTag)
-            return;
-        /**
-         * 18. If ns is the HTML namespace, and the node's localName matches the
-         * string "template", then this is a template element. Append to markup the
-         * result of XML serializing a DocumentFragment node given the template
-         * element's template contents (a DocumentFragment), providing inherited
-         * ns, map, prefix index, and the require well-formed flag.
-         *
-         * _Note:_ This allows template content to round-trip, given the rules for
-         * parsing XHTML documents.
-         *
-         * 19. Otherwise, append to markup the result of running the XML
-         * serialization algorithm on each of node's children, in tree order,
-         * providing inherited ns, map, prefix index, and the require well-formed
-         * flag.
-         */
-        for (const childNode of node._children) {
-            this.level++;
-            this._serializeNode(childNode, requireWellFormed);
-            this.level--;
-        }
-        /**
-         * 20. Append the following to markup, in the order listed:
-         * 20.1. "</" (U+003C LESS-THAN SIGN, U+002F SOLIDUS);
-         * 20.2. The value of qualified name;
-         * 20.3. ">" (U+003E GREATER-THAN SIGN).
-         * 21. Return the value of markup.
-         */
-        this.closeTag(qualifiedName);
-        this.endElement(qualifiedName);
-    }
-    /**
-     * Produces an XML serialization of a document node.
-     *
-     * @param node - node to serialize
-     * @param namespace - context namespace
-     * @param prefixMap - namespace prefix map
-     * @param prefixIndex - generated namespace prefix index
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeDocumentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
-        /**
-         * If the require well-formed flag is set (its value is true), and this node
-         * has no documentElement (the documentElement attribute's value is null),
-         * then throw an exception; the serialization of this node would not be a
-         * well-formed document.
-         */
-        if (requireWellFormed && node.documentElement === null) {
-            throw new Error("Missing document element (well-formed required).");
-        }
-        /**
-         * Otherwise, run the following steps:
-         * 1. Let serialized document be an empty string.
-         * 2. For each child child of node, in tree order, run the XML
-         * serialization algorithm on the child passing along the provided
-         * arguments, and append the result to serialized document.
-         *
-         * _Note:_ This will serialize any number of ProcessingInstruction and
-         * Comment nodes both before and after the Document's documentElement node,
-         * including at most one DocumentType node. (Text nodes are not allowed as
-         * children of the Document.)
-         *
-         * 3. Return the value of serialized document.
-        */
-        for (const childNode of node.childNodes) {
-            this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
-        }
-    }
-    /**
-     * Produces an XML serialization of a document node.
-     *
-     * @param node - node to serialize
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeDocument(node, requireWellFormed) {
-        /**
-         * If the require well-formed flag is set (its value is true), and this node
-         * has no documentElement (the documentElement attribute's value is null),
-         * then throw an exception; the serialization of this node would not be a
-         * well-formed document.
-         */
-        if (requireWellFormed && node.documentElement === null) {
-            throw new Error("Missing document element (well-formed required).");
-        }
-        /**
-         * Otherwise, run the following steps:
-         * 1. Let serialized document be an empty string.
-         * 2. For each child child of node, in tree order, run the XML
-         * serialization algorithm on the child passing along the provided
-         * arguments, and append the result to serialized document.
-         *
-         * _Note:_ This will serialize any number of ProcessingInstruction and
-         * Comment nodes both before and after the Document's documentElement node,
-         * including at most one DocumentType node. (Text nodes are not allowed as
-         * children of the Document.)
-         *
-         * 3. Return the value of serialized document.
-        */
-        for (const childNode of node._children) {
-            this._serializeNode(childNode, requireWellFormed);
-        }
-    }
-    /**
-     * Produces an XML serialization of a comment node.
-     *
-     * @param node - node to serialize
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeComment(node, requireWellFormed) {
-        /**
-         * If the require well-formed flag is set (its value is true), and node's
-         * data contains characters that are not matched by the XML Char production
-         * or contains "--" (two adjacent U+002D HYPHEN-MINUS characters) or that
-         * ends with a "-" (U+002D HYPHEN-MINUS) character, then throw an exception;
-         * the serialization of this node's data would not be well-formed.
-         */
-        if (requireWellFormed && (!(0, algorithm_1.xml_isLegalChar)(node.data) ||
-            node.data.indexOf("--") !== -1 || node.data.endsWith("-"))) {
-            throw new Error("Comment data contains invalid characters (well-formed required).");
-        }
-        /**
-         * Otherwise, return the concatenation of "<!--", node's data, and "-->".
-         */
-        this.comment(node.data);
-    }
-    /**
-     * Produces an XML serialization of a text node.
-     *
-     * @param node - node to serialize
-     * @param requireWellFormed - whether to check conformance
-     * @param level - current depth of the XML tree
-     */
-    _serializeText(node, requireWellFormed) {
-        /**
-         * 1. If the require well-formed flag is set (its value is true), and
-         * node's data contains characters that are not matched by the XML Char
-         * production, then throw an exception; the serialization of this node's
-         * data would not be well-formed.
-         */
-        if (requireWellFormed && !(0, algorithm_1.xml_isLegalChar)(node.data)) {
-            throw new Error("Text data contains invalid characters (well-formed required).");
-        }
-        /**
-         * 2. Let markup be the value of node's data.
-         * 3. Replace any occurrences of "&" in markup by "&amp;".
-         * 4. Replace any occurrences of "<" in markup by "&lt;".
-         * 5. Replace any occurrences of ">" in markup by "&gt;".
-         * 6. Return the value of markup.
-         */
-        const markup = node.data.replace(constants_1.nonEntityAmpersandRegex, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;');
-        this.text(markup);
-    }
-    /**
-     * Produces an XML serialization of a document fragment node.
-     *
-     * @param node - node to serialize
-     * @param namespace - context namespace
-     * @param prefixMap - namespace prefix map
-     * @param prefixIndex - generated namespace prefix index
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeDocumentFragmentNS(node, namespace, prefixMap, prefixIndex, requireWellFormed) {
-        /**
-         * 1. Let markup the empty string.
-         * 2. For each child child of node, in tree order, run the XML serialization
-         * algorithm on the child given namespace, prefix map, a reference to prefix
-         * index, and flag require well-formed. Concatenate the result to markup.
-         * 3. Return the value of markup.
-         */
-        for (const childNode of node.childNodes) {
-            this._serializeNodeNS(childNode, namespace, prefixMap, prefixIndex, requireWellFormed);
-        }
-    }
-    /**
-     * Produces an XML serialization of a document fragment node.
-     *
-     * @param node - node to serialize
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeDocumentFragment(node, requireWellFormed) {
-        /**
-         * 1. Let markup the empty string.
-         * 2. For each child child of node, in tree order, run the XML serialization
-         * algorithm on the child given namespace, prefix map, a reference to prefix
-         * index, and flag require well-formed. Concatenate the result to markup.
-         * 3. Return the value of markup.
-         */
-        for (const childNode of node._children) {
-            this._serializeNode(childNode, requireWellFormed);
-        }
-    }
-    /**
-     * Produces an XML serialization of a document type node.
-     *
-     * @param node - node to serialize
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeDocumentType(node, requireWellFormed) {
-        /**
-         * 1. If the require well-formed flag is true and the node's publicId
-         * attribute contains characters that are not matched by the XML PubidChar
-         *  production, then throw an exception; the serialization of this node
-         * would not be a well-formed document type declaration.
-         */
-        if (requireWellFormed && !(0, algorithm_1.xml_isPubidChar)(node.publicId)) {
-            throw new Error("DocType public identifier does not match PubidChar construct (well-formed required).");
-        }
-        /**
-         * 2. If the require well-formed flag is true and the node's systemId
-         * attribute contains characters that are not matched by the XML Char
-         * production or that contains both a """ (U+0022 QUOTATION MARK) and a
-         * "'" (U+0027 APOSTROPHE), then throw an exception; the serialization
-         * of this node would not be a well-formed document type declaration.
-         */
-        if (requireWellFormed &&
-            (!(0, algorithm_1.xml_isLegalChar)(node.systemId) ||
-                (node.systemId.indexOf('"') !== -1 && node.systemId.indexOf("'") !== -1))) {
-            throw new Error("DocType system identifier contains invalid characters (well-formed required).");
-        }
-        /**
-         * 3. Let markup be an empty string.
-         * 4. Append the string "<!DOCTYPE" to markup.
-         * 5. Append " " (U+0020 SPACE) to markup.
-         * 6. Append the value of the node's name attribute to markup. For a node
-         * belonging to an HTML document, the value will be all lowercase.
-         * 7. If the node's publicId is not the empty string then append the
-         * following, in the order listed, to markup:
-         * 7.1. " " (U+0020 SPACE);
-         * 7.2. The string "PUBLIC";
-         * 7.3. " " (U+0020 SPACE);
-         * 7.4. """ (U+0022 QUOTATION MARK);
-         * 7.5. The value of the node's publicId attribute;
-         * 7.6. """ (U+0022 QUOTATION MARK).
-         * 8. If the node's systemId is not the empty string and the node's publicId
-         * is set to the empty string, then append the following, in the order
-         * listed, to markup:
-         * 8.1. " " (U+0020 SPACE);
-         * 8.2. The string "SYSTEM".
-         * 9. If the node's systemId is not the empty string then append the
-         * following, in the order listed, to markup:
-         * 9.2. " " (U+0020 SPACE);
-         * 9.3. """ (U+0022 QUOTATION MARK);
-         * 9.3. The value of the node's systemId attribute;
-         * 9.4. """ (U+0022 QUOTATION MARK).
-         * 10. Append ">" (U+003E GREATER-THAN SIGN) to markup.
-         * 11. Return the value of markup.
-         */
-        this.docType(node.name, node.publicId, node.systemId);
-    }
-    /**
-     * Produces an XML serialization of a processing instruction node.
-     *
-     * @param node - node to serialize
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeProcessingInstruction(node, requireWellFormed) {
-        /**
-         * 1. If the require well-formed flag is set (its value is true), and node's
-         * target contains a ":" (U+003A COLON) character or is an ASCII
-         * case-insensitive match for the string "xml", then throw an exception;
-         * the serialization of this node's target would not be well-formed.
-         */
-        if (requireWellFormed && (node.target.indexOf(":") !== -1 || (/^xml$/i).test(node.target))) {
-            throw new Error("Processing instruction target contains invalid characters (well-formed required).");
-        }
-        /**
-         * 2. If the require well-formed flag is set (its value is true), and node's
-         * data contains characters that are not matched by the XML Char production
-         * or contains the string "?>" (U+003F QUESTION MARK,
-         * U+003E GREATER-THAN SIGN), then throw an exception; the serialization of
-         * this node's data would not be well-formed.
-         */
-        if (requireWellFormed && (!(0, algorithm_1.xml_isLegalChar)(node.data) ||
-            node.data.indexOf("?>") !== -1)) {
-            throw new Error("Processing instruction data contains invalid characters (well-formed required).");
-        }
-        /**
-         * 3. Let markup be the concatenation of the following, in the order listed:
-         * 3.1. "<?" (U+003C LESS-THAN SIGN, U+003F QUESTION MARK);
-         * 3.2. The value of node's target;
-         * 3.3. " " (U+0020 SPACE);
-         * 3.4. The value of node's data;
-         * 3.5. "?>" (U+003F QUESTION MARK, U+003E GREATER-THAN SIGN).
-         * 4. Return the value of markup.
-         */
-        this.instruction(node.target, node.data);
-    }
-    /**
-     * Produces an XML serialization of a CDATA node.
-     *
-     * @param node - node to serialize
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeCData(node, requireWellFormed) {
-        if (requireWellFormed && (node.data.indexOf("]]>") !== -1)) {
-            throw new Error("CDATA contains invalid characters (well-formed required).");
-        }
-        this.cdata(node.data);
-    }
-    /**
-    * Produces an XML serialization of the attributes of an element node.
-    *
-     * @param node - node to serialize
-     * @param map - namespace prefix map
-     * @param prefixIndex - generated namespace prefix index
-     * @param localPrefixesMap - local prefixes map
-     * @param ignoreNamespaceDefinitionAttribute - whether to ignore namespace
-     * attributes
-     * @param requireWellFormed - whether to check conformance
-    */
-    _serializeAttributesNS(node, map, prefixIndex, localPrefixesMap, ignoreNamespaceDefinitionAttribute, requireWellFormed) {
-        /**
-         * 1. Let result be the empty string.
-         * 2. Let localname set be a new empty namespace localname set. This
-         * localname set will contain tuples of unique attribute namespaceURI and
-         * localName pairs, and is populated as each attr is processed. This set is
-         * used to [optionally] enforce the well-formed constraint that an element
-         * cannot have two attributes with the same namespaceURI and localName.
-         * This can occur when two otherwise identical attributes on the same
-         * element differ only by their prefix values.
-         */
-        const result = [];
-        const localNameSet = requireWellFormed ? new LocalNameSet_1.LocalNameSet() : undefined;
-        /**
-         * 3. Loop: For each attribute attr in element's attributes, in the order
-         * they are specified in the element's attribute list:
-         */
-        for (const attr of node.attributes) {
-            // Optimize common case
-            if (!requireWellFormed && !ignoreNamespaceDefinitionAttribute && attr.namespaceURI === null) {
-                result.push([null, null, attr.localName,
-                    this._serializeAttributeValue(attr.value, requireWellFormed)]);
-                continue;
-            }
-            /**
-             * 3.1. If the require well-formed flag is set (its value is true), and the
-             * localname set contains a tuple whose values match those of a new tuple
-             * consisting of attr's namespaceURI attribute and localName attribute,
-             * then throw an exception; the serialization of this attr would fail to
-             * produce a well-formed element serialization.
-             */
-            if (requireWellFormed && localNameSet && localNameSet.has(attr.namespaceURI, attr.localName)) {
-                throw new Error("Element contains duplicate attributes (well-formed required).");
-            }
-            /**
-             * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
-             * localName attribute, and add it to the localname set.
-             * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
-             * 3.4. Let candidate prefix be null.
-             */
-            if (requireWellFormed && localNameSet)
-                localNameSet.set(attr.namespaceURI, attr.localName);
-            let attributeNamespace = attr.namespaceURI;
-            let candidatePrefix = null;
-            /** 3.5. If attribute namespace is not null, then run these sub-steps: */
-            if (attributeNamespace !== null) {
-                /**
-                 * 3.5.1. Let candidate prefix be the result of retrieving a preferred
-                 * prefix string from map given namespace attribute namespace with
-                 * preferred prefix being attr's prefix value.
-                 */
-                candidatePrefix = map.get(attr.prefix, attributeNamespace);
-                /**
-                 * 3.5.2. If the value of attribute namespace is the XMLNS namespace,
-                 * then run these steps:
-                 */
-                if (attributeNamespace === infra_1.namespace.XMLNS) {
-                    /**
-                     * 3.5.2.1. If any of the following are true, then stop running these
-                     * steps and goto Loop to visit the next attribute:
-                     * - the attr's value is the XML namespace;
-                     * _Note:_ The XML namespace cannot be redeclared and survive
-                     * round-tripping (unless it defines the prefix "xml"). To avoid this
-                     * problem, this algorithm always prefixes elements in the XML
-                     * namespace with "xml" and drops any related definitions as seen
-                     * in the above condition.
-                     * - the attr's prefix is null and the ignore namespace definition
-                     * attribute flag is true (the Element's default namespace attribute
-                     * should be skipped);
-                     * - the attr's prefix is not null and either
-                     *   * the attr's localName is not a key contained in the local
-                     *     prefixes map, or
-                     *   * the attr's localName is present in the local prefixes map but
-                     *     the value of the key does not match attr's value
-                     * and furthermore that the attr's localName (as the prefix to find)
-                     * is found in the namespace prefix map given the namespace consisting
-                     * of the attr's value (the current namespace prefix definition was
-                     * exactly defined previously--on an ancestor element not the current
-                     * element whose attributes are being processed).
-                     */
-                    if (attr.value === infra_1.namespace.XML ||
-                        (attr.prefix === null && ignoreNamespaceDefinitionAttribute) ||
-                        (attr.prefix !== null && (!(attr.localName in localPrefixesMap) ||
-                            localPrefixesMap[attr.localName] !== attr.value) &&
-                            map.has(attr.localName, attr.value)))
-                        continue;
-                    /**
-                     * 3.5.2.2. If the require well-formed flag is set (its value is true),
-                     * and the value of attr's value attribute matches the XMLNS
-                     * namespace, then throw an exception; the serialization of this
-                     * attribute would produce invalid XML because the XMLNS namespace
-                     * is reserved and cannot be applied as an element's namespace via
-                     * XML parsing.
-                     *
-                     * _Note:_ DOM APIs do allow creation of elements in the XMLNS
-                     * namespace but with strict qualifications.
-                     */
-                    if (requireWellFormed && attr.value === infra_1.namespace.XMLNS) {
-                        throw new Error("XMLNS namespace is reserved (well-formed required).");
-                    }
-                    /**
-                     * 3.5.2.3. If the require well-formed flag is set (its value is true),
-                     * and the value of attr's value attribute is the empty string, then
-                     * throw an exception; namespace prefix declarations cannot be used
-                     * to undeclare a namespace (use a default namespace declaration
-                     * instead).
-                     */
-                    if (requireWellFormed && attr.value === '') {
-                        throw new Error("Namespace prefix declarations cannot be used to undeclare a namespace (well-formed required).");
-                    }
-                    /**
-                     * 3.5.2.4. the attr's prefix matches the string "xmlns", then let
-                     * candidate prefix be the string "xmlns".
-                     */
-                    if (attr.prefix === 'xmlns')
-                        candidatePrefix = 'xmlns';
-                    /**
-                     * 3.5.3. Otherwise, the attribute namespace is not the XMLNS namespace.
-                     * Run these steps:
-                     *
-                     * _Note:_ The (candidatePrefix === null) check is not in the spec.
-                     * We deviate from the spec here. Otherwise a prefix is generated for
-                     * all attributes with namespaces.
-                     */
-                }
-                else if (candidatePrefix === null) {
-                    if (attr.prefix !== null &&
-                        (!map.hasPrefix(attr.prefix) ||
-                            map.has(attr.prefix, attributeNamespace))) {
-                        /**
-                         * Check if we can use the attribute's own prefix.
-                         * We deviate from the spec here.
-                         * TODO: This is not an efficient way of searching for prefixes.
-                         * Follow developments to the spec.
-                         */
-                        candidatePrefix = attr.prefix;
-                    }
-                    else {
-                        /**
-                         * 3.5.3.1. Let candidate prefix be the result of generating a prefix
-                         * providing map, attribute namespace, and prefix index as input.
-                         */
-                        candidatePrefix = this._generatePrefix(attributeNamespace, map, prefixIndex);
-                    }
-                    /**
-                     * 3.5.3.2. Append the following to result, in the order listed:
-                     * 3.5.3.2.1. " " (U+0020 SPACE);
-                     * 3.5.3.2.2. The string "xmlns:";
-                     * 3.5.3.2.3. The value of candidate prefix;
-                     * 3.5.3.2.4. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
-                     * 3.5.3.2.5. The result of serializing an attribute value given
-                     * attribute namespace and the require well-formed flag as input;
-                     * 3.5.3.2.6. """ (U+0022 QUOTATION MARK).
-                    */
-                    result.push([null, "xmlns", candidatePrefix,
-                        this._serializeAttributeValue(attributeNamespace, requireWellFormed)]);
-                }
-            }
-            /**
-             * 3.6. Append a " " (U+0020 SPACE) to result.
-             * 3.7. If candidate prefix is not null, then append to result the
-             * concatenation of candidate prefix with ":" (U+003A COLON).
-             */
-            let attrName = '';
-            if (candidatePrefix !== null) {
-                attrName = candidatePrefix;
-            }
-            /**
-             * 3.8. If the require well-formed flag is set (its value is true), and
-             * this attr's localName attribute contains the character
-             * ":" (U+003A COLON) or does not match the XML Name production or
-             * equals "xmlns" and attribute namespace is null, then throw an
-             * exception; the serialization of this attr would not be a
-             * well-formed attribute.
-             */
-            if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
-                !(0, algorithm_1.xml_isName)(attr.localName) ||
-                (attr.localName === "xmlns" && attributeNamespace === null))) {
-                throw new Error("Attribute local name contains invalid characters (well-formed required).");
-            }
-            /**
-             * 3.9. Append the following strings to result, in the order listed:
-             * 3.9.1. The value of attr's localName;
-             * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
-             * 3.9.3. The result of serializing an attribute value given attr's value
-             * attribute and the require well-formed flag as input;
-             * 3.9.4. """ (U+0022 QUOTATION MARK).
-             */
-            result.push([attributeNamespace, candidatePrefix, attr.localName,
-                this._serializeAttributeValue(attr.value, requireWellFormed)]);
-        }
-        /**
-         * 4. Return the value of result.
-         */
-        return result;
-    }
-    /**
-    * Produces an XML serialization of the attributes of an element node.
-    *
-     * @param node - node to serialize
-     * @param requireWellFormed - whether to check conformance
-    */
-    _serializeAttributes(node, requireWellFormed) {
-        /**
-         * 1. Let result be the empty string.
-         * 2. Let localname set be a new empty namespace localname set. This
-         * localname set will contain tuples of unique attribute namespaceURI and
-         * localName pairs, and is populated as each attr is processed. This set is
-         * used to [optionally] enforce the well-formed constraint that an element
-         * cannot have two attributes with the same namespaceURI and localName.
-         * This can occur when two otherwise identical attributes on the same
-         * element differ only by their prefix values.
-         */
-        const result = [];
-        const localNameSet = requireWellFormed ? {} : undefined;
-        /**
-         * 3. Loop: For each attribute attr in element's attributes, in the order
-         * they are specified in the element's attribute list:
-         */
-        for (const attr of node.attributes) {
-            // Optimize common case
-            if (!requireWellFormed) {
-                result.push([null, null, attr.localName,
-                    this._serializeAttributeValue(attr.value, requireWellFormed)]);
-                continue;
-            }
-            /**
-             * 3.1. If the require well-formed flag is set (its value is true), and the
-             * localname set contains a tuple whose values match those of a new tuple
-             * consisting of attr's namespaceURI attribute and localName attribute,
-             * then throw an exception; the serialization of this attr would fail to
-             * produce a well-formed element serialization.
-             */
-            if (requireWellFormed && localNameSet && (attr.localName in localNameSet)) {
-                throw new Error("Element contains duplicate attributes (well-formed required).");
-            }
-            /**
-             * 3.2. Create a new tuple consisting of attr's namespaceURI attribute and
-             * localName attribute, and add it to the localname set.
-             * 3.3. Let attribute namespace be the value of attr's namespaceURI value.
-             * 3.4. Let candidate prefix be null.
-             */
-            /* istanbul ignore else */
-            if (requireWellFormed && localNameSet)
-                localNameSet[attr.localName] = true;
-            /** 3.5. If attribute namespace is not null, then run these sub-steps: */
-            /**
-             * 3.6. Append a " " (U+0020 SPACE) to result.
-             * 3.7. If candidate prefix is not null, then append to result the
-             * concatenation of candidate prefix with ":" (U+003A COLON).
-             */
-            /**
-             * 3.8. If the require well-formed flag is set (its value is true), and
-             * this attr's localName attribute contains the character
-             * ":" (U+003A COLON) or does not match the XML Name production or
-             * equals "xmlns" and attribute namespace is null, then throw an
-             * exception; the serialization of this attr would not be a
-             * well-formed attribute.
-             */
-            if (requireWellFormed && (attr.localName.indexOf(":") !== -1 ||
-                !(0, algorithm_1.xml_isName)(attr.localName))) {
-                throw new Error("Attribute local name contains invalid characters (well-formed required).");
-            }
-            /**
-             * 3.9. Append the following strings to result, in the order listed:
-             * 3.9.1. The value of attr's localName;
-             * 3.9.2. "="" (U+003D EQUALS SIGN, U+0022 QUOTATION MARK);
-             * 3.9.3. The result of serializing an attribute value given attr's value
-             * attribute and the require well-formed flag as input;
-             * 3.9.4. """ (U+0022 QUOTATION MARK).
-             */
-            result.push([null, null, attr.localName,
-                this._serializeAttributeValue(attr.value, requireWellFormed)]);
-        }
-        /**
-         * 4. Return the value of result.
-         */
-        return result;
-    }
-    /**
-    * Records namespace information for the given element and returns the
-    * default namespace attribute value.
-    *
-    * @param node - element node to process
-    * @param map - namespace prefix map
-    * @param localPrefixesMap - local prefixes map
-    */
-    _recordNamespaceInformation(node, map, localPrefixesMap) {
-        /**
-         * 1. Let default namespace attr value be null.
-         */
-        let defaultNamespaceAttrValue = null;
-        /**
-         * 2. Main: For each attribute attr in element's attributes, in the order
-         * they are specified in the element's attribute list:
-         */
-        for (const attr of node.attributes) {
-            /**
-             * _Note:_ The following conditional steps find namespace prefixes. Only
-             * attributes in the XMLNS namespace are considered (e.g., attributes made
-             * to look like namespace declarations via
-             * setAttribute("xmlns:pretend-prefix", "pretend-namespace") are not
-             * included).
-             */
-            /** 2.1. Let attribute namespace be the value of attr's namespaceURI value. */
-            let attributeNamespace = attr.namespaceURI;
-            /** 2.2. Let attribute prefix be the value of attr's prefix. */
-            let attributePrefix = attr.prefix;
-            /** 2.3. If the attribute namespace is the XMLNS namespace, then: */
-            if (attributeNamespace === infra_1.namespace.XMLNS) {
-                /**
-                 * 2.3.1. If attribute prefix is null, then attr is a default namespace
-                 * declaration. Set the default namespace attr value to attr's value and
-                 * stop running these steps, returning to Main to visit the next
-                 * attribute.
-                 */
-                if (attributePrefix === null) {
-                    defaultNamespaceAttrValue = attr.value;
-                    continue;
-                    /**
-                     * 2.3.2. Otherwise, the attribute prefix is not null and attr is a
-                     * namespace prefix definition. Run the following steps:
-                     */
-                }
-                else {
-                    /** 2.3.2.1. Let prefix definition be the value of attr's localName. */
-                    let prefixDefinition = attr.localName;
-                    /** 2.3.2.2. Let namespace definition be the value of attr's value. */
-                    let namespaceDefinition = attr.value;
-                    /**
-                     * 2.3.2.3. If namespace definition is the XML namespace, then stop
-                     * running these steps, and return to Main to visit the next
-                     * attribute.
-                     *
-                     * _Note:_ XML namespace definitions in prefixes are completely
-                     * ignored (in order to avoid unnecessary work when there might be
-                     * prefix conflicts). XML namespaced elements are always handled
-                     * uniformly by prefixing (and overriding if necessary) the element's
-                     * localname with the reserved "xml" prefix.
-                     */
-                    if (namespaceDefinition === infra_1.namespace.XML) {
-                        continue;
-                    }
-                    /**
-                     * 2.3.2.4. If namespace definition is the empty string (the
-                     * declarative form of having no namespace), then let namespace
-                     * definition be null instead.
-                     */
-                    if (namespaceDefinition === '') {
-                        namespaceDefinition = null;
-                    }
-                    /**
-                     * 2.3.2.5. If prefix definition is found in map given the namespace
-                     * namespace definition, then stop running these steps, and return to
-                     * Main to visit the next attribute.
-                     *
-                     * _Note:_ This step avoids adding duplicate prefix definitions for
-                     * the same namespace in the map. This has the side-effect of avoiding
-                     * later serialization of duplicate namespace prefix declarations in
-                     * any descendant nodes.
-                     */
-                    if (map.has(prefixDefinition, namespaceDefinition)) {
-                        continue;
-                    }
-                    /**
-                     * 2.3.2.6. Add the prefix prefix definition to map given namespace
-                     * namespace definition.
-                     */
-                    map.set(prefixDefinition, namespaceDefinition);
-                    /**
-                     * 2.3.2.7. Add the value of prefix definition as a new key to the
-                     * local prefixes map, with the namespace definition as the key's
-                     * value replacing the value of null with the empty string if
-                     * applicable.
-                     */
-                    localPrefixesMap[prefixDefinition] = namespaceDefinition || '';
-                }
-            }
-        }
-        /**
-         * 3. Return the value of default namespace attr value.
-         *
-         * _Note:_ The empty string is a legitimate return value and is not
-         * converted to null.
-         */
-        return defaultNamespaceAttrValue;
-    }
-    /**
-    * Generates a new prefix for the given namespace.
-    *
-    * @param newNamespace - a namespace to generate prefix for
-    * @param prefixMap - namespace prefix map
-    * @param prefixIndex - generated namespace prefix index
-    */
-    _generatePrefix(newNamespace, prefixMap, prefixIndex) {
-        /**
-         * 1. Let generated prefix be the concatenation of the string "ns" and the
-         * current numerical value of prefix index.
-         * 2. Let the value of prefix index be incremented by one.
-         * 3. Add to map the generated prefix given the new namespace namespace.
-         * 4. Return the value of generated prefix.
-         */
-        const generatedPrefix = "ns" + prefixIndex.value.toString();
-        prefixIndex.value++;
-        prefixMap.set(generatedPrefix, newNamespace);
-        return generatedPrefix;
-    }
-    /**
-     * Produces an XML serialization of an attribute value.
-     *
-     * @param value - attribute value
-     * @param requireWellFormed - whether to check conformance
-     */
-    _serializeAttributeValue(value, requireWellFormed) {
-        /**
-         * From: https://w3c.github.io/DOM-Parsing/#dfn-serializing-an-attribute-value
-         *
-         * 1. If the require well-formed flag is set (its value is true), and
-         * attribute value contains characters that are not matched by the XML Char
-         * production, then throw an exception; the serialization of this attribute
-         * value would fail to produce a well-formed element serialization.
-         */
-        if (requireWellFormed && value !== null && !(0, algorithm_1.xml_isLegalChar)(value)) {
-            throw new Error("Invalid characters in attribute value.");
-        }
-        /**
-         * 2. If attribute value is null, then return the empty string.
-         */
-        if (value === null)
-            return "";
-        /**
-         * 3. Otherwise, attribute value is a string. Return the value of attribute
-         * value, first replacing any occurrences of the following:
-         * - "&" with "&amp;"
-         * - """ with "&quot;"
-         * - "<" with "&lt;"
-         * - ">" with "&gt;"
-         * NOTE
-         * This matches behavior present in browsers, and goes above and beyond the
-         * grammar requirement in the XML specification's AttValue production by
-         * also replacing ">" characters.
-         */
-        return value.replace(constants_1.nonEntityAmpersandRegex, '&amp;')
-            .replace(/</g, '&lt;')
-            .replace(/>/g, '&gt;')
-            .replace(/"/g, '&quot;');
-    }
-}
-exports.BaseWriter = BaseWriter;
-//# sourceMappingURL=BaseWriter.js.map
-
-/***/ }),
-
-/***/ 3198:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.JSONCBWriter = void 0;
-const BaseCBWriter_1 = __nccwpck_require__(63210);
-/**
- * Serializes XML nodes.
- */
-class JSONCBWriter extends BaseCBWriter_1.BaseCBWriter {
-    _hasChildren = [];
-    _additionalLevel = 0;
-    /**
-     * Initializes a new instance of `JSONCBWriter`.
-     *
-     * @param builderOptions - XML builder options
-     */
-    constructor(builderOptions) {
-        super(builderOptions);
-    }
-    /** @inheritdoc */
-    frontMatter() {
-        return "";
-    }
-    /** @inheritdoc */
-    declaration(version, encoding, standalone) {
-        return "";
-    }
-    /** @inheritdoc */
-    docType(name, publicId, systemId) {
-        return "";
-    }
-    /** @inheritdoc */
-    comment(data) {
-        // { "!": "hello" }
-        return this._comma() + this._beginLine() + "{" + this._sep() +
-            this._key(this._builderOptions.convert.comment) + this._sep() +
-            this._val(data) + this._sep() + "}";
-    }
-    /** @inheritdoc */
-    text(data) {
-        // { "#": "hello" }
-        return this._comma() + this._beginLine() + "{" + this._sep() +
-            this._key(this._builderOptions.convert.text) + this._sep() +
-            this._val(data) + this._sep() + "}";
-    }
-    /** @inheritdoc */
-    instruction(target, data) {
-        // { "?": "target hello" }
-        return this._comma() + this._beginLine() + "{" + this._sep() +
-            this._key(this._builderOptions.convert.ins) + this._sep() +
-            this._val(data ? target + " " + data : target) + this._sep() + "}";
-    }
-    /** @inheritdoc */
-    cdata(data) {
-        // { "$": "hello" }
-        return this._comma() + this._beginLine() + "{" + this._sep() +
-            this._key(this._builderOptions.convert.cdata) + this._sep() +
-            this._val(data) + this._sep() + "}";
-    }
-    /** @inheritdoc */
-    attribute(name, value) {
-        // { "@name": "val" }
-        return this._comma() + this._beginLine(1) + "{" + this._sep() +
-            this._key(this._builderOptions.convert.att + name) + this._sep() +
-            this._val(value) + this._sep() + "}";
-    }
-    /** @inheritdoc */
-    openTagBegin(name) {
-        // { "node": { "#": [
-        let str = this._comma() + this._beginLine() + "{" + this._sep() + this._key(name) + this._sep() + "{";
-        this._additionalLevel++;
-        this.hasData = true;
-        str += this._beginLine() + this._key(this._builderOptions.convert.text) + this._sep() + "[";
-        this._hasChildren.push(false);
-        return str;
-    }
-    /** @inheritdoc */
-    openTagEnd(name, selfClosing, voidElement) {
-        if (selfClosing) {
-            let str = this._sep() + "]";
-            this._additionalLevel--;
-            str += this._beginLine() + "}" + this._sep() + "}";
-            return str;
-        }
-        else {
-            return "";
-        }
-    }
-    /** @inheritdoc */
-    closeTag(name) {
-        // ] } }
-        let str = this._beginLine() + "]";
-        this._additionalLevel--;
-        str += this._beginLine() + "}" + this._sep() + "}";
-        return str;
-    }
-    /** @inheritdoc */
-    beginElement(name) { }
-    /** @inheritdoc */
-    endElement(name) { this._hasChildren.pop(); }
-    /**
-     * Produces characters to be prepended to a line of string in pretty-print
-     * mode.
-     */
-    _beginLine(additionalOffset = 0) {
-        if (this._writerOptions.prettyPrint) {
-            return (this.hasData ? this._writerOptions.newline : "") +
-                this._indent(this._writerOptions.offset + this.level + additionalOffset);
-        }
-        else {
-            return "";
-        }
-    }
-    /**
-     * Produces an indentation string.
-     *
-     * @param level - depth of the tree
-     */
-    _indent(level) {
-        if (level + this._additionalLevel <= 0) {
-            return "";
-        }
-        else {
-            return this._writerOptions.indent.repeat(level + this._additionalLevel);
-        }
-    }
-    /**
-     * Produces a comma before a child node if it has previous siblings.
-     */
-    _comma() {
-        const str = (this._hasChildren[this._hasChildren.length - 1] ? "," : "");
-        if (this._hasChildren.length > 0) {
-            this._hasChildren[this._hasChildren.length - 1] = true;
-        }
-        return str;
-    }
-    /**
-     * Produces a separator string.
-     */
-    _sep() {
-        return (this._writerOptions.prettyPrint ? " " : "");
-    }
-    /**
-     * Produces a JSON key string delimited with double quotes.
-     */
-    _key(key) {
-        return "\"" + key + "\":";
-    }
-    /**
-     * Produces a JSON value string delimited with double quotes.
-     */
-    _val(val) {
-        return JSON.stringify(val);
-    }
-}
-exports.JSONCBWriter = JSONCBWriter;
-//# sourceMappingURL=JSONCBWriter.js.map
-
-/***/ }),
-
-/***/ 53775:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.JSONWriter = void 0;
-const ObjectWriter_1 = __nccwpck_require__(24393);
-const util_1 = __nccwpck_require__(76195);
-const BaseWriter_1 = __nccwpck_require__(24189);
-/**
- * Serializes XML nodes into a JSON string.
- */
-class JSONWriter extends BaseWriter_1.BaseWriter {
-    /**
-     * Initializes a new instance of `JSONWriter`.
-     *
-     * @param builderOptions - XML builder options
-     * @param writerOptions - serialization options
-     */
-    constructor(builderOptions, writerOptions) {
-        super(builderOptions);
-        // provide default options
-        this._writerOptions = (0, util_1.applyDefaults)(writerOptions, {
-            wellFormed: false,
-            prettyPrint: false,
-            indent: '  ',
-            newline: '\n',
-            offset: 0,
-            group: false,
-            verbose: false
-        });
-    }
-    /**
-     * Produces an XML serialization of the given node.
-     *
-     * @param node - node to serialize
-     * @param writerOptions - serialization options
-     */
-    serialize(node) {
-        // convert to object
-        const objectWriterOptions = (0, util_1.applyDefaults)(this._writerOptions, {
-            format: "object",
-            wellFormed: false
-        });
-        const objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions, objectWriterOptions);
-        const val = objectWriter.serialize(node);
-        // recursively convert object into JSON string
-        return this._beginLine(this._writerOptions, 0) + this._convertObject(val, this._writerOptions);
-    }
-    /**
-     * Produces an XML serialization of the given object.
-     *
-     * @param obj - object to serialize
-     * @param options - serialization options
-     * @param level - depth of the XML tree
-     */
-    _convertObject(obj, options, level = 0) {
-        let markup = '';
-        const isLeaf = this._isLeafNode(obj);
-        if ((0, util_1.isArray)(obj)) {
-            markup += '[';
-            const len = obj.length;
-            let i = 0;
-            for (const val of obj) {
-                markup += this._endLine(options, level + 1) +
-                    this._beginLine(options, level + 1) +
-                    this._convertObject(val, options, level + 1);
-                if (i < len - 1) {
-                    markup += ',';
-                }
-                i++;
-            }
-            markup += this._endLine(options, level) + this._beginLine(options, level);
-            markup += ']';
-        }
-        else if ((0, util_1.isObject)(obj)) {
-            markup += '{';
-            const len = (0, util_1.objectLength)(obj);
-            let i = 0;
-            (0, util_1.forEachObject)(obj, (key, val) => {
-                if (isLeaf && options.prettyPrint) {
-                    markup += ' ';
-                }
-                else {
-                    markup += this._endLine(options, level + 1) + this._beginLine(options, level + 1);
-                }
-                markup += this._key(key);
-                if (options.prettyPrint) {
-                    markup += ' ';
-                }
-                markup += this._convertObject(val, options, level + 1);
-                if (i < len - 1) {
-                    markup += ',';
-                }
-                i++;
-            }, this);
-            if (isLeaf && options.prettyPrint) {
-                markup += ' ';
-            }
-            else {
-                markup += this._endLine(options, level) + this._beginLine(options, level);
-            }
-            markup += '}';
-        }
-        else {
-            markup += this._val(obj);
-        }
-        return markup;
-    }
-    /**
-     * Produces characters to be prepended to a line of string in pretty-print
-     * mode.
-     *
-     * @param options - serialization options
-     * @param level - current depth of the XML tree
-     */
-    _beginLine(options, level) {
-        if (!options.prettyPrint) {
-            return '';
-        }
-        else {
-            const indentLevel = options.offset + level + 1;
-            if (indentLevel > 0) {
-                return new Array(indentLevel).join(options.indent);
-            }
-        }
-        return '';
-    }
-    /**
-     * Produces characters to be appended to a line of string in pretty-print
-     * mode.
-     *
-     * @param options - serialization options
-     * @param level - current depth of the XML tree
-     */
-    _endLine(options, level) {
-        if (!options.prettyPrint) {
-            return '';
-        }
-        else {
-            return options.newline;
-        }
-    }
-    /**
-     * Produces a JSON key string delimited with double quotes.
-     */
-    _key(key) {
-        return "\"" + key + "\":";
-    }
-    /**
-     * Produces a JSON value string delimited with double quotes.
-     */
-    _val(val) {
-        return JSON.stringify(val);
-    }
-    /**
-     * Determines if an object is a leaf node.
-     *
-     * @param obj
-     */
-    _isLeafNode(obj) {
-        return this._descendantCount(obj) <= 1;
-    }
-    /**
-     * Counts the number of descendants of the given object.
-     *
-     * @param obj
-     * @param count
-     */
-    _descendantCount(obj, count = 0) {
-        if ((0, util_1.isArray)(obj)) {
-            (0, util_1.forEachArray)(obj, val => count += this._descendantCount(val, count), this);
-        }
-        else if ((0, util_1.isObject)(obj)) {
-            (0, util_1.forEachObject)(obj, (key, val) => count += this._descendantCount(val, count), this);
-        }
-        else {
-            count++;
-        }
-        return count;
-    }
-}
-exports.JSONWriter = JSONWriter;
-//# sourceMappingURL=JSONWriter.js.map
-
-/***/ }),
-
-/***/ 99675:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.MapWriter = void 0;
-const util_1 = __nccwpck_require__(76195);
-const ObjectWriter_1 = __nccwpck_require__(24393);
-const BaseWriter_1 = __nccwpck_require__(24189);
-/**
- * Serializes XML nodes into ES6 maps and arrays.
- */
-class MapWriter extends BaseWriter_1.BaseWriter {
-    /**
-     * Initializes a new instance of `MapWriter`.
-     *
-     * @param builderOptions - XML builder options
-     * @param writerOptions - serialization options
-     */
-    constructor(builderOptions, writerOptions) {
-        super(builderOptions);
-        // provide default options
-        this._writerOptions = (0, util_1.applyDefaults)(writerOptions, {
-            format: "map",
-            wellFormed: false,
-            group: false,
-            verbose: false
-        });
-    }
-    /**
-     * Produces an XML serialization of the given node.
-     *
-     * @param node - node to serialize
-     */
-    serialize(node) {
-        // convert to object
-        const objectWriterOptions = (0, util_1.applyDefaults)(this._writerOptions, {
-            format: "object",
-            wellFormed: false,
-            verbose: false
-        });
-        const objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions, objectWriterOptions);
-        const val = objectWriter.serialize(node);
-        // recursively convert object into Map
-        return this._convertObject(val);
-    }
-    /**
-     * Recursively converts a JS object into an ES5 map.
-     *
-     * @param obj - a JS object
-     */
-    _convertObject(obj) {
-        if ((0, util_1.isArray)(obj)) {
-            for (let i = 0; i < obj.length; i++) {
-                obj[i] = this._convertObject(obj[i]);
-            }
-            return obj;
-        }
-        else if ((0, util_1.isObject)(obj)) {
-            const map = new Map();
-            for (const key in obj) {
-                map.set(key, this._convertObject(obj[key]));
-            }
-            return map;
-        }
-        else {
-            return obj;
-        }
-    }
-}
-exports.MapWriter = MapWriter;
-//# sourceMappingURL=MapWriter.js.map
-
-/***/ }),
-
-/***/ 24393:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.ObjectWriter = void 0;
-const util_1 = __nccwpck_require__(76195);
-const interfaces_1 = __nccwpck_require__(27305);
-const BaseWriter_1 = __nccwpck_require__(24189);
-/**
- * Serializes XML nodes into objects and arrays.
- */
-class ObjectWriter extends BaseWriter_1.BaseWriter {
-    _currentList;
-    _currentIndex;
-    _listRegister;
-    /**
-     * Initializes a new instance of `ObjectWriter`.
-     *
-     * @param builderOptions - XML builder options
-     * @param writerOptions - serialization options
-     */
-    constructor(builderOptions, writerOptions) {
-        super(builderOptions);
-        this._writerOptions = (0, util_1.applyDefaults)(writerOptions, {
-            format: "object",
-            wellFormed: false,
-            group: false,
-            verbose: false
-        });
-    }
-    /**
-     * Produces an XML serialization of the given node.
-     *
-     * @param node - node to serialize
-     */
-    serialize(node) {
-        this._currentList = [];
-        this._currentIndex = 0;
-        this._listRegister = [this._currentList];
-        /**
-         * First pass, serialize nodes
-         * This creates a list of nodes grouped under node types while preserving
-         * insertion order. For example:
-         * [
-         *   root: [
-         *     node: [
-         *       { "@" : { "att1": "val1", "att2": "val2" }
-         *       { "#": "node text" }
-         *       { childNode: [] }
-         *       { "#": "more text" }
-         *     ],
-         *     node: [
-         *       { "@" : { "att": "val" }
-         *       { "#": [ "text line1", "text line2" ] }
-         *     ]
-         *   ]
-         * ]
-         */
-        this.serializeNode(node, this._writerOptions.wellFormed);
-        /**
-         * Second pass, process node lists. Above example becomes:
-         * {
-         *   root: {
-         *     node: [
-         *       {
-         *         "@att1": "val1",
-         *         "@att2": "val2",
-         *         "#1": "node text",
-         *         childNode: {},
-         *         "#2": "more text"
-         *       },
-         *       {
-         *         "@att": "val",
-         *         "#": [ "text line1", "text line2" ]
-         *       }
-         *     ]
-         *   }
-         * }
-         */
-        return this._process(this._currentList, this._writerOptions);
-    }
-    _process(items, options) {
-        if (items.length === 0)
-            return {};
-        // determine if there are non-unique element names
-        const namesSeen = {};
-        let hasNonUniqueNames = false;
-        let textCount = 0;
-        let commentCount = 0;
-        let instructionCount = 0;
-        let cdataCount = 0;
-        for (let i = 0; i < items.length; i++) {
-            const item = items[i];
-            const key = Object.keys(item)[0];
-            switch (key) {
-                case "@":
-                    continue;
-                case "#":
-                    textCount++;
-                    break;
-                case "!":
-                    commentCount++;
-                    break;
-                case "?":
-                    instructionCount++;
-                    break;
-                case "$":
-                    cdataCount++;
-                    break;
-                default:
-                    if (namesSeen[key]) {
-                        hasNonUniqueNames = true;
-                    }
-                    else {
-                        namesSeen[key] = true;
-                    }
-                    break;
-            }
-        }
-        const defAttrKey = this._getAttrKey();
-        const defTextKey = this._getNodeKey(interfaces_1.NodeType.Text);
-        const defCommentKey = this._getNodeKey(interfaces_1.NodeType.Comment);
-        const defInstructionKey = this._getNodeKey(interfaces_1.NodeType.ProcessingInstruction);
-        const defCdataKey = this._getNodeKey(interfaces_1.NodeType.CData);
-        if (textCount === 1 && items.length === 1 && (0, util_1.isString)(items[0]["#"])) {
-            // special case of an element node with a single text node
-            return items[0]["#"];
-        }
-        else if (hasNonUniqueNames) {
-            const obj = {};
-            // process attributes first
-            for (let i = 0; i < items.length; i++) {
-                const item = items[i];
-                const key = Object.keys(item)[0];
-                if (key === "@") {
-                    const attrs = item["@"];
-                    const attrKeys = Object.keys(attrs);
-                    if (!options.group || attrKeys.length === 1) {
-                        for (const attrName in attrs) {
-                            obj[defAttrKey + attrName] = attrs[attrName];
-                        }
-                    }
-                    else {
-                        obj[defAttrKey] = attrs;
-                    }
-                }
-            }
-            // list contains element nodes with non-unique names
-            // return an array with mixed content notation
-            const result = [];
-            for (let i = 0; i < items.length; i++) {
-                const item = items[i];
-                const key = Object.keys(item)[0];
-                switch (key) {
-                    case "@":
-                        // attributes were processed above
-                        break;
-                    case "#":
-                        result.push({ [defTextKey]: item["#"] });
-                        break;
-                    case "!":
-                        result.push({ [defCommentKey]: item["!"] });
-                        break;
-                    case "?":
-                        result.push({ [defInstructionKey]: item["?"] });
-                        break;
-                    case "$":
-                        result.push({ [defCdataKey]: item["$"] });
-                        break;
-                    default:
-                        // element node
-                        const ele = item;
-                        if (ele[key].length !== 0 && (0, util_1.isArray)(ele[key][0])) {
-                            // group of element nodes
-                            const eleGroup = [];
-                            const listOfLists = ele[key];
-                            for (let i = 0; i < listOfLists.length; i++) {
-                                eleGroup.push(this._process(listOfLists[i], options));
-                            }
-                            result.push({ [key]: eleGroup });
-                        }
-                        else {
-                            // single element node
-                            if (options.verbose) {
-                                result.push({ [key]: [this._process(ele[key], options)] });
-                            }
-                            else {
-                                result.push({ [key]: this._process(ele[key], options) });
-                            }
-                        }
-                        break;
-                }
-            }
-            obj[defTextKey] = result;
-            return obj;
-        }
-        else {
-            // all element nodes have unique names
-            // return an object while prefixing data node keys
-            let textId = 1;
-            let commentId = 1;
-            let instructionId = 1;
-            let cdataId = 1;
-            const obj = {};
-            for (let i = 0; i < items.length; i++) {
-                const item = items[i];
-                const key = Object.keys(item)[0];
-                switch (key) {
-                    case "@":
-                        const attrs = item["@"];
-                        const attrKeys = Object.keys(attrs);
-                        if (!options.group || attrKeys.length === 1) {
-                            for (const attrName in attrs) {
-                                obj[defAttrKey + attrName] = attrs[attrName];
-                            }
-                        }
-                        else {
-                            obj[defAttrKey] = attrs;
-                        }
-                        break;
-                    case "#":
-                        textId = this._processSpecItem(item["#"], obj, options.group, defTextKey, textCount, textId);
-                        break;
-                    case "!":
-                        commentId = this._processSpecItem(item["!"], obj, options.group, defCommentKey, commentCount, commentId);
-                        break;
-                    case "?":
-                        instructionId = this._processSpecItem(item["?"], obj, options.group, defInstructionKey, instructionCount, instructionId);
-                        break;
-                    case "$":
-                        cdataId = this._processSpecItem(item["$"], obj, options.group, defCdataKey, cdataCount, cdataId);
-                        break;
-                    default:
-                        // element node
-                        const ele = item;
-                        if (ele[key].length !== 0 && (0, util_1.isArray)(ele[key][0])) {
-                            // group of element nodes
-                            const eleGroup = [];
-                            const listOfLists = ele[key];
-                            for (let i = 0; i < listOfLists.length; i++) {
-                                eleGroup.push(this._process(listOfLists[i], options));
-                            }
-                            obj[key] = eleGroup;
-                        }
-                        else {
-                            // single element node
-                            if (options.verbose) {
-                                obj[key] = [this._process(ele[key], options)];
-                            }
-                            else {
-                                obj[key] = this._process(ele[key], options);
-                            }
-                        }
-                        break;
-                }
-            }
-            return obj;
-        }
-    }
-    _processSpecItem(item, obj, group, defKey, count, id) {
-        if (!group && (0, util_1.isArray)(item) && count + item.length > 2) {
-            for (const subItem of item) {
-                const key = defKey + (id++).toString();
-                obj[key] = subItem;
-            }
-        }
-        else {
-            const key = count > 1 ? defKey + (id++).toString() : defKey;
-            obj[key] = item;
-        }
-        return id;
-    }
-    /** @inheritdoc */
-    beginElement(name) {
-        const childItems = [];
-        if (this._currentList.length === 0) {
-            this._currentList.push({ [name]: childItems });
-        }
-        else {
-            const lastItem = this._currentList[this._currentList.length - 1];
-            if (this._isElementNode(lastItem, name)) {
-                if (lastItem[name].length !== 0 && (0, util_1.isArray)(lastItem[name][0])) {
-                    const listOfLists = lastItem[name];
-                    listOfLists.push(childItems);
-                }
-                else {
-                    lastItem[name] = [lastItem[name], childItems];
-                }
-            }
-            else {
-                this._currentList.push({ [name]: childItems });
-            }
-        }
-        this._currentIndex++;
-        if (this._listRegister.length > this._currentIndex) {
-            this._listRegister[this._currentIndex] = childItems;
-        }
-        else {
-            this._listRegister.push(childItems);
-        }
-        this._currentList = childItems;
-    }
-    /** @inheritdoc */
-    endElement() {
-        this._currentList = this._listRegister[--this._currentIndex];
-    }
-    /** @inheritdoc */
-    attribute(name, value) {
-        if (this._currentList.length === 0) {
-            this._currentList.push({ "@": { [name]: value } });
-        }
-        else {
-            const lastItem = this._currentList[this._currentList.length - 1];
-            /* istanbul ignore else */
-            if (this._isAttrNode(lastItem)) {
-                lastItem["@"][name] = value;
-            }
-            else {
-                this._currentList.push({ "@": { [name]: value } });
-            }
-        }
-    }
-    /** @inheritdoc */
-    comment(data) {
-        if (this._currentList.length === 0) {
-            this._currentList.push({ "!": data });
-        }
-        else {
-            const lastItem = this._currentList[this._currentList.length - 1];
-            if (this._isCommentNode(lastItem)) {
-                if ((0, util_1.isArray)(lastItem["!"])) {
-                    lastItem["!"].push(data);
-                }
-                else {
-                    lastItem["!"] = [lastItem["!"], data];
-                }
-            }
-            else {
-                this._currentList.push({ "!": data });
-            }
-        }
-    }
-    /** @inheritdoc */
-    text(data) {
-        if (this._currentList.length === 0) {
-            this._currentList.push({ "#": data });
-        }
-        else {
-            const lastItem = this._currentList[this._currentList.length - 1];
-            if (this._isTextNode(lastItem)) {
-                if ((0, util_1.isArray)(lastItem["#"])) {
-                    lastItem["#"].push(data);
-                }
-                else {
-                    lastItem["#"] = [lastItem["#"], data];
-                }
-            }
-            else {
-                this._currentList.push({ "#": data });
-            }
-        }
-    }
-    /** @inheritdoc */
-    instruction(target, data) {
-        const value = (data === "" ? target : target + " " + data);
-        if (this._currentList.length === 0) {
-            this._currentList.push({ "?": value });
-        }
-        else {
-            const lastItem = this._currentList[this._currentList.length - 1];
-            if (this._isInstructionNode(lastItem)) {
-                if ((0, util_1.isArray)(lastItem["?"])) {
-                    lastItem["?"].push(value);
-                }
-                else {
-                    lastItem["?"] = [lastItem["?"], value];
-                }
-            }
-            else {
-                this._currentList.push({ "?": value });
-            }
-        }
-    }
-    /** @inheritdoc */
-    cdata(data) {
-        if (this._currentList.length === 0) {
-            this._currentList.push({ "$": data });
-        }
-        else {
-            const lastItem = this._currentList[this._currentList.length - 1];
-            if (this._isCDATANode(lastItem)) {
-                if ((0, util_1.isArray)(lastItem["$"])) {
-                    lastItem["$"].push(data);
-                }
-                else {
-                    lastItem["$"] = [lastItem["$"], data];
-                }
-            }
-            else {
-                this._currentList.push({ "$": data });
-            }
-        }
-    }
-    _isAttrNode(x) {
-        return "@" in x;
-    }
-    _isTextNode(x) {
-        return "#" in x;
-    }
-    _isCommentNode(x) {
-        return "!" in x;
-    }
-    _isInstructionNode(x) {
-        return "?" in x;
-    }
-    _isCDATANode(x) {
-        return "$" in x;
-    }
-    _isElementNode(x, name) {
-        return name in x;
-    }
-    /**
-     * Returns an object key for an attribute or namespace declaration.
-     */
-    _getAttrKey() {
-        return this._builderOptions.convert.att;
-    }
-    /**
-     * Returns an object key for the given node type.
-     *
-     * @param nodeType - node type to get a key for
-     */
-    _getNodeKey(nodeType) {
-        switch (nodeType) {
-            case interfaces_1.NodeType.Comment:
-                return this._builderOptions.convert.comment;
-            case interfaces_1.NodeType.Text:
-                return this._builderOptions.convert.text;
-            case interfaces_1.NodeType.ProcessingInstruction:
-                return this._builderOptions.convert.ins;
-            case interfaces_1.NodeType.CData:
-                return this._builderOptions.convert.cdata;
-            /* istanbul ignore next */
-            default:
-                throw new Error("Invalid node type.");
-        }
-    }
-}
-exports.ObjectWriter = ObjectWriter;
-//# sourceMappingURL=ObjectWriter.js.map
-
-/***/ }),
-
-/***/ 7299:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLCBWriter = void 0;
-const BaseCBWriter_1 = __nccwpck_require__(63210);
-/**
- * Serializes XML nodes.
- */
-class XMLCBWriter extends BaseCBWriter_1.BaseCBWriter {
-    _lineLength = 0;
-    /**
-     * Initializes a new instance of `XMLCBWriter`.
-     *
-     * @param builderOptions - XML builder options
-     */
-    constructor(builderOptions) {
-        super(builderOptions);
-    }
-    /** @inheritdoc */
-    frontMatter() {
-        return "";
-    }
-    /** @inheritdoc */
-    declaration(version, encoding, standalone) {
-        let markup = this._beginLine() + "<?xml";
-        markup += " version=\"" + version + "\"";
-        if (encoding !== undefined) {
-            markup += " encoding=\"" + encoding + "\"";
-        }
-        if (standalone !== undefined) {
-            markup += " standalone=\"" + (standalone ? "yes" : "no") + "\"";
-        }
-        markup += "?>";
-        return markup;
-    }
-    /** @inheritdoc */
-    docType(name, publicId, systemId) {
-        let markup = this._beginLine();
-        if (publicId && systemId) {
-            markup += "<!DOCTYPE " + name + " PUBLIC \"" + publicId + "\" \"" + systemId + "\">";
-        }
-        else if (publicId) {
-            markup += "<!DOCTYPE " + name + " PUBLIC \"" + publicId + "\">";
-        }
-        else if (systemId) {
-            markup += "<!DOCTYPE " + name + " SYSTEM \"" + systemId + "\">";
-        }
-        else {
-            markup += "<!DOCTYPE " + name + ">";
-        }
-        return markup;
-    }
-    /** @inheritdoc */
-    comment(data) {
-        return this._beginLine() + "<!--" + data + "-->";
-    }
-    /** @inheritdoc */
-    text(data) {
-        return data;
-    }
-    /** @inheritdoc */
-    instruction(target, data) {
-        if (data) {
-            return this._beginLine() + "<?" + target + " " + data + "?>";
-        }
-        else {
-            return this._beginLine() + "<?" + target + "?>";
-        }
-    }
-    /** @inheritdoc */
-    cdata(data) {
-        return this._beginLine() + "<![CDATA[" + data + "]]>";
-    }
-    /** @inheritdoc */
-    openTagBegin(name) {
-        this._lineLength += 1 + name.length;
-        return this._beginLine() + "<" + name;
-    }
-    /** @inheritdoc */
-    openTagEnd(name, selfClosing, voidElement) {
-        if (voidElement) {
-            return " />";
-        }
-        else if (selfClosing) {
-            if (this._writerOptions.allowEmptyTags) {
-                return "></" + name + ">";
-            }
-            else if (this._writerOptions.spaceBeforeSlash) {
-                return " />";
-            }
-            else {
-                return "/>";
-            }
-        }
-        else {
-            return ">";
-        }
-    }
-    /** @inheritdoc */
-    closeTag(name, hasTextPayload) {
-        const ending = hasTextPayload ? '' : this._beginLine();
-        return ending + "</" + name + ">";
-    }
-    /** @inheritdoc */
-    attribute(name, value) {
-        let str = name + "=\"" + value + "\"";
-        if (this._writerOptions.prettyPrint && this._writerOptions.width > 0 &&
-            this._lineLength + 1 + str.length > this._writerOptions.width) {
-            str = this._beginLine() + this._indent(1) + str;
-            this._lineLength = str.length;
-            return str;
-        }
-        else {
-            this._lineLength += 1 + str.length;
-            return " " + str;
-        }
-    }
-    /** @inheritdoc */
-    beginElement(name) { }
-    /** @inheritdoc */
-    endElement(name) { }
-    /**
-     * Produces characters to be prepended to a line of string in pretty-print
-     * mode.
-     */
-    _beginLine() {
-        if (this._writerOptions.prettyPrint) {
-            const str = (this.hasData ? this._writerOptions.newline : "") +
-                this._indent(this._writerOptions.offset + this.level);
-            this._lineLength = str.length;
-            return str;
-        }
-        else {
-            return "";
-        }
-    }
-    /**
-     * Produces an indentation string.
-     *
-     * @param level - depth of the tree
-     */
-    _indent(level) {
-        if (level <= 0) {
-            return "";
-        }
-        else {
-            return this._writerOptions.indent.repeat(level);
-        }
-    }
-}
-exports.XMLCBWriter = XMLCBWriter;
-//# sourceMappingURL=XMLCBWriter.js.map
-
-/***/ }),
-
-/***/ 68998:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.XMLWriter = void 0;
-const util_1 = __nccwpck_require__(76195);
-const interfaces_1 = __nccwpck_require__(27305);
-const BaseWriter_1 = __nccwpck_require__(24189);
-const util_2 = __nccwpck_require__(65282);
-/**
- * Serializes XML nodes into strings.
- */
-class XMLWriter extends BaseWriter_1.BaseWriter {
-    _refs;
-    _indentation = {};
-    _lengthToLastNewline = 0;
-    /**
-     * Initializes a new instance of `XMLWriter`.
-     *
-     * @param builderOptions - XML builder options
-     * @param writerOptions - serialization options
-     */
-    constructor(builderOptions, writerOptions) {
-        super(builderOptions);
-        // provide default options
-        this._writerOptions = (0, util_1.applyDefaults)(writerOptions, {
-            wellFormed: false,
-            headless: false,
-            prettyPrint: false,
-            indent: "  ",
-            newline: "\n",
-            offset: 0,
-            width: 0,
-            allowEmptyTags: false,
-            indentTextOnlyNodes: false,
-            spaceBeforeSlash: false
-        });
-    }
-    /**
-     * Produces an XML serialization of the given node.
-     *
-     * @param node - node to serialize
-     */
-    serialize(node) {
-        this._refs = { suppressPretty: false, emptyNode: false, markup: "" };
-        // Serialize XML declaration
-        if (node.nodeType === interfaces_1.NodeType.Document && !this._writerOptions.headless) {
-            this.declaration(this._builderOptions.version, this._builderOptions.encoding, this._builderOptions.standalone);
-        }
-        // recursively serialize node
-        this.serializeNode(node, this._writerOptions.wellFormed);
-        // remove trailing newline
-        if (this._writerOptions.prettyPrint &&
-            this._refs.markup.slice(-this._writerOptions.newline.length) === this._writerOptions.newline) {
-            this._refs.markup = this._refs.markup.slice(0, -this._writerOptions.newline.length);
-        }
-        return this._refs.markup;
-    }
-    /** @inheritdoc */
-    declaration(version, encoding, standalone) {
-        this._beginLine();
-        this._refs.markup += "<?xml version=\"" + version + "\"";
-        if (encoding !== undefined) {
-            this._refs.markup += " encoding=\"" + encoding + "\"";
-        }
-        if (standalone !== undefined) {
-            this._refs.markup += " standalone=\"" + (standalone ? "yes" : "no") + "\"";
-        }
-        this._refs.markup += "?>";
-        this._endLine();
-    }
-    /** @inheritdoc */
-    docType(name, publicId, systemId) {
-        this._beginLine();
-        if (publicId && systemId) {
-            this._refs.markup += "<!DOCTYPE " + name + " PUBLIC \"" + publicId + "\" \"" + systemId + "\">";
-        }
-        else if (publicId) {
-            this._refs.markup += "<!DOCTYPE " + name + " PUBLIC \"" + publicId + "\">";
-        }
-        else if (systemId) {
-            this._refs.markup += "<!DOCTYPE " + name + " SYSTEM \"" + systemId + "\">";
-        }
-        else {
-            this._refs.markup += "<!DOCTYPE " + name + ">";
-        }
-        this._endLine();
-    }
-    /** @inheritdoc */
-    openTagBegin(name) {
-        this._beginLine();
-        this._refs.markup += "<" + name;
-    }
-    /** @inheritdoc */
-    openTagEnd(name, selfClosing, voidElement) {
-        // do not indent text only elements or elements with empty text nodes
-        this._refs.suppressPretty = false;
-        this._refs.emptyNode = false;
-        if (this._writerOptions.prettyPrint && !selfClosing && !voidElement) {
-            let textOnlyNode = true;
-            let emptyNode = true;
-            let childNode = this.currentNode.firstChild;
-            let cdataCount = 0;
-            let textCount = 0;
-            while (childNode) {
-                if (util_2.Guard.isExclusiveTextNode(childNode)) {
-                    textCount++;
-                }
-                else if (util_2.Guard.isCDATASectionNode(childNode)) {
-                    cdataCount++;
-                }
-                else {
-                    textOnlyNode = false;
-                    emptyNode = false;
-                    break;
-                }
-                if (childNode.data !== '') {
-                    emptyNode = false;
-                }
-                childNode = childNode.nextSibling;
-            }
-            this._refs.suppressPretty = !this._writerOptions.indentTextOnlyNodes && textOnlyNode && ((cdataCount <= 1 && textCount === 0) || cdataCount === 0);
-            this._refs.emptyNode = emptyNode;
-        }
-        if ((voidElement || selfClosing || this._refs.emptyNode) && this._writerOptions.allowEmptyTags) {
-            this._refs.markup += "></" + name + ">";
-        }
-        else {
-            this._refs.markup += voidElement ? " />" :
-                (selfClosing || this._refs.emptyNode) ? (this._writerOptions.spaceBeforeSlash ? " />" : "/>") : ">";
-        }
-        this._endLine();
-    }
-    /** @inheritdoc */
-    closeTag(name) {
-        if (!this._refs.emptyNode) {
-            this._beginLine();
-            this._refs.markup += "</" + name + ">";
-        }
-        this._refs.suppressPretty = false;
-        this._refs.emptyNode = false;
-        this._endLine();
-    }
-    /** @inheritdoc */
-    attribute(name, value) {
-        const str = name + "=\"" + value + "\"";
-        if (this._writerOptions.prettyPrint && this._writerOptions.width > 0 &&
-            this._refs.markup.length - this._lengthToLastNewline + 1 + str.length > this._writerOptions.width) {
-            this._endLine();
-            this._beginLine();
-            this._refs.markup += this._indent(1) + str;
-        }
-        else {
-            this._refs.markup += " " + str;
-        }
-    }
-    /** @inheritdoc */
-    text(data) {
-        if (data !== '') {
-            this._beginLine();
-            this._refs.markup += data;
-            this._endLine();
-        }
-    }
-    /** @inheritdoc */
-    cdata(data) {
-        if (data !== '') {
-            this._beginLine();
-            this._refs.markup += "<![CDATA[" + data + "]]>";
-            this._endLine();
-        }
-    }
-    /** @inheritdoc */
-    comment(data) {
-        this._beginLine();
-        this._refs.markup += "<!--" + data + "-->";
-        this._endLine();
-    }
-    /** @inheritdoc */
-    instruction(target, data) {
-        this._beginLine();
-        this._refs.markup += "<?" + (data === "" ? target : target + " " + data) + "?>";
-        this._endLine();
-    }
-    /**
-     * Produces characters to be prepended to a line of string in pretty-print
-     * mode.
-     */
-    _beginLine() {
-        if (this._writerOptions.prettyPrint && !this._refs.suppressPretty) {
-            this._refs.markup += this._indent(this._writerOptions.offset + this.level);
-        }
-    }
-    /**
-     * Produces characters to be appended to a line of string in pretty-print
-     * mode.
-     */
-    _endLine() {
-        if (this._writerOptions.prettyPrint && !this._refs.suppressPretty) {
-            this._refs.markup += this._writerOptions.newline;
-            this._lengthToLastNewline = this._refs.markup.length;
-        }
-    }
-    /**
-     * Produces an indentation string.
-     *
-     * @param level - depth of the tree
-     */
-    _indent(level) {
-        if (level <= 0) {
-            return "";
-        }
-        else if (this._indentation[level] !== undefined) {
-            return this._indentation[level];
-        }
-        else {
-            const str = this._writerOptions.indent.repeat(level);
-            this._indentation[level] = str;
-            return str;
-        }
-    }
-}
-exports.XMLWriter = XMLWriter;
-//# sourceMappingURL=XMLWriter.js.map
-
-/***/ }),
-
-/***/ 32770:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.YAMLCBWriter = void 0;
-const BaseCBWriter_1 = __nccwpck_require__(63210);
-/**
- * Serializes XML nodes.
- */
-class YAMLCBWriter extends BaseCBWriter_1.BaseCBWriter {
-    _rootWritten = false;
-    _additionalLevel = 0;
-    /**
-     * Initializes a new instance of `BaseCBWriter`.
-     *
-     * @param builderOptions - XML builder options
-     */
-    constructor(builderOptions) {
-        super(builderOptions);
-        if (builderOptions.indent.length < 2) {
-            throw new Error("YAML indententation string must be at least two characters long.");
-        }
-        if (builderOptions.offset < 0) {
-            throw new Error("YAML offset should be zero or a positive number.");
-        }
-    }
-    /** @inheritdoc */
-    frontMatter() {
-        return this._beginLine() + "---";
-    }
-    /** @inheritdoc */
-    declaration(version, encoding, standalone) {
-        return "";
-    }
-    /** @inheritdoc */
-    docType(name, publicId, systemId) {
-        return "";
-    }
-    /** @inheritdoc */
-    comment(data) {
-        // "!": "hello"
-        return this._beginLine() +
-            this._key(this._builderOptions.convert.comment) + " " +
-            this._val(data);
-    }
-    /** @inheritdoc */
-    text(data) {
-        // "#": "hello"
-        return this._beginLine() +
-            this._key(this._builderOptions.convert.text) + " " +
-            this._val(data);
-    }
-    /** @inheritdoc */
-    instruction(target, data) {
-        // "?": "target hello"
-        return this._beginLine() +
-            this._key(this._builderOptions.convert.ins) + " " +
-            this._val(data ? target + " " + data : target);
-    }
-    /** @inheritdoc */
-    cdata(data) {
-        // "$": "hello"
-        return this._beginLine() +
-            this._key(this._builderOptions.convert.cdata) + " " +
-            this._val(data);
-    }
-    /** @inheritdoc */
-    attribute(name, value) {
-        // "@name": "val"
-        this._additionalLevel++;
-        const str = this._beginLine() +
-            this._key(this._builderOptions.convert.att + name) + " " +
-            this._val(value);
-        this._additionalLevel--;
-        return str;
-    }
-    /** @inheritdoc */
-    openTagBegin(name) {
-        // "node":
-        //   "#":
-        //   -
-        let str = this._beginLine() + this._key(name);
-        if (!this._rootWritten) {
-            this._rootWritten = true;
-        }
-        this.hasData = true;
-        this._additionalLevel++;
-        str += this._beginLine(true) + this._key(this._builderOptions.convert.text);
-        return str;
-    }
-    /** @inheritdoc */
-    openTagEnd(name, selfClosing, voidElement) {
-        if (selfClosing) {
-            return " " + this._val("");
-        }
-        return "";
-    }
-    /** @inheritdoc */
-    closeTag(name) {
-        this._additionalLevel--;
-        return "";
-    }
-    /** @inheritdoc */
-    beginElement(name) { }
-    /** @inheritdoc */
-    endElement(name) { }
-    /**
-     * Produces characters to be prepended to a line of string in pretty-print
-     * mode.
-     */
-    _beginLine(suppressArray = false) {
-        return (this.hasData ? this._writerOptions.newline : "") +
-            this._indent(this._writerOptions.offset + this.level, suppressArray);
-    }
-    /**
-     * Produces an indentation string.
-     *
-     * @param level - depth of the tree
-     * @param suppressArray - whether the suppress array marker
-     */
-    _indent(level, suppressArray) {
-        if (level + this._additionalLevel <= 0) {
-            return "";
-        }
-        else {
-            const chars = this._writerOptions.indent.repeat(level + this._additionalLevel);
-            if (!suppressArray && this._rootWritten) {
-                return chars.substr(0, chars.length - 2) + '-' + chars.substr(-1, 1);
-            }
-            return chars;
-        }
-    }
-    /**
-     * Produces a YAML key string delimited with double quotes.
-     */
-    _key(key) {
-        return "\"" + key + "\":";
-    }
-    /**
-     * Produces a YAML value string delimited with double quotes.
-     */
-    _val(val) {
-        return JSON.stringify(val);
-    }
-}
-exports.YAMLCBWriter = YAMLCBWriter;
-//# sourceMappingURL=YAMLCBWriter.js.map
-
-/***/ }),
-
-/***/ 60469:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.YAMLWriter = void 0;
-const ObjectWriter_1 = __nccwpck_require__(24393);
-const util_1 = __nccwpck_require__(76195);
-const BaseWriter_1 = __nccwpck_require__(24189);
-/**
- * Serializes XML nodes into a YAML string.
- */
-class YAMLWriter extends BaseWriter_1.BaseWriter {
-    /**
-     * Initializes a new instance of `YAMLWriter`.
-     *
-     * @param builderOptions - XML builder options
-     * @param writerOptions - serialization options
-     */
-    constructor(builderOptions, writerOptions) {
-        super(builderOptions);
-        // provide default options
-        this._writerOptions = (0, util_1.applyDefaults)(writerOptions, {
-            wellFormed: false,
-            indent: '  ',
-            newline: '\n',
-            offset: 0,
-            group: false,
-            verbose: false
-        });
-        if (this._writerOptions.indent.length < 2) {
-            throw new Error("YAML indententation string must be at least two characters long.");
-        }
-        if (this._writerOptions.offset < 0) {
-            throw new Error("YAML offset should be zero or a positive number.");
-        }
-    }
-    /**
-     * Produces an XML serialization of the given node.
-     *
-     * @param node - node to serialize
-     * @param writerOptions - serialization options
-     */
-    serialize(node) {
-        // convert to object
-        const objectWriterOptions = (0, util_1.applyDefaults)(this._writerOptions, {
-            format: "object",
-            wellFormed: false
-        });
-        const objectWriter = new ObjectWriter_1.ObjectWriter(this._builderOptions, objectWriterOptions);
-        const val = objectWriter.serialize(node);
-        let markup = this._beginLine(this._writerOptions, 0) + '---' + this._endLine(this._writerOptions) +
-            this._convertObject(val, this._writerOptions, 0);
-        // remove trailing newline
-        /* istanbul ignore else */
-        if (markup.slice(-this._writerOptions.newline.length) === this._writerOptions.newline) {
-            markup = markup.slice(0, -this._writerOptions.newline.length);
-        }
-        return markup;
-    }
-    /**
-     * Produces an XML serialization of the given object.
-     *
-     * @param obj - object to serialize
-     * @param options - serialization options
-     * @param level - depth of the XML tree
-     * @param indentLeaf - indents leaf nodes
-     */
-    _convertObject(obj, options, level, suppressIndent = false) {
-        let markup = '';
-        if ((0, util_1.isArray)(obj)) {
-            for (const val of obj) {
-                markup += this._beginLine(options, level, true);
-                if (!(0, util_1.isObject)(val)) {
-                    markup += this._val(val) + this._endLine(options);
-                }
-                else if ((0, util_1.isEmpty)(val)) {
-                    markup += '""' + this._endLine(options);
-                }
-                else {
-                    markup += this._convertObject(val, options, level, true);
-                }
-            }
-        }
-        else /* if (isObject(obj)) */ {
-            (0, util_1.forEachObject)(obj, (key, val) => {
-                if (suppressIndent) {
-                    markup += this._key(key);
-                    suppressIndent = false;
-                }
-                else {
-                    markup += this._beginLine(options, level) + this._key(key);
-                }
-                if (!(0, util_1.isObject)(val) && !(0, util_1.isArray)(val)) {
-                    markup += ' ' + this._val(val) + this._endLine(options);
-                }
-                else if ((0, util_1.isEmpty)(val)) {
-                    markup += ' ""' + this._endLine(options);
-                }
-                else {
-                    markup += this._endLine(options) +
-                        this._convertObject(val, options, level + 1);
-                }
-            }, this);
-        }
-        return markup;
-    }
-    /**
-     * Produces characters to be prepended to a line of string in pretty-print
-     * mode.
-     *
-     * @param options - serialization options
-     * @param level - current depth of the XML tree
-     * @param isArray - whether this line is an array item
-     */
-    _beginLine(options, level, isArray = false) {
-        const indentLevel = options.offset + level + 1;
-        const chars = new Array(indentLevel).join(options.indent);
-        if (isArray) {
-            return chars.substr(0, chars.length - 2) + '-' + chars.substr(-1, 1);
-        }
-        else {
-            return chars;
-        }
-    }
-    /**
-     * Produces characters to be appended to a line of string in pretty-print
-     * mode.
-     *
-     * @param options - serialization options
-     */
-    _endLine(options) {
-        return options.newline;
-    }
-    /**
-     * Produces a YAML key string delimited with double quotes.
-     */
-    _key(key) {
-        return "\"" + key + "\":";
-    }
-    /**
-     * Produces a YAML value string delimited with double quotes.
-     */
-    _val(val) {
-        return JSON.stringify(val);
-    }
-}
-exports.YAMLWriter = YAMLWriter;
-//# sourceMappingURL=YAMLWriter.js.map
-
-/***/ }),
-
-/***/ 70469:
-/***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
-
-"use strict";
-
-Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.YAMLWriter = exports.JSONWriter = exports.ObjectWriter = exports.XMLWriter = exports.MapWriter = void 0;
-var MapWriter_1 = __nccwpck_require__(99675);
-Object.defineProperty(exports, "MapWriter", ({ enumerable: true, get: function () { return MapWriter_1.MapWriter; } }));
-var XMLWriter_1 = __nccwpck_require__(68998);
-Object.defineProperty(exports, "XMLWriter", ({ enumerable: true, get: function () { return XMLWriter_1.XMLWriter; } }));
-var ObjectWriter_1 = __nccwpck_require__(24393);
-Object.defineProperty(exports, "ObjectWriter", ({ enumerable: true, get: function () { return ObjectWriter_1.ObjectWriter; } }));
-var JSONWriter_1 = __nccwpck_require__(53775);
-Object.defineProperty(exports, "JSONWriter", ({ enumerable: true, get: function () { return JSONWriter_1.JSONWriter; } }));
-var YAMLWriter_1 = __nccwpck_require__(60469);
-Object.defineProperty(exports, "YAMLWriter", ({ enumerable: true, get: function () { return YAMLWriter_1.YAMLWriter; } }));
-//# sourceMappingURL=index.js.map
-
-/***/ }),
-
 /***/ 74577:
 /***/ ((module) => {
 
-(()=>{"use strict";var t={d:(e,i)=>{for(var n in i)t.o(i,n)&&!t.o(e,n)&&Object.defineProperty(e,n,{enumerable:!0,get:i[n]})},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r:t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})}},e={};t.r(e),t.d(e,{XMLBuilder:()=>lt,XMLParser:()=>tt,XMLValidator:()=>pt});const i=":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD",n=new RegExp("^["+i+"]["+i+"\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$");function s(t,e){const i=[];let n=e.exec(t);for(;n;){const s=[];s.startIndex=e.lastIndex-n[0].length;const r=n.length;for(let t=0;t<r;t++)s.push(n[t]);i.push(s),n=e.exec(t)}return i}const r=function(t){return!(null==n.exec(t))},o={allowBooleanAttributes:!1,unpairedTags:[]};function a(t,e){e=Object.assign({},o,e);const i=[];let n=!1,s=!1;"\ufeff"===t[0]&&(t=t.substr(1));for(let o=0;o<t.length;o++)if("<"===t[o]&&"?"===t[o+1]){if(o+=2,o=u(t,o),o.err)return o}else{if("<"!==t[o]){if(l(t[o]))continue;return x("InvalidChar","char '"+t[o]+"' is not expected.",b(t,o))}{let a=o;if(o++,"!"===t[o]){o=h(t,o);continue}{let d=!1;"/"===t[o]&&(d=!0,o++);let p="";for(;o<t.length&&">"!==t[o]&&" "!==t[o]&&"\t"!==t[o]&&"\n"!==t[o]&&"\r"!==t[o];o++)p+=t[o];if(p=p.trim(),"/"===p[p.length-1]&&(p=p.substring(0,p.length-1),o--),!r(p)){let e;return e=0===p.trim().length?"Invalid space after '<'.":"Tag '"+p+"' is an invalid name.",x("InvalidTag",e,b(t,o))}const c=f(t,o);if(!1===c)return x("InvalidAttr","Attributes for '"+p+"' have open quote.",b(t,o));let N=c.value;if(o=c.index,"/"===N[N.length-1]){const i=o-N.length;N=N.substring(0,N.length-1);const s=g(N,e);if(!0!==s)return x(s.err.code,s.err.msg,b(t,i+s.err.line));n=!0}else if(d){if(!c.tagClosed)return x("InvalidTag","Closing tag '"+p+"' doesn't have proper closing.",b(t,o));if(N.trim().length>0)return x("InvalidTag","Closing tag '"+p+"' can't have attributes or invalid starting.",b(t,a));if(0===i.length)return x("InvalidTag","Closing tag '"+p+"' has not been opened.",b(t,a));{const e=i.pop();if(p!==e.tagName){let i=b(t,e.tagStartPos);return x("InvalidTag","Expected closing tag '"+e.tagName+"' (opened in line "+i.line+", col "+i.col+") instead of closing tag '"+p+"'.",b(t,a))}0==i.length&&(s=!0)}}else{const r=g(N,e);if(!0!==r)return x(r.err.code,r.err.msg,b(t,o-N.length+r.err.line));if(!0===s)return x("InvalidXml","Multiple possible root nodes found.",b(t,o));-1!==e.unpairedTags.indexOf(p)||i.push({tagName:p,tagStartPos:a}),n=!0}for(o++;o<t.length;o++)if("<"===t[o]){if("!"===t[o+1]){o++,o=h(t,o);continue}if("?"!==t[o+1])break;if(o=u(t,++o),o.err)return o}else if("&"===t[o]){const e=m(t,o);if(-1==e)return x("InvalidChar","char '&' is not expected.",b(t,o));o=e}else if(!0===s&&!l(t[o]))return x("InvalidXml","Extra text at the end",b(t,o));"<"===t[o]&&o--}}}return n?1==i.length?x("InvalidTag","Unclosed tag '"+i[0].tagName+"'.",b(t,i[0].tagStartPos)):!(i.length>0)||x("InvalidXml","Invalid '"+JSON.stringify(i.map((t=>t.tagName)),null,4).replace(/\r?\n/g,"")+"' found.",{line:1,col:1}):x("InvalidXml","Start tag expected.",1)}function l(t){return" "===t||"\t"===t||"\n"===t||"\r"===t}function u(t,e){const i=e;for(;e<t.length;e++)if("?"!=t[e]&&" "!=t[e]);else{const n=t.substr(i,e-i);if(e>5&&"xml"===n)return x("InvalidXml","XML declaration allowed only at the start of the document.",b(t,e));if("?"==t[e]&&">"==t[e+1]){e++;break}}return e}function h(t,e){if(t.length>e+5&&"-"===t[e+1]&&"-"===t[e+2]){for(e+=3;e<t.length;e++)if("-"===t[e]&&"-"===t[e+1]&&">"===t[e+2]){e+=2;break}}else if(t.length>e+8&&"D"===t[e+1]&&"O"===t[e+2]&&"C"===t[e+3]&&"T"===t[e+4]&&"Y"===t[e+5]&&"P"===t[e+6]&&"E"===t[e+7]){let i=1;for(e+=8;e<t.length;e++)if("<"===t[e])i++;else if(">"===t[e]&&(i--,0===i))break}else if(t.length>e+9&&"["===t[e+1]&&"C"===t[e+2]&&"D"===t[e+3]&&"A"===t[e+4]&&"T"===t[e+5]&&"A"===t[e+6]&&"["===t[e+7])for(e+=8;e<t.length;e++)if("]"===t[e]&&"]"===t[e+1]&&">"===t[e+2]){e+=2;break}return e}const d='"',p="'";function f(t,e){let i="",n="",s=!1;for(;e<t.length;e++){if(t[e]===d||t[e]===p)""===n?n=t[e]:n!==t[e]||(n="");else if(">"===t[e]&&""===n){s=!0;break}i+=t[e]}return""===n&&{value:i,index:e,tagClosed:s}}const c=new RegExp("(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['\"])(([\\s\\S])*?)\\5)?","g");function g(t,e){const i=s(t,c),n={};for(let t=0;t<i.length;t++){if(0===i[t][1].length)return x("InvalidAttr","Attribute '"+i[t][2]+"' has no space in starting.",E(i[t]));if(void 0!==i[t][3]&&void 0===i[t][4])return x("InvalidAttr","Attribute '"+i[t][2]+"' is without value.",E(i[t]));if(void 0===i[t][3]&&!e.allowBooleanAttributes)return x("InvalidAttr","boolean attribute '"+i[t][2]+"' is not allowed.",E(i[t]));const s=i[t][2];if(!N(s))return x("InvalidAttr","Attribute '"+s+"' is an invalid name.",E(i[t]));if(n.hasOwnProperty(s))return x("InvalidAttr","Attribute '"+s+"' is repeated.",E(i[t]));n[s]=1}return!0}function m(t,e){if(";"===t[++e])return-1;if("#"===t[e])return function(t,e){let i=/\d/;for("x"===t[e]&&(e++,i=/[\da-fA-F]/);e<t.length;e++){if(";"===t[e])return e;if(!t[e].match(i))break}return-1}(t,++e);let i=0;for(;e<t.length;e++,i++)if(!(t[e].match(/\w/)&&i<20)){if(";"===t[e])break;return-1}return e}function x(t,e,i){return{err:{code:t,msg:e,line:i.line||i,col:i.col}}}function N(t){return r(t)}function b(t,e){const i=t.substring(0,e).split(/\r?\n/);return{line:i.length,col:i[i.length-1].length+1}}function E(t){return t.startIndex+t[1].length}const v={preserveOrder:!1,attributeNamePrefix:"@_",attributesGroupName:!1,textNodeName:"#text",ignoreAttributes:!0,removeNSPrefix:!1,allowBooleanAttributes:!1,parseTagValue:!0,parseAttributeValue:!1,trimValues:!0,cdataPropName:!1,numberParseOptions:{hex:!0,leadingZeros:!0,eNotation:!0},tagValueProcessor:function(t,e){return e},attributeValueProcessor:function(t,e){return e},stopNodes:[],alwaysCreateTextNode:!1,isArray:()=>!1,commentPropName:!1,unpairedTags:[],processEntities:!0,htmlEntities:!1,ignoreDeclaration:!1,ignorePiTags:!1,transformTagName:!1,transformAttributeName:!1,updateTag:function(t,e,i){return t},captureMetaData:!1};let T;T="function"!=typeof Symbol?"@@xmlMetadata":Symbol("XML Node Metadata");class y{constructor(t){this.tagname=t,this.child=[],this[":@"]={}}add(t,e){"__proto__"===t&&(t="#__proto__"),this.child.push({[t]:e})}addChild(t,e){"__proto__"===t.tagname&&(t.tagname="#__proto__"),t[":@"]&&Object.keys(t[":@"]).length>0?this.child.push({[t.tagname]:t.child,":@":t[":@"]}):this.child.push({[t.tagname]:t.child}),void 0!==e&&(this.child[this.child.length-1][T]={startIndex:e})}static getMetaDataSymbol(){return T}}class w{constructor(t){this.suppressValidationErr=!t}readDocType(t,e){const i={};if("O"!==t[e+3]||"C"!==t[e+4]||"T"!==t[e+5]||"Y"!==t[e+6]||"P"!==t[e+7]||"E"!==t[e+8])throw new Error("Invalid Tag instead of DOCTYPE");{e+=9;let n=1,s=!1,r=!1,o="";for(;e<t.length;e++)if("<"!==t[e]||r)if(">"===t[e]){if(r?"-"===t[e-1]&&"-"===t[e-2]&&(r=!1,n--):n--,0===n)break}else"["===t[e]?s=!0:o+=t[e];else{if(s&&P(t,"!ENTITY",e)){let n,s;e+=7,[n,s,e]=this.readEntityExp(t,e+1,this.suppressValidationErr),-1===s.indexOf("&")&&(i[n]={regx:RegExp(`&${n};`,"g"),val:s})}else if(s&&P(t,"!ELEMENT",e)){e+=8;const{index:i}=this.readElementExp(t,e+1);e=i}else if(s&&P(t,"!ATTLIST",e))e+=8;else if(s&&P(t,"!NOTATION",e)){e+=9;const{index:i}=this.readNotationExp(t,e+1,this.suppressValidationErr);e=i}else{if(!P(t,"!--",e))throw new Error("Invalid DOCTYPE");r=!0}n++,o=""}if(0!==n)throw new Error("Unclosed DOCTYPE")}return{entities:i,i:e}}readEntityExp(t,e){e=I(t,e);let i="";for(;e<t.length&&!/\s/.test(t[e])&&'"'!==t[e]&&"'"!==t[e];)i+=t[e],e++;if(O(i),e=I(t,e),!this.suppressValidationErr){if("SYSTEM"===t.substring(e,e+6).toUpperCase())throw new Error("External entities are not supported");if("%"===t[e])throw new Error("Parameter entities are not supported")}let n="";return[e,n]=this.readIdentifierVal(t,e,"entity"),[i,n,--e]}readNotationExp(t,e){e=I(t,e);let i="";for(;e<t.length&&!/\s/.test(t[e]);)i+=t[e],e++;!this.suppressValidationErr&&O(i),e=I(t,e);const n=t.substring(e,e+6).toUpperCase();if(!this.suppressValidationErr&&"SYSTEM"!==n&&"PUBLIC"!==n)throw new Error(`Expected SYSTEM or PUBLIC, found "${n}"`);e+=n.length,e=I(t,e);let s=null,r=null;if("PUBLIC"===n)[e,s]=this.readIdentifierVal(t,e,"publicIdentifier"),'"'!==t[e=I(t,e)]&&"'"!==t[e]||([e,r]=this.readIdentifierVal(t,e,"systemIdentifier"));else if("SYSTEM"===n&&([e,r]=this.readIdentifierVal(t,e,"systemIdentifier"),!this.suppressValidationErr&&!r))throw new Error("Missing mandatory system identifier for SYSTEM notation");return{notationName:i,publicIdentifier:s,systemIdentifier:r,index:--e}}readIdentifierVal(t,e,i){let n="";const s=t[e];if('"'!==s&&"'"!==s)throw new Error(`Expected quoted string, found "${s}"`);for(e++;e<t.length&&t[e]!==s;)n+=t[e],e++;if(t[e]!==s)throw new Error(`Unterminated ${i} value`);return[++e,n]}readElementExp(t,e){e=I(t,e);let i="";for(;e<t.length&&!/\s/.test(t[e]);)i+=t[e],e++;if(!this.suppressValidationErr&&!r(i))throw new Error(`Invalid element name: "${i}"`);let n="";if("E"===t[e=I(t,e)]&&P(t,"MPTY",e))e+=4;else if("A"===t[e]&&P(t,"NY",e))e+=2;else if("("===t[e]){for(e++;e<t.length&&")"!==t[e];)n+=t[e],e++;if(")"!==t[e])throw new Error("Unterminated content model")}else if(!this.suppressValidationErr)throw new Error(`Invalid Element Expression, found "${t[e]}"`);return{elementName:i,contentModel:n.trim(),index:e}}readAttlistExp(t,e){e=I(t,e);let i="";for(;e<t.length&&!/\s/.test(t[e]);)i+=t[e],e++;O(i),e=I(t,e);let n="";for(;e<t.length&&!/\s/.test(t[e]);)n+=t[e],e++;if(!O(n))throw new Error(`Invalid attribute name: "${n}"`);e=I(t,e);let s="";if("NOTATION"===t.substring(e,e+8).toUpperCase()){if(s="NOTATION","("!==t[e=I(t,e+=8)])throw new Error(`Expected '(', found "${t[e]}"`);e++;let i=[];for(;e<t.length&&")"!==t[e];){let n="";for(;e<t.length&&"|"!==t[e]&&")"!==t[e];)n+=t[e],e++;if(n=n.trim(),!O(n))throw new Error(`Invalid notation name: "${n}"`);i.push(n),"|"===t[e]&&(e++,e=I(t,e))}if(")"!==t[e])throw new Error("Unterminated list of notations");e++,s+=" ("+i.join("|")+")"}else{for(;e<t.length&&!/\s/.test(t[e]);)s+=t[e],e++;const i=["CDATA","ID","IDREF","IDREFS","ENTITY","ENTITIES","NMTOKEN","NMTOKENS"];if(!this.suppressValidationErr&&!i.includes(s.toUpperCase()))throw new Error(`Invalid attribute type: "${s}"`)}e=I(t,e);let r="";return"#REQUIRED"===t.substring(e,e+8).toUpperCase()?(r="#REQUIRED",e+=8):"#IMPLIED"===t.substring(e,e+7).toUpperCase()?(r="#IMPLIED",e+=7):[e,r]=this.readIdentifierVal(t,e,"ATTLIST"),{elementName:i,attributeName:n,attributeType:s,defaultValue:r,index:e}}}const I=(t,e)=>{for(;e<t.length&&/\s/.test(t[e]);)e++;return e};function P(t,e,i){for(let n=0;n<e.length;n++)if(e[n]!==t[i+n+1])return!1;return!0}function O(t){if(r(t))return t;throw new Error(`Invalid entity name ${t}`)}const A=/^[-+]?0x[a-fA-F0-9]+$/,S=/^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/,C={hex:!0,leadingZeros:!0,decimalPoint:".",eNotation:!0};const V=/^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;function $(t){return"function"==typeof t?t:Array.isArray(t)?e=>{for(const i of t){if("string"==typeof i&&e===i)return!0;if(i instanceof RegExp&&i.test(e))return!0}}:()=>!1}class D{constructor(t){if(this.options=t,this.currentNode=null,this.tagsNodeStack=[],this.docTypeEntities={},this.lastEntities={apos:{regex:/&(apos|#39|#x27);/g,val:"'"},gt:{regex:/&(gt|#62|#x3E);/g,val:">"},lt:{regex:/&(lt|#60|#x3C);/g,val:"<"},quot:{regex:/&(quot|#34|#x22);/g,val:'"'}},this.ampEntity={regex:/&(amp|#38|#x26);/g,val:"&"},this.htmlEntities={space:{regex:/&(nbsp|#160);/g,val:" "},cent:{regex:/&(cent|#162);/g,val:"¢"},pound:{regex:/&(pound|#163);/g,val:"£"},yen:{regex:/&(yen|#165);/g,val:"¥"},euro:{regex:/&(euro|#8364);/g,val:"€"},copyright:{regex:/&(copy|#169);/g,val:"©"},reg:{regex:/&(reg|#174);/g,val:"®"},inr:{regex:/&(inr|#8377);/g,val:"₹"},num_dec:{regex:/&#([0-9]{1,7});/g,val:(t,e)=>String.fromCodePoint(Number.parseInt(e,10))},num_hex:{regex:/&#x([0-9a-fA-F]{1,6});/g,val:(t,e)=>String.fromCodePoint(Number.parseInt(e,16))}},this.addExternalEntities=j,this.parseXml=L,this.parseTextData=M,this.resolveNameSpace=F,this.buildAttributesMap=k,this.isItStopNode=Y,this.replaceEntitiesValue=B,this.readStopNodeData=W,this.saveTextToParentTag=R,this.addChild=U,this.ignoreAttributesFn=$(this.options.ignoreAttributes),this.options.stopNodes&&this.options.stopNodes.length>0){this.stopNodesExact=new Set,this.stopNodesWildcard=new Set;for(let t=0;t<this.options.stopNodes.length;t++){const e=this.options.stopNodes[t];"string"==typeof e&&(e.startsWith("*.")?this.stopNodesWildcard.add(e.substring(2)):this.stopNodesExact.add(e))}}}}function j(t){const e=Object.keys(t);for(let i=0;i<e.length;i++){const n=e[i];this.lastEntities[n]={regex:new RegExp("&"+n+";","g"),val:t[n]}}}function M(t,e,i,n,s,r,o){if(void 0!==t&&(this.options.trimValues&&!n&&(t=t.trim()),t.length>0)){o||(t=this.replaceEntitiesValue(t));const n=this.options.tagValueProcessor(e,t,i,s,r);return null==n?t:typeof n!=typeof t||n!==t?n:this.options.trimValues||t.trim()===t?q(t,this.options.parseTagValue,this.options.numberParseOptions):t}}function F(t){if(this.options.removeNSPrefix){const e=t.split(":"),i="/"===t.charAt(0)?"/":"";if("xmlns"===e[0])return"";2===e.length&&(t=i+e[1])}return t}const _=new RegExp("([^\\s=]+)\\s*(=\\s*(['\"])([\\s\\S]*?)\\3)?","gm");function k(t,e){if(!0!==this.options.ignoreAttributes&&"string"==typeof t){const i=s(t,_),n=i.length,r={};for(let t=0;t<n;t++){const n=this.resolveNameSpace(i[t][1]);if(this.ignoreAttributesFn(n,e))continue;let s=i[t][4],o=this.options.attributeNamePrefix+n;if(n.length)if(this.options.transformAttributeName&&(o=this.options.transformAttributeName(o)),"__proto__"===o&&(o="#__proto__"),void 0!==s){this.options.trimValues&&(s=s.trim()),s=this.replaceEntitiesValue(s);const t=this.options.attributeValueProcessor(n,s,e);r[o]=null==t?s:typeof t!=typeof s||t!==s?t:q(s,this.options.parseAttributeValue,this.options.numberParseOptions)}else this.options.allowBooleanAttributes&&(r[o]=!0)}if(!Object.keys(r).length)return;if(this.options.attributesGroupName){const t={};return t[this.options.attributesGroupName]=r,t}return r}}const L=function(t){t=t.replace(/\r\n?/g,"\n");const e=new y("!xml");let i=e,n="",s="";const r=new w(this.options.processEntities);for(let o=0;o<t.length;o++)if("<"===t[o])if("/"===t[o+1]){const e=G(t,">",o,"Closing Tag is not closed.");let r=t.substring(o+2,e).trim();if(this.options.removeNSPrefix){const t=r.indexOf(":");-1!==t&&(r=r.substr(t+1))}this.options.transformTagName&&(r=this.options.transformTagName(r)),i&&(n=this.saveTextToParentTag(n,i,s));const a=s.substring(s.lastIndexOf(".")+1);if(r&&-1!==this.options.unpairedTags.indexOf(r))throw new Error(`Unpaired tag can not be used as closing tag: </${r}>`);let l=0;a&&-1!==this.options.unpairedTags.indexOf(a)?(l=s.lastIndexOf(".",s.lastIndexOf(".")-1),this.tagsNodeStack.pop()):l=s.lastIndexOf("."),s=s.substring(0,l),i=this.tagsNodeStack.pop(),n="",o=e}else if("?"===t[o+1]){let e=X(t,o,!1,"?>");if(!e)throw new Error("Pi Tag is not closed.");if(n=this.saveTextToParentTag(n,i,s),this.options.ignoreDeclaration&&"?xml"===e.tagName||this.options.ignorePiTags);else{const t=new y(e.tagName);t.add(this.options.textNodeName,""),e.tagName!==e.tagExp&&e.attrExpPresent&&(t[":@"]=this.buildAttributesMap(e.tagExp,s)),this.addChild(i,t,s,o)}o=e.closeIndex+1}else if("!--"===t.substr(o+1,3)){const e=G(t,"--\x3e",o+4,"Comment is not closed.");if(this.options.commentPropName){const r=t.substring(o+4,e-2);n=this.saveTextToParentTag(n,i,s),i.add(this.options.commentPropName,[{[this.options.textNodeName]:r}])}o=e}else if("!D"===t.substr(o+1,2)){const e=r.readDocType(t,o);this.docTypeEntities=e.entities,o=e.i}else if("!["===t.substr(o+1,2)){const e=G(t,"]]>",o,"CDATA is not closed.")-2,r=t.substring(o+9,e);n=this.saveTextToParentTag(n,i,s);let a=this.parseTextData(r,i.tagname,s,!0,!1,!0,!0);null==a&&(a=""),this.options.cdataPropName?i.add(this.options.cdataPropName,[{[this.options.textNodeName]:r}]):i.add(this.options.textNodeName,a),o=e+2}else{let r=X(t,o,this.options.removeNSPrefix),a=r.tagName;const l=r.rawTagName;let u=r.tagExp,h=r.attrExpPresent,d=r.closeIndex;if(this.options.transformTagName){const t=this.options.transformTagName(a);u===a&&(u=t),a=t}i&&n&&"!xml"!==i.tagname&&(n=this.saveTextToParentTag(n,i,s,!1));const p=i;p&&-1!==this.options.unpairedTags.indexOf(p.tagname)&&(i=this.tagsNodeStack.pop(),s=s.substring(0,s.lastIndexOf("."))),a!==e.tagname&&(s+=s?"."+a:a);const f=o;if(this.isItStopNode(this.stopNodesExact,this.stopNodesWildcard,s,a)){let e="";if(u.length>0&&u.lastIndexOf("/")===u.length-1)"/"===a[a.length-1]?(a=a.substr(0,a.length-1),s=s.substr(0,s.length-1),u=a):u=u.substr(0,u.length-1),o=r.closeIndex;else if(-1!==this.options.unpairedTags.indexOf(a))o=r.closeIndex;else{const i=this.readStopNodeData(t,l,d+1);if(!i)throw new Error(`Unexpected end of ${l}`);o=i.i,e=i.tagContent}const n=new y(a);a!==u&&h&&(n[":@"]=this.buildAttributesMap(u,s)),e&&(e=this.parseTextData(e,a,s,!0,h,!0,!0)),s=s.substr(0,s.lastIndexOf(".")),n.add(this.options.textNodeName,e),this.addChild(i,n,s,f)}else{if(u.length>0&&u.lastIndexOf("/")===u.length-1){if("/"===a[a.length-1]?(a=a.substr(0,a.length-1),s=s.substr(0,s.length-1),u=a):u=u.substr(0,u.length-1),this.options.transformTagName){const t=this.options.transformTagName(a);u===a&&(u=t),a=t}const t=new y(a);a!==u&&h&&(t[":@"]=this.buildAttributesMap(u,s)),this.addChild(i,t,s,f),s=s.substr(0,s.lastIndexOf("."))}else{const t=new y(a);this.tagsNodeStack.push(i),a!==u&&h&&(t[":@"]=this.buildAttributesMap(u,s)),this.addChild(i,t,s,f),i=t}n="",o=d}}else n+=t[o];return e.child};function U(t,e,i,n){this.options.captureMetaData||(n=void 0);const s=this.options.updateTag(e.tagname,i,e[":@"]);!1===s||("string"==typeof s?(e.tagname=s,t.addChild(e,n)):t.addChild(e,n))}const B=function(t){if(this.options.processEntities){for(let e in this.docTypeEntities){const i=this.docTypeEntities[e];t=t.replace(i.regx,i.val)}for(let e in this.lastEntities){const i=this.lastEntities[e];t=t.replace(i.regex,i.val)}if(this.options.htmlEntities)for(let e in this.htmlEntities){const i=this.htmlEntities[e];t=t.replace(i.regex,i.val)}t=t.replace(this.ampEntity.regex,this.ampEntity.val)}return t};function R(t,e,i,n){return t&&(void 0===n&&(n=0===e.child.length),void 0!==(t=this.parseTextData(t,e.tagname,i,!1,!!e[":@"]&&0!==Object.keys(e[":@"]).length,n))&&""!==t&&e.add(this.options.textNodeName,t),t=""),t}function Y(t,e,i,n){return!(!e||!e.has(n))||!(!t||!t.has(i))}function G(t,e,i,n){const s=t.indexOf(e,i);if(-1===s)throw new Error(n);return s+e.length-1}function X(t,e,i,n=">"){const s=function(t,e,i=">"){let n,s="";for(let r=e;r<t.length;r++){let e=t[r];if(n)e===n&&(n="");else if('"'===e||"'"===e)n=e;else if(e===i[0]){if(!i[1])return{data:s,index:r};if(t[r+1]===i[1])return{data:s,index:r}}else"\t"===e&&(e=" ");s+=e}}(t,e+1,n);if(!s)return;let r=s.data;const o=s.index,a=r.search(/\s/);let l=r,u=!0;-1!==a&&(l=r.substring(0,a),r=r.substring(a+1).trimStart());const h=l;if(i){const t=l.indexOf(":");-1!==t&&(l=l.substr(t+1),u=l!==s.data.substr(t+1))}return{tagName:l,tagExp:r,closeIndex:o,attrExpPresent:u,rawTagName:h}}function W(t,e,i){const n=i;let s=1;for(;i<t.length;i++)if("<"===t[i])if("/"===t[i+1]){const r=G(t,">",i,`${e} is not closed`);if(t.substring(i+2,r).trim()===e&&(s--,0===s))return{tagContent:t.substring(n,i),i:r};i=r}else if("?"===t[i+1])i=G(t,"?>",i+1,"StopNode is not closed.");else if("!--"===t.substr(i+1,3))i=G(t,"--\x3e",i+3,"StopNode is not closed.");else if("!["===t.substr(i+1,2))i=G(t,"]]>",i,"StopNode is not closed.")-2;else{const n=X(t,i,">");n&&((n&&n.tagName)===e&&"/"!==n.tagExp[n.tagExp.length-1]&&s++,i=n.closeIndex)}}function q(t,e,i){if(e&&"string"==typeof t){const e=t.trim();return"true"===e||"false"!==e&&function(t,e={}){if(e=Object.assign({},C,e),!t||"string"!=typeof t)return t;let i=t.trim();if(void 0!==e.skipLike&&e.skipLike.test(i))return t;if("0"===t)return 0;if(e.hex&&A.test(i))return function(t){if(parseInt)return parseInt(t,16);if(Number.parseInt)return Number.parseInt(t,16);if(window&&window.parseInt)return window.parseInt(t,16);throw new Error("parseInt, Number.parseInt, window.parseInt are not supported")}(i);if(-1!==i.search(/.+[eE].+/))return function(t,e,i){if(!i.eNotation)return t;const n=e.match(V);if(n){let s=n[1]||"";const r=-1===n[3].indexOf("e")?"E":"e",o=n[2],a=s?t[o.length+1]===r:t[o.length]===r;return o.length>1&&a?t:1!==o.length||!n[3].startsWith(`.${r}`)&&n[3][0]!==r?i.leadingZeros&&!a?(e=(n[1]||"")+n[3],Number(e)):t:Number(e)}return t}(t,i,e);{const s=S.exec(i);if(s){const r=s[1]||"",o=s[2];let a=(n=s[3])&&-1!==n.indexOf(".")?("."===(n=n.replace(/0+$/,""))?n="0":"."===n[0]?n="0"+n:"."===n[n.length-1]&&(n=n.substring(0,n.length-1)),n):n;const l=r?"."===t[o.length+1]:"."===t[o.length];if(!e.leadingZeros&&(o.length>1||1===o.length&&!l))return t;{const n=Number(i),s=String(n);if(0===n||-0===n)return n;if(-1!==s.search(/[eE]/))return e.eNotation?n:t;if(-1!==i.indexOf("."))return"0"===s||s===a||s===`${r}${a}`?n:t;let l=o?a:i;return o?l===s||r+l===s?n:t:l===s||l===r+s?n:t}}return t}var n}(t,i)}return void 0!==t?t:""}const Z=y.getMetaDataSymbol();function K(t,e){return Q(t,e)}function Q(t,e,i){let n;const s={};for(let r=0;r<t.length;r++){const o=t[r],a=z(o);let l="";if(l=void 0===i?a:i+"."+a,a===e.textNodeName)void 0===n?n=o[a]:n+=""+o[a];else{if(void 0===a)continue;if(o[a]){let t=Q(o[a],e,l);const i=H(t,e);void 0!==o[Z]&&(t[Z]=o[Z]),o[":@"]?J(t,o[":@"],l,e):1!==Object.keys(t).length||void 0===t[e.textNodeName]||e.alwaysCreateTextNode?0===Object.keys(t).length&&(e.alwaysCreateTextNode?t[e.textNodeName]="":t=""):t=t[e.textNodeName],void 0!==s[a]&&s.hasOwnProperty(a)?(Array.isArray(s[a])||(s[a]=[s[a]]),s[a].push(t)):e.isArray(a,l,i)?s[a]=[t]:s[a]=t}}}return"string"==typeof n?n.length>0&&(s[e.textNodeName]=n):void 0!==n&&(s[e.textNodeName]=n),s}function z(t){const e=Object.keys(t);for(let t=0;t<e.length;t++){const i=e[t];if(":@"!==i)return i}}function J(t,e,i,n){if(e){const s=Object.keys(e),r=s.length;for(let o=0;o<r;o++){const r=s[o];n.isArray(r,i+"."+r,!0,!0)?t[r]=[e[r]]:t[r]=e[r]}}}function H(t,e){const{textNodeName:i}=e,n=Object.keys(t).length;return 0===n||!(1!==n||!t[i]&&"boolean"!=typeof t[i]&&0!==t[i])}class tt{constructor(t){this.externalEntities={},this.options=function(t){return Object.assign({},v,t)}(t)}parse(t,e){if("string"!=typeof t&&t.toString)t=t.toString();else if("string"!=typeof t)throw new Error("XML data is accepted in String or Bytes[] form.");if(e){!0===e&&(e={});const i=a(t,e);if(!0!==i)throw Error(`${i.err.msg}:${i.err.line}:${i.err.col}`)}const i=new D(this.options);i.addExternalEntities(this.externalEntities);const n=i.parseXml(t);return this.options.preserveOrder||void 0===n?n:K(n,this.options)}addEntity(t,e){if(-1!==e.indexOf("&"))throw new Error("Entity value can't have '&'");if(-1!==t.indexOf("&")||-1!==t.indexOf(";"))throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");if("&"===e)throw new Error("An entity with value '&' is not permitted");this.externalEntities[t]=e}static getMetaDataSymbol(){return y.getMetaDataSymbol()}}function et(t,e){let i="";return e.format&&e.indentBy.length>0&&(i="\n"),it(t,e,"",i)}function it(t,e,i,n){let s="",r=!1;for(let o=0;o<t.length;o++){const a=t[o],l=nt(a);if(void 0===l)continue;let u="";if(u=0===i.length?l:`${i}.${l}`,l===e.textNodeName){let t=a[l];rt(u,e)||(t=e.tagValueProcessor(l,t),t=ot(t,e)),r&&(s+=n),s+=t,r=!1;continue}if(l===e.cdataPropName){r&&(s+=n),s+=`<![CDATA[${a[l][0][e.textNodeName]}]]>`,r=!1;continue}if(l===e.commentPropName){s+=n+`\x3c!--${a[l][0][e.textNodeName]}--\x3e`,r=!0;continue}if("?"===l[0]){const t=st(a[":@"],e),i="?xml"===l?"":n;let o=a[l][0][e.textNodeName];o=0!==o.length?" "+o:"",s+=i+`<${l}${o}${t}?>`,r=!0;continue}let h=n;""!==h&&(h+=e.indentBy);const d=n+`<${l}${st(a[":@"],e)}`,p=it(a[l],e,u,h);-1!==e.unpairedTags.indexOf(l)?e.suppressUnpairedNode?s+=d+">":s+=d+"/>":p&&0!==p.length||!e.suppressEmptyNode?p&&p.endsWith(">")?s+=d+`>${p}${n}</${l}>`:(s+=d+">",p&&""!==n&&(p.includes("/>")||p.includes("</"))?s+=n+e.indentBy+p+n:s+=p,s+=`</${l}>`):s+=d+"/>",r=!0}return s}function nt(t){const e=Object.keys(t);for(let i=0;i<e.length;i++){const n=e[i];if(t.hasOwnProperty(n)&&":@"!==n)return n}}function st(t,e){let i="";if(t&&!e.ignoreAttributes)for(let n in t){if(!t.hasOwnProperty(n))continue;let s=e.attributeValueProcessor(n,t[n]);s=ot(s,e),!0===s&&e.suppressBooleanAttributes?i+=` ${n.substr(e.attributeNamePrefix.length)}`:i+=` ${n.substr(e.attributeNamePrefix.length)}="${s}"`}return i}function rt(t,e){let i=(t=t.substr(0,t.length-e.textNodeName.length-1)).substr(t.lastIndexOf(".")+1);for(let n in e.stopNodes)if(e.stopNodes[n]===t||e.stopNodes[n]==="*."+i)return!0;return!1}function ot(t,e){if(t&&t.length>0&&e.processEntities)for(let i=0;i<e.entities.length;i++){const n=e.entities[i];t=t.replace(n.regex,n.val)}return t}const at={attributeNamePrefix:"@_",attributesGroupName:!1,textNodeName:"#text",ignoreAttributes:!0,cdataPropName:!1,format:!1,indentBy:"  ",suppressEmptyNode:!1,suppressUnpairedNode:!0,suppressBooleanAttributes:!0,tagValueProcessor:function(t,e){return e},attributeValueProcessor:function(t,e){return e},preserveOrder:!1,commentPropName:!1,unpairedTags:[],entities:[{regex:new RegExp("&","g"),val:"&amp;"},{regex:new RegExp(">","g"),val:"&gt;"},{regex:new RegExp("<","g"),val:"&lt;"},{regex:new RegExp("'","g"),val:"&apos;"},{regex:new RegExp('"',"g"),val:"&quot;"}],processEntities:!0,stopNodes:[],oneListGroup:!1};function lt(t){this.options=Object.assign({},at,t),!0===this.options.ignoreAttributes||this.options.attributesGroupName?this.isAttribute=function(){return!1}:(this.ignoreAttributesFn=$(this.options.ignoreAttributes),this.attrPrefixLen=this.options.attributeNamePrefix.length,this.isAttribute=dt),this.processTextOrObjNode=ut,this.options.format?(this.indentate=ht,this.tagEndChar=">\n",this.newLine="\n"):(this.indentate=function(){return""},this.tagEndChar=">",this.newLine="")}function ut(t,e,i,n){const s=this.j2x(t,i+1,n.concat(e));return void 0!==t[this.options.textNodeName]&&1===Object.keys(t).length?this.buildTextValNode(t[this.options.textNodeName],e,s.attrStr,i):this.buildObjectNode(s.val,e,s.attrStr,i)}function ht(t){return this.options.indentBy.repeat(t)}function dt(t){return!(!t.startsWith(this.options.attributeNamePrefix)||t===this.options.textNodeName)&&t.substr(this.attrPrefixLen)}lt.prototype.build=function(t){return this.options.preserveOrder?et(t,this.options):(Array.isArray(t)&&this.options.arrayNodeName&&this.options.arrayNodeName.length>1&&(t={[this.options.arrayNodeName]:t}),this.j2x(t,0,[]).val)},lt.prototype.j2x=function(t,e,i){let n="",s="";const r=i.join(".");for(let o in t)if(Object.prototype.hasOwnProperty.call(t,o))if(void 0===t[o])this.isAttribute(o)&&(s+="");else if(null===t[o])this.isAttribute(o)||o===this.options.cdataPropName?s+="":"?"===o[0]?s+=this.indentate(e)+"<"+o+"?"+this.tagEndChar:s+=this.indentate(e)+"<"+o+"/"+this.tagEndChar;else if(t[o]instanceof Date)s+=this.buildTextValNode(t[o],o,"",e);else if("object"!=typeof t[o]){const i=this.isAttribute(o);if(i&&!this.ignoreAttributesFn(i,r))n+=this.buildAttrPairStr(i,""+t[o]);else if(!i)if(o===this.options.textNodeName){let e=this.options.tagValueProcessor(o,""+t[o]);s+=this.replaceEntitiesValue(e)}else s+=this.buildTextValNode(t[o],o,"",e)}else if(Array.isArray(t[o])){const n=t[o].length;let r="",a="";for(let l=0;l<n;l++){const n=t[o][l];if(void 0===n);else if(null===n)"?"===o[0]?s+=this.indentate(e)+"<"+o+"?"+this.tagEndChar:s+=this.indentate(e)+"<"+o+"/"+this.tagEndChar;else if("object"==typeof n)if(this.options.oneListGroup){const t=this.j2x(n,e+1,i.concat(o));r+=t.val,this.options.attributesGroupName&&n.hasOwnProperty(this.options.attributesGroupName)&&(a+=t.attrStr)}else r+=this.processTextOrObjNode(n,o,e,i);else if(this.options.oneListGroup){let t=this.options.tagValueProcessor(o,n);t=this.replaceEntitiesValue(t),r+=t}else r+=this.buildTextValNode(n,o,"",e)}this.options.oneListGroup&&(r=this.buildObjectNode(r,o,a,e)),s+=r}else if(this.options.attributesGroupName&&o===this.options.attributesGroupName){const e=Object.keys(t[o]),i=e.length;for(let s=0;s<i;s++)n+=this.buildAttrPairStr(e[s],""+t[o][e[s]])}else s+=this.processTextOrObjNode(t[o],o,e,i);return{attrStr:n,val:s}},lt.prototype.buildAttrPairStr=function(t,e){return e=this.options.attributeValueProcessor(t,""+e),e=this.replaceEntitiesValue(e),this.options.suppressBooleanAttributes&&"true"===e?" "+t:" "+t+'="'+e+'"'},lt.prototype.buildObjectNode=function(t,e,i,n){if(""===t)return"?"===e[0]?this.indentate(n)+"<"+e+i+"?"+this.tagEndChar:this.indentate(n)+"<"+e+i+this.closeTag(e)+this.tagEndChar;{let s="</"+e+this.tagEndChar,r="";return"?"===e[0]&&(r="?",s=""),!i&&""!==i||-1!==t.indexOf("<")?!1!==this.options.commentPropName&&e===this.options.commentPropName&&0===r.length?this.indentate(n)+`\x3c!--${t}--\x3e`+this.newLine:this.indentate(n)+"<"+e+i+r+this.tagEndChar+t+this.indentate(n)+s:this.indentate(n)+"<"+e+i+r+">"+t+s}},lt.prototype.closeTag=function(t){let e="";return-1!==this.options.unpairedTags.indexOf(t)?this.options.suppressUnpairedNode||(e="/"):e=this.options.suppressEmptyNode?"/":`></${t}`,e},lt.prototype.buildTextValNode=function(t,e,i,n){if(!1!==this.options.cdataPropName&&e===this.options.cdataPropName)return this.indentate(n)+`<![CDATA[${t}]]>`+this.newLine;if(!1!==this.options.commentPropName&&e===this.options.commentPropName)return this.indentate(n)+`\x3c!--${t}--\x3e`+this.newLine;if("?"===e[0])return this.indentate(n)+"<"+e+i+"?"+this.tagEndChar;{let s=this.options.tagValueProcessor(e,t);return s=this.replaceEntitiesValue(s),""===s?this.indentate(n)+"<"+e+i+this.closeTag(e)+this.tagEndChar:this.indentate(n)+"<"+e+i+">"+s+"</"+e+this.tagEndChar}},lt.prototype.replaceEntitiesValue=function(t){if(t&&t.length>0&&this.options.processEntities)for(let e=0;e<this.options.entities.length;e++){const i=this.options.entities[e];t=t.replace(i.regex,i.val)}return t};const pt={validate:a};module.exports=e})();
+(()=>{"use strict";var t={d:(e,n)=>{for(var i in n)t.o(n,i)&&!t.o(e,i)&&Object.defineProperty(e,i,{enumerable:!0,get:n[i]})},o:(t,e)=>Object.prototype.hasOwnProperty.call(t,e),r:t=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(t,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(t,"__esModule",{value:!0})}},e={};t.r(e),t.d(e,{XMLBuilder:()=>gt,XMLParser:()=>it,XMLValidator:()=>xt});const n=":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD",i=new RegExp("^["+n+"]["+n+"\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040]*$");function s(t,e){const n=[];let i=e.exec(t);for(;i;){const s=[];s.startIndex=e.lastIndex-i[0].length;const r=i.length;for(let t=0;t<r;t++)s.push(i[t]);n.push(s),i=e.exec(t)}return n}const r=function(t){return!(null==i.exec(t))},o={allowBooleanAttributes:!1,unpairedTags:[]};function a(t,e){e=Object.assign({},o,e);const n=[];let i=!1,s=!1;"\ufeff"===t[0]&&(t=t.substr(1));for(let r=0;r<t.length;r++)if("<"===t[r]&&"?"===t[r+1]){if(r+=2,r=u(t,r),r.err)return r}else{if("<"!==t[r]){if(l(t[r]))continue;return m("InvalidChar","char '"+t[r]+"' is not expected.",N(t,r))}{let o=r;if(r++,"!"===t[r]){r=d(t,r);continue}{let a=!1;"/"===t[r]&&(a=!0,r++);let h="";for(;r<t.length&&">"!==t[r]&&" "!==t[r]&&"\t"!==t[r]&&"\n"!==t[r]&&"\r"!==t[r];r++)h+=t[r];if(h=h.trim(),"/"===h[h.length-1]&&(h=h.substring(0,h.length-1),r--),!b(h)){let e;return e=0===h.trim().length?"Invalid space after '<'.":"Tag '"+h+"' is an invalid name.",m("InvalidTag",e,N(t,r))}const p=c(t,r);if(!1===p)return m("InvalidAttr","Attributes for '"+h+"' have open quote.",N(t,r));let f=p.value;if(r=p.index,"/"===f[f.length-1]){const n=r-f.length;f=f.substring(0,f.length-1);const s=g(f,e);if(!0!==s)return m(s.err.code,s.err.msg,N(t,n+s.err.line));i=!0}else if(a){if(!p.tagClosed)return m("InvalidTag","Closing tag '"+h+"' doesn't have proper closing.",N(t,r));if(f.trim().length>0)return m("InvalidTag","Closing tag '"+h+"' can't have attributes or invalid starting.",N(t,o));if(0===n.length)return m("InvalidTag","Closing tag '"+h+"' has not been opened.",N(t,o));{const e=n.pop();if(h!==e.tagName){let n=N(t,e.tagStartPos);return m("InvalidTag","Expected closing tag '"+e.tagName+"' (opened in line "+n.line+", col "+n.col+") instead of closing tag '"+h+"'.",N(t,o))}0==n.length&&(s=!0)}}else{const a=g(f,e);if(!0!==a)return m(a.err.code,a.err.msg,N(t,r-f.length+a.err.line));if(!0===s)return m("InvalidXml","Multiple possible root nodes found.",N(t,r));-1!==e.unpairedTags.indexOf(h)||n.push({tagName:h,tagStartPos:o}),i=!0}for(r++;r<t.length;r++)if("<"===t[r]){if("!"===t[r+1]){r++,r=d(t,r);continue}if("?"!==t[r+1])break;if(r=u(t,++r),r.err)return r}else if("&"===t[r]){const e=x(t,r);if(-1==e)return m("InvalidChar","char '&' is not expected.",N(t,r));r=e}else if(!0===s&&!l(t[r]))return m("InvalidXml","Extra text at the end",N(t,r));"<"===t[r]&&r--}}}return i?1==n.length?m("InvalidTag","Unclosed tag '"+n[0].tagName+"'.",N(t,n[0].tagStartPos)):!(n.length>0)||m("InvalidXml","Invalid '"+JSON.stringify(n.map(t=>t.tagName),null,4).replace(/\r?\n/g,"")+"' found.",{line:1,col:1}):m("InvalidXml","Start tag expected.",1)}function l(t){return" "===t||"\t"===t||"\n"===t||"\r"===t}function u(t,e){const n=e;for(;e<t.length;e++)if("?"==t[e]||" "==t[e]){const i=t.substr(n,e-n);if(e>5&&"xml"===i)return m("InvalidXml","XML declaration allowed only at the start of the document.",N(t,e));if("?"==t[e]&&">"==t[e+1]){e++;break}continue}return e}function d(t,e){if(t.length>e+5&&"-"===t[e+1]&&"-"===t[e+2]){for(e+=3;e<t.length;e++)if("-"===t[e]&&"-"===t[e+1]&&">"===t[e+2]){e+=2;break}}else if(t.length>e+8&&"D"===t[e+1]&&"O"===t[e+2]&&"C"===t[e+3]&&"T"===t[e+4]&&"Y"===t[e+5]&&"P"===t[e+6]&&"E"===t[e+7]){let n=1;for(e+=8;e<t.length;e++)if("<"===t[e])n++;else if(">"===t[e]&&(n--,0===n))break}else if(t.length>e+9&&"["===t[e+1]&&"C"===t[e+2]&&"D"===t[e+3]&&"A"===t[e+4]&&"T"===t[e+5]&&"A"===t[e+6]&&"["===t[e+7])for(e+=8;e<t.length;e++)if("]"===t[e]&&"]"===t[e+1]&&">"===t[e+2]){e+=2;break}return e}const h='"',p="'";function c(t,e){let n="",i="",s=!1;for(;e<t.length;e++){if(t[e]===h||t[e]===p)""===i?i=t[e]:i!==t[e]||(i="");else if(">"===t[e]&&""===i){s=!0;break}n+=t[e]}return""===i&&{value:n,index:e,tagClosed:s}}const f=new RegExp("(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['\"])(([\\s\\S])*?)\\5)?","g");function g(t,e){const n=s(t,f),i={};for(let t=0;t<n.length;t++){if(0===n[t][1].length)return m("InvalidAttr","Attribute '"+n[t][2]+"' has no space in starting.",y(n[t]));if(void 0!==n[t][3]&&void 0===n[t][4])return m("InvalidAttr","Attribute '"+n[t][2]+"' is without value.",y(n[t]));if(void 0===n[t][3]&&!e.allowBooleanAttributes)return m("InvalidAttr","boolean attribute '"+n[t][2]+"' is not allowed.",y(n[t]));const s=n[t][2];if(!E(s))return m("InvalidAttr","Attribute '"+s+"' is an invalid name.",y(n[t]));if(Object.prototype.hasOwnProperty.call(i,s))return m("InvalidAttr","Attribute '"+s+"' is repeated.",y(n[t]));i[s]=1}return!0}function x(t,e){if(";"===t[++e])return-1;if("#"===t[e])return function(t,e){let n=/\d/;for("x"===t[e]&&(e++,n=/[\da-fA-F]/);e<t.length;e++){if(";"===t[e])return e;if(!t[e].match(n))break}return-1}(t,++e);let n=0;for(;e<t.length;e++,n++)if(!(t[e].match(/\w/)&&n<20)){if(";"===t[e])break;return-1}return e}function m(t,e,n){return{err:{code:t,msg:e,line:n.line||n,col:n.col}}}function E(t){return r(t)}function b(t){return r(t)}function N(t,e){const n=t.substring(0,e).split(/\r?\n/);return{line:n.length,col:n[n.length-1].length+1}}function y(t){return t.startIndex+t[1].length}const T={preserveOrder:!1,attributeNamePrefix:"@_",attributesGroupName:!1,textNodeName:"#text",ignoreAttributes:!0,removeNSPrefix:!1,allowBooleanAttributes:!1,parseTagValue:!0,parseAttributeValue:!1,trimValues:!0,cdataPropName:!1,numberParseOptions:{hex:!0,leadingZeros:!0,eNotation:!0},tagValueProcessor:function(t,e){return e},attributeValueProcessor:function(t,e){return e},stopNodes:[],alwaysCreateTextNode:!1,isArray:()=>!1,commentPropName:!1,unpairedTags:[],processEntities:!0,htmlEntities:!1,ignoreDeclaration:!1,ignorePiTags:!1,transformTagName:!1,transformAttributeName:!1,updateTag:function(t,e,n){return t},captureMetaData:!1,maxNestedTags:100,strictReservedNames:!0};function w(t){return"boolean"==typeof t?{enabled:t,maxEntitySize:1e4,maxExpansionDepth:10,maxTotalExpansions:1e3,maxExpandedLength:1e5,allowedTags:null,tagFilter:null}:"object"==typeof t&&null!==t?{enabled:!1!==t.enabled,maxEntitySize:t.maxEntitySize??1e4,maxExpansionDepth:t.maxExpansionDepth??10,maxTotalExpansions:t.maxTotalExpansions??1e3,maxExpandedLength:t.maxExpandedLength??1e5,allowedTags:t.allowedTags??null,tagFilter:t.tagFilter??null}:w(!0)}const v=function(t){const e=Object.assign({},T,t);return e.processEntities=w(e.processEntities),e};let O;O="function"!=typeof Symbol?"@@xmlMetadata":Symbol("XML Node Metadata");class I{constructor(t){this.tagname=t,this.child=[],this[":@"]=Object.create(null)}add(t,e){"__proto__"===t&&(t="#__proto__"),this.child.push({[t]:e})}addChild(t,e){"__proto__"===t.tagname&&(t.tagname="#__proto__"),t[":@"]&&Object.keys(t[":@"]).length>0?this.child.push({[t.tagname]:t.child,":@":t[":@"]}):this.child.push({[t.tagname]:t.child}),void 0!==e&&(this.child[this.child.length-1][O]={startIndex:e})}static getMetaDataSymbol(){return O}}class P{constructor(t){this.suppressValidationErr=!t,this.options=t}readDocType(t,e){const n=Object.create(null);if("O"!==t[e+3]||"C"!==t[e+4]||"T"!==t[e+5]||"Y"!==t[e+6]||"P"!==t[e+7]||"E"!==t[e+8])throw new Error("Invalid Tag instead of DOCTYPE");{e+=9;let i=1,s=!1,r=!1,o="";for(;e<t.length;e++)if("<"!==t[e]||r)if(">"===t[e]){if(r?"-"===t[e-1]&&"-"===t[e-2]&&(r=!1,i--):i--,0===i)break}else"["===t[e]?s=!0:o+=t[e];else{if(s&&S(t,"!ENTITY",e)){let i,s;if(e+=7,[i,s,e]=this.readEntityExp(t,e+1,this.suppressValidationErr),-1===s.indexOf("&")){const t=i.replace(/[.\-+*:]/g,"\\.");n[i]={regx:RegExp(`&${t};`,"g"),val:s}}}else if(s&&S(t,"!ELEMENT",e)){e+=8;const{index:n}=this.readElementExp(t,e+1);e=n}else if(s&&S(t,"!ATTLIST",e))e+=8;else if(s&&S(t,"!NOTATION",e)){e+=9;const{index:n}=this.readNotationExp(t,e+1,this.suppressValidationErr);e=n}else{if(!S(t,"!--",e))throw new Error("Invalid DOCTYPE");r=!0}i++,o=""}if(0!==i)throw new Error("Unclosed DOCTYPE")}return{entities:n,i:e}}readEntityExp(t,e){e=A(t,e);let n="";for(;e<t.length&&!/\s/.test(t[e])&&'"'!==t[e]&&"'"!==t[e];)n+=t[e],e++;if(C(n),e=A(t,e),!this.suppressValidationErr){if("SYSTEM"===t.substring(e,e+6).toUpperCase())throw new Error("External entities are not supported");if("%"===t[e])throw new Error("Parameter entities are not supported")}let i="";if([e,i]=this.readIdentifierVal(t,e,"entity"),!1!==this.options.enabled&&this.options.maxEntitySize&&i.length>this.options.maxEntitySize)throw new Error(`Entity "${n}" size (${i.length}) exceeds maximum allowed size (${this.options.maxEntitySize})`);return[n,i,--e]}readNotationExp(t,e){e=A(t,e);let n="";for(;e<t.length&&!/\s/.test(t[e]);)n+=t[e],e++;!this.suppressValidationErr&&C(n),e=A(t,e);const i=t.substring(e,e+6).toUpperCase();if(!this.suppressValidationErr&&"SYSTEM"!==i&&"PUBLIC"!==i)throw new Error(`Expected SYSTEM or PUBLIC, found "${i}"`);e+=i.length,e=A(t,e);let s=null,r=null;if("PUBLIC"===i)[e,s]=this.readIdentifierVal(t,e,"publicIdentifier"),'"'!==t[e=A(t,e)]&&"'"!==t[e]||([e,r]=this.readIdentifierVal(t,e,"systemIdentifier"));else if("SYSTEM"===i&&([e,r]=this.readIdentifierVal(t,e,"systemIdentifier"),!this.suppressValidationErr&&!r))throw new Error("Missing mandatory system identifier for SYSTEM notation");return{notationName:n,publicIdentifier:s,systemIdentifier:r,index:--e}}readIdentifierVal(t,e,n){let i="";const s=t[e];if('"'!==s&&"'"!==s)throw new Error(`Expected quoted string, found "${s}"`);for(e++;e<t.length&&t[e]!==s;)i+=t[e],e++;if(t[e]!==s)throw new Error(`Unterminated ${n} value`);return[++e,i]}readElementExp(t,e){e=A(t,e);let n="";for(;e<t.length&&!/\s/.test(t[e]);)n+=t[e],e++;if(!this.suppressValidationErr&&!r(n))throw new Error(`Invalid element name: "${n}"`);let i="";if("E"===t[e=A(t,e)]&&S(t,"MPTY",e))e+=4;else if("A"===t[e]&&S(t,"NY",e))e+=2;else if("("===t[e]){for(e++;e<t.length&&")"!==t[e];)i+=t[e],e++;if(")"!==t[e])throw new Error("Unterminated content model")}else if(!this.suppressValidationErr)throw new Error(`Invalid Element Expression, found "${t[e]}"`);return{elementName:n,contentModel:i.trim(),index:e}}readAttlistExp(t,e){e=A(t,e);let n="";for(;e<t.length&&!/\s/.test(t[e]);)n+=t[e],e++;C(n),e=A(t,e);let i="";for(;e<t.length&&!/\s/.test(t[e]);)i+=t[e],e++;if(!C(i))throw new Error(`Invalid attribute name: "${i}"`);e=A(t,e);let s="";if("NOTATION"===t.substring(e,e+8).toUpperCase()){if(s="NOTATION","("!==t[e=A(t,e+=8)])throw new Error(`Expected '(', found "${t[e]}"`);e++;let n=[];for(;e<t.length&&")"!==t[e];){let i="";for(;e<t.length&&"|"!==t[e]&&")"!==t[e];)i+=t[e],e++;if(i=i.trim(),!C(i))throw new Error(`Invalid notation name: "${i}"`);n.push(i),"|"===t[e]&&(e++,e=A(t,e))}if(")"!==t[e])throw new Error("Unterminated list of notations");e++,s+=" ("+n.join("|")+")"}else{for(;e<t.length&&!/\s/.test(t[e]);)s+=t[e],e++;const n=["CDATA","ID","IDREF","IDREFS","ENTITY","ENTITIES","NMTOKEN","NMTOKENS"];if(!this.suppressValidationErr&&!n.includes(s.toUpperCase()))throw new Error(`Invalid attribute type: "${s}"`)}e=A(t,e);let r="";return"#REQUIRED"===t.substring(e,e+8).toUpperCase()?(r="#REQUIRED",e+=8):"#IMPLIED"===t.substring(e,e+7).toUpperCase()?(r="#IMPLIED",e+=7):[e,r]=this.readIdentifierVal(t,e,"ATTLIST"),{elementName:n,attributeName:i,attributeType:s,defaultValue:r,index:e}}}const A=(t,e)=>{for(;e<t.length&&/\s/.test(t[e]);)e++;return e};function S(t,e,n){for(let i=0;i<e.length;i++)if(e[i]!==t[n+i+1])return!1;return!0}function C(t){if(r(t))return t;throw new Error(`Invalid entity name ${t}`)}const $=/^[-+]?0x[a-fA-F0-9]+$/,V=/^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/,D={hex:!0,leadingZeros:!0,decimalPoint:".",eNotation:!0};const j=/^([-+])?(0*)(\d*(\.\d*)?[eE][-\+]?\d+)$/;class L{constructor(t){var e;if(this.options=t,this.currentNode=null,this.tagsNodeStack=[],this.docTypeEntities={},this.lastEntities={apos:{regex:/&(apos|#39|#x27);/g,val:"'"},gt:{regex:/&(gt|#62|#x3E);/g,val:">"},lt:{regex:/&(lt|#60|#x3C);/g,val:"<"},quot:{regex:/&(quot|#34|#x22);/g,val:'"'}},this.ampEntity={regex:/&(amp|#38|#x26);/g,val:"&"},this.htmlEntities={space:{regex:/&(nbsp|#160);/g,val:" "},cent:{regex:/&(cent|#162);/g,val:"¢"},pound:{regex:/&(pound|#163);/g,val:"£"},yen:{regex:/&(yen|#165);/g,val:"¥"},euro:{regex:/&(euro|#8364);/g,val:"€"},copyright:{regex:/&(copy|#169);/g,val:"©"},reg:{regex:/&(reg|#174);/g,val:"®"},inr:{regex:/&(inr|#8377);/g,val:"₹"},num_dec:{regex:/&#([0-9]{1,7});/g,val:(t,e)=>K(e,10,"&#")},num_hex:{regex:/&#x([0-9a-fA-F]{1,6});/g,val:(t,e)=>K(e,16,"&#x")}},this.addExternalEntities=F,this.parseXml=R,this.parseTextData=M,this.resolveNameSpace=k,this.buildAttributesMap=U,this.isItStopNode=X,this.replaceEntitiesValue=Y,this.readStopNodeData=q,this.saveTextToParentTag=G,this.addChild=B,this.ignoreAttributesFn="function"==typeof(e=this.options.ignoreAttributes)?e:Array.isArray(e)?t=>{for(const n of e){if("string"==typeof n&&t===n)return!0;if(n instanceof RegExp&&n.test(t))return!0}}:()=>!1,this.entityExpansionCount=0,this.currentExpandedLength=0,this.options.stopNodes&&this.options.stopNodes.length>0){this.stopNodesExact=new Set,this.stopNodesWildcard=new Set;for(let t=0;t<this.options.stopNodes.length;t++){const e=this.options.stopNodes[t];"string"==typeof e&&(e.startsWith("*.")?this.stopNodesWildcard.add(e.substring(2)):this.stopNodesExact.add(e))}}}}function F(t){const e=Object.keys(t);for(let n=0;n<e.length;n++){const i=e[n],s=i.replace(/[.\-+*:]/g,"\\.");this.lastEntities[i]={regex:new RegExp("&"+s+";","g"),val:t[i]}}}function M(t,e,n,i,s,r,o){if(void 0!==t&&(this.options.trimValues&&!i&&(t=t.trim()),t.length>0)){o||(t=this.replaceEntitiesValue(t,e,n));const i=this.options.tagValueProcessor(e,t,n,s,r);return null==i?t:typeof i!=typeof t||i!==t?i:this.options.trimValues||t.trim()===t?Z(t,this.options.parseTagValue,this.options.numberParseOptions):t}}function k(t){if(this.options.removeNSPrefix){const e=t.split(":"),n="/"===t.charAt(0)?"/":"";if("xmlns"===e[0])return"";2===e.length&&(t=n+e[1])}return t}const _=new RegExp("([^\\s=]+)\\s*(=\\s*(['\"])([\\s\\S]*?)\\3)?","gm");function U(t,e,n){if(!0!==this.options.ignoreAttributes&&"string"==typeof t){const i=s(t,_),r=i.length,o={};for(let t=0;t<r;t++){const s=this.resolveNameSpace(i[t][1]);if(this.ignoreAttributesFn(s,e))continue;let r=i[t][4],a=this.options.attributeNamePrefix+s;if(s.length)if(this.options.transformAttributeName&&(a=this.options.transformAttributeName(a)),"__proto__"===a&&(a="#__proto__"),void 0!==r){this.options.trimValues&&(r=r.trim()),r=this.replaceEntitiesValue(r,n,e);const t=this.options.attributeValueProcessor(s,r,e);o[a]=null==t?r:typeof t!=typeof r||t!==r?t:Z(r,this.options.parseAttributeValue,this.options.numberParseOptions)}else this.options.allowBooleanAttributes&&(o[a]=!0)}if(!Object.keys(o).length)return;if(this.options.attributesGroupName){const t={};return t[this.options.attributesGroupName]=o,t}return o}}const R=function(t){t=t.replace(/\r\n?/g,"\n");const e=new I("!xml");let n=e,i="",s="";this.entityExpansionCount=0,this.currentExpandedLength=0;const r=new P(this.options.processEntities);for(let o=0;o<t.length;o++)if("<"===t[o])if("/"===t[o+1]){const e=z(t,">",o,"Closing Tag is not closed.");let r=t.substring(o+2,e).trim();if(this.options.removeNSPrefix){const t=r.indexOf(":");-1!==t&&(r=r.substr(t+1))}this.options.transformTagName&&(r=this.options.transformTagName(r)),n&&(i=this.saveTextToParentTag(i,n,s));const a=s.substring(s.lastIndexOf(".")+1);if(r&&-1!==this.options.unpairedTags.indexOf(r))throw new Error(`Unpaired tag can not be used as closing tag: </${r}>`);let l=0;a&&-1!==this.options.unpairedTags.indexOf(a)?(l=s.lastIndexOf(".",s.lastIndexOf(".")-1),this.tagsNodeStack.pop()):l=s.lastIndexOf("."),s=s.substring(0,l),n=this.tagsNodeStack.pop(),i="",o=e}else if("?"===t[o+1]){let e=W(t,o,!1,"?>");if(!e)throw new Error("Pi Tag is not closed.");if(i=this.saveTextToParentTag(i,n,s),this.options.ignoreDeclaration&&"?xml"===e.tagName||this.options.ignorePiTags);else{const t=new I(e.tagName);t.add(this.options.textNodeName,""),e.tagName!==e.tagExp&&e.attrExpPresent&&(t[":@"]=this.buildAttributesMap(e.tagExp,s,e.tagName)),this.addChild(n,t,s,o)}o=e.closeIndex+1}else if("!--"===t.substr(o+1,3)){const e=z(t,"--\x3e",o+4,"Comment is not closed.");if(this.options.commentPropName){const r=t.substring(o+4,e-2);i=this.saveTextToParentTag(i,n,s),n.add(this.options.commentPropName,[{[this.options.textNodeName]:r}])}o=e}else if("!D"===t.substr(o+1,2)){const e=r.readDocType(t,o);this.docTypeEntities=e.entities,o=e.i}else if("!["===t.substr(o+1,2)){const e=z(t,"]]>",o,"CDATA is not closed.")-2,r=t.substring(o+9,e);i=this.saveTextToParentTag(i,n,s);let a=this.parseTextData(r,n.tagname,s,!0,!1,!0,!0);null==a&&(a=""),this.options.cdataPropName?n.add(this.options.cdataPropName,[{[this.options.textNodeName]:r}]):n.add(this.options.textNodeName,a),o=e+2}else{let r=W(t,o,this.options.removeNSPrefix),a=r.tagName;const l=r.rawTagName;let u=r.tagExp,d=r.attrExpPresent,h=r.closeIndex;if(this.options.transformTagName){const t=this.options.transformTagName(a);u===a&&(u=t),a=t}if(this.options.strictReservedNames&&(a===this.options.commentPropName||a===this.options.cdataPropName))throw new Error(`Invalid tag name: ${a}`);n&&i&&"!xml"!==n.tagname&&(i=this.saveTextToParentTag(i,n,s,!1));const p=n;p&&-1!==this.options.unpairedTags.indexOf(p.tagname)&&(n=this.tagsNodeStack.pop(),s=s.substring(0,s.lastIndexOf("."))),a!==e.tagname&&(s+=s?"."+a:a);const c=o;if(this.isItStopNode(this.stopNodesExact,this.stopNodesWildcard,s,a)){let e="";if(u.length>0&&u.lastIndexOf("/")===u.length-1)"/"===a[a.length-1]?(a=a.substr(0,a.length-1),s=s.substr(0,s.length-1),u=a):u=u.substr(0,u.length-1),o=r.closeIndex;else if(-1!==this.options.unpairedTags.indexOf(a))o=r.closeIndex;else{const n=this.readStopNodeData(t,l,h+1);if(!n)throw new Error(`Unexpected end of ${l}`);o=n.i,e=n.tagContent}const i=new I(a);a!==u&&d&&(i[":@"]=this.buildAttributesMap(u,s,a)),e&&(e=this.parseTextData(e,a,s,!0,d,!0,!0)),s=s.substr(0,s.lastIndexOf(".")),i.add(this.options.textNodeName,e),this.addChild(n,i,s,c)}else{if(u.length>0&&u.lastIndexOf("/")===u.length-1){if("/"===a[a.length-1]?(a=a.substr(0,a.length-1),s=s.substr(0,s.length-1),u=a):u=u.substr(0,u.length-1),this.options.transformTagName){const t=this.options.transformTagName(a);u===a&&(u=t),a=t}const t=new I(a);a!==u&&d&&(t[":@"]=this.buildAttributesMap(u,s,a)),this.addChild(n,t,s,c),s=s.substr(0,s.lastIndexOf("."))}else{if(-1!==this.options.unpairedTags.indexOf(a)){const t=new I(a);a!==u&&d&&(t[":@"]=this.buildAttributesMap(u,s)),this.addChild(n,t,s,c),s=s.substr(0,s.lastIndexOf(".")),o=r.closeIndex;continue}{const t=new I(a);if(this.tagsNodeStack.length>this.options.maxNestedTags)throw new Error("Maximum nested tags exceeded");this.tagsNodeStack.push(n),a!==u&&d&&(t[":@"]=this.buildAttributesMap(u,s,a)),this.addChild(n,t,s,c),n=t}}i="",o=h}}else i+=t[o];return e.child};function B(t,e,n,i){this.options.captureMetaData||(i=void 0);const s=this.options.updateTag(e.tagname,n,e[":@"]);!1===s||("string"==typeof s?(e.tagname=s,t.addChild(e,i)):t.addChild(e,i))}const Y=function(t,e,n){if(-1===t.indexOf("&"))return t;const i=this.options.processEntities;if(!i.enabled)return t;if(i.allowedTags&&!i.allowedTags.includes(e))return t;if(i.tagFilter&&!i.tagFilter(e,n))return t;for(let e in this.docTypeEntities){const n=this.docTypeEntities[e],s=t.match(n.regx);if(s){if(this.entityExpansionCount+=s.length,i.maxTotalExpansions&&this.entityExpansionCount>i.maxTotalExpansions)throw new Error(`Entity expansion limit exceeded: ${this.entityExpansionCount} > ${i.maxTotalExpansions}`);const e=t.length;if(t=t.replace(n.regx,n.val),i.maxExpandedLength&&(this.currentExpandedLength+=t.length-e,this.currentExpandedLength>i.maxExpandedLength))throw new Error(`Total expanded content size exceeded: ${this.currentExpandedLength} > ${i.maxExpandedLength}`)}}if(-1===t.indexOf("&"))return t;for(let e in this.lastEntities){const n=this.lastEntities[e];t=t.replace(n.regex,n.val)}if(-1===t.indexOf("&"))return t;if(this.options.htmlEntities)for(let e in this.htmlEntities){const n=this.htmlEntities[e];t=t.replace(n.regex,n.val)}return t.replace(this.ampEntity.regex,this.ampEntity.val)};function G(t,e,n,i){return t&&(void 0===i&&(i=0===e.child.length),void 0!==(t=this.parseTextData(t,e.tagname,n,!1,!!e[":@"]&&0!==Object.keys(e[":@"]).length,i))&&""!==t&&e.add(this.options.textNodeName,t),t=""),t}function X(t,e,n,i){return!(!e||!e.has(i))||!(!t||!t.has(n))}function z(t,e,n,i){const s=t.indexOf(e,n);if(-1===s)throw new Error(i);return s+e.length-1}function W(t,e,n,i=">"){const s=function(t,e,n=">"){let i,s="";for(let r=e;r<t.length;r++){let e=t[r];if(i)e===i&&(i="");else if('"'===e||"'"===e)i=e;else if(e===n[0]){if(!n[1])return{data:s,index:r};if(t[r+1]===n[1])return{data:s,index:r}}else"\t"===e&&(e=" ");s+=e}}(t,e+1,i);if(!s)return;let r=s.data;const o=s.index,a=r.search(/\s/);let l=r,u=!0;-1!==a&&(l=r.substring(0,a),r=r.substring(a+1).trimStart());const d=l;if(n){const t=l.indexOf(":");-1!==t&&(l=l.substr(t+1),u=l!==s.data.substr(t+1))}return{tagName:l,tagExp:r,closeIndex:o,attrExpPresent:u,rawTagName:d}}function q(t,e,n){const i=n;let s=1;for(;n<t.length;n++)if("<"===t[n])if("/"===t[n+1]){const r=z(t,">",n,`${e} is not closed`);if(t.substring(n+2,r).trim()===e&&(s--,0===s))return{tagContent:t.substring(i,n),i:r};n=r}else if("?"===t[n+1])n=z(t,"?>",n+1,"StopNode is not closed.");else if("!--"===t.substr(n+1,3))n=z(t,"--\x3e",n+3,"StopNode is not closed.");else if("!["===t.substr(n+1,2))n=z(t,"]]>",n,"StopNode is not closed.")-2;else{const i=W(t,n,">");i&&((i&&i.tagName)===e&&"/"!==i.tagExp[i.tagExp.length-1]&&s++,n=i.closeIndex)}}function Z(t,e,n){if(e&&"string"==typeof t){const e=t.trim();return"true"===e||"false"!==e&&function(t,e={}){if(e=Object.assign({},D,e),!t||"string"!=typeof t)return t;let n=t.trim();if(void 0!==e.skipLike&&e.skipLike.test(n))return t;if("0"===t)return 0;if(e.hex&&$.test(n))return function(t){if(parseInt)return parseInt(t,16);if(Number.parseInt)return Number.parseInt(t,16);if(window&&window.parseInt)return window.parseInt(t,16);throw new Error("parseInt, Number.parseInt, window.parseInt are not supported")}(n);if(n.includes("e")||n.includes("E"))return function(t,e,n){if(!n.eNotation)return t;const i=e.match(j);if(i){let s=i[1]||"";const r=-1===i[3].indexOf("e")?"E":"e",o=i[2],a=s?t[o.length+1]===r:t[o.length]===r;return o.length>1&&a?t:1!==o.length||!i[3].startsWith(`.${r}`)&&i[3][0]!==r?n.leadingZeros&&!a?(e=(i[1]||"")+i[3],Number(e)):t:Number(e)}return t}(t,n,e);{const s=V.exec(n);if(s){const r=s[1]||"",o=s[2];let a=(i=s[3])&&-1!==i.indexOf(".")?("."===(i=i.replace(/0+$/,""))?i="0":"."===i[0]?i="0"+i:"."===i[i.length-1]&&(i=i.substring(0,i.length-1)),i):i;const l=r?"."===t[o.length+1]:"."===t[o.length];if(!e.leadingZeros&&(o.length>1||1===o.length&&!l))return t;{const i=Number(n),s=String(i);if(0===i)return i;if(-1!==s.search(/[eE]/))return e.eNotation?i:t;if(-1!==n.indexOf("."))return"0"===s||s===a||s===`${r}${a}`?i:t;let l=o?a:n;return o?l===s||r+l===s?i:t:l===s||l===r+s?i:t}}return t}var i}(t,n)}return void 0!==t?t:""}function K(t,e,n){const i=Number.parseInt(t,e);return i>=0&&i<=1114111?String.fromCodePoint(i):n+t+";"}const Q=I.getMetaDataSymbol();function J(t,e){return H(t,e)}function H(t,e,n){let i;const s={};for(let r=0;r<t.length;r++){const o=t[r],a=tt(o);let l="";if(l=void 0===n?a:n+"."+a,a===e.textNodeName)void 0===i?i=o[a]:i+=""+o[a];else{if(void 0===a)continue;if(o[a]){let t=H(o[a],e,l);const n=nt(t,e);o[":@"]?et(t,o[":@"],l,e):1!==Object.keys(t).length||void 0===t[e.textNodeName]||e.alwaysCreateTextNode?0===Object.keys(t).length&&(e.alwaysCreateTextNode?t[e.textNodeName]="":t=""):t=t[e.textNodeName],void 0!==o[Q]&&"object"==typeof t&&null!==t&&(t[Q]=o[Q]),void 0!==s[a]&&Object.prototype.hasOwnProperty.call(s,a)?(Array.isArray(s[a])||(s[a]=[s[a]]),s[a].push(t)):e.isArray(a,l,n)?s[a]=[t]:s[a]=t}}}return"string"==typeof i?i.length>0&&(s[e.textNodeName]=i):void 0!==i&&(s[e.textNodeName]=i),s}function tt(t){const e=Object.keys(t);for(let t=0;t<e.length;t++){const n=e[t];if(":@"!==n)return n}}function et(t,e,n,i){if(e){const s=Object.keys(e),r=s.length;for(let o=0;o<r;o++){const r=s[o];i.isArray(r,n+"."+r,!0,!0)?t[r]=[e[r]]:t[r]=e[r]}}}function nt(t,e){const{textNodeName:n}=e,i=Object.keys(t).length;return 0===i||!(1!==i||!t[n]&&"boolean"!=typeof t[n]&&0!==t[n])}class it{constructor(t){this.externalEntities={},this.options=v(t)}parse(t,e){if("string"!=typeof t&&t.toString)t=t.toString();else if("string"!=typeof t)throw new Error("XML data is accepted in String or Bytes[] form.");if(e){!0===e&&(e={});const n=a(t,e);if(!0!==n)throw Error(`${n.err.msg}:${n.err.line}:${n.err.col}`)}const n=new L(this.options);n.addExternalEntities(this.externalEntities);const i=n.parseXml(t);return this.options.preserveOrder||void 0===i?i:J(i,this.options)}addEntity(t,e){if(-1!==e.indexOf("&"))throw new Error("Entity value can't have '&'");if(-1!==t.indexOf("&")||-1!==t.indexOf(";"))throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");if("&"===e)throw new Error("An entity with value '&' is not permitted");this.externalEntities[t]=e}static getMetaDataSymbol(){return I.getMetaDataSymbol()}}function st(t,e){let n="";return e.format&&e.indentBy.length>0&&(n="\n"),rt(t,e,"",n)}function rt(t,e,n,i){let s="",r=!1;if(!Array.isArray(t)){if(null!=t){let n=t.toString();return n=ut(n,e),n}return""}for(let o=0;o<t.length;o++){const a=t[o],l=ot(a);if(void 0===l)continue;let u="";if(u=0===n.length?l:`${n}.${l}`,l===e.textNodeName){let t=a[l];lt(u,e)||(t=e.tagValueProcessor(l,t),t=ut(t,e)),r&&(s+=i),s+=t,r=!1;continue}if(l===e.cdataPropName){r&&(s+=i),s+=`<![CDATA[${a[l][0][e.textNodeName]}]]>`,r=!1;continue}if(l===e.commentPropName){s+=i+`\x3c!--${a[l][0][e.textNodeName]}--\x3e`,r=!0;continue}if("?"===l[0]){const t=at(a[":@"],e),n="?xml"===l?"":i;let o=a[l][0][e.textNodeName];o=0!==o.length?" "+o:"",s+=n+`<${l}${o}${t}?>`,r=!0;continue}let d=i;""!==d&&(d+=e.indentBy);const h=i+`<${l}${at(a[":@"],e)}`,p=rt(a[l],e,u,d);-1!==e.unpairedTags.indexOf(l)?e.suppressUnpairedNode?s+=h+">":s+=h+"/>":p&&0!==p.length||!e.suppressEmptyNode?p&&p.endsWith(">")?s+=h+`>${p}${i}</${l}>`:(s+=h+">",p&&""!==i&&(p.includes("/>")||p.includes("</"))?s+=i+e.indentBy+p+i:s+=p,s+=`</${l}>`):s+=h+"/>",r=!0}return s}function ot(t){const e=Object.keys(t);for(let n=0;n<e.length;n++){const i=e[n];if(Object.prototype.hasOwnProperty.call(t,i)&&":@"!==i)return i}}function at(t,e){let n="";if(t&&!e.ignoreAttributes)for(let i in t){if(!Object.prototype.hasOwnProperty.call(t,i))continue;let s=e.attributeValueProcessor(i,t[i]);s=ut(s,e),!0===s&&e.suppressBooleanAttributes?n+=` ${i.substr(e.attributeNamePrefix.length)}`:n+=` ${i.substr(e.attributeNamePrefix.length)}="${s}"`}return n}function lt(t,e){let n=(t=t.substr(0,t.length-e.textNodeName.length-1)).substr(t.lastIndexOf(".")+1);for(let i in e.stopNodes)if(e.stopNodes[i]===t||e.stopNodes[i]==="*."+n)return!0;return!1}function ut(t,e){if(t&&t.length>0&&e.processEntities)for(let n=0;n<e.entities.length;n++){const i=e.entities[n];t=t.replace(i.regex,i.val)}return t}const dt={attributeNamePrefix:"@_",attributesGroupName:!1,textNodeName:"#text",ignoreAttributes:!0,cdataPropName:!1,format:!1,indentBy:"  ",suppressEmptyNode:!1,suppressUnpairedNode:!0,suppressBooleanAttributes:!0,tagValueProcessor:function(t,e){return e},attributeValueProcessor:function(t,e){return e},preserveOrder:!1,commentPropName:!1,unpairedTags:[],entities:[{regex:new RegExp("&","g"),val:"&amp;"},{regex:new RegExp(">","g"),val:"&gt;"},{regex:new RegExp("<","g"),val:"&lt;"},{regex:new RegExp("'","g"),val:"&apos;"},{regex:new RegExp('"',"g"),val:"&quot;"}],processEntities:!0,stopNodes:[],oneListGroup:!1};function ht(t){var e;this.options=Object.assign({},dt,t),!0===this.options.ignoreAttributes||this.options.attributesGroupName?this.isAttribute=function(){return!1}:(this.ignoreAttributesFn="function"==typeof(e=this.options.ignoreAttributes)?e:Array.isArray(e)?t=>{for(const n of e){if("string"==typeof n&&t===n)return!0;if(n instanceof RegExp&&n.test(t))return!0}}:()=>!1,this.attrPrefixLen=this.options.attributeNamePrefix.length,this.isAttribute=ft),this.processTextOrObjNode=pt,this.options.format?(this.indentate=ct,this.tagEndChar=">\n",this.newLine="\n"):(this.indentate=function(){return""},this.tagEndChar=">",this.newLine="")}function pt(t,e,n,i){const s=this.j2x(t,n+1,i.concat(e));return void 0!==t[this.options.textNodeName]&&1===Object.keys(t).length?this.buildTextValNode(t[this.options.textNodeName],e,s.attrStr,n):this.buildObjectNode(s.val,e,s.attrStr,n)}function ct(t){return this.options.indentBy.repeat(t)}function ft(t){return!(!t.startsWith(this.options.attributeNamePrefix)||t===this.options.textNodeName)&&t.substr(this.attrPrefixLen)}ht.prototype.build=function(t){return this.options.preserveOrder?st(t,this.options):(Array.isArray(t)&&this.options.arrayNodeName&&this.options.arrayNodeName.length>1&&(t={[this.options.arrayNodeName]:t}),this.j2x(t,0,[]).val)},ht.prototype.j2x=function(t,e,n){let i="",s="";const r=n.join(".");for(let o in t)if(Object.prototype.hasOwnProperty.call(t,o))if(void 0===t[o])this.isAttribute(o)&&(s+="");else if(null===t[o])this.isAttribute(o)||o===this.options.cdataPropName?s+="":"?"===o[0]?s+=this.indentate(e)+"<"+o+"?"+this.tagEndChar:s+=this.indentate(e)+"<"+o+"/"+this.tagEndChar;else if(t[o]instanceof Date)s+=this.buildTextValNode(t[o],o,"",e);else if("object"!=typeof t[o]){const n=this.isAttribute(o);if(n&&!this.ignoreAttributesFn(n,r))i+=this.buildAttrPairStr(n,""+t[o]);else if(!n)if(o===this.options.textNodeName){let e=this.options.tagValueProcessor(o,""+t[o]);s+=this.replaceEntitiesValue(e)}else s+=this.buildTextValNode(t[o],o,"",e)}else if(Array.isArray(t[o])){const i=t[o].length;let r="",a="";for(let l=0;l<i;l++){const i=t[o][l];if(void 0===i);else if(null===i)"?"===o[0]?s+=this.indentate(e)+"<"+o+"?"+this.tagEndChar:s+=this.indentate(e)+"<"+o+"/"+this.tagEndChar;else if("object"==typeof i)if(this.options.oneListGroup){const t=this.j2x(i,e+1,n.concat(o));r+=t.val,this.options.attributesGroupName&&i.hasOwnProperty(this.options.attributesGroupName)&&(a+=t.attrStr)}else r+=this.processTextOrObjNode(i,o,e,n);else if(this.options.oneListGroup){let t=this.options.tagValueProcessor(o,i);t=this.replaceEntitiesValue(t),r+=t}else r+=this.buildTextValNode(i,o,"",e)}this.options.oneListGroup&&(r=this.buildObjectNode(r,o,a,e)),s+=r}else if(this.options.attributesGroupName&&o===this.options.attributesGroupName){const e=Object.keys(t[o]),n=e.length;for(let s=0;s<n;s++)i+=this.buildAttrPairStr(e[s],""+t[o][e[s]])}else s+=this.processTextOrObjNode(t[o],o,e,n);return{attrStr:i,val:s}},ht.prototype.buildAttrPairStr=function(t,e){return e=this.options.attributeValueProcessor(t,""+e),e=this.replaceEntitiesValue(e),this.options.suppressBooleanAttributes&&"true"===e?" "+t:" "+t+'="'+e+'"'},ht.prototype.buildObjectNode=function(t,e,n,i){if(""===t)return"?"===e[0]?this.indentate(i)+"<"+e+n+"?"+this.tagEndChar:this.indentate(i)+"<"+e+n+this.closeTag(e)+this.tagEndChar;{let s="</"+e+this.tagEndChar,r="";return"?"===e[0]&&(r="?",s=""),!n&&""!==n||-1!==t.indexOf("<")?!1!==this.options.commentPropName&&e===this.options.commentPropName&&0===r.length?this.indentate(i)+`\x3c!--${t}--\x3e`+this.newLine:this.indentate(i)+"<"+e+n+r+this.tagEndChar+t+this.indentate(i)+s:this.indentate(i)+"<"+e+n+r+">"+t+s}},ht.prototype.closeTag=function(t){let e="";return-1!==this.options.unpairedTags.indexOf(t)?this.options.suppressUnpairedNode||(e="/"):e=this.options.suppressEmptyNode?"/":`></${t}`,e},ht.prototype.buildTextValNode=function(t,e,n,i){if(!1!==this.options.cdataPropName&&e===this.options.cdataPropName)return this.indentate(i)+`<![CDATA[${t}]]>`+this.newLine;if(!1!==this.options.commentPropName&&e===this.options.commentPropName)return this.indentate(i)+`\x3c!--${t}--\x3e`+this.newLine;if("?"===e[0])return this.indentate(i)+"<"+e+n+"?"+this.tagEndChar;{let s=this.options.tagValueProcessor(e,t);return s=this.replaceEntitiesValue(s),""===s?this.indentate(i)+"<"+e+n+this.closeTag(e)+this.tagEndChar:this.indentate(i)+"<"+e+n+">"+s+"</"+e+this.tagEndChar}},ht.prototype.replaceEntitiesValue=function(t){if(t&&t.length>0&&this.options.processEntities)for(let e=0;e<this.options.entities.length;e++){const n=this.options.entities[e];t=t.replace(n.regex,n.val)}return t};const gt=ht,xt={validate:a};module.exports=e})();
 
 /***/ }),
 
diff --git a/docs/advanced-usage.md b/docs/advanced-usage.md
index a82e422..b4035c6 100644
--- a/docs/advanced-usage.md
+++ b/docs/advanced-usage.md
@@ -31,7 +31,7 @@ Inputs `java-version` and `distribution` are mandatory and needs to be provided.
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'temurin'
@@ -44,7 +44,7 @@ steps:
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'adopt-hotspot'
@@ -56,7 +56,7 @@ steps:
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'zulu'
@@ -69,7 +69,7 @@ steps:
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'liberica'
@@ -82,7 +82,7 @@ steps:
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'microsoft'
@@ -111,7 +111,7 @@ If the runner is not able to access github.com, any Java versions requested duri
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'corretto'
@@ -124,7 +124,7 @@ steps:
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'oracle'
@@ -137,7 +137,7 @@ steps:
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'dragonwell'
@@ -149,7 +149,7 @@ steps:
 **NOTE:** An OpenJDK release maintained and supported by SAP
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'sapmachine'
@@ -162,7 +162,7 @@ steps:
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'graalvm'
@@ -181,7 +181,7 @@ For example, `11.0.24` is not available but `11.0.16` is.
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'jetbrains'
@@ -194,7 +194,7 @@ GitHub token to the action to increase the rate limit. Set the `GITHUB_TOKEN` en
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'jetbrains'
@@ -219,7 +219,7 @@ The available package types are:
 ## Installing custom Java package type
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: '<distribution>'
@@ -232,7 +232,7 @@ steps:
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: '<distribution>'
@@ -296,7 +296,7 @@ jobs:
         java: [ '8', '11' ]
     name: Java ${{ matrix.Java }} (${{ matrix.distribution }}) sample
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Setup java
         uses: actions/setup-java@v5
         with:
@@ -316,7 +316,7 @@ jobs:
         os: [ 'ubuntu-latest', 'macos-latest', 'windows-latest' ]
     name: Java ${{ matrix.Java }} (${{ matrix.os }}) sample
     steps:
-      - uses: actions/checkout@v5
+      - uses: actions/checkout@v6
       - name: Setup java
         uses: actions/setup-java@v5
         with:
@@ -333,7 +333,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
     - name: Set up JDK 11
       uses: actions/setup-java@v5
       with:
@@ -446,7 +446,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
     - name: Set up JDK 11 for Shared Runner
       uses: actions/setup-java@v5
       with:
@@ -472,7 +472,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v5
+    - uses: actions/checkout@v6
 
     - name: Set up JDK 11
       uses: actions/setup-java@v5
@@ -574,7 +574,7 @@ Each JDK provider will receive a default `id` based on the combination of `distr
 
 ```yaml
 steps:
-- uses: actions/checkout@v5
+- uses: actions/checkout@v6
 - uses: actions/setup-java@v5
   with:
     distribution: 'temurin'
diff --git a/package-lock.json b/package-lock.json
index 382cd32..78c46ca 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "setup-java",
-  "version": "5.0.1",
+  "version": "5.2.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "setup-java",
-      "version": "5.0.1",
+      "version": "5.2.0",
       "license": "MIT",
       "dependencies": {
         "@actions/cache": "^5.0.1",
@@ -17,7 +17,7 @@
         "@actions/io": "^1.0.2",
         "@actions/tool-cache": "^2.0.1",
         "semver": "^7.6.0",
-        "xmlbuilder2": "^4.0.3"
+        "xmlbuilder2": "^2.4.0"
       },
       "devDependencies": {
         "@types/jest": "^29.5.14",
@@ -86,13 +86,13 @@
       }
     },
     "node_modules/@actions/cache/node_modules/@actions/http-client": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-3.0.0.tgz",
-      "integrity": "sha512-1s3tXAfVMSz9a4ZEBkXXRQD4QhY3+GAsWSbaYpeknPOKEeyRiU3lH+bHiLMZdo2x/fIeQ/hscL1wCkDLVM2DZQ==",
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/@actions/http-client/-/http-client-3.0.2.tgz",
+      "integrity": "sha512-JP38FYYpyqvUsz+Igqlc/JG6YO9PaKuvqjM3iGvaLqFnJ7TFmcLyy2IDrY0bI0qCQug8E9K+elv5ZNfw62ZJzA==",
       "license": "MIT",
       "dependencies": {
         "tunnel": "^0.0.6",
-        "undici": "^5.28.5"
+        "undici": "^6.23.0"
       }
     },
     "node_modules/@actions/cache/node_modules/@actions/io": {
@@ -109,6 +109,15 @@
         "semver": "bin/semver.js"
       }
     },
+    "node_modules/@actions/cache/node_modules/undici": {
+      "version": "6.23.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-6.23.0.tgz",
+      "integrity": "sha512-VfQPToRA5FZs/qJxLIinmU59u0r7LXqoJkCzinq3ckNJp3vKEh7jTWN589YQ5+aoAC/TGRLyJLCPKcLQbM8r9g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.17"
+      }
+    },
     "node_modules/@actions/core": {
       "version": "1.11.1",
       "resolved": "https://registry.npmjs.org/@actions/core/-/core-1.11.1.tgz",
@@ -1540,51 +1549,47 @@
       }
     },
     "node_modules/@oozcitak/dom": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/@oozcitak/dom/-/dom-2.0.2.tgz",
-      "integrity": "sha512-GjpKhkSYC3Mj4+lfwEyI1dqnsKTgwGy48ytZEhm4A/xnH/8z9M3ZVXKr/YGQi3uCLs1AEBS+x5T2JPiueEDW8w==",
-      "license": "MIT",
+      "version": "1.15.8",
+      "resolved": "https://registry.npmjs.org/@oozcitak/dom/-/dom-1.15.8.tgz",
+      "integrity": "sha512-MoOnLBNsF+ok0HjpAvxYxR4piUhRDCEWK0ot3upwOOHYudJd30j6M+LNcE8RKpwfnclAX9T66nXXzkytd29XSw==",
       "dependencies": {
-        "@oozcitak/infra": "^2.0.2",
-        "@oozcitak/url": "^3.0.0",
-        "@oozcitak/util": "^10.0.0"
+        "@oozcitak/infra": "1.0.8",
+        "@oozcitak/url": "1.0.4",
+        "@oozcitak/util": "8.3.8"
       },
       "engines": {
-        "node": ">=20.0"
+        "node": ">=8.0"
       }
     },
     "node_modules/@oozcitak/infra": {
-      "version": "2.0.2",
-      "resolved": "https://registry.npmjs.org/@oozcitak/infra/-/infra-2.0.2.tgz",
-      "integrity": "sha512-2g+E7hoE2dgCz/APPOEK5s3rMhJvNxSMBrP+U+j1OWsIbtSpWxxlUjq1lU8RIsFJNYv7NMlnVsCuHcUzJW+8vA==",
-      "license": "MIT",
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/@oozcitak/infra/-/infra-1.0.8.tgz",
+      "integrity": "sha512-JRAUc9VR6IGHOL7OGF+yrvs0LO8SlqGnPAMqyzOuFZPSZSXI7Xf2O9+awQPSMXgIWGtgUf/dA6Hs6X6ySEaWTg==",
       "dependencies": {
-        "@oozcitak/util": "^10.0.0"
+        "@oozcitak/util": "8.3.8"
       },
       "engines": {
-        "node": ">=20.0"
+        "node": ">=6.0"
       }
     },
     "node_modules/@oozcitak/url": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/@oozcitak/url/-/url-3.0.0.tgz",
-      "integrity": "sha512-ZKfET8Ak1wsLAiLWNfFkZc/BraDccuTJKR6svTYc7sVjbR+Iu0vtXdiDMY4o6jaFl5TW2TlS7jbLl4VovtAJWQ==",
-      "license": "MIT",
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@oozcitak/url/-/url-1.0.4.tgz",
+      "integrity": "sha512-kDcD8y+y3FCSOvnBI6HJgl00viO/nGbQoCINmQ0h98OhnGITrWR3bOGfwYCthgcrV8AnTJz8MzslTQbC3SOAmw==",
       "dependencies": {
-        "@oozcitak/infra": "^2.0.2",
-        "@oozcitak/util": "^10.0.0"
+        "@oozcitak/infra": "1.0.8",
+        "@oozcitak/util": "8.3.8"
       },
       "engines": {
-        "node": ">=20.0"
+        "node": ">=8.0"
       }
     },
     "node_modules/@oozcitak/util": {
-      "version": "10.0.0",
-      "resolved": "https://registry.npmjs.org/@oozcitak/util/-/util-10.0.0.tgz",
-      "integrity": "sha512-hAX0pT/73190NLqBPPWSdBVGtbY6VOhWYK3qqHqtXQ1gK7kS2yz4+ivsN07hpJ6I3aeMtKP6J6npsEKOAzuTLA==",
-      "license": "MIT",
+      "version": "8.3.8",
+      "resolved": "https://registry.npmjs.org/@oozcitak/util/-/util-8.3.8.tgz",
+      "integrity": "sha512-T8TbSnGsxo6TDBJx/Sgv/BlVJL3tshxZP7Aq5R1mSnM5OcHY2dQaxLMu2+E8u3gN0MLOzdjurqN4ZRVuzQycOQ==",
       "engines": {
-        "node": ">=20.0"
+        "node": ">=8.0"
       }
     },
     "node_modules/@protobuf-ts/runtime": {
@@ -1715,7 +1720,6 @@
       "version": "24.1.0",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-24.1.0.tgz",
       "integrity": "sha512-ut5FthK5moxFKH2T1CUOC6ctR67rQRvvHdFLCD2Ql6KXmMuCrjsSsRI9UsLCm9M18BMwClv4pn327UvB7eeO1w==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "undici-types": "~7.8.0"
@@ -1940,12 +1944,13 @@
       }
     },
     "node_modules/@typescript-eslint/typescript-estree/node_modules/minimatch": {
-      "version": "9.0.5",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
-      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "version": "9.0.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",
+      "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",
       "dev": true,
+      "license": "ISC",
       "dependencies": {
-        "brace-expansion": "^2.0.1"
+        "brace-expansion": "^2.0.2"
       },
       "engines": {
         "node": ">=16 || 14 >=14.17"
@@ -2066,10 +2071,11 @@
       }
     },
     "node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "version": "6.14.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.14.0.tgz",
+      "integrity": "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "fast-json-stable-stringify": "^2.0.0",
@@ -2148,7 +2154,8 @@
     "node_modules/argparse": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/argparse/-/argparse-2.0.1.tgz",
-      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="
+      "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
+      "dev": true
     },
     "node_modules/async": {
       "version": "3.2.6",
@@ -2904,7 +2911,6 @@
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz",
       "integrity": "sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==",
-      "dev": true,
       "bin": {
         "esparse": "bin/esparse.js",
         "esvalidate": "bin/esvalidate.js"
@@ -3066,18 +3072,32 @@
       "integrity": "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==",
       "dev": true
     },
-    "node_modules/fast-xml-parser": {
-      "version": "5.3.3",
-      "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.3.3.tgz",
-      "integrity": "sha512-2O3dkPAAC6JavuMm8+4+pgTk+5hoAs+CjZ+sWcQLkX9+/tHRuTkQh/Oaifr8qDmZ8iEHb771Ea6G8CdwkrgvYA==",
+    "node_modules/fast-xml-builder": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.0.0.tgz",
+      "integrity": "sha512-fpZuDogrAgnyt9oDDz+5DBz0zgPdPZz6D4IR7iESxRXElrlGTRkHJ9eEt+SACRJwT0FNFrt71DFQIUFBJfX/uQ==",
       "funding": [
         {
           "type": "github",
           "url": "https://github.com/sponsors/NaturalIntelligence"
         }
       ],
+      "license": "MIT"
+    },
+    "node_modules/fast-xml-parser": {
+      "version": "5.4.1",
+      "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.4.1.tgz",
+      "integrity": "sha512-BQ30U1mKkvXQXXkAGcuyUA/GA26oEB7NzOtsxCDtyu62sjGw5QraKFhx2Em3WQNjPw9PG6MQ9yuIIgkSDfGu5A==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/NaturalIntelligence"
+        }
+      ],
+      "license": "MIT",
       "dependencies": {
-        "strnum": "^2.1.0"
+        "fast-xml-builder": "^1.0.0",
+        "strnum": "^2.1.2"
       },
       "bin": {
         "fxparser": "src/cli/cli.js"
@@ -3133,9 +3153,9 @@
       }
     },
     "node_modules/filelist/node_modules/minimatch": {
-      "version": "5.1.6",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
-      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
@@ -4195,6 +4215,7 @@
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
       "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "argparse": "^2.0.1"
@@ -4402,9 +4423,10 @@
       }
     },
     "node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "version": "3.1.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.5.tgz",
+      "integrity": "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w==",
+      "license": "ISC",
       "dependencies": {
         "brace-expansion": "^1.1.7"
       },
@@ -5006,8 +5028,7 @@
     "node_modules/sprintf-js": {
       "version": "1.0.3",
       "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
-      "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==",
-      "dev": true
+      "integrity": "sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g=="
     },
     "node_modules/stack-utils": {
       "version": "2.0.6",
@@ -5321,7 +5342,6 @@
       "version": "7.8.0",
       "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.8.0.tgz",
       "integrity": "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw==",
-      "dev": true,
       "license": "MIT"
     },
     "node_modules/update-browserslist-db": {
@@ -5447,18 +5467,38 @@
       }
     },
     "node_modules/xmlbuilder2": {
-      "version": "4.0.3",
-      "resolved": "https://registry.npmjs.org/xmlbuilder2/-/xmlbuilder2-4.0.3.tgz",
-      "integrity": "sha512-bx8Q1STctnNaaDymWnkfQLKofs0mGNN7rLLapJlGuV3VlvegD7Ls4ggMjE3aUSWItCCzU0PEv45lI87iSigiCA==",
-      "license": "MIT",
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/xmlbuilder2/-/xmlbuilder2-2.4.1.tgz",
+      "integrity": "sha512-vliUplZsk5vJnhxXN/mRcij/AE24NObTUm/Zo4vkLusgayO6s3Et5zLEA14XZnY1c3hX5o1ToR0m0BJOPy0UvQ==",
       "dependencies": {
-        "@oozcitak/dom": "^2.0.2",
-        "@oozcitak/infra": "^2.0.2",
-        "@oozcitak/util": "^10.0.0",
-        "js-yaml": "^4.1.1"
+        "@oozcitak/dom": "1.15.8",
+        "@oozcitak/infra": "1.0.8",
+        "@oozcitak/util": "8.3.8",
+        "@types/node": "*",
+        "js-yaml": "3.14.0"
       },
       "engines": {
-        "node": ">=20.0"
+        "node": ">=10.0"
+      }
+    },
+    "node_modules/xmlbuilder2/node_modules/argparse": {
+      "version": "1.0.10",
+      "resolved": "https://registry.npmjs.org/argparse/-/argparse-1.0.10.tgz",
+      "integrity": "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg==",
+      "dependencies": {
+        "sprintf-js": "~1.0.2"
+      }
+    },
+    "node_modules/xmlbuilder2/node_modules/js-yaml": {
+      "version": "3.14.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-3.14.0.tgz",
+      "integrity": "sha512-/4IbIeHcD9VMHFqDR/gQ7EdZdLimOvW2DdcxFjdyyZ9NsbS+ccrXqVWDtab/lRl5AlUqmpBx8EhPaWR+OtY17A==",
+      "dependencies": {
+        "argparse": "^1.0.7",
+        "esprima": "^4.0.0"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
       }
     },
     "node_modules/y18n": {
diff --git a/package.json b/package.json
index 7b10e83..c73e178 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "setup-java",
-  "version": "5.0.1",
+  "version": "5.2.0",
   "private": true,
   "description": "setup java action",
   "main": "dist/setup/index.js",
@@ -37,7 +37,7 @@
     "@actions/io": "^1.0.2",
     "@actions/tool-cache": "^2.0.1",
     "semver": "^7.6.0",
-    "xmlbuilder2": "^4.0.3"
+    "xmlbuilder2": "^2.4.0"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",