From 3dc99aad864048ca17a43ed225d74a4898ed858a Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Mon, 18 May 2026 16:17:15 +0100
Subject: [PATCH 01/65] Default to `StartProxyRemoveUnusedRegistries` behaviour

---
 lib/entry-points.js       | 25 +++----------------------
 lib/upload-lib.js         |  5 -----
 src/feature-flags.ts      |  6 ------
 src/start-proxy-action.ts |  8 +-------
 src/start-proxy.test.ts   | 26 ++++----------------------
 src/start-proxy.ts        | 18 ++----------------
 6 files changed, 10 insertions(+), 78 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 079b8eee5a..8d14547199 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -149475,11 +149475,6 @@ var featureConfig = {
     minimumVersion: void 0,
     toolsFeature: "suppressesMissingFileBaselineWarning" /* SuppressesMissingFileBaselineWarning */
   },
-  ["start_proxy_remove_unused_registries" /* StartProxyRemoveUnusedRegistries */]: {
-    defaultValue: false,
-    envVar: "CODEQL_ACTION_START_PROXY_REMOVE_UNUSED_REGISTRIES",
-    minimumVersion: void 0
-  },
   ["start_proxy_use_features_release" /* StartProxyUseFeaturesRelease */]: {
     defaultValue: false,
     envVar: "CODEQL_ACTION_START_PROXY_USE_FEATURES_RELEASE",
@@ -160351,15 +160346,6 @@ function isPAT(value) {
   ]);
 }
 var LANGUAGE_TO_REGISTRY_TYPE = {
-  java: ["maven_repository"],
-  csharp: ["nuget_feed"],
-  javascript: ["npm_registry"],
-  python: ["python_index"],
-  ruby: ["rubygems_server"],
-  rust: ["cargo_registry"],
-  go: ["goproxy_server", "git_source"]
-};
-var NEW_LANGUAGE_TO_REGISTRY_TYPE = {
   actions: [],
   cpp: [],
   java: ["maven_repository"],
@@ -160388,9 +160374,8 @@ function getRegistryAddress(registry) {
     );
   }
 }
-function getCredentials(logger, registrySecrets, registriesCredentials, language, skipUnusedRegistries = false) {
-  const registryMapping = skipUnusedRegistries ? NEW_LANGUAGE_TO_REGISTRY_TYPE : LANGUAGE_TO_REGISTRY_TYPE;
-  const registryTypeForLanguage = language ? registryMapping[language] : void 0;
+function getCredentials(logger, registrySecrets, registriesCredentials, language) {
+  const registryTypeForLanguage = language ? LANGUAGE_TO_REGISTRY_TYPE[language] : void 0;
   let credentialsStr;
   if (registriesCredentials !== void 0) {
     logger.info(`Using registries_credentials input.`);
@@ -160914,15 +160899,11 @@ async function run7(startedAt) {
     );
     const languageInput = getOptionalInput("language");
     language = languageInput ? parseBuiltInLanguage(languageInput) : void 0;
-    const skipUnusedRegistries = await features.getValue(
-      "start_proxy_remove_unused_registries" /* StartProxyRemoveUnusedRegistries */
-    );
     const credentials = getCredentials(
       logger,
       getOptionalInput("registry_secrets"),
       getOptionalInput("registries_credentials"),
-      language,
-      skipUnusedRegistries
+      language
     );
     if (credentials.length === 0) {
       logger.info("No credentials found, skipping proxy setup.");
diff --git a/lib/upload-lib.js b/lib/upload-lib.js
index d355fedf43..c32e49e424 100644
--- a/lib/upload-lib.js
+++ b/lib/upload-lib.js
@@ -89498,11 +89498,6 @@ var featureConfig = {
     minimumVersion: void 0,
     toolsFeature: "suppressesMissingFileBaselineWarning" /* SuppressesMissingFileBaselineWarning */
   },
-  ["start_proxy_remove_unused_registries" /* StartProxyRemoveUnusedRegistries */]: {
-    defaultValue: false,
-    envVar: "CODEQL_ACTION_START_PROXY_REMOVE_UNUSED_REGISTRIES",
-    minimumVersion: void 0
-  },
   ["start_proxy_use_features_release" /* StartProxyUseFeaturesRelease */]: {
     defaultValue: false,
     envVar: "CODEQL_ACTION_START_PROXY_USE_FEATURES_RELEASE",
diff --git a/src/feature-flags.ts b/src/feature-flags.ts
index 6b40d04dab..c7cfb7efef 100644
--- a/src/feature-flags.ts
+++ b/src/feature-flags.ts
@@ -129,7 +129,6 @@ export enum Feature {
   QaTelemetryEnabled = "qa_telemetry_enabled",
   /** Note that this currently only disables baseline file coverage information. */
   SkipFileCoverageOnPrs = "skip_file_coverage_on_prs",
-  StartProxyRemoveUnusedRegistries = "start_proxy_remove_unused_registries",
   StartProxyUseFeaturesRelease = "start_proxy_use_features_release",
   UploadOverlayDbToApi = "upload_overlay_db_to_api",
   ValidateDbConfig = "validate_db_config",
@@ -365,11 +364,6 @@ export const featureConfig = {
     minimumVersion: undefined,
     toolsFeature: ToolsFeature.SuppressesMissingFileBaselineWarning,
   },
-  [Feature.StartProxyRemoveUnusedRegistries]: {
-    defaultValue: false,
-    envVar: "CODEQL_ACTION_START_PROXY_REMOVE_UNUSED_REGISTRIES",
-    minimumVersion: undefined,
-  },
   [Feature.StartProxyUseFeaturesRelease]: {
     defaultValue: false,
     envVar: "CODEQL_ACTION_START_PROXY_USE_FEATURES_RELEASE",
diff --git a/src/start-proxy-action.ts b/src/start-proxy-action.ts
index 609b576441..3e376ec64f 100644
--- a/src/start-proxy-action.ts
+++ b/src/start-proxy-action.ts
@@ -5,7 +5,7 @@ import * as core from "@actions/core";
 
 import * as actionsUtil from "./actions-util";
 import { getGitHubVersion } from "./api-client";
-import { Feature, FeatureEnablement, initFeatures } from "./feature-flags";
+import { FeatureEnablement, initFeatures } from "./feature-flags";
 import { BuiltInLanguage, parseBuiltInLanguage } from "./languages";
 import { getActionsLogger, Logger } from "./logging";
 import { getRepositoryNwo } from "./repository";
@@ -57,18 +57,12 @@ async function run(startedAt: Date) {
     const languageInput = actionsUtil.getOptionalInput("language");
     language = languageInput ? parseBuiltInLanguage(languageInput) : undefined;
 
-    // Query the FF for whether we should use the reduced registry mapping.
-    const skipUnusedRegistries = await features.getValue(
-      Feature.StartProxyRemoveUnusedRegistries,
-    );
-
     // Get the registry configurations from one of the inputs.
     const credentials = getCredentials(
       logger,
       actionsUtil.getOptionalInput("registry_secrets"),
       actionsUtil.getOptionalInput("registries_credentials"),
       language,
-      skipUnusedRegistries,
     );
 
     if (credentials.length === 0) {
diff --git a/src/start-proxy.test.ts b/src/start-proxy.test.ts
index 9f12656f62..6a905f16b7 100644
--- a/src/start-proxy.test.ts
+++ b/src/start-proxy.test.ts
@@ -585,7 +585,6 @@ test("getCredentials validates 'replaces-base' correctly", async (t) => {
     undefined,
     credentialsInput,
     BuiltInLanguage.java,
-    false,
   );
 
   t.is(credentials.length, 3);
@@ -604,8 +603,7 @@ test("getCredentials validates 'replaces-base' correctly", async (t) => {
       getRunnerLogger(true),
       undefined,
       toEncodedJSON([{ ...baseInvalid, "replaces-base": null }]),
-      BuiltInLanguage.actions,
-      false,
+      BuiltInLanguage.java,
     ),
   );
   t.throws(() =>
@@ -613,8 +611,7 @@ test("getCredentials validates 'replaces-base' correctly", async (t) => {
       getRunnerLogger(true),
       undefined,
       toEncodedJSON([{ ...baseInvalid, "replaces-base": 123 }]),
-      BuiltInLanguage.actions,
-      false,
+      BuiltInLanguage.java,
     ),
   );
   t.throws(() =>
@@ -622,13 +619,12 @@ test("getCredentials validates 'replaces-base' correctly", async (t) => {
       getRunnerLogger(true),
       undefined,
       toEncodedJSON([{ ...baseInvalid, "replaces-base": "true" }]),
-      BuiltInLanguage.actions,
-      false,
+      BuiltInLanguage.java,
     ),
   );
 });
 
-test("getCredentials returns all credentials for Actions when using LANGUAGE_TO_REGISTRY_TYPE", async (t) => {
+test("getCredentials returns no credentials for Actions", async (t) => {
   const credentialsInput = toEncodedJSON(mixedCredentials);
 
   const credentials = startProxyExports.getCredentials(
@@ -636,20 +632,6 @@ test("getCredentials returns all credentials for Actions when using LANGUAGE_TO_
     undefined,
     credentialsInput,
     BuiltInLanguage.actions,
-    false,
-  );
-  t.is(credentials.length, mixedCredentials.length);
-});
-
-test("getCredentials returns no credentials for Actions when using NEW_LANGUAGE_TO_REGISTRY_TYPE", async (t) => {
-  const credentialsInput = toEncodedJSON(mixedCredentials);
-
-  const credentials = startProxyExports.getCredentials(
-    getRunnerLogger(true),
-    undefined,
-    credentialsInput,
-    BuiltInLanguage.actions,
-    true,
   );
   t.deepEqual(credentials, []);
 });
diff --git a/src/start-proxy.ts b/src/start-proxy.ts
index d6111510f6..6b956d6473 100644
--- a/src/start-proxy.ts
+++ b/src/start-proxy.ts
@@ -189,17 +189,7 @@ function isPAT(value: string) {
 
 type RegistryMapping = Partial<Record<BuiltInLanguage, string[]>>;
 
-const LANGUAGE_TO_REGISTRY_TYPE: RegistryMapping = {
-  java: ["maven_repository"],
-  csharp: ["nuget_feed"],
-  javascript: ["npm_registry"],
-  python: ["python_index"],
-  ruby: ["rubygems_server"],
-  rust: ["cargo_registry"],
-  go: ["goproxy_server", "git_source"],
-} as const;
-
-const NEW_LANGUAGE_TO_REGISTRY_TYPE: Required<RegistryMapping> = {
+const LANGUAGE_TO_REGISTRY_TYPE: Required<RegistryMapping> = {
   actions: [],
   cpp: [],
   java: ["maven_repository"],
@@ -251,13 +241,9 @@ export function getCredentials(
   registrySecrets: string | undefined,
   registriesCredentials: string | undefined,
   language: BuiltInLanguage | undefined,
-  skipUnusedRegistries: boolean = false,
 ): Credential[] {
-  const registryMapping = skipUnusedRegistries
-    ? NEW_LANGUAGE_TO_REGISTRY_TYPE
-    : LANGUAGE_TO_REGISTRY_TYPE;
   const registryTypeForLanguage = language
-    ? registryMapping[language]
+    ? LANGUAGE_TO_REGISTRY_TYPE[language]
     : undefined;
 
   let credentialsStr: string;

From c05837d3e8b7cc67635eaa027d64ae173ec2b7d5 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Mon, 18 May 2026 19:38:16 +0100
Subject: [PATCH 02/65] Scaffold `update-ghes-versions.ts` script

---
 pr-checks/update-ghes-versions.ts | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 pr-checks/update-ghes-versions.ts

diff --git a/pr-checks/update-ghes-versions.ts b/pr-checks/update-ghes-versions.ts
new file mode 100644
index 0000000000..cf8b205177
--- /dev/null
+++ b/pr-checks/update-ghes-versions.ts
@@ -0,0 +1,14 @@
+#!/usr/bin/env npx tsx
+
+/**
+ * Updates src/api-compatibility.json with the current range of supported
+ * GitHub Enterprise Server versions by reading the releases.json file from
+ * an `enterprise-releases` checkout.
+ */
+
+function main() {}
+
+// Only call `main` if this script was run directly.
+if (require.main === module) {
+  main();
+}

From 04d4fd51e91c01115baa17a4aa26dc1634d61862 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Mon, 18 May 2026 19:42:36 +0100
Subject: [PATCH 03/65] Add `semver` dependency

---
 package-lock.json      | 7 ++++---
 pr-checks/package.json | 1 +
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 6608c05602..0604abf7d6 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8320,9 +8320,9 @@
       }
     },
     "node_modules/semver": {
-      "version": "7.7.4",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",
-      "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",
+      "version": "7.8.0",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.0.tgz",
+      "integrity": "sha512-AcM7dV/5ul4EekoQ29Agm5vri8JNqRyj39o0qpX6vDF2GZrtutZl5RwgD1XnZjiTAfncsJhMI48QQH3sN87YNA==",
       "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
@@ -10404,6 +10404,7 @@
         "@octokit/core": "^7.0.6",
         "@octokit/plugin-paginate-rest": ">=9.2.2",
         "@octokit/plugin-rest-endpoint-methods": "^17.0.0",
+        "semver": "^7.8.0",
         "yaml": "^2.8.4"
       },
       "devDependencies": {
diff --git a/pr-checks/package.json b/pr-checks/package.json
index 2741560f68..f21f86fd70 100644
--- a/pr-checks/package.json
+++ b/pr-checks/package.json
@@ -7,6 +7,7 @@
     "@octokit/core": "^7.0.6",
     "@octokit/plugin-paginate-rest": ">=9.2.2",
     "@octokit/plugin-rest-endpoint-methods": "^17.0.0",
+    "semver": "^7.8.0",
     "yaml": "^2.8.4"
   },
   "devDependencies": {

From 952a538c2494e0a870e46f57cb12d4319b048503 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 12:34:53 +0100
Subject: [PATCH 04/65] Add constant for `API_COMPATIBILITY_FILE`

---
 pr-checks/config.ts               | 6 ++++++
 pr-checks/update-ghes-versions.ts | 2 ++
 2 files changed, 8 insertions(+)

diff --git a/pr-checks/config.ts b/pr-checks/config.ts
index 92c8beef0a..97858c776c 100644
--- a/pr-checks/config.ts
+++ b/pr-checks/config.ts
@@ -21,3 +21,9 @@ export const BUILTIN_LANGUAGES_FILE = path.join(
   "languages",
   "builtin.json",
 );
+
+/** Path to the api-compatibility.json file. */
+export const API_COMPATIBILITY_FILE = path.join(
+  SOURCE_ROOT,
+  "api-compatibility.json",
+);
diff --git a/pr-checks/update-ghes-versions.ts b/pr-checks/update-ghes-versions.ts
index cf8b205177..38f8cd9abc 100644
--- a/pr-checks/update-ghes-versions.ts
+++ b/pr-checks/update-ghes-versions.ts
@@ -6,6 +6,8 @@
  * an `enterprise-releases` checkout.
  */
 
+import { API_COMPATIBILITY_FILE } from "./config";
+
 function main() {}
 
 // Only call `main` if this script was run directly.

From d98bedfdeaba5517699673b9941676502483b8af Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 12:35:13 +0100
Subject: [PATCH 05/65] Add constant for `FIRST_SUPPORTED_RELEASE`

---
 pr-checks/update-ghes-versions.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/pr-checks/update-ghes-versions.ts b/pr-checks/update-ghes-versions.ts
index 38f8cd9abc..784c12a054 100644
--- a/pr-checks/update-ghes-versions.ts
+++ b/pr-checks/update-ghes-versions.ts
@@ -6,8 +6,14 @@
  * an `enterprise-releases` checkout.
  */
 
+import { type SemVer } from "semver";
+import * as semver from "semver";
+
 import { API_COMPATIBILITY_FILE } from "./config";
 
+/** The first GHES version that included Code Scanning. */
+const FIRST_SUPPORTED_RELEASE: SemVer = new semver.SemVer("2.22.0");
+
 function main() {}
 
 // Only call `main` if this script was run directly.

From 4536424fcf7cf51b567c6ef9707462ae03638b84 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 12:36:02 +0100
Subject: [PATCH 06/65] Throw if `ENTERPRISE_RELEASES_PATH` is not set

---
 pr-checks/update-ghes-versions.ts | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/pr-checks/update-ghes-versions.ts b/pr-checks/update-ghes-versions.ts
index 784c12a054..2836015727 100644
--- a/pr-checks/update-ghes-versions.ts
+++ b/pr-checks/update-ghes-versions.ts
@@ -14,7 +14,19 @@ import { API_COMPATIBILITY_FILE } from "./config";
 /** The first GHES version that included Code Scanning. */
 const FIRST_SUPPORTED_RELEASE: SemVer = new semver.SemVer("2.22.0");
 
-function main() {}
+/** Environment variables specific to this script. */
+export enum EnvVar {
+  ENTERPRISE_RELEASES_PATH = "ENTERPRISE_RELEASES_PATH",
+}
+
+function main() {
+  const enterpriseReleasesPath = process.env[EnvVar.ENTERPRISE_RELEASES_PATH];
+  if (!enterpriseReleasesPath) {
+    throw new Error(
+      `${EnvVar.ENTERPRISE_RELEASES_PATH} environment variable must be set`,
+    );
+  }
+}
 
 // Only call `main` if this script was run directly.
 if (require.main === module) {

From da26a016eee901f2047ac74b00a9c175a3313c73 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 12:50:40 +0100
Subject: [PATCH 07/65] Add `readApiCompatibility`

---
 pr-checks/update-ghes-versions.ts | 37 +++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/pr-checks/update-ghes-versions.ts b/pr-checks/update-ghes-versions.ts
index 2836015727..72e7fbe2f8 100644
--- a/pr-checks/update-ghes-versions.ts
+++ b/pr-checks/update-ghes-versions.ts
@@ -6,9 +6,13 @@
  * an `enterprise-releases` checkout.
  */
 
+import * as fs from "node:fs";
+
 import { type SemVer } from "semver";
 import * as semver from "semver";
 
+import * as json from "../src/json";
+
 import { API_COMPATIBILITY_FILE } from "./config";
 
 /** The first GHES version that included Code Scanning. */
@@ -19,6 +23,36 @@ export enum EnvVar {
   ENTERPRISE_RELEASES_PATH = "ENTERPRISE_RELEASES_PATH",
 }
 
+/** The JSON schema for `API_COMPATIBILITY_FILE`. */
+const apiCompatibilitySchema = {
+  minimumVersion: json.string,
+  maximumVersion: json.string,
+} as const satisfies json.Schema;
+
+/** The type representing the expected contents of `API_COMPATIBILITY_FILE`. */
+type ApiCompatibility = json.FromSchema<typeof apiCompatibilitySchema>;
+
+/** Reads the current contents of the `API_COMPATIBILITY_FILE` file. */
+export function readApiCompatibility(): ApiCompatibility {
+  const apiCompatibilityData: unknown = JSON.parse(
+    fs.readFileSync(API_COMPATIBILITY_FILE, "utf8"),
+  );
+
+  if (!json.isObject(apiCompatibilityData)) {
+    throw new Error(
+      `Expected '${API_COMPATIBILITY_FILE}' to contain an object.`,
+    );
+  }
+  if (!json.validateSchema(apiCompatibilitySchema, apiCompatibilityData)) {
+    throw new Error(
+      `The contents of '${API_COMPATIBILITY_FILE}' do not match the expected JSON schema.`,
+    );
+  }
+
+  return apiCompatibilityData;
+}
+
+
 function main() {
   const enterpriseReleasesPath = process.env[EnvVar.ENTERPRISE_RELEASES_PATH];
   if (!enterpriseReleasesPath) {
@@ -26,6 +60,9 @@ function main() {
       `${EnvVar.ENTERPRISE_RELEASES_PATH} environment variable must be set`,
     );
   }
+
+  // Get the version compatibility data stored in the repo.
+  const apiCompatibilityData = readApiCompatibility();
 }
 
 // Only call `main` if this script was run directly.

From f5808271b06681af837cfdfee1eca4b91230337d Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 13:15:51 +0100
Subject: [PATCH 08/65] Add `readEnterpriseReleases`

---
 pr-checks/update-ghes-versions.ts | 46 +++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/pr-checks/update-ghes-versions.ts b/pr-checks/update-ghes-versions.ts
index 72e7fbe2f8..52b3367a26 100644
--- a/pr-checks/update-ghes-versions.ts
+++ b/pr-checks/update-ghes-versions.ts
@@ -7,6 +7,7 @@
  */
 
 import * as fs from "node:fs";
+import * as path from "node:path";
 
 import { type SemVer } from "semver";
 import * as semver from "semver";
@@ -52,6 +53,48 @@ export function readApiCompatibility(): ApiCompatibility {
   return apiCompatibilityData;
 }
 
+/** The JSON schema for entries in the `releases.json` file. */
+const releaseDataSchema = {
+  feature_freeze: json.string,
+  end: json.string,
+} as const satisfies json.Schema;
+
+/** The type representing entries in the `releases.json` file. */
+export type ReleaseData = json.FromSchema<typeof releaseDataSchema>;
+
+/** A mapping from GHES releases to release information. */
+export type EnterpriseReleases = Record<string, ReleaseData>;
+
+/** Reads information about GHES releases. */
+export function readEnterpriseReleases(
+  enterpriseReleasesPath: string,
+): EnterpriseReleases {
+  const releaseFilePath = path.join(enterpriseReleasesPath, "releases.json");
+  const releases: unknown = JSON.parse(
+    fs.readFileSync(releaseFilePath, "utf8"),
+  );
+
+  if (!json.isObject(releases)) {
+    throw new Error(`Expected '${releaseFilePath}' to contain an object.`);
+  }
+
+  // Remove GHES version using a previous version numbering scheme.
+  delete releases["11.10"];
+
+  // Validate that the object satisfies the schema.
+  for (const [, releaseData] of Object.entries(releases)) {
+    if (!json.isObject(releaseData)) {
+      throw new Error(
+        `Expected release data to be an object, but it is ${typeof releaseData}.`,
+      );
+    }
+    if (!json.validateSchema(releaseDataSchema, releaseData)) {
+      throw new Error("Expected release data to satisfy schema.");
+    }
+  }
+
+  return releases;
+}
 
 function main() {
   const enterpriseReleasesPath = process.env[EnvVar.ENTERPRISE_RELEASES_PATH];
@@ -63,6 +106,9 @@ function main() {
 
   // Get the version compatibility data stored in the repo.
   const apiCompatibilityData = readApiCompatibility();
+
+  // Get the GHES release information.
+  const releases = readEnterpriseReleases(enterpriseReleasesPath);
 }
 
 // Only call `main` if this script was run directly.

From 71b697dd8b66782914ce9f72d5184b81e04f3cf6 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 13:16:56 +0100
Subject: [PATCH 09/65] Add helpers for GHES versions

---
 pr-checks/update-ghes-versions.ts | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/pr-checks/update-ghes-versions.ts b/pr-checks/update-ghes-versions.ts
index 52b3367a26..8d171cfdc5 100644
--- a/pr-checks/update-ghes-versions.ts
+++ b/pr-checks/update-ghes-versions.ts
@@ -24,6 +24,26 @@ export enum EnvVar {
   ENTERPRISE_RELEASES_PATH = "ENTERPRISE_RELEASES_PATH",
 }
 
+/**
+ * The semver specification requires three numeric components, but GHES release families
+ * only have two. This function uses `semver.coerce` to first coerce the version string
+ * into an acceptable input for `semver.parse`. E.g. `3.10` becomes `3.10.0`.
+ */
+export function parseEnterpriseVersion(val: string): SemVer | null {
+  return semver.parse(semver.coerce(val));
+}
+
+/**
+ * Mirroring `parseEnterpriseVersion`, this function returns only the major and minor
+ * version components from `ver`.
+ */
+export function printEnterpriseVersion(ver: SemVer) {
+  if (ver.patch === 0) {
+    return `${ver.major}.${ver.minor}`;
+  }
+  return ver.toString();
+}
+
 /** The JSON schema for `API_COMPATIBILITY_FILE`. */
 const apiCompatibilitySchema = {
   minimumVersion: json.string,

From 51cc08af6fe83e6ea15b1b2de56eced26b76c913 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 13:51:56 +0100
Subject: [PATCH 10/65] Add `determineSupportedRange`

---
 pr-checks/update-ghes-versions.ts | 103 ++++++++++++++++++++++++++++++
 1 file changed, 103 insertions(+)
 mode change 100644 => 100755 pr-checks/update-ghes-versions.ts

diff --git a/pr-checks/update-ghes-versions.ts b/pr-checks/update-ghes-versions.ts
old mode 100644
new mode 100755
index 8d171cfdc5..0508f9897e
--- a/pr-checks/update-ghes-versions.ts
+++ b/pr-checks/update-ghes-versions.ts
@@ -116,6 +116,85 @@ export function readEnterpriseReleases(
   return releases;
 }
 
+/** Adds `weeks`-many weeks to the UTC date of `date`. */
+export function addWeeks(date: Date, weeks: number): Date {
+  const result = new Date(date);
+  result.setUTCDate(date.getUTCDate() + weeks * 7);
+  return result;
+}
+
+/** Determines the current range of GHES versions we should support. */
+export function determineSupportedRange(
+  apiCompatibilityData: ApiCompatibility,
+  releases: EnterpriseReleases,
+): ApiCompatibility {
+  // Our goal is to identify the oldest and newest GHES release we should support.
+  // We begin with `oldestSupportRelease = undefined` so that we determine the
+  // minimum from scratch and don't stick to `apiCompatibilityData.minimumVersion`
+  // when it is no longer supported.
+  // For `newestSupportedRelease`, we assume that `apiCompatibilityData.maximumVersion`
+  // is guaranteed to not be outdated.
+  let oldestSupportedRelease: SemVer | undefined;
+  let newestSupportedRelease = parseEnterpriseVersion(
+    apiCompatibilityData.maximumVersion,
+  );
+
+  if (newestSupportedRelease === null) {
+    throw new Error(
+      `${apiCompatibilityData.maximumVersion} is not a valid semantic version.`,
+    );
+  }
+
+  const today = new Date();
+
+  // NOTE: We deliberately omit including any data from `releases` in the error messages below.
+
+  for (const [releaseVersionString, releaseData] of Object.entries(releases)) {
+    const releaseVersion = parseEnterpriseVersion(releaseVersionString);
+
+    if (releaseVersion === null) {
+      throw new Error("Invalid enterprise release version.");
+    }
+
+    // Ignore GHES releases older than `FIRST_SUPPORTED_RELEASE`.
+    if (semver.compare(releaseVersion, FIRST_SUPPORTED_RELEASE) < 0) {
+      continue;
+    }
+
+    // If the GHES release is newer than the current, newest release we support,
+    // check whether at least two weeks have passed since the feature freeze date
+    // so we don't set `newestSupportedRelease` too early.
+    if (semver.compare(releaseVersion, newestSupportedRelease) > 0) {
+      const featureFreezeDate = new Date(releaseData.feature_freeze);
+      if (featureFreezeDate < addWeeks(today, 2)) {
+        newestSupportedRelease = releaseVersion;
+      }
+    }
+
+    if (
+      oldestSupportedRelease === undefined ||
+      semver.compare(releaseVersion, oldestSupportedRelease) < 0
+    ) {
+      const endOfLifeDate = new Date(releaseData.end);
+      // The GHES version is not actually end of life until the end of the day
+      // specified by `endOfLifeDate`. Wait an extra week to be safe.
+      const isEndOfLife = today > addWeeks(endOfLifeDate, 1);
+      if (!isEndOfLife) {
+        oldestSupportedRelease = releaseVersion;
+      }
+    }
+  }
+
+  if (!oldestSupportedRelease) {
+    throw new Error("Could not determine oldest supported release.");
+  }
+
+  return {
+    maximumVersion: printEnterpriseVersion(newestSupportedRelease),
+    minimumVersion: printEnterpriseVersion(oldestSupportedRelease),
+  };
+}
+
 function main() {
   const enterpriseReleasesPath = process.env[EnvVar.ENTERPRISE_RELEASES_PATH];
   if (!enterpriseReleasesPath) {
@@ -129,6 +208,30 @@ function main() {
 
   // Get the GHES release information.
   const releases = readEnterpriseReleases(enterpriseReleasesPath);
+
+  // Determine the supported range.
+  const newCompatibilityData: ApiCompatibility = determineSupportedRange(
+    apiCompatibilityData,
+    releases,
+  );
+
+  // If the version range has changed, write the updates to `API_COMPATIBILITY_FILE`.
+  if (
+    newCompatibilityData.minimumVersion !==
+      apiCompatibilityData.minimumVersion ||
+    newCompatibilityData.maximumVersion !== apiCompatibilityData.maximumVersion
+  ) {
+    const data = JSON.stringify(newCompatibilityData);
+    fs.writeFileSync(API_COMPATIBILITY_FILE, `${data}\n`);
+
+    console.log(
+      `Updated '${path.basename(API_COMPATIBILITY_FILE)}': ${newCompatibilityData.minimumVersion} - ${newCompatibilityData.maximumVersion}`,
+    );
+  } else {
+    console.log(
+      `No changes, not writing to '${path.basename(API_COMPATIBILITY_FILE)}'.`,
+    );
+  }
 }
 
 // Only call `main` if this script was run directly.

From 15f19e18702e542de041230c6a334dfc968bc78b Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 13:59:49 +0100
Subject: [PATCH 11/65] Add `date` as a parameter for `determineSupportedRange`

---
 pr-checks/update-ghes-versions.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/pr-checks/update-ghes-versions.ts b/pr-checks/update-ghes-versions.ts
index 0508f9897e..2e458711ff 100755
--- a/pr-checks/update-ghes-versions.ts
+++ b/pr-checks/update-ghes-versions.ts
@@ -125,6 +125,7 @@ export function addWeeks(date: Date, weeks: number): Date {
 
 /** Determines the current range of GHES versions we should support. */
 export function determineSupportedRange(
+  today: Date,
   apiCompatibilityData: ApiCompatibility,
   releases: EnterpriseReleases,
 ): ApiCompatibility {
@@ -145,8 +146,6 @@ export function determineSupportedRange(
     );
   }
 
-  const today = new Date();
-
   // NOTE: We deliberately omit including any data from `releases` in the error messages below.
 
   for (const [releaseVersionString, releaseData] of Object.entries(releases)) {
@@ -211,6 +210,7 @@ function main() {
 
   // Determine the supported range.
   const newCompatibilityData: ApiCompatibility = determineSupportedRange(
+    new Date(),
     apiCompatibilityData,
     releases,
   );

From f9feddd874d4b3da054c2d5a50bf973b7c0dcbb9 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 14:03:20 +0100
Subject: [PATCH 12/65] Add tests for `update-ghes-versions.ts`

---
 pr-checks/update-ghes-versions.test.ts | 204 +++++++++++++++++++++++++
 1 file changed, 204 insertions(+)
 create mode 100644 pr-checks/update-ghes-versions.test.ts

diff --git a/pr-checks/update-ghes-versions.test.ts b/pr-checks/update-ghes-versions.test.ts
new file mode 100644
index 0000000000..187c067c37
--- /dev/null
+++ b/pr-checks/update-ghes-versions.test.ts
@@ -0,0 +1,204 @@
+#!/usr/bin/env npx tsx
+
+/*
+ * Tests for the update-ghes-versions.ts script
+ */
+
+import * as assert from "node:assert/strict";
+import { describe, it } from "node:test";
+
+import {
+  addWeeks,
+  determineSupportedRange,
+  type EnterpriseReleases,
+  parseEnterpriseVersion,
+  printEnterpriseVersion,
+} from "./update-ghes-versions";
+
+describe("parseEnterpriseVersion", async () => {
+  await it("parses a two-component version string", () => {
+    const ver = parseEnterpriseVersion("3.10");
+    assert.notEqual(ver, null);
+    assert.equal(ver!.major, 3);
+    assert.equal(ver!.minor, 10);
+    assert.equal(ver!.patch, 0);
+  });
+
+  await it("parses a three-component version string", () => {
+    const ver = parseEnterpriseVersion("3.10.2");
+    assert.notEqual(ver, null);
+    assert.equal(ver!.major, 3);
+    assert.equal(ver!.minor, 10);
+    assert.equal(ver!.patch, 2);
+  });
+
+  await it("returns null for invalid input", () => {
+    assert.equal(parseEnterpriseVersion("not-a-version"), null);
+  });
+});
+
+describe("printEnterpriseVersion", async () => {
+  await it("prints only major.minor when patch is 0", () => {
+    const ver = parseEnterpriseVersion("3.10")!;
+    assert.equal(printEnterpriseVersion(ver), "3.10");
+  });
+
+  await it("includes patch when non-zero", () => {
+    const ver = parseEnterpriseVersion("3.10.2")!;
+    assert.equal(printEnterpriseVersion(ver), "3.10.2");
+  });
+});
+
+describe("addWeeks", async () => {
+  await it("adds weeks to a date", () => {
+    const date = new Date("2025-01-01T00:00:00Z");
+    const result = addWeeks(date, 2);
+    assert.equal(result.toISOString(), "2025-01-15T00:00:00.000Z");
+  });
+
+  await it("does not mutate the original date", () => {
+    const date = new Date("2025-01-01T00:00:00Z");
+    addWeeks(date, 2);
+    assert.equal(date.toISOString(), "2025-01-01T00:00:00.000Z");
+  });
+});
+
+/**
+ * Helper to build a release entry with a feature freeze and end-of-life date.
+ * Dates are ISO date strings (e.g. "2025-06-01").
+ */
+function release(featureFreeze: string, end: string) {
+  return { feature_freeze: featureFreeze, end };
+}
+
+describe("determineSupportedRange", async () => {
+  // A fixed "today" for deterministic tests.
+  const today = new Date("2025-06-15");
+
+  const farPastEnd = "2020-01-01";
+  const farFutureEnd = "2099-12-31";
+  const farPastFreeze = "2020-01-01";
+  const farFutureFreeze = "2099-12-31";
+
+  await it("returns the only supported release as both min and max", () => {
+    const releases: EnterpriseReleases = {
+      "3.10": release(farPastFreeze, farFutureEnd),
+    };
+    const result = determineSupportedRange(
+      today,
+      { minimumVersion: "3.10", maximumVersion: "3.10" },
+      releases,
+    );
+    assert.equal(result.minimumVersion, "3.10");
+    assert.equal(result.maximumVersion, "3.10");
+  });
+
+  await it("determines the range from multiple supported releases", () => {
+    const releases: EnterpriseReleases = {
+      "3.10": release(farPastFreeze, farFutureEnd),
+      "3.11": release(farPastFreeze, farFutureEnd),
+      "3.12": release(farPastFreeze, farFutureEnd),
+    };
+    const result = determineSupportedRange(
+      today,
+      { minimumVersion: "3.10", maximumVersion: "3.12" },
+      releases,
+    );
+    assert.equal(result.minimumVersion, "3.10");
+    assert.equal(result.maximumVersion, "3.12");
+  });
+
+  await it("drops an end-of-life release from the minimum", () => {
+    const releases: EnterpriseReleases = {
+      // 3.10 has been end of life for a long time.
+      "3.10": release(farPastFreeze, farPastEnd),
+      "3.11": release(farPastFreeze, farFutureEnd),
+      "3.12": release(farPastFreeze, farFutureEnd),
+    };
+    const result = determineSupportedRange(
+      today,
+      { minimumVersion: "3.10", maximumVersion: "3.12" },
+      releases,
+    );
+    assert.equal(result.minimumVersion, "3.11");
+    assert.equal(result.maximumVersion, "3.12");
+  });
+
+  await it("bumps the maximum when a newer release's feature freeze has passed", () => {
+    const releases: EnterpriseReleases = {
+      "3.10": release(farPastFreeze, farFutureEnd),
+      "3.11": release(farPastFreeze, farFutureEnd),
+      // 3.12 has a feature freeze far in the past, so it should be picked up.
+      "3.12": release(farPastFreeze, farFutureEnd),
+    };
+    const result = determineSupportedRange(
+      today,
+      // The stored maximum is 3.11, but 3.12 should be picked up.
+      { minimumVersion: "3.10", maximumVersion: "3.11" },
+      releases,
+    );
+    assert.equal(result.minimumVersion, "3.10");
+    assert.equal(result.maximumVersion, "3.12");
+  });
+
+  await it("does not bump the maximum when feature freeze is far in the future", () => {
+    const releases: EnterpriseReleases = {
+      "3.10": release(farPastFreeze, farFutureEnd),
+      "3.11": release(farPastFreeze, farFutureEnd),
+      // 3.12 has a feature freeze far in the future, so it should NOT be picked up.
+      "3.12": release(farFutureFreeze, farFutureEnd),
+    };
+    const result = determineSupportedRange(
+      today,
+      { minimumVersion: "3.10", maximumVersion: "3.11" },
+      releases,
+    );
+    assert.equal(result.minimumVersion, "3.10");
+    assert.equal(result.maximumVersion, "3.11");
+  });
+
+  await it("ignores releases older than the first supported release (2.22)", () => {
+    const releases: EnterpriseReleases = {
+      "2.21": release(farPastFreeze, farFutureEnd),
+      "3.10": release(farPastFreeze, farFutureEnd),
+      "3.11": release(farPastFreeze, farFutureEnd),
+    };
+    const result = determineSupportedRange(
+      today,
+      { minimumVersion: "3.10", maximumVersion: "3.11" },
+      releases,
+    );
+    // 2.21 is older than 2.22, so it should be ignored — 3.10 remains the minimum.
+    assert.equal(result.minimumVersion, "3.10");
+    assert.equal(result.maximumVersion, "3.11");
+  });
+
+  await it("throws when no supported releases remain", () => {
+    const releases: EnterpriseReleases = {
+      // All releases are end of life.
+      "3.10": release(farPastFreeze, farPastEnd),
+      "3.11": release(farPastFreeze, farPastEnd),
+    };
+    assert.throws(
+      () =>
+        determineSupportedRange(
+          today,
+          { minimumVersion: "3.10", maximumVersion: "3.11" },
+          releases,
+        ),
+      /Could not determine oldest supported release/,
+    );
+  });
+
+  await it("throws when maximumVersion is not a valid version", () => {
+    assert.throws(
+      () =>
+        determineSupportedRange(
+          today,
+          { minimumVersion: "3.10", maximumVersion: "invalid" },
+          {},
+        ),
+      /is not a valid semantic version/,
+    );
+  });
+});

From 5aed9f7d6474db332d9f131acf29f65467de602d Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 14:08:22 +0100
Subject: [PATCH 13/65] Update workflow to use `update-ghes-versions.ts`

---
 ...e-supported-enterprise-server-versions.yml | 28 +++++++++++--------
 1 file changed, 17 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/update-supported-enterprise-server-versions.yml b/.github/workflows/update-supported-enterprise-server-versions.yml
index 4cead58f4f..1727ea8f5d 100644
--- a/.github/workflows/update-supported-enterprise-server-versions.yml
+++ b/.github/workflows/update-supported-enterprise-server-versions.yml
@@ -9,7 +9,7 @@ on:
       - main
     paths:
       - .github/workflows/update-supported-enterprise-server-versions.yml
-      - .github/workflows/update-supported-enterprise-server-versions/update.py
+      - pr-checks/update-ghes-versions.ts
 
 jobs:
   update-supported-enterprise-server-versions:
@@ -22,12 +22,18 @@ jobs:
       pull-requests: write # needed to create pull request
 
     steps:
-      - name: Setup Python
-        uses: actions/setup-python@v6
-        with:
-          python-version: "3.13"
       - name: Checkout CodeQL Action
         uses: actions/checkout@v6
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 24
+          cache: 'npm'
+
+      - name: Install dependencies
+        run: npm ci
+
       - name: Checkout Enterprise Releases
         uses: actions/checkout@v6
         with:
@@ -35,18 +41,18 @@ jobs:
           token: ${{ secrets.ENTERPRISE_RELEASE_TOKEN }}
           path: ${{ github.workspace }}/enterprise-releases/
           sparse-checkout: releases.json
+
       - name: Update Supported Enterprise Server Versions
+        working-directory: pr-checks
         run: |
-          cd ./.github/workflows/update-supported-enterprise-server-versions/
-          python3 -m pip install pipenv
-          pipenv install
-          pipenv run ./update.py
+          npx tsx update-ghes-versions.ts
           rm --recursive "$ENTERPRISE_RELEASES_PATH"
-          npm ci
-          npm run build
         env:
           ENTERPRISE_RELEASES_PATH: ${{ github.workspace }}/enterprise-releases/
 
+      - name: Rebuild
+        run: npm run build
+
       - name: Update git config
         run: |
           git config --global user.email "41898282+github-actions[bot]@users.noreply.github.com"

From 3e8588443487f8f5ec06d9ab1f6a51e21644dc75 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 14:08:51 +0100
Subject: [PATCH 14/65] Remove Python version

---
 .../Pipfile                                   |  9 ----
 .../Pipfile.lock                              | 27 ----------
 .../update.py                                 | 51 -------------------
 3 files changed, 87 deletions(-)
 delete mode 100644 .github/workflows/update-supported-enterprise-server-versions/Pipfile
 delete mode 100644 .github/workflows/update-supported-enterprise-server-versions/Pipfile.lock
 delete mode 100755 .github/workflows/update-supported-enterprise-server-versions/update.py

diff --git a/.github/workflows/update-supported-enterprise-server-versions/Pipfile b/.github/workflows/update-supported-enterprise-server-versions/Pipfile
deleted file mode 100644
index e892e49219..0000000000
--- a/.github/workflows/update-supported-enterprise-server-versions/Pipfile
+++ /dev/null
@@ -1,9 +0,0 @@
-[[source]]
-name = "pypi"
-url = "https://pypi.org/simple"
-verify_ssl = true
-
-[dev-packages]
-
-[packages]
-semver = "*"
diff --git a/.github/workflows/update-supported-enterprise-server-versions/Pipfile.lock b/.github/workflows/update-supported-enterprise-server-versions/Pipfile.lock
deleted file mode 100644
index 3357cf2864..0000000000
--- a/.github/workflows/update-supported-enterprise-server-versions/Pipfile.lock
+++ /dev/null
@@ -1,27 +0,0 @@
-{
-    "_meta": {
-        "hash": {
-            "sha256": "e3ba923dcb4888e05de5448c18a732bf40197e80fabfa051a61c01b22c504879"
-        },
-        "pipfile-spec": 6,
-        "requires": {},
-        "sources": [
-            {
-                "name": "pypi",
-                "url": "https://pypi.org/simple",
-                "verify_ssl": true
-            }
-        ]
-    },
-    "default": {
-        "semver": {
-            "hashes": [
-                "sha256:ced8b23dceb22134307c1b8abfa523da14198793d9787ac838e70e29e77458d4",
-                "sha256:fa0fe2722ee1c3f57eac478820c3a5ae2f624af8264cbdf9000c980ff7f75e3f"
-            ],
-            "index": "pypi",
-            "version": "==2.13.0"
-        }
-    },
-    "develop": {}
-}
diff --git a/.github/workflows/update-supported-enterprise-server-versions/update.py b/.github/workflows/update-supported-enterprise-server-versions/update.py
deleted file mode 100755
index bdda902cd0..0000000000
--- a/.github/workflows/update-supported-enterprise-server-versions/update.py
+++ /dev/null
@@ -1,51 +0,0 @@
-#!/usr/bin/env python3
-import datetime
-import json
-import os
-import pathlib
-
-import semver
-
-_API_COMPATIBILITY_PATH = pathlib.Path(__file__).absolute().parents[3] / "src" / "api-compatibility.json"
-_ENTERPRISE_RELEASES_PATH = pathlib.Path(os.environ["ENTERPRISE_RELEASES_PATH"])
-_RELEASE_FILE_PATH = _ENTERPRISE_RELEASES_PATH / "releases.json"
-_FIRST_SUPPORTED_RELEASE = semver.VersionInfo.parse("2.22.0") # Versions older than this did not include Code Scanning.
-
-def main():
-	api_compatibility_data = json.loads(_API_COMPATIBILITY_PATH.read_text())
-
-	releases = json.loads(_RELEASE_FILE_PATH.read_text())
-
-	# Remove GHES version using a previous version numbering scheme.
-	if "11.10" in releases:
-		del releases["11.10"]
-
-	oldest_supported_release = None
-	newest_supported_release = semver.VersionInfo.parse(api_compatibility_data["maximumVersion"] + ".0")
-
-	for release_version_string, release_data in releases.items():
-		release_version = semver.VersionInfo.parse(release_version_string + ".0")
-		if release_version < _FIRST_SUPPORTED_RELEASE:
-			continue
-
-		if release_version > newest_supported_release:
-			feature_freeze_date = datetime.date.fromisoformat(release_data["feature_freeze"])
-			if feature_freeze_date < datetime.date.today() + datetime.timedelta(weeks=2):
-				newest_supported_release = release_version
-
-		if oldest_supported_release is None or release_version < oldest_supported_release:
-			end_of_life_date = datetime.date.fromisoformat(release_data["end"])
-			# The GHES version is not actually end of life until the end of the day specified by
-			# `end_of_life_date`. Wait an extra week to be safe.
-			is_end_of_life = datetime.date.today() > end_of_life_date + datetime.timedelta(weeks=1)
-			if not is_end_of_life:
-				oldest_supported_release = release_version
-
-	api_compatibility_data = {
-		"minimumVersion": f"{oldest_supported_release.major}.{oldest_supported_release.minor}",
-		"maximumVersion": f"{newest_supported_release.major}.{newest_supported_release.minor}",
-	}
-	_API_COMPATIBILITY_PATH.write_text(json.dumps(api_compatibility_data, sort_keys=True) + "\n")
-
-if __name__ == "__main__":
-	main()

From 74374a38936300557019bb7cb361fac05c3c22e1 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 14:15:04 +0100
Subject: [PATCH 15/65] Rebuild (newer `semver` version)

---
 lib/entry-points.js | 43 +++++++++++++++++++++++++++++++++++++++++++
 lib/upload-lib.js   | 43 +++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 86 insertions(+)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 079b8eee5a..3f0bc15480 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -26704,6 +26704,47 @@ var require_coerce = __commonJS({
   }
 });
 
+// node_modules/semver/functions/truncate.js
+var require_truncate = __commonJS({
+  "node_modules/semver/functions/truncate.js"(exports2, module2) {
+    "use strict";
+    var parse2 = require_parse2();
+    var constants = require_constants6();
+    var SemVer = require_semver();
+    var truncate = (version, truncation, options) => {
+      if (!constants.RELEASE_TYPES.includes(truncation)) {
+        return null;
+      }
+      const clonedVersion = cloneInputVersion(version, options);
+      return clonedVersion && doTruncation(clonedVersion, truncation);
+    };
+    var cloneInputVersion = (version, options) => {
+      const versionStringToParse = version instanceof SemVer ? version.version : version;
+      return parse2(versionStringToParse, options);
+    };
+    var doTruncation = (version, truncation) => {
+      if (isPrerelease(truncation)) {
+        return version.version;
+      }
+      version.prerelease = [];
+      switch (truncation) {
+        case "major":
+          version.minor = 0;
+          version.patch = 0;
+          break;
+        case "minor":
+          version.patch = 0;
+          break;
+      }
+      return version.format();
+    };
+    var isPrerelease = (type2) => {
+      return type2.startsWith("pre");
+    };
+    module2.exports = truncate;
+  }
+});
+
 // node_modules/semver/internal/lrucache.js
 var require_lrucache = __commonJS({
   "node_modules/semver/internal/lrucache.js"(exports2, module2) {
@@ -27738,6 +27779,7 @@ var require_semver2 = __commonJS({
     var lte = require_lte();
     var cmp = require_cmp();
     var coerce3 = require_coerce();
+    var truncate = require_truncate();
     var Comparator = require_comparator();
     var Range2 = require_range();
     var satisfies2 = require_satisfies();
@@ -27776,6 +27818,7 @@ var require_semver2 = __commonJS({
       lte,
       cmp,
       coerce: coerce3,
+      truncate,
       Comparator,
       Range: Range2,
       satisfies: satisfies2,
diff --git a/lib/upload-lib.js b/lib/upload-lib.js
index d355fedf43..66dfb4a73a 100644
--- a/lib/upload-lib.js
+++ b/lib/upload-lib.js
@@ -28009,6 +28009,47 @@ var require_coerce = __commonJS({
   }
 });
 
+// node_modules/semver/functions/truncate.js
+var require_truncate = __commonJS({
+  "node_modules/semver/functions/truncate.js"(exports2, module2) {
+    "use strict";
+    var parse2 = require_parse2();
+    var constants = require_constants6();
+    var SemVer = require_semver();
+    var truncate = (version, truncation, options) => {
+      if (!constants.RELEASE_TYPES.includes(truncation)) {
+        return null;
+      }
+      const clonedVersion = cloneInputVersion(version, options);
+      return clonedVersion && doTruncation(clonedVersion, truncation);
+    };
+    var cloneInputVersion = (version, options) => {
+      const versionStringToParse = version instanceof SemVer ? version.version : version;
+      return parse2(versionStringToParse, options);
+    };
+    var doTruncation = (version, truncation) => {
+      if (isPrerelease(truncation)) {
+        return version.version;
+      }
+      version.prerelease = [];
+      switch (truncation) {
+        case "major":
+          version.minor = 0;
+          version.patch = 0;
+          break;
+        case "minor":
+          version.patch = 0;
+          break;
+      }
+      return version.format();
+    };
+    var isPrerelease = (type2) => {
+      return type2.startsWith("pre");
+    };
+    module2.exports = truncate;
+  }
+});
+
 // node_modules/semver/internal/lrucache.js
 var require_lrucache = __commonJS({
   "node_modules/semver/internal/lrucache.js"(exports2, module2) {
@@ -29043,6 +29084,7 @@ var require_semver2 = __commonJS({
     var lte = require_lte();
     var cmp = require_cmp();
     var coerce3 = require_coerce();
+    var truncate = require_truncate();
     var Comparator = require_comparator();
     var Range2 = require_range();
     var satisfies2 = require_satisfies();
@@ -29081,6 +29123,7 @@ var require_semver2 = __commonJS({
       lte,
       cmp,
       coerce: coerce3,
+      truncate,
       Comparator,
       Range: Range2,
       satisfies: satisfies2,

From 7ba697a3ec70911c8056f5a58199d02016517293 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 19 May 2026 14:32:00 +0100
Subject: [PATCH 16/65] Fix comment and clear time component

---
 pr-checks/update-ghes-versions.ts | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/pr-checks/update-ghes-versions.ts b/pr-checks/update-ghes-versions.ts
index 2e458711ff..055424dff1 100755
--- a/pr-checks/update-ghes-versions.ts
+++ b/pr-checks/update-ghes-versions.ts
@@ -129,6 +129,9 @@ export function determineSupportedRange(
   apiCompatibilityData: ApiCompatibility,
   releases: EnterpriseReleases,
 ): ApiCompatibility {
+  // We only care about the UTC date component.
+  today.setUTCHours(0, 0, 0, 0);
+
   // Our goal is to identify the oldest and newest GHES release we should support.
   // We begin with `oldestSupportRelease = undefined` so that we determine the
   // minimum from scratch and don't stick to `apiCompatibilityData.minimumVersion`
@@ -160,9 +163,9 @@ export function determineSupportedRange(
       continue;
     }
 
-    // If the GHES release is newer than the current, newest release we support,
-    // check whether at least two weeks have passed since the feature freeze date
-    // so we don't set `newestSupportedRelease` too early.
+    // Set `newestSupportedRelease` to a GHES release if it has a greater version
+    // than the current `newestSupportedRelease` and the feature freeze has
+    // already happened or will be in the next two weeks.
     if (semver.compare(releaseVersion, newestSupportedRelease) > 0) {
       const featureFreezeDate = new Date(releaseData.feature_freeze);
       if (featureFreezeDate < addWeeks(today, 2)) {

From d24f3022a89758a938831dfa2adf689894d0ca1c Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Thu, 4 Jun 2026 14:27:20 +0000
Subject: [PATCH 17/65] Update changelog and version after v4.36.2

---
 CHANGELOG.md      | 4 ++++
 package-lock.json | 4 ++--
 package.json      | 2 +-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a16b469fad..8cd4b3ee44 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,10 @@
 
 See the [releases page](https://github.com/github/codeql-action/releases) for the relevant changes to the CodeQL CLI and language packs.
 
+## [UNRELEASED]
+
+No user facing changes.
+
 ## 4.36.2 - 04 Jun 2026
 
  - Cache CodeQL CLI version information across Actions steps. [#3943](https://github.com/github/codeql-action/pull/3943)
diff --git a/package-lock.json b/package-lock.json
index 18253b6b9d..7b059d3092 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "codeql",
-  "version": "4.36.2",
+  "version": "4.36.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "codeql",
-      "version": "4.36.2",
+      "version": "4.36.3",
       "license": "MIT",
       "workspaces": [
         "pr-checks"
diff --git a/package.json b/package.json
index ec33e335b0..6432b20086 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "codeql",
-  "version": "4.36.2",
+  "version": "4.36.3",
   "private": true,
   "description": "CodeQL action",
   "scripts": {

From 446948f50b59b0bcf9fb9f281aa712747509ff5b Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Thu, 4 Jun 2026 14:27:34 +0000
Subject: [PATCH 18/65] Rebuild

---
 lib/entry-points.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 0e93e0ec61..0b55a8109d 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -148398,7 +148398,7 @@ function getDiffRangesJsonFilePath() {
   return path2.join(getTemporaryDirectory(), PR_DIFF_RANGE_JSON_FILENAME);
 }
 function getActionVersion() {
-  return "4.36.2";
+  return "4.36.3";
 }
 function getWorkflowEventName() {
   return getRequiredEnvParam("GITHUB_EVENT_NAME");

From 2b0250fe46c8527ef4816168dc57ba9db8d003d6 Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Thu, 4 Jun 2026 15:56:12 +0100
Subject: [PATCH 19/65] Fix CHANGELOG indentation

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 CHANGELOG.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8cd4b3ee44..1c0d6f84ea 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,8 +8,8 @@ No user facing changes.
 
 ## 4.36.2 - 04 Jun 2026
 
- - Cache CodeQL CLI version information across Actions steps. [#3943](https://github.com/github/codeql-action/pull/3943)
- - Reduce requests while waiting for analysis processing by using exponential backoff when polling SARIF processing status. [#3937](https://github.com/github/codeql-action/pull/3937)
+- Cache CodeQL CLI version information across Actions steps. [#3943](https://github.com/github/codeql-action/pull/3943)
+- Reduce requests while waiting for analysis processing by using exponential backoff when polling SARIF processing status. [#3937](https://github.com/github/codeql-action/pull/3937)
 - Update default CodeQL bundle version to [2.25.6](https://github.com/github/codeql-action/releases/tag/codeql-bundle-v2.25.6). [#3948](https://github.com/github/codeql-action/pull/3948)
 
 ## 4.36.1 - 02 Jun 2026

From 72f4abcfcc0dc467c2ed6c419408955d3bd40c4e Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Thu, 4 Jun 2026 16:45:01 +0100
Subject: [PATCH 20/65] Use local `upload-sarif` Action in PR checks job

---
 .github/workflows/pr-checks.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/pr-checks.yml b/.github/workflows/pr-checks.yml
index 195494c185..e0c37dbe24 100644
--- a/.github/workflows/pr-checks.yml
+++ b/.github/workflows/pr-checks.yml
@@ -69,7 +69,7 @@ jobs:
         run: npm run lint-ci
 
       - name: Upload sarif
-        uses: github/codeql-action/upload-sarif@v4
+        uses: ./upload-sarif
         if: matrix.os == 'ubuntu-latest' && matrix.node-version == 24
         with:
           sarif_file: eslint.sarif

From 72b0f9fed48324fc5411e08a2f04d0e38a47d7c9 Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Fri, 5 Jun 2026 12:50:57 +0100
Subject: [PATCH 21/65] Clean up `codeql.resolveLanguages`

Only the betterjson option is now used, so remove the old version.
---
 lib/entry-points.js      | 24 ++++--------------------
 src/codeql.ts            | 38 ++++++--------------------------------
 src/config-utils.test.ts | 22 +++++++++++-----------
 src/config-utils.ts      |  2 +-
 src/trap-caching.test.ts |  2 +-
 src/trap-caching.ts      |  2 +-
 src/workflow.test.ts     |  2 +-
 src/workflow.ts          |  2 +-
 8 files changed, 26 insertions(+), 68 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 0b55a8109d..6e1ea433b3 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -151527,7 +151527,7 @@ async function getTrapCachesForLanguage(allCaches, language, logger) {
 }
 async function getLanguagesSupportingCaching(codeql, languages, logger) {
   const result = [];
-  const resolveResult = await codeql.betterResolveLanguages();
+  const resolveResult = await codeql.resolveLanguages();
   outer: for (const lang of languages) {
     const extractorsForLanguage = resolveResult.extractors[lang];
     if (extractorsForLanguage === void 0) {
@@ -151580,7 +151580,7 @@ async function getSupportedLanguageMap(codeql, logger) {
   const resolveSupportedLanguagesUsingCli = await codeql.supportsFeature(
     "builtinExtractorsSpecifyDefaultQueries" /* BuiltinExtractorsSpecifyDefaultQueries */
   );
-  const resolveResult = await codeql.betterResolveLanguages({
+  const resolveResult = await codeql.resolveLanguages({
     filterToLanguagesWithQueries: resolveSupportedLanguagesUsingCli
   });
   if (resolveSupportedLanguagesUsingCli) {
@@ -154078,23 +154078,7 @@ async function getCodeQLForCmd(cmd, checkVersion) {
       ];
       await runCli(cmd, args);
     },
-    async resolveLanguages() {
-      const codeqlArgs = [
-        "resolve",
-        "languages",
-        "--format=json",
-        ...getExtraOptionsFromEnv(["resolve", "languages"])
-      ];
-      const output = await runCli(cmd, codeqlArgs);
-      try {
-        return JSON.parse(output);
-      } catch (e) {
-        throw new Error(
-          `Unexpected output from codeql resolve languages: ${e}`
-        );
-      }
-    },
-    async betterResolveLanguages({
+    async resolveLanguages({
       filterToLanguagesWithQueries
     } = { filterToLanguagesWithQueries: false }) {
       const codeqlArgs = [
@@ -158779,7 +158763,7 @@ var WorkflowErrors = toCodedErrors({
   InconsistentActionVersion: `Not all workflow steps that use \`github/codeql-action\` actions use the same version. Please ensure that all such steps use the same version to avoid compatibility issues.`
 });
 async function groupLanguagesByExtractor(languages, codeql) {
-  const resolveResult = await codeql.betterResolveLanguages();
+  const resolveResult = await codeql.resolveLanguages();
   if (!resolveResult.aliases) {
     return void 0;
   }
diff --git a/src/codeql.ts b/src/codeql.ts
index afae491a4a..cc6e2ed697 100644
--- a/src/codeql.ts
+++ b/src/codeql.ts
@@ -117,16 +117,12 @@ export interface CodeQL {
     memoryFlag: string,
     enableDebugLogging: boolean,
   ): Promise<void>;
-  /**
-   * Run 'codeql resolve languages'.
-   */
-  resolveLanguages(): Promise<ResolveLanguagesOutput>;
   /**
    * Run 'codeql resolve languages' with '--format=betterjson'.
    */
-  betterResolveLanguages(options?: {
+  resolveLanguages(options?: {
     filterToLanguagesWithQueries: boolean;
-  }): Promise<BetterResolveLanguagesOutput>;
+  }): Promise<ResolveLanguagesOutput>;
   /**
    * Run 'codeql resolve build-environment'
    */
@@ -239,10 +235,6 @@ export interface ResolveDatabaseOutput {
 }
 
 export interface ResolveLanguagesOutput {
-  [language: string]: [string];
-}
-
-export interface BetterResolveLanguagesOutput {
   aliases?: {
     [alias: string]: string;
   };
@@ -460,10 +452,9 @@ export function createStubCodeQL(partialCodeql: Partial<CodeQL>): CodeQL {
       "extractUsingBuildMode",
     ),
     finalizeDatabase: resolveFunction(partialCodeql, "finalizeDatabase"),
-    resolveLanguages: resolveFunction(partialCodeql, "resolveLanguages"),
-    betterResolveLanguages: resolveFunction(
+    resolveLanguages: resolveFunction(
       partialCodeql,
-      "betterResolveLanguages",
+      "resolveLanguages",
       async () => ({ aliases: {}, extractors: {} }),
     ),
     resolveBuildEnvironment: resolveFunction(
@@ -735,24 +726,7 @@ async function getCodeQLForCmd(
       ];
       await runCli(cmd, args);
     },
-    async resolveLanguages() {
-      const codeqlArgs = [
-        "resolve",
-        "languages",
-        "--format=json",
-        ...getExtraOptionsFromEnv(["resolve", "languages"]),
-      ];
-      const output = await runCli(cmd, codeqlArgs);
-
-      try {
-        return JSON.parse(output) as ResolveLanguagesOutput;
-      } catch (e) {
-        throw new Error(
-          `Unexpected output from codeql resolve languages: ${e}`,
-        );
-      }
-    },
-    async betterResolveLanguages(
+    async resolveLanguages(
       {
         filterToLanguagesWithQueries,
       }: {
@@ -773,7 +747,7 @@ async function getCodeQLForCmd(
       const output = await runCli(cmd, codeqlArgs);
 
       try {
-        return JSON.parse(output) as BetterResolveLanguagesOutput;
+        return JSON.parse(output) as ResolveLanguagesOutput;
       } catch (e) {
         throw new Error(
           `Unexpected output from codeql resolve languages with --format=betterjson: ${e}`,
diff --git a/src/config-utils.test.ts b/src/config-utils.test.ts
index 25f9293c40..27de780ad5 100644
--- a/src/config-utils.test.ts
+++ b/src/config-utils.test.ts
@@ -75,7 +75,7 @@ function createTestInitConfigInputs(
       repository: { owner: "github", repo: "example" },
       tempDir: "",
       codeql: createStubCodeQL({
-        async betterResolveLanguages() {
+        async resolveLanguages() {
           return {
             extractors: {
               html: [{ extractor_root: "" }],
@@ -150,7 +150,7 @@ test.serial("load empty config", async (t) => {
     setupActionsVars(tempDir, tempDir);
 
     const codeql = createStubCodeQL({
-      async betterResolveLanguages() {
+      async resolveLanguages() {
         return {
           extractors: {
             javascript: [{ extractor_root: "" }],
@@ -193,7 +193,7 @@ test.serial("load code quality config", async (t) => {
     setupActionsVars(tempDir, tempDir);
 
     const codeql = createStubCodeQL({
-      async betterResolveLanguages() {
+      async resolveLanguages() {
         return {
           extractors: {
             actions: [{ extractor_root: "" }],
@@ -247,7 +247,7 @@ test.serial(
       setupActionsVars(tempDir, tempDir);
 
       const codeql = createStubCodeQL({
-        async betterResolveLanguages() {
+        async resolveLanguages() {
           return {
             extractors: {
               javascript: [{ extractor_root: "" }],
@@ -305,7 +305,7 @@ test.serial("loading a saved config produces the same config", async (t) => {
     const logger = getRunnerLogger(true);
 
     const codeql = createStubCodeQL({
-      async betterResolveLanguages() {
+      async resolveLanguages() {
         return {
           extractors: {
             javascript: [{ extractor_root: "" }],
@@ -352,7 +352,7 @@ test.serial("loading config with version mismatch throws", async (t) => {
     const logger = getRunnerLogger(true);
 
     const codeql = createStubCodeQL({
-      async betterResolveLanguages() {
+      async resolveLanguages() {
         return {
           extractors: {
             javascript: [{ extractor_root: "" }],
@@ -487,7 +487,7 @@ test.serial("load non-empty input", async (t) => {
     setupActionsVars(tempDir, tempDir);
 
     const codeql = createStubCodeQL({
-      async betterResolveLanguages() {
+      async resolveLanguages() {
         return {
           extractors: {
             javascript: [{ extractor_root: "" }],
@@ -582,7 +582,7 @@ test.serial(
       fs.mkdirSync(path.join(tempDir, "foo"));
 
       const codeql = createStubCodeQL({
-        async betterResolveLanguages() {
+        async resolveLanguages() {
           return {
             extractors: {
               javascript: [{ extractor_root: "" }],
@@ -615,7 +615,7 @@ test.serial(
 test.serial("API client used when reading remote config", async (t) => {
   return await withTmpDir(async (tempDir) => {
     const codeql = createStubCodeQL({
-      async betterResolveLanguages() {
+      async resolveLanguages() {
         return {
           extractors: {
             javascript: [{ extractor_root: "" }],
@@ -725,7 +725,7 @@ test.serial("No detected languages", async (t) => {
     mockListLanguages([]);
     const codeql = createStubCodeQL({
       async resolveLanguages() {
-        return {};
+        return { extractors: {} };
       },
     });
 
@@ -891,7 +891,7 @@ const mockRepositoryNwo = parseRepositoryNwo("owner/repo");
       extractor_root: "",
     };
     const codeQL = createStubCodeQL({
-      betterResolveLanguages: (options) =>
+      resolveLanguages: (options) =>
         Promise.resolve({
           aliases: {
             "c#": BuiltInLanguage.csharp,
diff --git a/src/config-utils.ts b/src/config-utils.ts
index f4bd761a23..972734877a 100644
--- a/src/config-utils.ts
+++ b/src/config-utils.ts
@@ -266,7 +266,7 @@ async function getSupportedLanguageMap(
   const resolveSupportedLanguagesUsingCli = await codeql.supportsFeature(
     ToolsFeature.BuiltinExtractorsSpecifyDefaultQueries,
   );
-  const resolveResult = await codeql.betterResolveLanguages({
+  const resolveResult = await codeql.resolveLanguages({
     filterToLanguagesWithQueries: resolveSupportedLanguagesUsingCli,
   });
   if (resolveSupportedLanguagesUsingCli) {
diff --git a/src/trap-caching.test.ts b/src/trap-caching.test.ts
index 9805475796..478305e577 100644
--- a/src/trap-caching.test.ts
+++ b/src/trap-caching.test.ts
@@ -38,7 +38,7 @@ const stubCodeql = createStubCodeQL({
   async getVersion() {
     return makeVersionInfo("2.10.3");
   },
-  async betterResolveLanguages() {
+  async resolveLanguages() {
     return {
       extractors: {
         [BuiltInLanguage.javascript]: [
diff --git a/src/trap-caching.ts b/src/trap-caching.ts
index 216122d47e..a802aac892 100644
--- a/src/trap-caching.ts
+++ b/src/trap-caching.ts
@@ -280,7 +280,7 @@ export async function getLanguagesSupportingCaching(
   logger: Logger,
 ): Promise<Language[]> {
   const result: Language[] = [];
-  const resolveResult = await codeql.betterResolveLanguages();
+  const resolveResult = await codeql.resolveLanguages();
   outer: for (const lang of languages) {
     const extractorsForLanguage = resolveResult.extractors[lang];
     if (extractorsForLanguage === undefined) {
diff --git a/src/workflow.test.ts b/src/workflow.test.ts
index bc5075dd0c..c7f168a9dc 100644
--- a/src/workflow.test.ts
+++ b/src/workflow.test.ts
@@ -383,7 +383,7 @@ async function testLanguageAliases(
   process.env.GITHUB_JOB = "test";
 
   const codeql = await getCodeQLForTesting();
-  sinon.stub(codeql, "betterResolveLanguages").resolves({
+  sinon.stub(codeql, "resolveLanguages").resolves({
     aliases:
       aliases !== undefined
         ? // Remap from languageName -> aliases to alias -> languageName
diff --git a/src/workflow.ts b/src/workflow.ts
index 467980fb0a..151cfd5c5d 100644
--- a/src/workflow.ts
+++ b/src/workflow.ts
@@ -86,7 +86,7 @@ async function groupLanguagesByExtractor(
   languages: string[],
   codeql: CodeQL,
 ): Promise<{ [extractorName: string]: string[] } | undefined> {
-  const resolveResult = await codeql.betterResolveLanguages();
+  const resolveResult = await codeql.resolveLanguages();
   if (!resolveResult.aliases) {
     return undefined;
   }

From 99576d59b9fc0a52007dd1903d940c4066d3d4ec Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Fri, 5 Jun 2026 12:53:01 +0100
Subject: [PATCH 22/65] Fix broken log grouping due to nested log group

---
 lib/entry-points.js                 | 19 +++++++++----------
 src/diff-informed-analysis-utils.ts | 21 ++++++++++-----------
 2 files changed, 19 insertions(+), 21 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 0b55a8109d..68ac7319b1 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -150962,16 +150962,14 @@ async function prepareDiffInformedAnalysis(codeql, features, logger) {
   if (!branches) {
     return false;
   }
-  return await withGroupAsync("Computing PR diff ranges", async () => {
-    try {
-      return await computeAndPersistDiffRanges(branches, logger);
-    } catch (e) {
-      logger.warning(
-        `Failed to compute diff-informed analysis ranges: ${getErrorMessage(e)}`
-      );
-      return false;
-    }
-  });
+  try {
+    return await computeAndPersistDiffRanges(branches, logger);
+  } catch (e) {
+    logger.warning(
+      `Failed to compute diff-informed analysis ranges: ${getErrorMessage(e)}`
+    );
+    return false;
+  }
 }
 function writeDiffRangesJsonFile(logger, ranges) {
   const jsonContents = JSON.stringify(ranges, null, 2);
@@ -151024,6 +151022,7 @@ async function getPullRequestEditedDiffRanges(branches, logger) {
   return results;
 }
 async function computeAndPersistDiffRanges(branches, logger) {
+  logger.info("Computing PR diff ranges...");
   const ranges = await getPullRequestEditedDiffRanges(branches, logger);
   if (ranges === void 0) {
     return false;
diff --git a/src/diff-informed-analysis-utils.ts b/src/diff-informed-analysis-utils.ts
index a48c6dcfdf..b8e9c6915d 100644
--- a/src/diff-informed-analysis-utils.ts
+++ b/src/diff-informed-analysis-utils.ts
@@ -5,7 +5,7 @@ import type { PullRequestBranches } from "./actions-util";
 import { getApiClient, getGitHubVersion } from "./api-client";
 import type { CodeQL } from "./codeql";
 import { Feature, FeatureEnablement } from "./feature-flags";
-import { Logger, withGroupAsync } from "./logging";
+import { Logger } from "./logging";
 import { getRepositoryNwoFromEnv } from "./repository";
 import { getErrorMessage, GitHubVariant, satisfiesGHESVersion } from "./util";
 
@@ -83,16 +83,14 @@ export async function prepareDiffInformedAnalysis(
     return false;
   }
 
-  return await withGroupAsync("Computing PR diff ranges", async () => {
-    try {
-      return await computeAndPersistDiffRanges(branches, logger);
-    } catch (e) {
-      logger.warning(
-        `Failed to compute diff-informed analysis ranges: ${getErrorMessage(e)}`,
-      );
-      return false;
-    }
-  });
+  try {
+    return await computeAndPersistDiffRanges(branches, logger);
+  } catch (e) {
+    logger.warning(
+      `Failed to compute diff-informed analysis ranges: ${getErrorMessage(e)}`,
+    );
+    return false;
+  }
 }
 
 export interface DiffThunkRange {
@@ -192,6 +190,7 @@ export async function computeAndPersistDiffRanges(
   branches: PullRequestBranches,
   logger: Logger,
 ): Promise<boolean> {
+  logger.info("Computing PR diff ranges...");
   const ranges = await getPullRequestEditedDiffRanges(branches, logger);
   if (ranges === undefined) {
     return false;

From ddef2892897e23d4bd7719648360a88a39af7605 Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Fri, 5 Jun 2026 13:01:12 +0100
Subject: [PATCH 23/65] Remove one extractor per language assumption

---
 src/codeql.ts | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/codeql.ts b/src/codeql.ts
index cc6e2ed697..5d78337d2e 100644
--- a/src/codeql.ts
+++ b/src/codeql.ts
@@ -239,12 +239,10 @@ export interface ResolveLanguagesOutput {
     [alias: string]: string;
   };
   extractors: {
-    [language: string]: [
-      {
-        extractor_root: string;
-        extractor_options?: any;
-      },
-    ];
+    [language: string]: Array<{
+      extractor_root: string;
+      extractor_options?: any;
+    }>;
   };
 }
 

From 5f5ed8735c8fc7edf8fa54acef2b630625ec9e06 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 10 Jun 2026 17:55:22 +0000
Subject: [PATCH 24/65] Bump the npm-minor group across 1 directory with 4
 updates

Bumps the npm-minor group with 4 updates in the / directory: [js-yaml](https://github.com/nodeca/js-yaml), [eslint-import-resolver-typescript](https://github.com/import-js/eslint-import-resolver-typescript), [typescript-eslint](https://github.com/typescript-eslint/typescript-eslint/tree/HEAD/packages/typescript-eslint) and [tsx](https://github.com/privatenumber/tsx).


Updates `js-yaml` from 4.1.1 to 4.2.0
- [Changelog](https://github.com/nodeca/js-yaml/blob/master/CHANGELOG.md)
- [Commits](https://github.com/nodeca/js-yaml/commits)

Updates `eslint-import-resolver-typescript` from 4.4.4 to 4.4.5
- [Release notes](https://github.com/import-js/eslint-import-resolver-typescript/releases)
- [Changelog](https://github.com/import-js/eslint-import-resolver-typescript/blob/master/CHANGELOG.md)
- [Commits](https://github.com/import-js/eslint-import-resolver-typescript/compare/v4.4.4...v4.4.5)

Updates `typescript-eslint` from 8.60.0 to 8.60.1
- [Release notes](https://github.com/typescript-eslint/typescript-eslint/releases)
- [Changelog](https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/typescript-eslint/CHANGELOG.md)
- [Commits](https://github.com/typescript-eslint/typescript-eslint/commits/v8.60.1/packages/typescript-eslint)

Updates `tsx` from 4.22.3 to 4.22.4
- [Release notes](https://github.com/privatenumber/tsx/releases)
- [Changelog](https://github.com/privatenumber/tsx/blob/master/release.config.cjs)
- [Commits](https://github.com/privatenumber/tsx/compare/v4.22.3...v4.22.4)

---
updated-dependencies:
- dependency-name: js-yaml
  dependency-version: 4.2.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: npm-minor
- dependency-name: eslint-import-resolver-typescript
  dependency-version: 4.4.5
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: npm-minor
- dependency-name: typescript-eslint
  dependency-version: 8.60.1
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: npm-minor
- dependency-name: tsx
  dependency-version: 4.22.4
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: npm-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 package-lock.json      | 158 ++++++++++++++++++++++-------------------
 package.json           |   6 +-
 pr-checks/package.json |   2 +-
 3 files changed, 88 insertions(+), 78 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 7b059d3092..2ccb2f360f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -28,7 +28,7 @@
         "follow-redirects": "^1.16.0",
         "get-folder-size": "^5.0.0",
         "https-proxy-agent": "^7.0.6",
-        "js-yaml": "^4.1.1",
+        "js-yaml": "^4.2.0",
         "jsonschema": "1.5.0",
         "long": "^5.3.2",
         "node-forge": "^1.4.0",
@@ -51,7 +51,7 @@
         "ava": "^6.4.1",
         "esbuild": "^0.28.0",
         "eslint": "^9.39.4",
-        "eslint-import-resolver-typescript": "^4.4.4",
+        "eslint-import-resolver-typescript": "^4.4.5",
         "eslint-plugin-github": "^6.0.0",
         "eslint-plugin-import-x": "^4.16.2",
         "eslint-plugin-jsdoc": "^62.9.0",
@@ -61,7 +61,7 @@
         "nock": "^14.0.15",
         "sinon": "^22.0.0",
         "typescript": "^6.0.3",
-        "typescript-eslint": "^8.60.0"
+        "typescript-eslint": "^8.60.1"
       }
     },
     "node_modules/@aashutoshrathi/word-wrap": {
@@ -2528,17 +2528,17 @@
       "license": "MIT"
     },
     "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.60.0.tgz",
-      "integrity": "sha512-QYb/sa74/s7OKMbACMjrYnGspj9Hs5YI5aaffSL65UfeBUzVzBJfVo3oWSpbzPurvm7yaCCo2Lk7lVj610HqKw==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.60.1.tgz",
+      "integrity": "sha512-JQ4S5GB0tfjO8BuJ4fcX+HodkzJjYBV+7OJ+wLygaX7OGQ7FudyHL4NSCA6ob+w3Yn+5MkKIozOwQhXeM7opVg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/regexpp": "^4.12.2",
-        "@typescript-eslint/scope-manager": "8.60.0",
-        "@typescript-eslint/type-utils": "8.60.0",
-        "@typescript-eslint/utils": "8.60.0",
-        "@typescript-eslint/visitor-keys": "8.60.0",
+        "@typescript-eslint/scope-manager": "8.60.1",
+        "@typescript-eslint/type-utils": "8.60.1",
+        "@typescript-eslint/utils": "8.60.1",
+        "@typescript-eslint/visitor-keys": "8.60.1",
         "ignore": "^7.0.5",
         "natural-compare": "^1.4.0",
         "ts-api-utils": "^2.5.0"
@@ -2551,7 +2551,7 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "@typescript-eslint/parser": "^8.60.0",
+        "@typescript-eslint/parser": "^8.60.1",
         "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
         "typescript": ">=4.8.4 <6.1.0"
       }
@@ -2567,16 +2567,16 @@
       }
     },
     "node_modules/@typescript-eslint/parser": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.60.0.tgz",
-      "integrity": "sha512-fcqpj/MyK4sxDPcbe7STNPbpQL4RLZOPWuaTmwZYuc+hJKzRf58yRxfhqGpc6PIq9ZyfSBpfHgmUHmHs0KwHwg==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.60.1.tgz",
+      "integrity": "sha512-A0M6ua6H252bVjPvvtSgl2QA4+ET9S5Mtkb2GDyTxIhH/C4qDItT7RQNO5PhMC6NXGYXOR9dIalcDDgBKT7oFA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/scope-manager": "8.60.0",
-        "@typescript-eslint/types": "8.60.0",
-        "@typescript-eslint/typescript-estree": "8.60.0",
-        "@typescript-eslint/visitor-keys": "8.60.0",
+        "@typescript-eslint/scope-manager": "8.60.1",
+        "@typescript-eslint/types": "8.60.1",
+        "@typescript-eslint/typescript-estree": "8.60.1",
+        "@typescript-eslint/visitor-keys": "8.60.1",
         "debug": "^4.4.3"
       },
       "engines": {
@@ -2610,14 +2610,14 @@
       }
     },
     "node_modules/@typescript-eslint/project-service": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.60.0.tgz",
-      "integrity": "sha512-aZu74NNKJeUWqCjDddzdiKaS82dgYgV/vmf+Ui3ZdZejmgfXR/q+pRumgobnQ2cCJTgGTWp4ypiwsuofFubavg==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.60.1.tgz",
+      "integrity": "sha512-eXkTH2bxmXlqD1RnOPmLZ9ZM9D3VwSx04JOwBnP9RQ+yUA5a2Mu7SfW8uaV2Aon53NJzZlZYuX7tn91Izf+xaw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/tsconfig-utils": "^8.60.0",
-        "@typescript-eslint/types": "^8.60.0",
+        "@typescript-eslint/tsconfig-utils": "^8.60.1",
+        "@typescript-eslint/types": "^8.60.1",
         "debug": "^4.4.3"
       },
       "engines": {
@@ -2650,14 +2650,14 @@
       }
     },
     "node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.60.0.tgz",
-      "integrity": "sha512-pFzqhllJMs+jghLQWzV00ds39xLzuyqPSev5pd8f4Ir0rtKR3ZLUB4/4dhjOFighWb9larvtfJvqL+4yKDI3Xw==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.60.1.tgz",
+      "integrity": "sha512-gvI5OQoptnxQnchOirukCuQ55svJSTuD/4k5+pC267xyBtYry748R9/c3tYUzb/iE6RZfllRz2lVulLCHkTm4w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.60.0",
-        "@typescript-eslint/visitor-keys": "8.60.0"
+        "@typescript-eslint/types": "8.60.1",
+        "@typescript-eslint/visitor-keys": "8.60.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2668,9 +2668,9 @@
       }
     },
     "node_modules/@typescript-eslint/tsconfig-utils": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.60.0.tgz",
-      "integrity": "sha512-BZPR3RGYlAXnly6ymAxfkVn5rCbZzQNou0rxv3GfWZ8cTQp+hhVd73khbGLAd8k1TlAPLISH337M+tAgAnaJDQ==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.60.1.tgz",
+      "integrity": "sha512-nh8w4qAteiKuZu3pSSzG/yGKpw0OlkrKnzFmbVRenKaD4qc+7i1GrmZaLVkr8rk4uipiPGMOW4YsM6WmKZ5CvA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -2685,15 +2685,15 @@
       }
     },
     "node_modules/@typescript-eslint/type-utils": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.60.0.tgz",
-      "integrity": "sha512-SX46wEUtitCpq7AN38HkUU/+zvUpdKf7ephtWAFgckH8O7PQIyL5gvrhQgBLuEYgLfuKWOVvWVskMbuFHAz5xg==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.60.1.tgz",
+      "integrity": "sha512-sdwTrpjosW7ANQYJ39ZBF1ZyEMEGVB2UsikrserVM/30a/F1dTLnu9bGxEdosugyu5caigjLrR2qiD11asjI1A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.60.0",
-        "@typescript-eslint/typescript-estree": "8.60.0",
-        "@typescript-eslint/utils": "8.60.0",
+        "@typescript-eslint/types": "8.60.1",
+        "@typescript-eslint/typescript-estree": "8.60.1",
+        "@typescript-eslint/utils": "8.60.1",
         "debug": "^4.4.3",
         "ts-api-utils": "^2.5.0"
       },
@@ -2728,9 +2728,9 @@
       }
     },
     "node_modules/@typescript-eslint/types": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.60.0.tgz",
-      "integrity": "sha512-AsE7x2XaAK+CVbeih0Fvbn+r1qHxtpLDJ3XUuFcIinT318T90yHMJC+Zgv+jUuDjQQd06HKwxnDu6sz1IcTilA==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.60.1.tgz",
+      "integrity": "sha512-4h0tY8ppCkdCzcrl2YM5M3my0xsE1Tf8om3owEu5oPWmXwkKRmk0j0LGDzYBGUcAlesEbxBhazqu/K4cu3Ug7w==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -2742,16 +2742,16 @@
       }
     },
     "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.60.0.tgz",
-      "integrity": "sha512-3AcZNBGMClm6CXDyo8kYvVGT/sx29sS0oBsIb9oZI2gunA4Vm2M3YHzRLPvsUBBsl+yB5FPtltq7gGH0iTlp9g==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.60.1.tgz",
+      "integrity": "sha512-alpRkfG8hlVE5kdJW2GkfgDgXxold3e8e4l6EnmhRmRLbekgAPCCGDVD++sABy9FcgPFroq+uFcCSM1vR57Cew==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/project-service": "8.60.0",
-        "@typescript-eslint/tsconfig-utils": "8.60.0",
-        "@typescript-eslint/types": "8.60.0",
-        "@typescript-eslint/visitor-keys": "8.60.0",
+        "@typescript-eslint/project-service": "8.60.1",
+        "@typescript-eslint/tsconfig-utils": "8.60.1",
+        "@typescript-eslint/types": "8.60.1",
+        "@typescript-eslint/visitor-keys": "8.60.1",
         "debug": "^4.4.3",
         "minimatch": "^10.2.2",
         "semver": "^7.7.3",
@@ -2827,16 +2827,16 @@
       }
     },
     "node_modules/@typescript-eslint/utils": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.60.0.tgz",
-      "integrity": "sha512-HtXuPfrHTyBDkameWpl+vJb1Uevu2tznAyahM1Oc4AENidCLTPiZDWIo4GfcxNdC/RcfGcadzzkqbRG87dUrQA==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.60.1.tgz",
+      "integrity": "sha512-h2MPBLoNtjc3qZWfY3Tl51yPorQ2McHn8pJfcMNTcIvrrZrr90Ykffit0yjrPFWQcRcUxzH20+6OcVdW4yHtUg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.9.1",
-        "@typescript-eslint/scope-manager": "8.60.0",
-        "@typescript-eslint/types": "8.60.0",
-        "@typescript-eslint/typescript-estree": "8.60.0"
+        "@typescript-eslint/scope-manager": "8.60.1",
+        "@typescript-eslint/types": "8.60.1",
+        "@typescript-eslint/typescript-estree": "8.60.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2851,13 +2851,13 @@
       }
     },
     "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.60.0.tgz",
-      "integrity": "sha512-9WI52t8ZGLVGrPMBet25yAftqY/n95+zmoUUtJBBQTKDSKUu7OsPTroT2op7U9JatkoRccL0YkWDNMFfC4Sjxg==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.60.1.tgz",
+      "integrity": "sha512-EbGRQg4FhrmwLodl+t3JNAnXHWVr9Vp+Zl1QBZVPY4ByfkzIT8cX3K6QWODHtkIZqqJVEWvhHSx3v5PDHsaQag==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.60.0",
+        "@typescript-eslint/types": "8.60.1",
         "eslint-visitor-keys": "^5.0.0"
       },
       "engines": {
@@ -4825,9 +4825,9 @@
       }
     },
     "node_modules/eslint-import-resolver-typescript": {
-      "version": "4.4.4",
-      "resolved": "https://registry.npmjs.org/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-4.4.4.tgz",
-      "integrity": "sha512-1iM2zeBvrYmUNTj2vSC/90JTHDth+dfOfiNKkxApWRsTJYNrc8rOdxxIf5vazX+BiAXTeOT0UvWpGI/7qIWQOw==",
+      "version": "4.4.5",
+      "resolved": "https://registry.npmjs.org/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-4.4.5.tgz",
+      "integrity": "sha512-nbE5XLph6TLtGYcu/U6e6ZVXyKBhbDWK5cLGk76eJ7NdZpwf1P9EFkpt1Z01mNZNrrilsAYWKH6zUkL4reoXbw==",
       "dev": true,
       "license": "ISC",
       "dependencies": {
@@ -6960,9 +6960,19 @@
       }
     },
     "node_modules/js-yaml": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
-      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.2.0.tgz",
+      "integrity": "sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/puzrin"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodeca"
+        }
+      ],
       "license": "MIT",
       "dependencies": {
         "argparse": "^2.0.1"
@@ -9140,9 +9150,9 @@
       "license": "0BSD"
     },
     "node_modules/tsx": {
-      "version": "4.22.3",
-      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.22.3.tgz",
-      "integrity": "sha512-mdoNxBC/cSQObGGVQ5Bpn5i+yv7j68gk3Nfm3wFjcJg3Z0Mix9jzAFfP12prmm5eVGmDKtp0yyArrs0Q+8gZHg==",
+      "version": "4.22.4",
+      "resolved": "https://registry.npmjs.org/tsx/-/tsx-4.22.4.tgz",
+      "integrity": "sha512-X8EX+XV4QR5xCsrgxaED954zTDfY8KqlDtskKEL0cHhyS/P8b4IFOvGDQpsC9Q1XnLq915wEfwwY/zzskCtmhg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -9292,16 +9302,16 @@
       }
     },
     "node_modules/typescript-eslint": {
-      "version": "8.60.0",
-      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.60.0.tgz",
-      "integrity": "sha512-9f65qWLZdAW9m1JaxBDUHcqRUfL8bkxxXL7XxEfI+F09q56PkBvIfCjLF3yInsDM/BBmwkqmCQdCZe/RYlIWEw==",
+      "version": "8.60.1",
+      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.60.1.tgz",
+      "integrity": "sha512-6m5hkkRAp8lKvhVpcprAIn5KkehQEh+47oHH2VGnExEh7dhNxXlg6GPAOIu6TxbVQxhebrJDvjl3020ooiWCMA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/eslint-plugin": "8.60.0",
-        "@typescript-eslint/parser": "8.60.0",
-        "@typescript-eslint/typescript-estree": "8.60.0",
-        "@typescript-eslint/utils": "8.60.0"
+        "@typescript-eslint/eslint-plugin": "8.60.1",
+        "@typescript-eslint/parser": "8.60.1",
+        "@typescript-eslint/typescript-estree": "8.60.1",
+        "@typescript-eslint/utils": "8.60.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -9821,7 +9831,7 @@
       },
       "devDependencies": {
         "@types/node": "^20.19.41",
-        "tsx": "^4.22.3"
+        "tsx": "^4.22.4"
       }
     }
   }
diff --git a/package.json b/package.json
index 6432b20086..df687912be 100644
--- a/package.json
+++ b/package.json
@@ -36,7 +36,7 @@
     "follow-redirects": "^1.16.0",
     "get-folder-size": "^5.0.0",
     "https-proxy-agent": "^7.0.6",
-    "js-yaml": "^4.1.1",
+    "js-yaml": "^4.2.0",
     "jsonschema": "1.5.0",
     "long": "^5.3.2",
     "node-forge": "^1.4.0",
@@ -59,7 +59,7 @@
     "ava": "^6.4.1",
     "esbuild": "^0.28.0",
     "eslint": "^9.39.4",
-    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-github": "^6.0.0",
     "eslint-plugin-import-x": "^4.16.2",
     "eslint-plugin-jsdoc": "^62.9.0",
@@ -69,7 +69,7 @@
     "nock": "^14.0.15",
     "sinon": "^22.0.0",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.60.0"
+    "typescript-eslint": "^8.60.1"
   },
   "overrides": {
     "@actions/tool-cache": {
diff --git a/pr-checks/package.json b/pr-checks/package.json
index 02b841e6d5..c79f818d4c 100644
--- a/pr-checks/package.json
+++ b/pr-checks/package.json
@@ -11,6 +11,6 @@
   },
   "devDependencies": {
     "@types/node": "^20.19.41",
-    "tsx": "^4.22.3"
+    "tsx": "^4.22.4"
   }
 }

From 9f2d709a33e07d1680d0f5a50b698fb9aba8f7e0 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 10 Jun 2026 17:57:20 +0000
Subject: [PATCH 25/65] Rebuild

---
 lib/entry-points.js | 7941 +++++++++++++++++++++----------------------
 1 file changed, 3858 insertions(+), 4083 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 006389be49..21cf78a4b9 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -3611,12 +3611,12 @@ var require_data_url = __commonJS({
     function parseMIMEType(input) {
       input = removeHTTPWhitespace(input, true, true);
       const position = { position: 0 };
-      const type2 = collectASequenceOfCodePointsFast(
+      const type = collectASequenceOfCodePointsFast(
         "/",
         input,
         position
       );
-      if (type2.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type2)) {
+      if (type.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(type)) {
         return "failure";
       }
       if (position.position > input.length) {
@@ -3632,7 +3632,7 @@ var require_data_url = __commonJS({
       if (subtype.length === 0 || !HTTP_TOKEN_CODEPOINTS.test(subtype)) {
         return "failure";
       }
-      const typeLowercase = type2.toLowerCase();
+      const typeLowercase = type.toLowerCase();
       const subtypeLowercase = subtype.toLowerCase();
       const mimeType = {
         type: typeLowercase,
@@ -3763,25 +3763,25 @@ var require_data_url = __commonJS({
     function isHTTPWhiteSpace(char) {
       return char === 13 || char === 10 || char === 9 || char === 32;
     }
-    function removeHTTPWhitespace(str2, leading = true, trailing = true) {
-      return removeChars(str2, leading, trailing, isHTTPWhiteSpace);
+    function removeHTTPWhitespace(str, leading = true, trailing = true) {
+      return removeChars(str, leading, trailing, isHTTPWhiteSpace);
     }
     function isASCIIWhitespace(char) {
       return char === 13 || char === 10 || char === 9 || char === 12 || char === 32;
     }
-    function removeASCIIWhitespace(str2, leading = true, trailing = true) {
-      return removeChars(str2, leading, trailing, isASCIIWhitespace);
+    function removeASCIIWhitespace(str, leading = true, trailing = true) {
+      return removeChars(str, leading, trailing, isASCIIWhitespace);
     }
-    function removeChars(str2, leading, trailing, predicate) {
+    function removeChars(str, leading, trailing, predicate) {
       let lead = 0;
-      let trail = str2.length - 1;
+      let trail = str.length - 1;
       if (leading) {
-        while (lead < str2.length && predicate(str2.charCodeAt(lead))) lead++;
+        while (lead < str.length && predicate(str.charCodeAt(lead))) lead++;
       }
       if (trailing) {
-        while (trail > 0 && predicate(str2.charCodeAt(trail))) trail--;
+        while (trail > 0 && predicate(str.charCodeAt(trail))) trail--;
       }
-      return lead === 0 && trail === str2.length - 1 ? str2 : str2.slice(lead, trail + 1);
+      return lead === 0 && trail === str.length - 1 ? str : str.slice(lead, trail + 1);
     }
     function isomorphicDecode(input) {
       const length = input.length;
@@ -3857,7 +3857,7 @@ var require_data_url = __commonJS({
 var require_webidl = __commonJS({
   "node_modules/undici/lib/web/fetch/webidl.js"(exports2, module2) {
     "use strict";
-    var { types, inspect } = require("node:util");
+    var { types: types2, inspect } = require("node:util");
     var { markAsUncloneable } = require("node:worker_threads");
     var { toUSVString } = require_util();
     var webidl = {};
@@ -3999,8 +3999,8 @@ var require_webidl = __commonJS({
       return r;
     };
     webidl.util.Stringify = function(V) {
-      const type2 = webidl.util.Type(V);
-      switch (type2) {
+      const type = webidl.util.Type(V);
+      switch (type) {
         case "Symbol":
           return `Symbol(${V.description})`;
         case "Object":
@@ -4020,7 +4020,7 @@ var require_webidl = __commonJS({
           });
         }
         const method = typeof Iterable === "function" ? Iterable() : V?.[Symbol.iterator]?.();
-        const seq2 = [];
+        const seq = [];
         let index = 0;
         if (method === void 0 || typeof method.next !== "function") {
           throw webidl.errors.exception({
@@ -4033,9 +4033,9 @@ var require_webidl = __commonJS({
           if (done) {
             break;
           }
-          seq2.push(converter(value, prefix, `${argument}[${index++}]`));
+          seq.push(converter(value, prefix, `${argument}[${index++}]`));
         }
-        return seq2;
+        return seq;
       };
     };
     webidl.recordConverter = function(keyConverter, valueConverter) {
@@ -4047,7 +4047,7 @@ var require_webidl = __commonJS({
           });
         }
         const result = {};
-        if (!types.isProxy(O)) {
+        if (!types2.isProxy(O)) {
           const keys2 = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)];
           for (const key of keys2) {
             const typedKey = keyConverter(key, prefix, argument);
@@ -4081,11 +4081,11 @@ var require_webidl = __commonJS({
     };
     webidl.dictionaryConverter = function(converters) {
       return (dictionary, prefix, argument) => {
-        const type2 = webidl.util.Type(dictionary);
+        const type = webidl.util.Type(dictionary);
         const dict = {};
-        if (type2 === "Null" || type2 === "Undefined") {
+        if (type === "Null" || type === "Undefined") {
           return dict;
-        } else if (type2 !== "Object") {
+        } else if (type !== "Object") {
           throw webidl.errors.exception({
             header: prefix,
             message: `Expected ${dictionary} to be one of: Null, Undefined, Object.`
@@ -4176,14 +4176,14 @@ var require_webidl = __commonJS({
       return x;
     };
     webidl.converters.ArrayBuffer = function(V, prefix, argument, opts) {
-      if (webidl.util.Type(V) !== "Object" || !types.isAnyArrayBuffer(V)) {
+      if (webidl.util.Type(V) !== "Object" || !types2.isAnyArrayBuffer(V)) {
         throw webidl.errors.conversionFailed({
           prefix,
           argument: `${argument} ("${webidl.util.Stringify(V)}")`,
           types: ["ArrayBuffer"]
         });
       }
-      if (opts?.allowShared === false && types.isSharedArrayBuffer(V)) {
+      if (opts?.allowShared === false && types2.isSharedArrayBuffer(V)) {
         throw webidl.errors.exception({
           header: "ArrayBuffer",
           message: "SharedArrayBuffer is not allowed."
@@ -4198,14 +4198,14 @@ var require_webidl = __commonJS({
       return V;
     };
     webidl.converters.TypedArray = function(V, T, prefix, name, opts) {
-      if (webidl.util.Type(V) !== "Object" || !types.isTypedArray(V) || V.constructor.name !== T.name) {
+      if (webidl.util.Type(V) !== "Object" || !types2.isTypedArray(V) || V.constructor.name !== T.name) {
         throw webidl.errors.conversionFailed({
           prefix,
           argument: `${name} ("${webidl.util.Stringify(V)}")`,
           types: [T.name]
         });
       }
-      if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
+      if (opts?.allowShared === false && types2.isSharedArrayBuffer(V.buffer)) {
         throw webidl.errors.exception({
           header: "ArrayBuffer",
           message: "SharedArrayBuffer is not allowed."
@@ -4220,13 +4220,13 @@ var require_webidl = __commonJS({
       return V;
     };
     webidl.converters.DataView = function(V, prefix, name, opts) {
-      if (webidl.util.Type(V) !== "Object" || !types.isDataView(V)) {
+      if (webidl.util.Type(V) !== "Object" || !types2.isDataView(V)) {
         throw webidl.errors.exception({
           header: prefix,
           message: `${name} is not a DataView.`
         });
       }
-      if (opts?.allowShared === false && types.isSharedArrayBuffer(V.buffer)) {
+      if (opts?.allowShared === false && types2.isSharedArrayBuffer(V.buffer)) {
         throw webidl.errors.exception({
           header: "ArrayBuffer",
           message: "SharedArrayBuffer is not allowed."
@@ -4241,13 +4241,13 @@ var require_webidl = __commonJS({
       return V;
     };
     webidl.converters.BufferSource = function(V, prefix, name, opts) {
-      if (types.isAnyArrayBuffer(V)) {
+      if (types2.isAnyArrayBuffer(V)) {
         return webidl.converters.ArrayBuffer(V, prefix, name, { ...opts, allowShared: false });
       }
-      if (types.isTypedArray(V)) {
+      if (types2.isTypedArray(V)) {
         return webidl.converters.TypedArray(V, V.constructor, prefix, name, { ...opts, allowShared: false });
       }
-      if (types.isDataView(V)) {
+      if (types2.isDataView(V)) {
         return webidl.converters.DataView(V, prefix, name, { ...opts, allowShared: false });
       }
       throw webidl.errors.conversionFailed({
@@ -4416,8 +4416,8 @@ var require_util2 = __commonJS({
         request3.headersList.append("origin", serializedOrigin, true);
       }
     }
-    function coarsenTime(timestamp2, crossOriginIsolatedCapability) {
-      return timestamp2;
+    function coarsenTime(timestamp, crossOriginIsolatedCapability) {
+      return timestamp;
     }
     function clampAndCoarsenConnectionTimingInfo(connectionTimingInfo, defaultStartTime, crossOriginIsolatedCapability) {
       if (!connectionTimingInfo?.startTime || connectionTimingInfo.startTime < defaultStartTime) {
@@ -5685,13 +5685,13 @@ var require_body = __commonJS({
       let action = null;
       let source = null;
       let length = null;
-      let type2 = null;
+      let type = null;
       if (typeof object === "string") {
         source = object;
-        type2 = "text/plain;charset=UTF-8";
+        type = "text/plain;charset=UTF-8";
       } else if (object instanceof URLSearchParams) {
         source = object.toString();
-        type2 = "application/x-www-form-urlencoded;charset=UTF-8";
+        type = "application/x-www-form-urlencoded;charset=UTF-8";
       } else if (isArrayBuffer(object)) {
         source = new Uint8Array(object.slice());
       } else if (ArrayBuffer.isView(object)) {
@@ -5700,7 +5700,7 @@ var require_body = __commonJS({
         const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`;
         const prefix = `--${boundary}\r
 Content-Disposition: form-data`;
-        const escape2 = (str2) => str2.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
+        const escape2 = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
         const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n");
         const blobParts = [];
         const rn = new Uint8Array([13, 10]);
@@ -5744,12 +5744,12 @@ Content-Type: ${value.type || "application/octet-stream"}\r
             }
           }
         };
-        type2 = `multipart/form-data; boundary=${boundary}`;
+        type = `multipart/form-data; boundary=${boundary}`;
       } else if (isBlobLike(object)) {
         source = object;
         length = object.size;
         if (object.type) {
-          type2 = object.type;
+          type = object.type;
         }
       } else if (typeof object[Symbol.asyncIterator] === "function") {
         if (keepalive) {
@@ -5795,7 +5795,7 @@ Content-Type: ${value.type || "application/octet-stream"}\r
         });
       }
       const body = { stream: stream2, source, length };
-      return [body, type2];
+      return [body, type];
     }
     function safelyExtractBody(object, keepalive = false) {
       if (object instanceof ReadableStream) {
@@ -6077,14 +6077,14 @@ var require_client_h1 = __commonJS({
         this.connection = "";
         this.maxResponseSize = client[kMaxResponseSize];
       }
-      setTimeout(delay2, type2) {
-        if (delay2 !== this.timeoutValue || type2 & USE_FAST_TIMER ^ this.timeoutType & USE_FAST_TIMER) {
+      setTimeout(delay2, type) {
+        if (delay2 !== this.timeoutValue || type & USE_FAST_TIMER ^ this.timeoutType & USE_FAST_TIMER) {
           if (this.timeout) {
             timers.clearTimeout(this.timeout);
             this.timeout = null;
           }
           if (delay2) {
-            if (type2 & USE_FAST_TIMER) {
+            if (type & USE_FAST_TIMER) {
               this.timeout = timers.setFastTimeout(onParserTimeout, delay2, new WeakRef(this));
             } else {
               this.timeout = setTimeout(onParserTimeout, delay2, new WeakRef(this));
@@ -6097,7 +6097,7 @@ var require_client_h1 = __commonJS({
             this.timeout.refresh();
           }
         }
-        this.timeoutType = type2;
+        this.timeoutType = type;
       }
       resume() {
         if (this.socket.destroyed || !this.paused) {
@@ -7116,9 +7116,9 @@ var require_client_h2 = __commonJS({
       this[kSocket][kError] = err;
       this[kClient][kOnError](err);
     }
-    function onHttp2FrameError(type2, code, id) {
+    function onHttp2FrameError(type, code, id) {
       if (id === 0) {
-        const err = new InformationalError(`HTTP/2: "frameError" received - type ${type2}, code ${code}`);
+        const err = new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`);
         this[kSocket][kError] = err;
         this[kClient][kOnError](err);
       }
@@ -7304,8 +7304,8 @@ var require_client_h2 = __commonJS({
       stream2.once("error", function(err) {
         abort(err);
       });
-      stream2.once("frameError", (type2, code) => {
-        abort(new InformationalError(`HTTP/2: "frameError" received - type ${type2}, code ${code}`));
+      stream2.once("frameError", (type, code) => {
+        abort(new InformationalError(`HTTP/2: "frameError" received - type ${type}, code ${code}`));
       });
       return true;
       function writeBodyH2() {
@@ -9603,7 +9603,7 @@ var require_readable = __commonJS({
     function isUnusable(self2) {
       return util.isDisturbed(self2) || isLocked(self2);
     }
-    async function consume(stream2, type2) {
+    async function consume(stream2, type) {
       assert(!stream2[kConsume]);
       return new Promise((resolve13, reject) => {
         if (isUnusable(stream2)) {
@@ -9620,7 +9620,7 @@ var require_readable = __commonJS({
         } else {
           queueMicrotask(() => {
             stream2[kConsume] = {
-              type: type2,
+              type,
               stream: stream2,
               resolve: resolve13,
               reject,
@@ -9692,17 +9692,17 @@ var require_readable = __commonJS({
       return buffer;
     }
     function consumeEnd(consume2) {
-      const { type: type2, body, resolve: resolve13, stream: stream2, length } = consume2;
+      const { type, body, resolve: resolve13, stream: stream2, length } = consume2;
       try {
-        if (type2 === "text") {
+        if (type === "text") {
           resolve13(chunksDecode(body, length));
-        } else if (type2 === "json") {
+        } else if (type === "json") {
           resolve13(JSON.parse(chunksDecode(body, length)));
-        } else if (type2 === "arrayBuffer") {
+        } else if (type === "arrayBuffer") {
           resolve13(chunksConcat(body, length).buffer);
-        } else if (type2 === "blob") {
+        } else if (type === "blob") {
           resolve13(new Blob(body, { type: stream2[kContentType] }));
-        } else if (type2 === "bytes") {
+        } else if (type === "bytes") {
           resolve13(chunksConcat(body, length));
         }
         consumeFinish(consume2);
@@ -11793,10 +11793,10 @@ var require_dns = __commonJS({
         return ip;
       }
       setRecords(origin, addresses) {
-        const timestamp2 = Date.now();
+        const timestamp = Date.now();
         const records = { records: { 4: null, 6: null } };
         for (const record of addresses) {
-          record.timestamp = timestamp2;
+          record.timestamp = timestamp;
           if (typeof record.ttl === "number") {
             record.ttl = Math.min(record.ttl, this.#maxTTL);
           } else {
@@ -12399,7 +12399,7 @@ var require_response = __commonJS({
     var { URLSerializer } = require_data_url();
     var { kConstruct } = require_symbols();
     var assert = require("node:assert");
-    var { types } = require("node:util");
+    var { types: types2 } = require("node:util");
     var textEncoder = new TextEncoder("utf-8");
     var Response = class _Response {
       // Creates network error Response.
@@ -12457,8 +12457,8 @@ var require_response = __commonJS({
         setHeadersList(this[kHeaders], this[kState].headersList);
         let bodyWithType = null;
         if (body != null) {
-          const [extractedBody, type2] = extractBody(body);
-          bodyWithType = { body: extractedBody, type: type2 };
+          const [extractedBody, type] = extractBody(body);
+          bodyWithType = { body: extractedBody, type };
         }
         initializeResponse(this, init, bodyWithType);
       }
@@ -12627,18 +12627,18 @@ var require_response = __commonJS({
         }
       });
     }
-    function filterResponse(response, type2) {
-      if (type2 === "basic") {
+    function filterResponse(response, type) {
+      if (type === "basic") {
         return makeFilteredResponse(response, {
           type: "basic",
           headersList: response.headersList
         });
-      } else if (type2 === "cors") {
+      } else if (type === "cors") {
         return makeFilteredResponse(response, {
           type: "cors",
           headersList: response.headersList
         });
-      } else if (type2 === "opaque") {
+      } else if (type === "opaque") {
         return makeFilteredResponse(response, {
           type: "opaque",
           urlList: Object.freeze([]),
@@ -12646,7 +12646,7 @@ var require_response = __commonJS({
           statusText: "",
           body: null
         });
-      } else if (type2 === "opaqueredirect") {
+      } else if (type === "opaqueredirect") {
         return makeFilteredResponse(response, {
           type: "opaqueredirect",
           status: 0,
@@ -12720,7 +12720,7 @@ var require_response = __commonJS({
       if (isBlobLike(V)) {
         return webidl.converters.Blob(V, prefix, name, { strict: false });
       }
-      if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
+      if (ArrayBuffer.isView(V) || types2.isArrayBuffer(V)) {
         return webidl.converters.BufferSource(V, prefix, name);
       }
       if (util.isFormDataLike(V)) {
@@ -13911,13 +13911,13 @@ var require_fetch = __commonJS({
           const response = makeResponse();
           const fullLength = blob.size;
           const serializedFullLength = isomorphicEncode(`${fullLength}`);
-          const type2 = blob.type;
+          const type = blob.type;
           if (!request3.headersList.contains("range", true)) {
             const bodyWithType = extractBody(blob);
             response.statusText = "OK";
             response.body = bodyWithType[0];
             response.headersList.set("content-length", serializedFullLength, true);
-            response.headersList.set("content-type", type2, true);
+            response.headersList.set("content-type", type, true);
           } else {
             response.rangeRequested = true;
             const rangeHeader = request3.headersList.get("range", true);
@@ -13937,7 +13937,7 @@ var require_fetch = __commonJS({
                 rangeEnd = fullLength - 1;
               }
             }
-            const slicedBlob = blob.slice(rangeStart, rangeEnd, type2);
+            const slicedBlob = blob.slice(rangeStart, rangeEnd, type);
             const slicedBodyWithType = extractBody(slicedBlob);
             response.body = slicedBodyWithType[0];
             const serializedSlicedLength = isomorphicEncode(`${slicedBlob.size}`);
@@ -13945,7 +13945,7 @@ var require_fetch = __commonJS({
             response.status = 206;
             response.statusText = "Partial Content";
             response.headersList.set("content-length", serializedSlicedLength, true);
-            response.headersList.set("content-type", type2, true);
+            response.headersList.set("content-type", type, true);
             response.headersList.set("content-range", contentRange, true);
           }
           return Promise.resolve(response);
@@ -14595,10 +14595,10 @@ var require_progressevent = __commonJS({
     var { webidl } = require_webidl();
     var kState = /* @__PURE__ */ Symbol("ProgressEvent state");
     var ProgressEvent = class _ProgressEvent extends Event {
-      constructor(type2, eventInitDict = {}) {
-        type2 = webidl.converters.DOMString(type2, "ProgressEvent constructor", "type");
+      constructor(type, eventInitDict = {}) {
+        type = webidl.converters.DOMString(type, "ProgressEvent constructor", "type");
         eventInitDict = webidl.converters.ProgressEventInit(eventInitDict ?? {});
-        super(type2, eventInitDict);
+        super(type, eventInitDict);
         this[kState] = {
           lengthComputable: eventInitDict.lengthComputable,
           loaded: eventInitDict.loaded,
@@ -14956,7 +14956,7 @@ var require_util4 = __commonJS({
     var { ProgressEvent } = require_progressevent();
     var { getEncoding } = require_encoding();
     var { serializeAMimeType, parseMIMEType } = require_data_url();
-    var { types } = require("node:util");
+    var { types: types2 } = require("node:util");
     var { StringDecoder } = require("string_decoder");
     var { btoa: btoa2 } = require("node:buffer");
     var staticPropertyDescriptors = {
@@ -14964,7 +14964,7 @@ var require_util4 = __commonJS({
       writable: false,
       configurable: false
     };
-    function readOperation(fr, blob, type2, encodingName) {
+    function readOperation(fr, blob, type, encodingName) {
       if (fr[kState] === "loading") {
         throw new DOMException("Invalid state", "InvalidStateError");
       }
@@ -14986,7 +14986,7 @@ var require_util4 = __commonJS({
               });
             }
             isFirstChunk = false;
-            if (!done && types.isUint8Array(value)) {
+            if (!done && types2.isUint8Array(value)) {
               bytes.push(value);
               if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) {
                 fr[kLastProgressEventFired] = Date.now();
@@ -14999,7 +14999,7 @@ var require_util4 = __commonJS({
               queueMicrotask(() => {
                 fr[kState] = "done";
                 try {
-                  const result = packageData(bytes, type2, blob.type, encodingName);
+                  const result = packageData(bytes, type, blob.type, encodingName);
                   if (fr[kAborted]) {
                     return;
                   }
@@ -15039,8 +15039,8 @@ var require_util4 = __commonJS({
       });
       reader.dispatchEvent(event);
     }
-    function packageData(bytes, type2, mimeType, encodingName) {
-      switch (type2) {
+    function packageData(bytes, type, mimeType, encodingName) {
+      switch (type) {
         case "DataURL": {
           let dataURL = "data:";
           const parsed = parseMIMEType(mimeType || "application/octet-stream");
@@ -15061,9 +15061,9 @@ var require_util4 = __commonJS({
             encoding = getEncoding(encodingName);
           }
           if (encoding === "failure" && mimeType) {
-            const type3 = parseMIMEType(mimeType);
-            if (type3 !== "failure") {
-              encoding = getEncoding(type3.parameters.get("charset"));
+            const type2 = parseMIMEType(mimeType);
+            if (type2 !== "failure") {
+              encoding = getEncoding(type2.parameters.get("charset"));
             }
           }
           if (encoding === "failure") {
@@ -16452,9 +16452,9 @@ var require_cookies = __commonJS({
       webidl.argumentLengthCheck(arguments, 2, "setCookie");
       webidl.brandCheck(headers, Headers, { strict: false });
       cookie = webidl.converters.Cookie(cookie);
-      const str2 = stringify(cookie);
-      if (str2) {
-        headers.append("Set-Cookie", str2);
+      const str = stringify(cookie);
+      if (str) {
+        headers.append("Set-Cookie", str);
       }
     }
     webidl.converters.DeleteCookieAttributes = webidl.dictionaryConverter([
@@ -16543,17 +16543,17 @@ var require_events = __commonJS({
     var { MessagePort } = require("node:worker_threads");
     var MessageEvent = class _MessageEvent extends Event {
       #eventInit;
-      constructor(type2, eventInitDict = {}) {
-        if (type2 === kConstruct) {
+      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);
-        type2 = webidl.converters.DOMString(type2, prefix, "type");
+        type = webidl.converters.DOMString(type, prefix, "type");
         eventInitDict = webidl.converters.MessageEventInit(eventInitDict, prefix, "eventInitDict");
-        super(type2, eventInitDict);
+        super(type, eventInitDict);
         this.#eventInit = eventInitDict;
         webidl.util.markAsUncloneable(this);
       }
@@ -16580,10 +16580,10 @@ var require_events = __commonJS({
         }
         return this.#eventInit.ports;
       }
-      initMessageEvent(type2, bubbles = false, cancelable = false, data = null, origin = "", lastEventId = "", source = null, 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(type2, {
+        return new _MessageEvent(type, {
           bubbles,
           cancelable,
           data,
@@ -16593,8 +16593,8 @@ var require_events = __commonJS({
           ports
         });
       }
-      static createFastMessageEvent(type2, init) {
-        const messageEvent = new _MessageEvent(kConstruct, type2, init);
+      static createFastMessageEvent(type, init) {
+        const messageEvent = new _MessageEvent(kConstruct, type, init);
         messageEvent.#eventInit = init;
         messageEvent.#eventInit.data ??= null;
         messageEvent.#eventInit.origin ??= "";
@@ -16608,12 +16608,12 @@ var require_events = __commonJS({
     delete MessageEvent.createFastMessageEvent;
     var CloseEvent = class _CloseEvent extends Event {
       #eventInit;
-      constructor(type2, eventInitDict = {}) {
+      constructor(type, eventInitDict = {}) {
         const prefix = "CloseEvent constructor";
         webidl.argumentLengthCheck(arguments, 1, prefix);
-        type2 = webidl.converters.DOMString(type2, prefix, "type");
+        type = webidl.converters.DOMString(type, prefix, "type");
         eventInitDict = webidl.converters.CloseEventInit(eventInitDict);
-        super(type2, eventInitDict);
+        super(type, eventInitDict);
         this.#eventInit = eventInitDict;
         webidl.util.markAsUncloneable(this);
       }
@@ -16632,12 +16632,12 @@ var require_events = __commonJS({
     };
     var ErrorEvent = class _ErrorEvent extends Event {
       #eventInit;
-      constructor(type2, eventInitDict) {
+      constructor(type, eventInitDict) {
         const prefix = "ErrorEvent constructor";
         webidl.argumentLengthCheck(arguments, 1, prefix);
-        super(type2, eventInitDict);
+        super(type, eventInitDict);
         webidl.util.markAsUncloneable(this);
-        type2 = webidl.converters.DOMString(type2, prefix, "type");
+        type = webidl.converters.DOMString(type, prefix, "type");
         eventInitDict = webidl.converters.ErrorEventInit(eventInitDict ?? {});
         this.#eventInit = eventInitDict;
       }
@@ -16894,23 +16894,23 @@ var require_util7 = __commonJS({
     function isClosed(ws) {
       return ws[kReadyState] === states.CLOSED;
     }
-    function fireEvent(e, target, eventFactory = (type2, init) => new Event(type2, init), eventInitDict = {}) {
+    function fireEvent(e, target, eventFactory = (type, init) => new Event(type, init), eventInitDict = {}) {
       const event = eventFactory(e, eventInitDict);
       target.dispatchEvent(event);
     }
-    function websocketMessageReceived(ws, type2, data) {
+    function websocketMessageReceived(ws, type, data) {
       if (ws[kReadyState] !== states.OPEN) {
         return;
       }
       let dataForEvent;
-      if (type2 === opcodes.TEXT) {
+      if (type === opcodes.TEXT) {
         try {
           dataForEvent = utf8Decode(data);
         } catch {
           failWebsocketConnection(ws, "Received invalid UTF-8 in text frame.");
           return;
         }
-      } else if (type2 === opcodes.BINARY) {
+      } else if (type === opcodes.BINARY) {
         if (ws[kBinaryType] === "blob") {
           dataForEvent = new Blob([data]);
         } else {
@@ -16972,7 +16972,7 @@ var require_util7 = __commonJS({
         response.socket.destroy();
       }
       if (reason) {
-        fireEvent("error", ws, (type2, init) => new ErrorEvent(type2, init), {
+        fireEvent("error", ws, (type, init) => new ErrorEvent(type, init), {
           error: new Error(reason),
           message: reason
         });
@@ -17280,7 +17280,7 @@ var require_connection = __commonJS({
         code = 1006;
       }
       ws[kReadyState] = states.CLOSED;
-      fireEvent("close", ws, (type2, init) => new CloseEvent(type2, init), {
+      fireEvent("close", ws, (type, init) => new CloseEvent(type, init), {
         wasClean,
         code,
         reason
@@ -17820,7 +17820,7 @@ var require_websocket = __commonJS({
     var { ByteParser } = require_receiver();
     var { kEnumerableProperty, isBlobLike } = require_util();
     var { getGlobalDispatcher } = require_global2();
-    var { types } = require("node:util");
+    var { types: types2 } = require("node:util");
     var { ErrorEvent, CloseEvent } = require_events();
     var { SendQueue } = require_sender();
     var WebSocket = class _WebSocket extends EventTarget {
@@ -17943,7 +17943,7 @@ var require_websocket = __commonJS({
           this.#sendQueue.add(data, () => {
             this.#bufferedAmount -= length;
           }, sendHints.string);
-        } else if (types.isArrayBuffer(data)) {
+        } else if (types2.isArrayBuffer(data)) {
           this.#bufferedAmount += data.byteLength;
           this.#sendQueue.add(data, () => {
             this.#bufferedAmount -= data.byteLength;
@@ -18048,12 +18048,12 @@ var require_websocket = __commonJS({
         webidl.brandCheck(this, _WebSocket);
         return this[kBinaryType];
       }
-      set binaryType(type2) {
+      set binaryType(type) {
         webidl.brandCheck(this, _WebSocket);
-        if (type2 !== "blob" && type2 !== "arraybuffer") {
+        if (type !== "blob" && type !== "arraybuffer") {
           this[kBinaryType] = "blob";
         } else {
-          this[kBinaryType] = type2;
+          this[kBinaryType] = type;
         }
       }
       /**
@@ -18149,7 +18149,7 @@ var require_websocket = __commonJS({
         if (isBlobLike(V)) {
           return webidl.converters.Blob(V, { strict: false });
         }
-        if (ArrayBuffer.isView(V) || types.isArrayBuffer(V)) {
+        if (ArrayBuffer.isView(V) || types2.isArrayBuffer(V)) {
           return webidl.converters.BufferSource(V);
         }
       }
@@ -19366,7 +19366,7 @@ var require_lib = __commonJS({
        * For headers that must always be a single string (like Content-Type), use the
        * specialized _getExistingOrDefaultContentTypeHeader method instead.
        */
-      _getExistingOrDefaultHeader(additionalHeaders, header, _default2) {
+      _getExistingOrDefaultHeader(additionalHeaders, header, _default) {
         let clientHeader;
         if (this.requestOptions && this.requestOptions.headers) {
           const headerValue = lowercaseKeys2(this.requestOptions.headers)[header];
@@ -19381,7 +19381,7 @@ var require_lib = __commonJS({
         if (clientHeader !== void 0) {
           return clientHeader;
         }
-        return _default2;
+        return _default;
       }
       /**
        * Specialized version of _getExistingOrDefaultHeader for Content-Type header.
@@ -19390,7 +19390,7 @@ var require_lib = __commonJS({
        * This was split from _getExistingOrDefaultHeader to provide stricter typing for callers
        * that assign the result to places expecting a string (e.g., additionalHeaders[Headers.ContentType]).
        */
-      _getExistingOrDefaultContentTypeHeader(additionalHeaders, _default2) {
+      _getExistingOrDefaultContentTypeHeader(additionalHeaders, _default) {
         let clientHeader;
         if (this.requestOptions && this.requestOptions.headers) {
           const headerValue = lowercaseKeys2(this.requestOptions.headers)[Headers.ContentType];
@@ -19417,7 +19417,7 @@ var require_lib = __commonJS({
         if (clientHeader !== void 0) {
           return clientHeader;
         }
-        return _default2;
+        return _default;
       }
       _getAgent(parsedUrl) {
         let agent;
@@ -20736,8 +20736,8 @@ var require_toolrunner = __commonJS({
         }
         return this.args;
       }
-      _endsWith(str2, end) {
-        return str2.endsWith(end);
+      _endsWith(str, end) {
+        return str.endsWith(end);
       }
       _isCmdFile() {
         const upperToolPath = this.toolPath.toUpperCase();
@@ -21972,16 +21972,16 @@ function omit(object, keysToOmit) {
   }
   return result;
 }
-function encodeReserved(str2) {
-  return str2.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) {
+function encodeReserved(str) {
+  return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) {
     if (!/%[0-9A-Fa-f]/.test(part)) {
       part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
     }
     return part;
   }).join("");
 }
-function encodeUnreserved(str2) {
-  return encodeURIComponent(str2).replace(/[!'()*]/g, function(c) {
+function encodeUnreserved(str) {
+  return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
     return "%" + c.charCodeAt(0).toString(16).toUpperCase();
   });
 }
@@ -22233,12 +22233,12 @@ var require_fast_content_type_parse = __commonJS({
         throw new TypeError("argument header is required and must be a string");
       }
       let index = header.indexOf(";");
-      const type2 = index !== -1 ? header.slice(0, index).trim() : header.trim();
-      if (mediaTypeRE.test(type2) === false) {
+      const type = index !== -1 ? header.slice(0, index).trim() : header.trim();
+      if (mediaTypeRE.test(type) === false) {
         throw new TypeError("invalid media type");
       }
       const result = {
-        type: type2.toLowerCase(),
+        type: type.toLowerCase(),
         parameters: new NullObject()
       };
       if (index === -1) {
@@ -22271,12 +22271,12 @@ var require_fast_content_type_parse = __commonJS({
         return defaultContentType;
       }
       let index = header.indexOf(";");
-      const type2 = index !== -1 ? header.slice(0, index).trim() : header.trim();
-      if (mediaTypeRE.test(type2) === false) {
+      const type = index !== -1 ? header.slice(0, index).trim() : header.trim();
+      if (mediaTypeRE.test(type) === false) {
         return defaultContentType;
       }
       const result = {
-        type: type2.toLowerCase(),
+        type: type.toLowerCase(),
         parameters: new NullObject()
       };
       if (index === -1) {
@@ -26738,8 +26738,8 @@ var require_truncate = __commonJS({
       }
       return version.format();
     };
-    var isPrerelease = (type2) => {
-      return type2.startsWith("pre");
+    var isPrerelease = (type) => {
+      return type.startsWith("pre");
     };
     module2.exports = truncate;
   }
@@ -27137,20 +27137,20 @@ var require_range = __commonJS({
       }
       return `${from} ${to}`.trim();
     };
-    var testSet = (set2, version, options) => {
-      for (let i = 0; i < set2.length; i++) {
-        if (!set2[i].test(version)) {
+    var testSet = (set, version, options) => {
+      for (let i = 0; i < set.length; i++) {
+        if (!set[i].test(version)) {
           return false;
         }
       }
       if (version.prerelease.length && !options.includePrerelease) {
-        for (let i = 0; i < set2.length; i++) {
-          debug6(set2[i].semver);
-          if (set2[i].semver === Comparator.ANY) {
+        for (let i = 0; i < set.length; i++) {
+          debug6(set[i].semver);
+          if (set[i].semver === Comparator.ANY) {
             continue;
           }
-          if (set2[i].semver.prerelease.length > 0) {
-            const allowed = set2[i].semver;
+          if (set[i].semver.prerelease.length > 0) {
+            const allowed = set[i].semver;
             if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
               return true;
             }
@@ -27546,7 +27546,7 @@ var require_simplify = __commonJS({
     var satisfies2 = require_satisfies();
     var compare3 = require_compare();
     module2.exports = (versions, range, options) => {
-      const set2 = [];
+      const set = [];
       let first = null;
       let prev = null;
       const v = versions.sort((a, b) => compare3(a, b, options));
@@ -27559,17 +27559,17 @@ var require_simplify = __commonJS({
           }
         } else {
           if (prev) {
-            set2.push([first, prev]);
+            set.push([first, prev]);
           }
           prev = null;
           first = null;
         }
       }
       if (first) {
-        set2.push([first, null]);
+        set.push([first, null]);
       }
       const ranges = [];
-      for (const [min, max] of set2) {
+      for (const [min, max] of set) {
         if (min === max) {
           ranges.push(min);
         } else if (!max && min === v[0]) {
@@ -29171,7 +29171,7 @@ var require_light = __commonJS({
 var require_helpers = __commonJS({
   "node_modules/jsonschema/lib/helpers.js"(exports2, module2) {
     "use strict";
-    var ValidationError = exports2.ValidationError = function ValidationError2(message, instance, schema2, path28, name, argument) {
+    var ValidationError = exports2.ValidationError = function ValidationError2(message, instance, schema, path28, name, argument) {
       if (Array.isArray(path28)) {
         this.path = path28;
         this.property = path28.reduce(function(sum, item) {
@@ -29183,9 +29183,9 @@ var require_helpers = __commonJS({
       if (message) {
         this.message = message;
       }
-      if (schema2) {
-        var id = schema2.$id || schema2.id;
-        this.schema = id || schema2;
+      if (schema) {
+        var id = schema.$id || schema.id;
+        this.schema = id || schema;
       }
       if (instance !== void 0) {
         this.instance = instance;
@@ -29194,12 +29194,12 @@ var require_helpers = __commonJS({
       this.argument = argument;
       this.stack = this.toString();
     };
-    ValidationError.prototype.toString = function toString3() {
+    ValidationError.prototype.toString = function toString2() {
       return this.property + " " + this.message;
     };
-    var ValidatorResult = exports2.ValidatorResult = function ValidatorResult2(instance, schema2, options, ctx) {
+    var ValidatorResult = exports2.ValidatorResult = function ValidatorResult2(instance, schema, options, ctx) {
       this.instance = instance;
-      this.schema = schema2;
+      this.schema = schema;
       this.options = options;
       this.path = ctx.path;
       this.propertyPath = ctx.propertyPath;
@@ -29237,7 +29237,7 @@ var require_helpers = __commonJS({
     function stringizer(v, i) {
       return i + ": " + v.toString() + "\n";
     }
-    ValidatorResult.prototype.toString = function toString3(res) {
+    ValidatorResult.prototype.toString = function toString2(res) {
       return this.errors.map(stringizer).join("");
     };
     Object.defineProperty(ValidatorResult.prototype, "valid", { get: function() {
@@ -29256,9 +29256,9 @@ var require_helpers = __commonJS({
     ValidatorResultError.prototype = new Error();
     ValidatorResultError.prototype.constructor = ValidatorResultError;
     ValidatorResultError.prototype.name = "Validation Error";
-    var SchemaError = exports2.SchemaError = function SchemaError2(msg, schema2) {
+    var SchemaError = exports2.SchemaError = function SchemaError2(msg, schema) {
       this.message = msg;
-      this.schema = schema2;
+      this.schema = schema;
       Error.call(this, msg);
       if (typeof Error.captureStackTrace === "function") {
         Error.captureStackTrace(this, SchemaError2);
@@ -29271,8 +29271,8 @@ var require_helpers = __commonJS({
         name: { value: "SchemaError", enumerable: false }
       }
     );
-    var SchemaContext = exports2.SchemaContext = function SchemaContext2(schema2, options, path28, base, schemas) {
-      this.schema = schema2;
+    var SchemaContext = exports2.SchemaContext = function SchemaContext2(schema, options, path28, base, schemas) {
+      this.schema = schema;
       this.options = options;
       if (Array.isArray(path28)) {
         this.path = path28;
@@ -29288,13 +29288,13 @@ var require_helpers = __commonJS({
     SchemaContext.prototype.resolve = function resolve13(target) {
       return (() => resolveUrl(this.base, target))();
     };
-    SchemaContext.prototype.makeChild = function makeChild(schema2, propertyName) {
+    SchemaContext.prototype.makeChild = function makeChild(schema, propertyName) {
       var path28 = propertyName === void 0 ? this.path : this.path.concat([propertyName]);
-      var id = schema2.$id || schema2.id;
+      var id = schema.$id || schema.id;
       let base = (() => resolveUrl(this.base, id || ""))();
-      var ctx = new SchemaContext(schema2, this.options, path28, base, Object.create(this.schemas));
+      var ctx = new SchemaContext(schema, this.options, path28, base, Object.create(this.schemas));
       if (id && !ctx.schemas[base]) {
-        ctx.schemas[base] = schema2;
+        ctx.schemas[base] = schema;
       }
       return ctx;
     };
@@ -29520,14 +29520,14 @@ var require_attribute = __commonJS({
       "extends": true
     };
     var validators = attribute.validators = {};
-    validators.type = function validateType(instance, schema2, options, ctx) {
+    validators.type = function validateType(instance, schema, options, ctx) {
       if (instance === void 0) {
         return null;
       }
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      var types = Array.isArray(schema2.type) ? schema2.type : [schema2.type];
-      if (!types.some(this.testType.bind(this, instance, schema2, options, ctx))) {
-        var list = types.map(function(v) {
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      var types2 = Array.isArray(schema.type) ? schema.type : [schema.type];
+      if (!types2.some(this.testType.bind(this, instance, schema, options, ctx))) {
+        var list = types2.map(function(v) {
           if (!v) return;
           var id = v.$id || v.id;
           return id ? "<" + id + ">" : v + "";
@@ -29540,29 +29540,29 @@ var require_attribute = __commonJS({
       }
       return result;
     };
-    function testSchemaNoThrow(instance, options, ctx, callback, schema2) {
-      var throwError2 = options.throwError;
+    function testSchemaNoThrow(instance, options, ctx, callback, schema) {
+      var throwError = options.throwError;
       var throwAll = options.throwAll;
       options.throwError = false;
       options.throwAll = false;
-      var res = this.validateSchema(instance, schema2, options, ctx);
-      options.throwError = throwError2;
+      var res = this.validateSchema(instance, schema, options, ctx);
+      options.throwError = throwError;
       options.throwAll = throwAll;
       if (!res.valid && callback instanceof Function) {
         callback(res);
       }
       return res.valid;
     }
-    validators.anyOf = function validateAnyOf(instance, schema2, options, ctx) {
+    validators.anyOf = function validateAnyOf(instance, schema, options, ctx) {
       if (instance === void 0) {
         return null;
       }
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      var inner = new ValidatorResult(instance, schema2, options, ctx);
-      if (!Array.isArray(schema2.anyOf)) {
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      var inner = new ValidatorResult(instance, schema, options, ctx);
+      if (!Array.isArray(schema.anyOf)) {
         throw new SchemaError("anyOf must be an array");
       }
-      if (!schema2.anyOf.some(
+      if (!schema.anyOf.some(
         testSchemaNoThrow.bind(
           this,
           instance,
@@ -29573,7 +29573,7 @@ var require_attribute = __commonJS({
           }
         )
       )) {
-        var list = schema2.anyOf.map(function(v, i) {
+        var list = schema.anyOf.map(function(v, i) {
           var id = v.$id || v.id;
           if (id) return "<" + id + ">";
           return v.title && JSON.stringify(v.title) || v["$ref"] && "<" + v["$ref"] + ">" || "[subschema " + i + "]";
@@ -29589,16 +29589,16 @@ var require_attribute = __commonJS({
       }
       return result;
     };
-    validators.allOf = function validateAllOf(instance, schema2, options, ctx) {
+    validators.allOf = function validateAllOf(instance, schema, options, ctx) {
       if (instance === void 0) {
         return null;
       }
-      if (!Array.isArray(schema2.allOf)) {
+      if (!Array.isArray(schema.allOf)) {
         throw new SchemaError("allOf must be an array");
       }
-      var result = new ValidatorResult(instance, schema2, options, ctx);
+      var result = new ValidatorResult(instance, schema, options, ctx);
       var self2 = this;
-      schema2.allOf.forEach(function(v, i) {
+      schema.allOf.forEach(function(v, i) {
         var valid4 = self2.validateSchema(instance, v, options, ctx);
         if (!valid4.valid) {
           var id = v.$id || v.id;
@@ -29613,16 +29613,16 @@ var require_attribute = __commonJS({
       });
       return result;
     };
-    validators.oneOf = function validateOneOf(instance, schema2, options, ctx) {
+    validators.oneOf = function validateOneOf(instance, schema, options, ctx) {
       if (instance === void 0) {
         return null;
       }
-      if (!Array.isArray(schema2.oneOf)) {
+      if (!Array.isArray(schema.oneOf)) {
         throw new SchemaError("oneOf must be an array");
       }
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      var inner = new ValidatorResult(instance, schema2, options, ctx);
-      var count = schema2.oneOf.filter(
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      var inner = new ValidatorResult(instance, schema, options, ctx);
+      var count = schema.oneOf.filter(
         testSchemaNoThrow.bind(
           this,
           instance,
@@ -29633,7 +29633,7 @@ var require_attribute = __commonJS({
           }
         )
       ).length;
-      var list = schema2.oneOf.map(function(v, i) {
+      var list = schema.oneOf.map(function(v, i) {
         var id = v.$id || v.id;
         return id || v.title && JSON.stringify(v.title) || v["$ref"] && "<" + v["$ref"] + ">" || "[subschema " + i + "]";
       });
@@ -29649,21 +29649,21 @@ var require_attribute = __commonJS({
       }
       return result;
     };
-    validators.if = function validateIf(instance, schema2, options, ctx) {
+    validators.if = function validateIf(instance, schema, options, ctx) {
       if (instance === void 0) return null;
-      if (!helpers.isSchema(schema2.if)) throw new Error('Expected "if" keyword to be a schema');
-      var ifValid = testSchemaNoThrow.call(this, instance, options, ctx, null, schema2.if);
-      var result = new ValidatorResult(instance, schema2, options, ctx);
+      if (!helpers.isSchema(schema.if)) throw new Error('Expected "if" keyword to be a schema');
+      var ifValid = testSchemaNoThrow.call(this, instance, options, ctx, null, schema.if);
+      var result = new ValidatorResult(instance, schema, options, ctx);
       var res;
       if (ifValid) {
-        if (schema2.then === void 0) return;
-        if (!helpers.isSchema(schema2.then)) throw new Error('Expected "then" keyword to be a schema');
-        res = this.validateSchema(instance, schema2.then, options, ctx.makeChild(schema2.then));
+        if (schema.then === void 0) return;
+        if (!helpers.isSchema(schema.then)) throw new Error('Expected "then" keyword to be a schema');
+        res = this.validateSchema(instance, schema.then, options, ctx.makeChild(schema.then));
         result.importErrors(res);
       } else {
-        if (schema2.else === void 0) return;
-        if (!helpers.isSchema(schema2.else)) throw new Error('Expected "else" keyword to be a schema');
-        res = this.validateSchema(instance, schema2.else, options, ctx.makeChild(schema2.else));
+        if (schema.else === void 0) return;
+        if (!helpers.isSchema(schema.else)) throw new Error('Expected "else" keyword to be a schema');
+        res = this.validateSchema(instance, schema.else, options, ctx.makeChild(schema.else));
         result.importErrors(res);
       }
       return result;
@@ -29675,10 +29675,10 @@ var require_attribute = __commonJS({
         if (Object.propertyIsEnumerable.call(object, key)) return object[key];
       }
     }
-    validators.propertyNames = function validatePropertyNames(instance, schema2, options, ctx) {
+    validators.propertyNames = function validatePropertyNames(instance, schema, options, ctx) {
       if (!this.types.object(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      var subschema = schema2.propertyNames !== void 0 ? schema2.propertyNames : {};
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      var subschema = schema.propertyNames !== void 0 ? schema.propertyNames : {};
       if (!helpers.isSchema(subschema)) throw new SchemaError('Expected "propertyNames" to be a schema (object or boolean)');
       for (var property in instance) {
         if (getEnumerableProperty(instance, property) !== void 0) {
@@ -29688,10 +29688,10 @@ var require_attribute = __commonJS({
       }
       return result;
     };
-    validators.properties = function validateProperties(instance, schema2, options, ctx) {
+    validators.properties = function validateProperties(instance, schema, options, ctx) {
       if (!this.types.object(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      var properties = schema2.properties || {};
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      var properties = schema.properties || {};
       for (var property in properties) {
         var subschema = properties[property];
         if (subschema === void 0) {
@@ -29709,19 +29709,19 @@ var require_attribute = __commonJS({
       }
       return result;
     };
-    function testAdditionalProperty(instance, schema2, options, ctx, property, result) {
+    function testAdditionalProperty(instance, schema, options, ctx, property, result) {
       if (!this.types.object(instance)) return;
-      if (schema2.properties && schema2.properties[property] !== void 0) {
+      if (schema.properties && schema.properties[property] !== void 0) {
         return;
       }
-      if (schema2.additionalProperties === false) {
+      if (schema.additionalProperties === false) {
         result.addError({
           name: "additionalProperties",
           argument: property,
           message: "is not allowed to have the additional property " + JSON.stringify(property)
         });
       } else {
-        var additionalProperties = schema2.additionalProperties || {};
+        var additionalProperties = schema.additionalProperties || {};
         if (typeof options.preValidateProperty == "function") {
           options.preValidateProperty(instance, property, additionalProperties, options, ctx);
         }
@@ -29730,10 +29730,10 @@ var require_attribute = __commonJS({
         result.importErrors(res);
       }
     }
-    validators.patternProperties = function validatePatternProperties(instance, schema2, options, ctx) {
+    validators.patternProperties = function validatePatternProperties(instance, schema, options, ctx) {
       if (!this.types.object(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      var patternProperties = schema2.patternProperties || {};
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      var patternProperties = schema.patternProperties || {};
       for (var property in instance) {
         var test = true;
         for (var pattern in patternProperties) {
@@ -29760,58 +29760,58 @@ var require_attribute = __commonJS({
           result.importErrors(res);
         }
         if (test) {
-          testAdditionalProperty.call(this, instance, schema2, options, ctx, property, result);
+          testAdditionalProperty.call(this, instance, schema, options, ctx, property, result);
         }
       }
       return result;
     };
-    validators.additionalProperties = function validateAdditionalProperties(instance, schema2, options, ctx) {
+    validators.additionalProperties = function validateAdditionalProperties(instance, schema, options, ctx) {
       if (!this.types.object(instance)) return;
-      if (schema2.patternProperties) {
+      if (schema.patternProperties) {
         return null;
       }
-      var result = new ValidatorResult(instance, schema2, options, ctx);
+      var result = new ValidatorResult(instance, schema, options, ctx);
       for (var property in instance) {
-        testAdditionalProperty.call(this, instance, schema2, options, ctx, property, result);
+        testAdditionalProperty.call(this, instance, schema, options, ctx, property, result);
       }
       return result;
     };
-    validators.minProperties = function validateMinProperties(instance, schema2, options, ctx) {
+    validators.minProperties = function validateMinProperties(instance, schema, options, ctx) {
       if (!this.types.object(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
+      var result = new ValidatorResult(instance, schema, options, ctx);
       var keys = Object.keys(instance);
-      if (!(keys.length >= schema2.minProperties)) {
+      if (!(keys.length >= schema.minProperties)) {
         result.addError({
           name: "minProperties",
-          argument: schema2.minProperties,
-          message: "does not meet minimum property length of " + schema2.minProperties
+          argument: schema.minProperties,
+          message: "does not meet minimum property length of " + schema.minProperties
         });
       }
       return result;
     };
-    validators.maxProperties = function validateMaxProperties(instance, schema2, options, ctx) {
+    validators.maxProperties = function validateMaxProperties(instance, schema, options, ctx) {
       if (!this.types.object(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
+      var result = new ValidatorResult(instance, schema, options, ctx);
       var keys = Object.keys(instance);
-      if (!(keys.length <= schema2.maxProperties)) {
+      if (!(keys.length <= schema.maxProperties)) {
         result.addError({
           name: "maxProperties",
-          argument: schema2.maxProperties,
-          message: "does not meet maximum property length of " + schema2.maxProperties
+          argument: schema.maxProperties,
+          message: "does not meet maximum property length of " + schema.maxProperties
         });
       }
       return result;
     };
-    validators.items = function validateItems(instance, schema2, options, ctx) {
+    validators.items = function validateItems(instance, schema, options, ctx) {
       var self2 = this;
       if (!this.types.array(instance)) return;
-      if (schema2.items === void 0) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
+      if (schema.items === void 0) return;
+      var result = new ValidatorResult(instance, schema, options, ctx);
       instance.every(function(value, i) {
-        if (Array.isArray(schema2.items)) {
-          var items = schema2.items[i] === void 0 ? schema2.additionalItems : schema2.items[i];
+        if (Array.isArray(schema.items)) {
+          var items = schema.items[i] === void 0 ? schema.additionalItems : schema.items[i];
         } else {
-          var items = schema2.items;
+          var items = schema.items;
         }
         if (items === void 0) {
           return true;
@@ -29830,104 +29830,104 @@ var require_attribute = __commonJS({
       });
       return result;
     };
-    validators.contains = function validateContains(instance, schema2, options, ctx) {
+    validators.contains = function validateContains(instance, schema, options, ctx) {
       var self2 = this;
       if (!this.types.array(instance)) return;
-      if (schema2.contains === void 0) return;
-      if (!helpers.isSchema(schema2.contains)) throw new Error('Expected "contains" keyword to be a schema');
-      var result = new ValidatorResult(instance, schema2, options, ctx);
+      if (schema.contains === void 0) return;
+      if (!helpers.isSchema(schema.contains)) throw new Error('Expected "contains" keyword to be a schema');
+      var result = new ValidatorResult(instance, schema, options, ctx);
       var count = instance.some(function(value, i) {
-        var res = self2.validateSchema(value, schema2.contains, options, ctx.makeChild(schema2.contains, i));
+        var res = self2.validateSchema(value, schema.contains, options, ctx.makeChild(schema.contains, i));
         return res.errors.length === 0;
       });
       if (count === false) {
         result.addError({
           name: "contains",
-          argument: schema2.contains,
+          argument: schema.contains,
           message: "must contain an item matching given schema"
         });
       }
       return result;
     };
-    validators.minimum = function validateMinimum(instance, schema2, options, ctx) {
+    validators.minimum = function validateMinimum(instance, schema, options, ctx) {
       if (!this.types.number(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      if (schema2.exclusiveMinimum && schema2.exclusiveMinimum === true) {
-        if (!(instance > schema2.minimum)) {
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      if (schema.exclusiveMinimum && schema.exclusiveMinimum === true) {
+        if (!(instance > schema.minimum)) {
           result.addError({
             name: "minimum",
-            argument: schema2.minimum,
-            message: "must be greater than " + schema2.minimum
+            argument: schema.minimum,
+            message: "must be greater than " + schema.minimum
           });
         }
       } else {
-        if (!(instance >= schema2.minimum)) {
+        if (!(instance >= schema.minimum)) {
           result.addError({
             name: "minimum",
-            argument: schema2.minimum,
-            message: "must be greater than or equal to " + schema2.minimum
+            argument: schema.minimum,
+            message: "must be greater than or equal to " + schema.minimum
           });
         }
       }
       return result;
     };
-    validators.maximum = function validateMaximum(instance, schema2, options, ctx) {
+    validators.maximum = function validateMaximum(instance, schema, options, ctx) {
       if (!this.types.number(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      if (schema2.exclusiveMaximum && schema2.exclusiveMaximum === true) {
-        if (!(instance < schema2.maximum)) {
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      if (schema.exclusiveMaximum && schema.exclusiveMaximum === true) {
+        if (!(instance < schema.maximum)) {
           result.addError({
             name: "maximum",
-            argument: schema2.maximum,
-            message: "must be less than " + schema2.maximum
+            argument: schema.maximum,
+            message: "must be less than " + schema.maximum
           });
         }
       } else {
-        if (!(instance <= schema2.maximum)) {
+        if (!(instance <= schema.maximum)) {
           result.addError({
             name: "maximum",
-            argument: schema2.maximum,
-            message: "must be less than or equal to " + schema2.maximum
+            argument: schema.maximum,
+            message: "must be less than or equal to " + schema.maximum
           });
         }
       }
       return result;
     };
-    validators.exclusiveMinimum = function validateExclusiveMinimum(instance, schema2, options, ctx) {
-      if (typeof schema2.exclusiveMinimum === "boolean") return;
+    validators.exclusiveMinimum = function validateExclusiveMinimum(instance, schema, options, ctx) {
+      if (typeof schema.exclusiveMinimum === "boolean") return;
       if (!this.types.number(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      var valid4 = instance > schema2.exclusiveMinimum;
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      var valid4 = instance > schema.exclusiveMinimum;
       if (!valid4) {
         result.addError({
           name: "exclusiveMinimum",
-          argument: schema2.exclusiveMinimum,
-          message: "must be strictly greater than " + schema2.exclusiveMinimum
+          argument: schema.exclusiveMinimum,
+          message: "must be strictly greater than " + schema.exclusiveMinimum
         });
       }
       return result;
     };
-    validators.exclusiveMaximum = function validateExclusiveMaximum(instance, schema2, options, ctx) {
-      if (typeof schema2.exclusiveMaximum === "boolean") return;
+    validators.exclusiveMaximum = function validateExclusiveMaximum(instance, schema, options, ctx) {
+      if (typeof schema.exclusiveMaximum === "boolean") return;
       if (!this.types.number(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      var valid4 = instance < schema2.exclusiveMaximum;
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      var valid4 = instance < schema.exclusiveMaximum;
       if (!valid4) {
         result.addError({
           name: "exclusiveMaximum",
-          argument: schema2.exclusiveMaximum,
-          message: "must be strictly less than " + schema2.exclusiveMaximum
+          argument: schema.exclusiveMaximum,
+          message: "must be strictly less than " + schema.exclusiveMaximum
         });
       }
       return result;
     };
-    var validateMultipleOfOrDivisbleBy = function validateMultipleOfOrDivisbleBy2(instance, schema2, options, ctx, validationType, errorMessage) {
+    var validateMultipleOfOrDivisbleBy = function validateMultipleOfOrDivisbleBy2(instance, schema, options, ctx, validationType, errorMessage) {
       if (!this.types.number(instance)) return;
-      var validationArgument = schema2[validationType];
+      var validationArgument = schema[validationType];
       if (validationArgument == 0) {
         throw new SchemaError(validationType + " cannot be zero");
       }
-      var result = new ValidatorResult(instance, schema2, options, ctx);
+      var result = new ValidatorResult(instance, schema, options, ctx);
       var instanceDecimals = helpers.getDecimalPlaces(instance);
       var divisorDecimals = helpers.getDecimalPlaces(validationArgument);
       var maxDecimals = Math.max(instanceDecimals, divisorDecimals);
@@ -29941,21 +29941,21 @@ var require_attribute = __commonJS({
       }
       return result;
     };
-    validators.multipleOf = function validateMultipleOf(instance, schema2, options, ctx) {
-      return validateMultipleOfOrDivisbleBy.call(this, instance, schema2, options, ctx, "multipleOf", "is not a multiple of (divisible by) ");
+    validators.multipleOf = function validateMultipleOf(instance, schema, options, ctx) {
+      return validateMultipleOfOrDivisbleBy.call(this, instance, schema, options, ctx, "multipleOf", "is not a multiple of (divisible by) ");
     };
-    validators.divisibleBy = function validateDivisibleBy(instance, schema2, options, ctx) {
-      return validateMultipleOfOrDivisbleBy.call(this, instance, schema2, options, ctx, "divisibleBy", "is not divisible by (multiple of) ");
+    validators.divisibleBy = function validateDivisibleBy(instance, schema, options, ctx) {
+      return validateMultipleOfOrDivisbleBy.call(this, instance, schema, options, ctx, "divisibleBy", "is not divisible by (multiple of) ");
     };
-    validators.required = function validateRequired(instance, schema2, options, ctx) {
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      if (instance === void 0 && schema2.required === true) {
+    validators.required = function validateRequired(instance, schema, options, ctx) {
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      if (instance === void 0 && schema.required === true) {
         result.addError({
           name: "required",
           message: "is required"
         });
-      } else if (this.types.object(instance) && Array.isArray(schema2.required)) {
-        schema2.required.forEach(function(n) {
+      } else if (this.types.object(instance) && Array.isArray(schema.required)) {
+        schema.required.forEach(function(n) {
           if (getEnumerableProperty(instance, n) === void 0) {
             result.addError({
               name: "required",
@@ -29967,10 +29967,10 @@ var require_attribute = __commonJS({
       }
       return result;
     };
-    validators.pattern = function validatePattern(instance, schema2, options, ctx) {
+    validators.pattern = function validatePattern(instance, schema, options, ctx) {
       if (!this.types.string(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      var pattern = schema2.pattern;
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      var pattern = schema.pattern;
       try {
         var regexp = new RegExp(pattern, "u");
       } catch (_e) {
@@ -29979,72 +29979,72 @@ var require_attribute = __commonJS({
       if (!instance.match(regexp)) {
         result.addError({
           name: "pattern",
-          argument: schema2.pattern,
-          message: "does not match pattern " + JSON.stringify(schema2.pattern.toString())
+          argument: schema.pattern,
+          message: "does not match pattern " + JSON.stringify(schema.pattern.toString())
         });
       }
       return result;
     };
-    validators.format = function validateFormat(instance, schema2, options, ctx) {
+    validators.format = function validateFormat(instance, schema, options, ctx) {
       if (instance === void 0) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      if (!result.disableFormat && !helpers.isFormat(instance, schema2.format, this)) {
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      if (!result.disableFormat && !helpers.isFormat(instance, schema.format, this)) {
         result.addError({
           name: "format",
-          argument: schema2.format,
-          message: "does not conform to the " + JSON.stringify(schema2.format) + " format"
+          argument: schema.format,
+          message: "does not conform to the " + JSON.stringify(schema.format) + " format"
         });
       }
       return result;
     };
-    validators.minLength = function validateMinLength(instance, schema2, options, ctx) {
+    validators.minLength = function validateMinLength(instance, schema, options, ctx) {
       if (!this.types.string(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
+      var result = new ValidatorResult(instance, schema, options, ctx);
       var hsp = instance.match(/[\uDC00-\uDFFF]/g);
       var length = instance.length - (hsp ? hsp.length : 0);
-      if (!(length >= schema2.minLength)) {
+      if (!(length >= schema.minLength)) {
         result.addError({
           name: "minLength",
-          argument: schema2.minLength,
-          message: "does not meet minimum length of " + schema2.minLength
+          argument: schema.minLength,
+          message: "does not meet minimum length of " + schema.minLength
         });
       }
       return result;
     };
-    validators.maxLength = function validateMaxLength(instance, schema2, options, ctx) {
+    validators.maxLength = function validateMaxLength(instance, schema, options, ctx) {
       if (!this.types.string(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
+      var result = new ValidatorResult(instance, schema, options, ctx);
       var hsp = instance.match(/[\uDC00-\uDFFF]/g);
       var length = instance.length - (hsp ? hsp.length : 0);
-      if (!(length <= schema2.maxLength)) {
+      if (!(length <= schema.maxLength)) {
         result.addError({
           name: "maxLength",
-          argument: schema2.maxLength,
-          message: "does not meet maximum length of " + schema2.maxLength
+          argument: schema.maxLength,
+          message: "does not meet maximum length of " + schema.maxLength
         });
       }
       return result;
     };
-    validators.minItems = function validateMinItems(instance, schema2, options, ctx) {
+    validators.minItems = function validateMinItems(instance, schema, options, ctx) {
       if (!this.types.array(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      if (!(instance.length >= schema2.minItems)) {
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      if (!(instance.length >= schema.minItems)) {
         result.addError({
           name: "minItems",
-          argument: schema2.minItems,
-          message: "does not meet minimum length of " + schema2.minItems
+          argument: schema.minItems,
+          message: "does not meet minimum length of " + schema.minItems
         });
       }
       return result;
     };
-    validators.maxItems = function validateMaxItems(instance, schema2, options, ctx) {
+    validators.maxItems = function validateMaxItems(instance, schema, options, ctx) {
       if (!this.types.array(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      if (!(instance.length <= schema2.maxItems)) {
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      if (!(instance.length <= schema.maxItems)) {
         result.addError({
           name: "maxItems",
-          argument: schema2.maxItems,
-          message: "does not meet maximum length of " + schema2.maxItems
+          argument: schema.maxItems,
+          message: "does not meet maximum length of " + schema.maxItems
         });
       }
       return result;
@@ -30058,10 +30058,10 @@ var require_attribute = __commonJS({
       }
       return true;
     }
-    validators.uniqueItems = function validateUniqueItems(instance, schema2, options, ctx) {
-      if (schema2.uniqueItems !== true) return;
+    validators.uniqueItems = function validateUniqueItems(instance, schema, options, ctx) {
+      if (schema.uniqueItems !== true) return;
       if (!this.types.array(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
+      var result = new ValidatorResult(instance, schema, options, ctx);
       if (!instance.every(testArrays)) {
         result.addError({
           name: "uniqueItems",
@@ -30070,14 +30070,14 @@ var require_attribute = __commonJS({
       }
       return result;
     };
-    validators.dependencies = function validateDependencies(instance, schema2, options, ctx) {
+    validators.dependencies = function validateDependencies(instance, schema, options, ctx) {
       if (!this.types.object(instance)) return;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      for (var property in schema2.dependencies) {
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      for (var property in schema.dependencies) {
         if (instance[property] === void 0) {
           continue;
         }
-        var dep = schema2.dependencies[property];
+        var dep = schema.dependencies[property];
         var childContext = ctx.makeChild(dep, property);
         if (typeof dep == "string") {
           dep = [dep];
@@ -30109,48 +30109,48 @@ var require_attribute = __commonJS({
       }
       return result;
     };
-    validators["enum"] = function validateEnum(instance, schema2, options, ctx) {
+    validators["enum"] = function validateEnum(instance, schema, options, ctx) {
       if (instance === void 0) {
         return null;
       }
-      if (!Array.isArray(schema2["enum"])) {
-        throw new SchemaError("enum expects an array", schema2);
+      if (!Array.isArray(schema["enum"])) {
+        throw new SchemaError("enum expects an array", schema);
       }
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      if (!schema2["enum"].some(helpers.deepCompareStrict.bind(null, instance))) {
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      if (!schema["enum"].some(helpers.deepCompareStrict.bind(null, instance))) {
         result.addError({
           name: "enum",
-          argument: schema2["enum"],
-          message: "is not one of enum values: " + schema2["enum"].map(String).join(",")
+          argument: schema["enum"],
+          message: "is not one of enum values: " + schema["enum"].map(String).join(",")
         });
       }
       return result;
     };
-    validators["const"] = function validateEnum(instance, schema2, options, ctx) {
+    validators["const"] = function validateEnum(instance, schema, options, ctx) {
       if (instance === void 0) {
         return null;
       }
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      if (!helpers.deepCompareStrict(schema2["const"], instance)) {
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      if (!helpers.deepCompareStrict(schema["const"], instance)) {
         result.addError({
           name: "const",
-          argument: schema2["const"],
-          message: "does not exactly match expected constant: " + schema2["const"]
+          argument: schema["const"],
+          message: "does not exactly match expected constant: " + schema["const"]
         });
       }
       return result;
     };
-    validators.not = validators.disallow = function validateNot(instance, schema2, options, ctx) {
+    validators.not = validators.disallow = function validateNot(instance, schema, options, ctx) {
       var self2 = this;
       if (instance === void 0) return null;
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      var notTypes = schema2.not || schema2.disallow;
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      var notTypes = schema.not || schema.disallow;
       if (!notTypes) return null;
       if (!Array.isArray(notTypes)) notTypes = [notTypes];
-      notTypes.forEach(function(type2) {
-        if (self2.testType(instance, schema2, options, ctx, type2)) {
-          var id = type2 && (type2.$id || type2.id);
-          var schemaId = id || type2;
+      notTypes.forEach(function(type) {
+        if (self2.testType(instance, schema, options, ctx, type)) {
+          var id = type && (type.$id || type.id);
+          var schemaId = id || type;
           result.addError({
             name: "not",
             argument: schemaId,
@@ -30174,43 +30174,43 @@ var require_scan = __commonJS({
       this.id = found;
       this.ref = ref;
     }
-    module2.exports.scan = function scan(base, schema2) {
-      function scanSchema(baseuri, schema3) {
-        if (!schema3 || typeof schema3 != "object") return;
-        if (schema3.$ref) {
-          let resolvedUri = helpers.resolveUrl(baseuri, schema3.$ref);
+    module2.exports.scan = function scan(base, schema) {
+      function scanSchema(baseuri, schema2) {
+        if (!schema2 || typeof schema2 != "object") return;
+        if (schema2.$ref) {
+          let resolvedUri = helpers.resolveUrl(baseuri, schema2.$ref);
           ref[resolvedUri] = ref[resolvedUri] ? ref[resolvedUri] + 1 : 0;
           return;
         }
-        var id = schema3.$id || schema3.id;
+        var id = schema2.$id || schema2.id;
         let resolvedBase = helpers.resolveUrl(baseuri, id);
         var ourBase = id ? resolvedBase : baseuri;
         if (ourBase) {
           if (ourBase.indexOf("#") < 0) ourBase += "#";
           if (found[ourBase]) {
-            if (!helpers.deepCompareStrict(found[ourBase], schema3)) {
+            if (!helpers.deepCompareStrict(found[ourBase], schema2)) {
               throw new Error("Schema <" + ourBase + "> already exists with different definition");
             }
             return found[ourBase];
           }
-          found[ourBase] = schema3;
+          found[ourBase] = schema2;
           if (ourBase[ourBase.length - 1] == "#") {
-            found[ourBase.substring(0, ourBase.length - 1)] = schema3;
-          }
-        }
-        scanArray(ourBase + "/items", Array.isArray(schema3.items) ? schema3.items : [schema3.items]);
-        scanArray(ourBase + "/extends", Array.isArray(schema3.extends) ? schema3.extends : [schema3.extends]);
-        scanSchema(ourBase + "/additionalItems", schema3.additionalItems);
-        scanObject(ourBase + "/properties", schema3.properties);
-        scanSchema(ourBase + "/additionalProperties", schema3.additionalProperties);
-        scanObject(ourBase + "/definitions", schema3.definitions);
-        scanObject(ourBase + "/patternProperties", schema3.patternProperties);
-        scanObject(ourBase + "/dependencies", schema3.dependencies);
-        scanArray(ourBase + "/disallow", schema3.disallow);
-        scanArray(ourBase + "/allOf", schema3.allOf);
-        scanArray(ourBase + "/anyOf", schema3.anyOf);
-        scanArray(ourBase + "/oneOf", schema3.oneOf);
-        scanSchema(ourBase + "/not", schema3.not);
+            found[ourBase.substring(0, ourBase.length - 1)] = schema2;
+          }
+        }
+        scanArray(ourBase + "/items", Array.isArray(schema2.items) ? schema2.items : [schema2.items]);
+        scanArray(ourBase + "/extends", Array.isArray(schema2.extends) ? schema2.extends : [schema2.extends]);
+        scanSchema(ourBase + "/additionalItems", schema2.additionalItems);
+        scanObject(ourBase + "/properties", schema2.properties);
+        scanSchema(ourBase + "/additionalProperties", schema2.additionalProperties);
+        scanObject(ourBase + "/definitions", schema2.definitions);
+        scanObject(ourBase + "/patternProperties", schema2.patternProperties);
+        scanObject(ourBase + "/dependencies", schema2.dependencies);
+        scanArray(ourBase + "/disallow", schema2.disallow);
+        scanArray(ourBase + "/allOf", schema2.allOf);
+        scanArray(ourBase + "/anyOf", schema2.anyOf);
+        scanArray(ourBase + "/oneOf", schema2.oneOf);
+        scanSchema(ourBase + "/not", schema2.not);
       }
       function scanArray(baseuri, schemas) {
         if (!Array.isArray(schemas)) return;
@@ -30226,7 +30226,7 @@ var require_scan = __commonJS({
       }
       var found = {};
       var ref = {};
-      scanSchema(base, schema2);
+      scanSchema(base, schema);
       return new SchemaScanResult(found, ref);
     };
   }
@@ -30248,7 +30248,7 @@ var require_validator = __commonJS({
       this.customFormats = Object.create(Validator4.prototype.customFormats);
       this.schemas = {};
       this.unresolvedRefs = [];
-      this.types = Object.create(types);
+      this.types = Object.create(types2);
       this.attributes = Object.create(attribute.validators);
     };
     Validator3.prototype.customFormats = {};
@@ -30256,13 +30256,13 @@ var require_validator = __commonJS({
     Validator3.prototype.types = null;
     Validator3.prototype.attributes = null;
     Validator3.prototype.unresolvedRefs = null;
-    Validator3.prototype.addSchema = function addSchema(schema2, base) {
+    Validator3.prototype.addSchema = function addSchema(schema, base) {
       var self2 = this;
-      if (!schema2) {
+      if (!schema) {
         return null;
       }
-      var scan = scanSchema(base || anonymousBase, schema2);
-      var ourUri = base || schema2.$id || schema2.id;
+      var scan = scanSchema(base || anonymousBase, schema);
+      var ourUri = base || schema.$id || schema.id;
       for (var uri in scan.id) {
         this.schemas[uri] = scan.id[uri];
       }
@@ -30292,32 +30292,32 @@ var require_validator = __commonJS({
     Validator3.prototype.getSchema = function getSchema(urn) {
       return this.schemas[urn];
     };
-    Validator3.prototype.validate = function validate(instance, schema2, options, ctx) {
-      if (typeof schema2 !== "boolean" && typeof schema2 !== "object" || schema2 === null) {
+    Validator3.prototype.validate = function validate(instance, schema, options, ctx) {
+      if (typeof schema !== "boolean" && typeof schema !== "object" || schema === null) {
         throw new SchemaError("Expected `schema` to be an object or boolean");
       }
       if (!options) {
         options = {};
       }
-      var id = schema2.$id || schema2.id;
+      var id = schema.$id || schema.id;
       let base = helpers.resolveUrl(options.base, id || "");
       if (!ctx) {
-        ctx = new SchemaContext(schema2, options, [], base, Object.create(this.schemas));
+        ctx = new SchemaContext(schema, options, [], base, Object.create(this.schemas));
         if (!ctx.schemas[base]) {
-          ctx.schemas[base] = schema2;
+          ctx.schemas[base] = schema;
         }
-        var found = scanSchema(base, schema2);
+        var found = scanSchema(base, schema);
         for (var n in found.id) {
           var sch = found.id[n];
           ctx.schemas[n] = sch;
         }
       }
       if (options.required && instance === void 0) {
-        var result = new ValidatorResult(instance, schema2, options, ctx);
+        var result = new ValidatorResult(instance, schema, options, ctx);
         result.addError("is required, but is undefined");
         return result;
       }
-      var result = this.validateSchema(instance, schema2, options, ctx);
+      var result = this.validateSchema(instance, schema, options, ctx);
       if (!result) {
         throw new Error("Result undefined");
       } else if (options.throwAll && result.errors.length) {
@@ -30325,49 +30325,49 @@ var require_validator = __commonJS({
       }
       return result;
     };
-    function shouldResolve(schema2) {
-      var ref = typeof schema2 === "string" ? schema2 : schema2.$ref;
+    function shouldResolve(schema) {
+      var ref = typeof schema === "string" ? schema : schema.$ref;
       if (typeof ref == "string") return ref;
       return false;
     }
-    Validator3.prototype.validateSchema = function validateSchema2(instance, schema2, options, ctx) {
-      var result = new ValidatorResult(instance, schema2, options, ctx);
-      if (typeof schema2 === "boolean") {
-        if (schema2 === true) {
-          schema2 = {};
-        } else if (schema2 === false) {
-          schema2 = { type: [] };
+    Validator3.prototype.validateSchema = function validateSchema2(instance, schema, options, ctx) {
+      var result = new ValidatorResult(instance, schema, options, ctx);
+      if (typeof schema === "boolean") {
+        if (schema === true) {
+          schema = {};
+        } else if (schema === false) {
+          schema = { type: [] };
         }
-      } else if (!schema2) {
+      } else if (!schema) {
         throw new Error("schema is undefined");
       }
-      if (schema2["extends"]) {
-        if (Array.isArray(schema2["extends"])) {
-          var schemaobj = { schema: schema2, ctx };
-          schema2["extends"].forEach(this.schemaTraverser.bind(this, schemaobj));
-          schema2 = schemaobj.schema;
+      if (schema["extends"]) {
+        if (Array.isArray(schema["extends"])) {
+          var schemaobj = { schema, ctx };
+          schema["extends"].forEach(this.schemaTraverser.bind(this, schemaobj));
+          schema = schemaobj.schema;
           schemaobj.schema = null;
           schemaobj.ctx = null;
           schemaobj = null;
         } else {
-          schema2 = helpers.deepMerge(schema2, this.superResolve(schema2["extends"], ctx));
+          schema = helpers.deepMerge(schema, this.superResolve(schema["extends"], ctx));
         }
       }
-      var switchSchema = shouldResolve(schema2);
+      var switchSchema = shouldResolve(schema);
       if (switchSchema) {
-        var resolved = this.resolve(schema2, switchSchema, ctx);
+        var resolved = this.resolve(schema, switchSchema, ctx);
         var subctx = new SchemaContext(resolved.subschema, options, ctx.path, resolved.switchSchema, ctx.schemas);
         return this.validateSchema(instance, resolved.subschema, options, subctx);
       }
       var skipAttributes = options && options.skipAttributes || [];
-      for (var key in schema2) {
+      for (var key in schema) {
         if (!attribute.ignoreProperties[key] && skipAttributes.indexOf(key) < 0) {
           var validatorErr = null;
           var validator = this.attributes[key];
           if (validator) {
-            validatorErr = validator.call(this, instance, schema2, options, ctx);
+            validatorErr = validator.call(this, instance, schema, options, ctx);
           } else if (options.allowUnknownAttributes === false) {
-            throw new SchemaError("Unsupported attribute: " + key, schema2);
+            throw new SchemaError("Unsupported attribute: " + key, schema);
           }
           if (validatorErr) {
             result.importErrors(validatorErr);
@@ -30375,7 +30375,7 @@ var require_validator = __commonJS({
         }
       }
       if (typeof options.rewrite == "function") {
-        var value = options.rewrite.call(this, instance, schema2, options, ctx);
+        var value = options.rewrite.call(this, instance, schema, options, ctx);
         result.instance = value;
       }
       return result;
@@ -30383,14 +30383,14 @@ var require_validator = __commonJS({
     Validator3.prototype.schemaTraverser = function schemaTraverser(schemaobj, s) {
       schemaobj.schema = helpers.deepMerge(schemaobj.schema, this.superResolve(s, schemaobj.ctx));
     };
-    Validator3.prototype.superResolve = function superResolve(schema2, ctx) {
-      var ref = shouldResolve(schema2);
+    Validator3.prototype.superResolve = function superResolve(schema, ctx) {
+      var ref = shouldResolve(schema);
       if (ref) {
-        return this.resolve(schema2, ref, ctx).subschema;
+        return this.resolve(schema, ref, ctx).subschema;
       }
-      return schema2;
+      return schema;
     };
-    Validator3.prototype.resolve = function resolve13(schema2, switchSchema, ctx) {
+    Validator3.prototype.resolve = function resolve13(schema, switchSchema, ctx) {
       switchSchema = ctx.resolve(switchSchema);
       if (ctx.schemas[switchSchema]) {
         return { subschema: ctx.schemas[switchSchema], switchSchema };
@@ -30399,55 +30399,55 @@ var require_validator = __commonJS({
       let fragment = parsed.hash;
       var document2 = fragment && fragment.length && switchSchema.substr(0, switchSchema.length - fragment.length);
       if (!document2 || !ctx.schemas[document2]) {
-        throw new SchemaError("no such schema <" + switchSchema + ">", schema2);
+        throw new SchemaError("no such schema <" + switchSchema + ">", schema);
       }
       var subschema = helpers.objectGetPath(ctx.schemas[document2], fragment.substr(1));
       if (subschema === void 0) {
-        throw new SchemaError("no such schema " + fragment + " located in <" + document2 + ">", schema2);
+        throw new SchemaError("no such schema " + fragment + " located in <" + document2 + ">", schema);
       }
       return { subschema, switchSchema };
     };
-    Validator3.prototype.testType = function validateType(instance, schema2, options, ctx, type2) {
-      if (type2 === void 0) {
+    Validator3.prototype.testType = function validateType(instance, schema, options, ctx, type) {
+      if (type === void 0) {
         return;
-      } else if (type2 === null) {
+      } else if (type === null) {
         throw new SchemaError('Unexpected null in "type" keyword');
       }
-      if (typeof this.types[type2] == "function") {
-        return this.types[type2].call(this, instance);
+      if (typeof this.types[type] == "function") {
+        return this.types[type].call(this, instance);
       }
-      if (type2 && typeof type2 == "object") {
-        var res = this.validateSchema(instance, type2, options, ctx);
+      if (type && typeof type == "object") {
+        var res = this.validateSchema(instance, type, options, ctx);
         return res === void 0 || !(res && res.errors.length);
       }
       return true;
     };
-    var types = Validator3.prototype.types = {};
-    types.string = function testString(instance) {
+    var types2 = Validator3.prototype.types = {};
+    types2.string = function testString(instance) {
       return typeof instance == "string";
     };
-    types.number = function testNumber(instance) {
+    types2.number = function testNumber(instance) {
       return typeof instance == "number" && isFinite(instance);
     };
-    types.integer = function testInteger(instance) {
+    types2.integer = function testInteger(instance) {
       return typeof instance == "number" && instance % 1 === 0;
     };
-    types.boolean = function testBoolean(instance) {
+    types2.boolean = function testBoolean(instance) {
       return typeof instance == "boolean";
     };
-    types.array = function testArray(instance) {
+    types2.array = function testArray(instance) {
       return Array.isArray(instance);
     };
-    types["null"] = function testNull(instance) {
+    types2["null"] = function testNull(instance) {
       return instance === null;
     };
-    types.date = function testDate(instance) {
+    types2.date = function testDate(instance) {
       return instance instanceof Date;
     };
-    types.any = function testAny(instance) {
+    types2.any = function testAny(instance) {
       return true;
     };
-    types.object = function testObject(instance) {
+    types2.object = function testObject(instance) {
       return instance && typeof instance === "object" && !Array.isArray(instance) && !(instance instanceof Date);
     };
     module2.exports = Validator3;
@@ -30465,9 +30465,9 @@ var require_lib2 = __commonJS({
     module2.exports.SchemaError = require_helpers().SchemaError;
     module2.exports.SchemaScanResult = require_scan().SchemaScanResult;
     module2.exports.scan = require_scan().scan;
-    module2.exports.validate = function(instance, schema2, options) {
+    module2.exports.validate = function(instance, schema, options) {
       var v = new Validator3();
-      return v.validate(instance, schema2, options);
+      return v.validate(instance, schema, options);
     };
   }
 });
@@ -30666,7 +30666,7 @@ var require_internal_glob_options_helper = __commonJS({
     })();
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getOptions = getOptions;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     function getOptions(copy) {
       const result = {
         followSymbolicLinks: true,
@@ -30678,23 +30678,23 @@ var require_internal_glob_options_helper = __commonJS({
       if (copy) {
         if (typeof copy.followSymbolicLinks === "boolean") {
           result.followSymbolicLinks = copy.followSymbolicLinks;
-          core31.debug(`followSymbolicLinks '${result.followSymbolicLinks}'`);
+          core30.debug(`followSymbolicLinks '${result.followSymbolicLinks}'`);
         }
         if (typeof copy.implicitDescendants === "boolean") {
           result.implicitDescendants = copy.implicitDescendants;
-          core31.debug(`implicitDescendants '${result.implicitDescendants}'`);
+          core30.debug(`implicitDescendants '${result.implicitDescendants}'`);
         }
         if (typeof copy.matchDirectories === "boolean") {
           result.matchDirectories = copy.matchDirectories;
-          core31.debug(`matchDirectories '${result.matchDirectories}'`);
+          core30.debug(`matchDirectories '${result.matchDirectories}'`);
         }
         if (typeof copy.omitBrokenSymbolicLinks === "boolean") {
           result.omitBrokenSymbolicLinks = copy.omitBrokenSymbolicLinks;
-          core31.debug(`omitBrokenSymbolicLinks '${result.omitBrokenSymbolicLinks}'`);
+          core30.debug(`omitBrokenSymbolicLinks '${result.omitBrokenSymbolicLinks}'`);
         }
         if (typeof copy.excludeHiddenFiles === "boolean") {
           result.excludeHiddenFiles = copy.excludeHiddenFiles;
-          core31.debug(`excludeHiddenFiles '${result.excludeHiddenFiles}'`);
+          core30.debug(`excludeHiddenFiles '${result.excludeHiddenFiles}'`);
         }
       }
       return result;
@@ -30981,35 +30981,35 @@ var require_balanced_match = __commonJS({
   "node_modules/balanced-match/index.js"(exports2, module2) {
     "use strict";
     module2.exports = balanced;
-    function balanced(a, b, str2) {
-      if (a instanceof RegExp) a = maybeMatch(a, str2);
-      if (b instanceof RegExp) b = maybeMatch(b, str2);
-      var r = range(a, b, str2);
+    function balanced(a, b, str) {
+      if (a instanceof RegExp) a = maybeMatch(a, str);
+      if (b instanceof RegExp) b = maybeMatch(b, str);
+      var r = range(a, b, str);
       return r && {
         start: r[0],
         end: r[1],
-        pre: str2.slice(0, r[0]),
-        body: str2.slice(r[0] + a.length, r[1]),
-        post: str2.slice(r[1] + b.length)
+        pre: str.slice(0, r[0]),
+        body: str.slice(r[0] + a.length, r[1]),
+        post: str.slice(r[1] + b.length)
       };
     }
-    function maybeMatch(reg, str2) {
-      var m = str2.match(reg);
+    function maybeMatch(reg, str) {
+      var m = str.match(reg);
       return m ? m[0] : null;
     }
     balanced.range = range;
-    function range(a, b, str2) {
+    function range(a, b, str) {
       var begs, beg, left, right, result;
-      var ai = str2.indexOf(a);
-      var bi = str2.indexOf(b, ai + 1);
+      var ai = str.indexOf(a);
+      var bi = str.indexOf(b, ai + 1);
       var i = ai;
       if (ai >= 0 && bi > 0) {
         begs = [];
-        left = str2.length;
+        left = str.length;
         while (i >= 0 && !result) {
           if (i == ai) {
             begs.push(i);
-            ai = str2.indexOf(a, i + 1);
+            ai = str.indexOf(a, i + 1);
           } else if (begs.length == 1) {
             result = [begs.pop(), bi];
           } else {
@@ -31018,7 +31018,7 @@ var require_balanced_match = __commonJS({
               left = beg;
               right = bi;
             }
-            bi = str2.indexOf(b, i + 1);
+            bi = str.indexOf(b, i + 1);
           }
           i = ai < bi && ai >= 0 ? ai : bi;
         }
@@ -31042,22 +31042,22 @@ var require_brace_expansion = __commonJS({
     var escClose = "\0CLOSE" + Math.random() + "\0";
     var escComma = "\0COMMA" + Math.random() + "\0";
     var escPeriod = "\0PERIOD" + Math.random() + "\0";
-    function numeric(str2) {
-      return parseInt(str2, 10) == str2 ? parseInt(str2, 10) : str2.charCodeAt(0);
+    function numeric(str) {
+      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
     }
-    function escapeBraces(str2) {
-      return str2.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+    function escapeBraces(str) {
+      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
     }
-    function unescapeBraces(str2) {
-      return str2.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+    function unescapeBraces(str) {
+      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
     }
-    function parseCommaParts(str2) {
-      if (!str2)
+    function parseCommaParts(str) {
+      if (!str)
         return [""];
       var parts = [];
-      var m = balanced("{", "}", str2);
+      var m = balanced("{", "}", str);
       if (!m)
-        return str2.split(",");
+        return str.split(",");
       var pre = m.pre;
       var body = m.body;
       var post = m.post;
@@ -31071,18 +31071,18 @@ var require_brace_expansion = __commonJS({
       parts.push.apply(parts, p);
       return parts;
     }
-    function expandTop(str2, options) {
-      if (!str2)
+    function expandTop(str, options) {
+      if (!str)
         return [];
       options = options || {};
       var max = options.max == null ? Infinity : options.max;
-      if (str2.substr(0, 2) === "{}") {
-        str2 = "\\{\\}" + str2.substr(2);
+      if (str.substr(0, 2) === "{}") {
+        str = "\\{\\}" + str.substr(2);
       }
-      return expand2(escapeBraces(str2), max, true).map(unescapeBraces);
+      return expand2(escapeBraces(str), max, true).map(unescapeBraces);
     }
-    function embrace(str2) {
-      return "{" + str2 + "}";
+    function embrace(str) {
+      return "{" + str + "}";
     }
     function isPadded(el) {
       return /^-?0\d/.test(el);
@@ -31093,20 +31093,20 @@ var require_brace_expansion = __commonJS({
     function gte6(i, y) {
       return i >= y;
     }
-    function expand2(str2, max, isTop) {
+    function expand2(str, max, isTop) {
       var expansions = [];
-      var m = balanced("{", "}", str2);
-      if (!m || /\$$/.test(m.pre)) return [str2];
+      var m = balanced("{", "}", str);
+      if (!m || /\$$/.test(m.pre)) return [str];
       var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
       var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
       var isSequence = isNumericSequence || isAlphaSequence;
       var isOptions = m.body.indexOf(",") >= 0;
       if (!isSequence && !isOptions) {
         if (m.post.match(/,(?!,).*\}/)) {
-          str2 = m.pre + "{" + m.body + escClose + m.post;
-          return expand2(str2, max, true);
+          str = m.pre + "{" + m.body + escClose + m.post;
+          return expand2(str, max, true);
         }
-        return [str2];
+        return [str];
       }
       var n;
       if (isSequence) {
@@ -31206,9 +31206,9 @@ var require_minimatch = __commonJS({
     var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
     var reSpecials = charSet("().*{}+?[]^$\\!");
     function charSet(s) {
-      return s.split("").reduce(function(set2, c) {
-        set2[c] = true;
-        return set2;
+      return s.split("").reduce(function(set, c) {
+        set[c] = true;
+        return set;
       }, {});
     }
     var slashSplit = /\/+/;
@@ -31308,24 +31308,24 @@ var require_minimatch = __commonJS({
         return;
       }
       this.parseNegate();
-      var set2 = this.globSet = this.braceExpand();
+      var set = this.globSet = this.braceExpand();
       if (options.debug) this.debug = function debug6() {
         console.error.apply(console, arguments);
       };
-      this.debug(this.pattern, set2);
-      set2 = this.globParts = set2.map(function(s) {
+      this.debug(this.pattern, set);
+      set = this.globParts = set.map(function(s) {
         return s.split(slashSplit);
       });
-      this.debug(this.pattern, set2);
-      set2 = set2.map(function(s, si, set3) {
+      this.debug(this.pattern, set);
+      set = set.map(function(s, si, set2) {
         return s.map(this.parse, this);
       }, this);
-      this.debug(this.pattern, set2);
-      set2 = set2.filter(function(s) {
+      this.debug(this.pattern, set);
+      set = set.filter(function(s) {
         return s.indexOf(false) === -1;
       });
-      this.debug(this.pattern, set2);
-      this.set = set2;
+      this.debug(this.pattern, set);
+      this.set = set;
     }
     Minimatch.prototype.parseNegate = parseNegate;
     function parseNegate() {
@@ -31611,15 +31611,15 @@ var require_minimatch = __commonJS({
     Minimatch.prototype.makeRe = makeRe;
     function makeRe() {
       if (this.regexp || this.regexp === false) return this.regexp;
-      var set2 = this.set;
-      if (!set2.length) {
+      var set = this.set;
+      if (!set.length) {
         this.regexp = false;
         return this.regexp;
       }
       var options = this.options;
       var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
       var flags = options.nocase ? "i" : "";
-      var re = set2.map(function(pattern) {
+      var re = set.map(function(pattern) {
         return pattern.map(function(p) {
           return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._src;
         }).join("\\/");
@@ -31656,16 +31656,16 @@ var require_minimatch = __commonJS({
       }
       f = f.split(slashSplit);
       this.debug(this.pattern, "split", f);
-      var set2 = this.set;
-      this.debug(this.pattern, "set", set2);
+      var set = this.set;
+      this.debug(this.pattern, "set", set);
       var filename;
       var i;
       for (i = f.length - 1; i >= 0; i--) {
         filename = f[i];
         if (filename) break;
       }
-      for (i = 0; i < set2.length; i++) {
-        var pattern = set2[i];
+      for (i = 0; i < set.length; i++) {
+        var pattern = set[i];
         var file = f;
         if (options.matchBase && pattern.length === 1) {
           file = [filename];
@@ -32134,26 +32134,26 @@ var require_internal_pattern = __commonJS({
           } else if (c === "*" || c === "?") {
             return "";
           } else if (c === "[" && i + 1 < segment.length) {
-            let set2 = "";
+            let set = "";
             let closed = -1;
             for (let i2 = i + 1; i2 < segment.length; i2++) {
               const c2 = segment[i2];
               if (c2 === "\\" && !IS_WINDOWS && i2 + 1 < segment.length) {
-                set2 += segment[++i2];
+                set += segment[++i2];
                 continue;
               } else if (c2 === "]") {
                 closed = i2;
                 break;
               } else {
-                set2 += c2;
+                set += c2;
               }
             }
             if (closed >= 0) {
-              if (set2.length > 1) {
+              if (set.length > 1) {
                 return "";
               }
-              if (set2) {
-                literal += set2;
+              if (set) {
+                literal += set;
                 i = closed;
                 continue;
               }
@@ -32324,7 +32324,7 @@ var require_internal_globber = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DefaultGlobber = void 0;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var fs30 = __importStar2(require("fs"));
     var globOptionsHelper = __importStar2(require_internal_glob_options_helper());
     var path28 = __importStar2(require("path"));
@@ -32377,7 +32377,7 @@ var require_internal_globber = __commonJS({
           }
           const stack = [];
           for (const searchPath of patternHelper.getSearchPaths(patterns)) {
-            core31.debug(`Search path '${searchPath}'`);
+            core30.debug(`Search path '${searchPath}'`);
             try {
               yield __await2(fs30.promises.lstat(searchPath));
             } catch (err) {
@@ -32452,7 +32452,7 @@ var require_internal_globber = __commonJS({
             } catch (err) {
               if (err.code === "ENOENT") {
                 if (options.omitBrokenSymbolicLinks) {
-                  core31.debug(`Broken symlink '${item.path}'`);
+                  core30.debug(`Broken symlink '${item.path}'`);
                   return void 0;
                 }
                 throw new Error(`No information found for the path '${item.path}'. This may indicate a broken symbolic link.`);
@@ -32468,7 +32468,7 @@ var require_internal_globber = __commonJS({
               traversalChain.pop();
             }
             if (traversalChain.some((x) => x === realPath)) {
-              core31.debug(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`);
+              core30.debug(`Symlink cycle detected for path '${item.path}' and realpath '${realPath}'`);
               return void 0;
             }
             traversalChain.push(realPath);
@@ -32571,7 +32571,7 @@ var require_internal_hash_files = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.hashFiles = hashFiles2;
     var crypto3 = __importStar2(require("crypto"));
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var fs30 = __importStar2(require("fs"));
     var stream2 = __importStar2(require("stream"));
     var util = __importStar2(require("util"));
@@ -32580,7 +32580,7 @@ var require_internal_hash_files = __commonJS({
       return __awaiter2(this, arguments, void 0, function* (globber, currentWorkspace, verbose = false) {
         var _a, e_1, _b, _c;
         var _d;
-        const writeDelegate = verbose ? core31.info : core31.debug;
+        const writeDelegate = verbose ? core30.info : core30.debug;
         let hasMatch = false;
         const githubWorkspace = currentWorkspace ? currentWorkspace : (_d = process.env["GITHUB_WORKSPACE"]) !== null && _d !== void 0 ? _d : process.cwd();
         const result = crypto3.createHash("sha256");
@@ -33373,18 +33373,18 @@ var require_semver3 = __commonJS({
       range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace);
       range = range.split(/\s+/).join(" ");
       var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR];
-      var set2 = range.split(" ").map(function(comp) {
+      var set = range.split(" ").map(function(comp) {
         return parseComparator(comp, this.options);
       }, this).join(" ").split(/\s+/);
       if (this.options.loose) {
-        set2 = set2.filter(function(comp) {
+        set = set.filter(function(comp) {
           return !!comp.match(compRe);
         });
       }
-      set2 = set2.map(function(comp) {
+      set = set.map(function(comp) {
         return new Comparator(comp, this.options);
       }, this);
-      return set2;
+      return set;
     };
     Range2.prototype.intersects = function(range, options) {
       if (!(range instanceof Range2)) {
@@ -33612,20 +33612,20 @@ var require_semver3 = __commonJS({
       }
       return false;
     };
-    function testSet(set2, version, options) {
-      for (var i2 = 0; i2 < set2.length; i2++) {
-        if (!set2[i2].test(version)) {
+    function testSet(set, version, options) {
+      for (var i2 = 0; i2 < set.length; i2++) {
+        if (!set[i2].test(version)) {
           return false;
         }
       }
       if (version.prerelease.length && !options.includePrerelease) {
-        for (i2 = 0; i2 < set2.length; i2++) {
-          debug6(set2[i2].semver);
-          if (set2[i2].semver === ANY) {
+        for (i2 = 0; i2 < set.length; i2++) {
+          debug6(set[i2].semver);
+          if (set[i2].semver === ANY) {
             continue;
           }
-          if (set2[i2].semver.prerelease.length > 0) {
-            var allowed = set2[i2].semver;
+          if (set[i2].semver.prerelease.length > 0) {
+            var allowed = set[i2].semver;
             if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
               return true;
             }
@@ -33971,7 +33971,7 @@ var require_cacheUtils = __commonJS({
     exports2.assertDefined = assertDefined;
     exports2.getCacheVersion = getCacheVersion;
     exports2.getRuntimeToken = getRuntimeToken;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var exec3 = __importStar2(require_exec());
     var glob2 = __importStar2(require_glob());
     var io9 = __importStar2(require_io());
@@ -34022,7 +34022,7 @@ var require_cacheUtils = __commonJS({
             _e = false;
             const file = _c;
             const relativeFile = path28.relative(workspace, file).replace(new RegExp(`\\${path28.sep}`, "g"), "/");
-            core31.debug(`Matched: ${relativeFile}`);
+            core30.debug(`Matched: ${relativeFile}`);
             if (relativeFile === "") {
               paths.push(".");
             } else {
@@ -34050,7 +34050,7 @@ var require_cacheUtils = __commonJS({
       return __awaiter2(this, arguments, void 0, function* (app, additionalArgs = []) {
         let versionOutput = "";
         additionalArgs.push("--version");
-        core31.debug(`Checking ${app} ${additionalArgs.join(" ")}`);
+        core30.debug(`Checking ${app} ${additionalArgs.join(" ")}`);
         try {
           yield exec3.exec(`${app}`, additionalArgs, {
             ignoreReturnCode: true,
@@ -34061,10 +34061,10 @@ var require_cacheUtils = __commonJS({
             }
           });
         } catch (err) {
-          core31.debug(err.message);
+          core30.debug(err.message);
         }
         versionOutput = versionOutput.trim();
-        core31.debug(versionOutput);
+        core30.debug(versionOutput);
         return versionOutput;
       });
     }
@@ -34072,7 +34072,7 @@ var require_cacheUtils = __commonJS({
       return __awaiter2(this, void 0, void 0, function* () {
         const versionOutput = yield getVersion("zstd", ["--quiet"]);
         const version = semver11.clean(versionOutput);
-        core31.debug(`zstd version: ${version}`);
+        core30.debug(`zstd version: ${version}`);
         if (versionOutput === "") {
           return constants_1.CompressionMethod.Gzip;
         } else {
@@ -34810,7 +34810,7 @@ var require_debug2 = __commonJS({
         destroy,
         log: debugObj.log,
         namespace,
-        extend: extend3
+        extend
       });
       function debug6(...args) {
         if (!newDebugger.enabled) {
@@ -34832,7 +34832,7 @@ var require_debug2 = __commonJS({
       }
       return false;
     }
-    function extend3(namespace) {
+    function extend(namespace) {
       const newDebugger = createDebugger(`${this.namespace}:${namespace}`);
       newDebugger.log = this.log;
       return newDebugger;
@@ -34957,8 +34957,8 @@ var require_httpHeaders = __commonJS({
     function normalizeName(name) {
       return name.toLowerCase();
     }
-    function* headerIterator(map2) {
-      for (const entry of map2.values()) {
+    function* headerIterator(map) {
+      for (const entry of map.values()) {
         yield [entry.name, entry.value];
       }
     }
@@ -35315,8 +35315,8 @@ var require_object = __commonJS({
   "node_modules/@typespec/ts-http-runtime/dist/commonjs/util/object.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.isObject = isObject3;
-    function isObject3(input) {
+    exports2.isObject = isObject2;
+    function isObject2(input) {
       return typeof input === "object" && input !== null && !Array.isArray(input) && !(input instanceof RegExp) && !(input instanceof Date);
     }
   }
@@ -36012,16 +36012,16 @@ var require_userAgentPlatform = __commonJS({
     function getHeaderName() {
       return "User-Agent";
     }
-    async function setPlatformSpecificData(map2) {
+    async function setPlatformSpecificData(map) {
       if (node_process_1.default && node_process_1.default.versions) {
         const osInfo = `${node_os_1.default.type()} ${node_os_1.default.release()}; ${node_os_1.default.arch()}`;
         const versions = node_process_1.default.versions;
         if (versions.bun) {
-          map2.set("Bun", `${versions.bun} (${osInfo})`);
+          map.set("Bun", `${versions.bun} (${osInfo})`);
         } else if (versions.deno) {
-          map2.set("Deno", `${versions.deno} (${osInfo})`);
+          map.set("Deno", `${versions.deno} (${osInfo})`);
         } else if (versions.node) {
-          map2.set("Node", `${versions.node} (${osInfo})`);
+          map.set("Node", `${versions.node} (${osInfo})`);
         }
       }
     }
@@ -36532,30 +36532,30 @@ var require_ms = __commonJS({
     var y = d * 365.25;
     module2.exports = function(val, options) {
       options = options || {};
-      var type2 = typeof val;
-      if (type2 === "string" && val.length > 0) {
+      var type = typeof val;
+      if (type === "string" && val.length > 0) {
         return parse2(val);
-      } else if (type2 === "number" && isFinite(val)) {
+      } else if (type === "number" && isFinite(val)) {
         return options.long ? fmtLong(val) : fmtShort(val);
       }
       throw new Error(
         "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
       );
     };
-    function parse2(str2) {
-      str2 = String(str2);
-      if (str2.length > 100) {
+    function parse2(str) {
+      str = String(str);
+      if (str.length > 100) {
         return;
       }
       var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
-        str2
+        str
       );
       if (!match) {
         return;
       }
       var n = parseFloat(match[1]);
-      var type2 = (match[2] || "ms").toLowerCase();
-      switch (type2) {
+      var type = (match[2] || "ms").toLowerCase();
+      switch (type) {
         case "years":
         case "year":
         case "yrs":
@@ -36638,7 +36638,7 @@ var require_ms = __commonJS({
 });
 
 // node_modules/debug/src/common.js
-var require_common = __commonJS({
+var require_common2 = __commonJS({
   "node_modules/debug/src/common.js"(exports2, module2) {
     function setup(env) {
       createDebug.debug = createDebug;
@@ -36706,7 +36706,7 @@ var require_common = __commonJS({
         debug6.namespace = namespace;
         debug6.useColors = createDebug.useColors();
         debug6.color = createDebug.selectColor(namespace);
-        debug6.extend = extend3;
+        debug6.extend = extend;
         debug6.destroy = createDebug.destroy;
         Object.defineProperty(debug6, "enabled", {
           enumerable: true,
@@ -36730,7 +36730,7 @@ var require_common = __commonJS({
         }
         return debug6;
       }
-      function extend3(namespace, delimiter) {
+      function extend(namespace, delimiter) {
         const newDebug = createDebug(this.namespace + (typeof delimiter === "undefined" ? ":" : delimiter) + namespace);
         newDebug.log = this.log;
         return newDebug;
@@ -36972,7 +36972,7 @@ var require_browser = __commonJS({
       } catch (error3) {
       }
     }
-    module2.exports = require_common()(exports2);
+    module2.exports = require_common2()(exports2);
     var { formatters } = module2.exports;
     formatters.j = function(v) {
       try {
@@ -37260,11 +37260,11 @@ var require_node = __commonJS({
         debug6.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
       }
     }
-    module2.exports = require_common()(exports2);
+    module2.exports = require_common2()(exports2);
     var { formatters } = module2.exports;
     formatters.o = function(v) {
       this.inspectOpts.colors = this.useColors;
-      return util.inspect(v, this.inspectOpts).split("\n").map((str2) => str2.trim()).join(" ");
+      return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
     };
     formatters.O = function(v) {
       this.inspectOpts.colors = this.useColors;
@@ -37329,18 +37329,18 @@ var require_helpers3 = __commonJS({
       return Buffer.concat(chunks, length);
     }
     exports2.toBuffer = toBuffer;
-    async function json2(stream2) {
+    async function json(stream2) {
       const buf = await toBuffer(stream2);
-      const str2 = buf.toString("utf8");
+      const str = buf.toString("utf8");
       try {
-        return JSON.parse(str2);
+        return JSON.parse(str);
       } catch (_err) {
         const err = _err;
-        err.message += ` (input: ${str2})`;
+        err.message += ` (input: ${str})`;
         throw err;
       }
     }
-    exports2.json = json2;
+    exports2.json = json;
     function req(url2, opts = {}) {
       const href = typeof url2 === "string" ? url2 : url2.href;
       const req2 = (href.startsWith("https:") ? https3 : http).request(url2, opts);
@@ -37966,9 +37966,9 @@ var require_proxyPolicy = __commonJS({
         }
       }
       const parsedUrl = new URL(proxyUrl);
-      const schema2 = parsedUrl.protocol ? parsedUrl.protocol + "//" : "";
+      const schema = parsedUrl.protocol ? parsedUrl.protocol + "//" : "";
       return {
-        host: schema2 + parsedUrl.hostname,
+        host: schema + parsedUrl.hostname,
         port: Number.parseInt(parsedUrl.port || "80"),
         username: parsedUrl.username,
         password: parsedUrl.password
@@ -39444,16 +39444,16 @@ var require_userAgentPlatform2 = __commonJS({
     function getHeaderName() {
       return "User-Agent";
     }
-    async function setPlatformSpecificData(map2) {
+    async function setPlatformSpecificData(map) {
       if (node_process_1.default && node_process_1.default.versions) {
         const osInfo = `${node_os_1.default.type()} ${node_os_1.default.release()}; ${node_os_1.default.arch()}`;
         const versions = node_process_1.default.versions;
         if (versions.bun) {
-          map2.set("Bun", `${versions.bun} (${osInfo})`);
+          map.set("Bun", `${versions.bun} (${osInfo})`);
         } else if (versions.deno) {
-          map2.set("Deno", `${versions.deno} (${osInfo})`);
+          map.set("Deno", `${versions.deno} (${osInfo})`);
         } else if (versions.node) {
-          map2.set("Node", `${versions.node} (${osInfo})`);
+          map.set("Node", `${versions.node} (${osInfo})`);
         }
       }
     }
@@ -39802,7 +39802,7 @@ var require_commonjs4 = __commonJS({
     exports2.computeSha256Hmac = computeSha256Hmac;
     exports2.getRandomIntegerInclusive = getRandomIntegerInclusive;
     exports2.isError = isError;
-    exports2.isObject = isObject3;
+    exports2.isObject = isObject2;
     exports2.randomUUID = randomUUID;
     exports2.uint8ArrayToString = uint8ArrayToString;
     exports2.stringToUint8Array = stringToUint8Array;
@@ -39849,7 +39849,7 @@ var require_commonjs4 = __commonJS({
     function isError(e) {
       return tspRuntime.isError(e);
     }
-    function isObject3(input) {
+    function isObject2(input) {
       return tspRuntime.isObject(input);
     }
     function randomUUID() {
@@ -41782,12 +41782,12 @@ var require_serializer = __commonJS({
     function createSerializer(modelMappers = {}, isXML = false) {
       return new SerializerImpl(modelMappers, isXML);
     }
-    function trimEnd(str2, ch) {
-      let len = str2.length;
-      while (len - 1 >= 0 && str2[len - 1] === ch) {
+    function trimEnd(str, ch) {
+      let len = str.length;
+      while (len - 1 >= 0 && str[len - 1] === ch) {
         --len;
       }
-      return str2.substr(0, len);
+      return str.substr(0, len);
     }
     function bufferToBase64Url(buffer) {
       if (!buffer) {
@@ -41796,18 +41796,18 @@ var require_serializer = __commonJS({
       if (!(buffer instanceof Uint8Array)) {
         throw new Error(`Please provide an input of type Uint8Array for converting to Base64Url.`);
       }
-      const str2 = base64.encodeByteArray(buffer);
-      return trimEnd(str2, "=").replace(/\+/g, "-").replace(/\//g, "_");
+      const str = base64.encodeByteArray(buffer);
+      return trimEnd(str, "=").replace(/\+/g, "-").replace(/\//g, "_");
     }
-    function base64UrlToByteArray(str2) {
-      if (!str2) {
+    function base64UrlToByteArray(str) {
+      if (!str) {
         return void 0;
       }
-      if (str2 && typeof str2.valueOf() !== "string") {
+      if (str && typeof str.valueOf() !== "string") {
         throw new Error("Please provide an input of type string for converting to Uint8Array");
       }
-      str2 = str2.replace(/-/g, "+").replace(/_/g, "/");
-      return base64.decodeString(str2);
+      str = str.replace(/-/g, "+").replace(/_/g, "/");
+      return base64.decodeString(str);
     }
     function splitSerializeName(prop) {
       const classes = [];
@@ -42958,8 +42958,8 @@ var require_urlHelpers2 = __commonJS({
         return result;
       }
       queryString = queryString.slice(1);
-      const pairs2 = queryString.split("&");
-      for (const pair of pairs2) {
+      const pairs = queryString.split("&");
+      for (const pair of pairs) {
         const [name, value] = pair.split("=", 2);
         const existingValue = result.get(name);
         if (existingValue) {
@@ -45414,16 +45414,16 @@ var require_xml = __commonJS({
       const xmlData = j2x.build(node);
       return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>${xmlData}`.replace(/\n/g, "");
     }
-    async function parseXML(str2, opts = {}) {
-      if (!str2) {
+    async function parseXML(str, opts = {}) {
+      if (!str) {
         throw new Error("Document is empty");
       }
-      const validation = fast_xml_parser_1.XMLValidator.validate(str2);
+      const validation = fast_xml_parser_1.XMLValidator.validate(str);
       if (validation !== true) {
         throw validation;
       }
       const parser = new fast_xml_parser_1.XMLParser(getParserOptions(opts));
-      const parsedXml = parser.parse(str2);
+      const parsedXml = parser.parse(str);
       if (parsedXml["?xml"]) {
         delete parsedXml["?xml"];
       }
@@ -45788,7 +45788,7 @@ var require_utils_common = __commonJS({
     exports2.base64decode = base64decode;
     exports2.generateBlockID = generateBlockID;
     exports2.delay = delay2;
-    exports2.padStart = padStart2;
+    exports2.padStart = padStart;
     exports2.sanitizeURL = sanitizeURL;
     exports2.sanitizeHeaders = sanitizeHeaders;
     exports2.iEqual = iEqual;
@@ -46013,7 +46013,7 @@ var require_utils_common = __commonJS({
       if (blockIDPrefix.length > maxAllowedBlockIDPrefixLength) {
         blockIDPrefix = blockIDPrefix.slice(0, maxAllowedBlockIDPrefixLength);
       }
-      const res = blockIDPrefix + padStart2(blockIndex.toString(), maxSourceStringLength - blockIDPrefix.length, "0");
+      const res = blockIDPrefix + padStart(blockIndex.toString(), maxSourceStringLength - blockIDPrefix.length, "0");
       return base64encode(res);
     }
     async function delay2(timeInMs, aborter, abortError) {
@@ -46037,7 +46037,7 @@ var require_utils_common = __commonJS({
         }
       });
     }
-    function padStart2(currentString, targetLength, padString = " ") {
+    function padStart(currentString, targetLength, padString = " ") {
       if (String.prototype.padStart) {
         return currentString.padStart(targetLength, padString);
       }
@@ -47855,7 +47855,7 @@ var require_utils_common2 = __commonJS({
     exports2.base64decode = base64decode;
     exports2.generateBlockID = generateBlockID;
     exports2.delay = delay2;
-    exports2.padStart = padStart2;
+    exports2.padStart = padStart;
     exports2.sanitizeURL = sanitizeURL;
     exports2.sanitizeHeaders = sanitizeHeaders;
     exports2.iEqual = iEqual;
@@ -48071,7 +48071,7 @@ var require_utils_common2 = __commonJS({
       if (blockIDPrefix.length > maxAllowedBlockIDPrefixLength) {
         blockIDPrefix = blockIDPrefix.slice(0, maxAllowedBlockIDPrefixLength);
       }
-      const res = blockIDPrefix + padStart2(blockIndex.toString(), maxSourceStringLength - blockIDPrefix.length, "0");
+      const res = blockIDPrefix + padStart(blockIndex.toString(), maxSourceStringLength - blockIDPrefix.length, "0");
       return base64encode(res);
     }
     async function delay2(timeInMs, aborter, abortError) {
@@ -48095,7 +48095,7 @@ var require_utils_common2 = __commonJS({
         }
       });
     }
-    function padStart2(currentString, targetLength, padString = " ") {
+    function padStart(currentString, targetLength, padString = " ") {
       if (String.prototype.padStart) {
         return currentString.padStart(targetLength, padString);
       }
@@ -64634,14 +64634,14 @@ var require_BlobSASSignatureValues = __commonJS({
         throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when 'identifier' is not provided.");
       }
       let resource = "c";
-      let timestamp2 = blobSASSignatureValues.snapshotTime;
+      let timestamp = blobSASSignatureValues.snapshotTime;
       if (blobSASSignatureValues.blobName) {
         resource = "b";
         if (blobSASSignatureValues.snapshotTime) {
           resource = "bs";
         } else if (blobSASSignatureValues.versionId) {
           resource = "bv";
-          timestamp2 = blobSASSignatureValues.versionId;
+          timestamp = blobSASSignatureValues.versionId;
         }
       }
       let verifiedPermissions;
@@ -64662,7 +64662,7 @@ var require_BlobSASSignatureValues = __commonJS({
         blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
         blobSASSignatureValues.version,
         resource,
-        timestamp2,
+        timestamp,
         blobSASSignatureValues.cacheControl ? blobSASSignatureValues.cacheControl : "",
         blobSASSignatureValues.contentDisposition ? blobSASSignatureValues.contentDisposition : "",
         blobSASSignatureValues.contentEncoding ? blobSASSignatureValues.contentEncoding : "",
@@ -64681,14 +64681,14 @@ var require_BlobSASSignatureValues = __commonJS({
         throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when 'identifier' is not provided.");
       }
       let resource = "c";
-      let timestamp2 = blobSASSignatureValues.snapshotTime;
+      let timestamp = blobSASSignatureValues.snapshotTime;
       if (blobSASSignatureValues.blobName) {
         resource = "b";
         if (blobSASSignatureValues.snapshotTime) {
           resource = "bs";
         } else if (blobSASSignatureValues.versionId) {
           resource = "bv";
-          timestamp2 = blobSASSignatureValues.versionId;
+          timestamp = blobSASSignatureValues.versionId;
         }
       }
       let verifiedPermissions;
@@ -64709,7 +64709,7 @@ var require_BlobSASSignatureValues = __commonJS({
         blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
         blobSASSignatureValues.version,
         resource,
-        timestamp2,
+        timestamp,
         blobSASSignatureValues.encryptionScope,
         blobSASSignatureValues.cacheControl ? blobSASSignatureValues.cacheControl : "",
         blobSASSignatureValues.contentDisposition ? blobSASSignatureValues.contentDisposition : "",
@@ -64729,14 +64729,14 @@ var require_BlobSASSignatureValues = __commonJS({
         throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when generating user delegation SAS.");
       }
       let resource = "c";
-      let timestamp2 = blobSASSignatureValues.snapshotTime;
+      let timestamp = blobSASSignatureValues.snapshotTime;
       if (blobSASSignatureValues.blobName) {
         resource = "b";
         if (blobSASSignatureValues.snapshotTime) {
           resource = "bs";
         } else if (blobSASSignatureValues.versionId) {
           resource = "bv";
-          timestamp2 = blobSASSignatureValues.versionId;
+          timestamp = blobSASSignatureValues.versionId;
         }
       }
       let verifiedPermissions;
@@ -64762,7 +64762,7 @@ var require_BlobSASSignatureValues = __commonJS({
         blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
         blobSASSignatureValues.version,
         resource,
-        timestamp2,
+        timestamp,
         blobSASSignatureValues.cacheControl,
         blobSASSignatureValues.contentDisposition,
         blobSASSignatureValues.contentEncoding,
@@ -64781,14 +64781,14 @@ var require_BlobSASSignatureValues = __commonJS({
         throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when generating user delegation SAS.");
       }
       let resource = "c";
-      let timestamp2 = blobSASSignatureValues.snapshotTime;
+      let timestamp = blobSASSignatureValues.snapshotTime;
       if (blobSASSignatureValues.blobName) {
         resource = "b";
         if (blobSASSignatureValues.snapshotTime) {
           resource = "bs";
         } else if (blobSASSignatureValues.versionId) {
           resource = "bv";
-          timestamp2 = blobSASSignatureValues.versionId;
+          timestamp = blobSASSignatureValues.versionId;
         }
       }
       let verifiedPermissions;
@@ -64818,7 +64818,7 @@ var require_BlobSASSignatureValues = __commonJS({
         blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
         blobSASSignatureValues.version,
         resource,
-        timestamp2,
+        timestamp,
         blobSASSignatureValues.cacheControl,
         blobSASSignatureValues.contentDisposition,
         blobSASSignatureValues.contentEncoding,
@@ -64837,14 +64837,14 @@ var require_BlobSASSignatureValues = __commonJS({
         throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when generating user delegation SAS.");
       }
       let resource = "c";
-      let timestamp2 = blobSASSignatureValues.snapshotTime;
+      let timestamp = blobSASSignatureValues.snapshotTime;
       if (blobSASSignatureValues.blobName) {
         resource = "b";
         if (blobSASSignatureValues.snapshotTime) {
           resource = "bs";
         } else if (blobSASSignatureValues.versionId) {
           resource = "bv";
-          timestamp2 = blobSASSignatureValues.versionId;
+          timestamp = blobSASSignatureValues.versionId;
         }
       }
       let verifiedPermissions;
@@ -64874,7 +64874,7 @@ var require_BlobSASSignatureValues = __commonJS({
         blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
         blobSASSignatureValues.version,
         resource,
-        timestamp2,
+        timestamp,
         blobSASSignatureValues.encryptionScope,
         blobSASSignatureValues.cacheControl,
         blobSASSignatureValues.contentDisposition,
@@ -64894,14 +64894,14 @@ var require_BlobSASSignatureValues = __commonJS({
         throw new RangeError("Must provide 'permissions' and 'expiresOn' for Blob SAS generation when generating user delegation SAS.");
       }
       let resource = "c";
-      let timestamp2 = blobSASSignatureValues.snapshotTime;
+      let timestamp = blobSASSignatureValues.snapshotTime;
       if (blobSASSignatureValues.blobName) {
         resource = "b";
         if (blobSASSignatureValues.snapshotTime) {
           resource = "bs";
         } else if (blobSASSignatureValues.versionId) {
           resource = "bv";
-          timestamp2 = blobSASSignatureValues.versionId;
+          timestamp = blobSASSignatureValues.versionId;
         }
       }
       let verifiedPermissions;
@@ -64935,7 +64935,7 @@ var require_BlobSASSignatureValues = __commonJS({
         blobSASSignatureValues.protocol ? blobSASSignatureValues.protocol : "",
         blobSASSignatureValues.version,
         resource,
-        timestamp2,
+        timestamp,
         blobSASSignatureValues.encryptionScope,
         blobSASSignatureValues.cacheControl,
         blobSASSignatureValues.contentDisposition,
@@ -65884,9 +65884,9 @@ var require_AvroParser = __commonJS({
         const readPairMethod = (s, opts = {}) => {
           return _AvroParser.readMapPair(s, readItemMethod, opts);
         };
-        const pairs2 = await _AvroParser.readArray(stream2, readPairMethod, options);
+        const pairs = await _AvroParser.readArray(stream2, readPairMethod, options);
         const dict = {};
-        for (const pair of pairs2) {
+        for (const pair of pairs) {
           dict[pair.key] = pair.value;
         }
         return dict;
@@ -65932,17 +65932,17 @@ var require_AvroParser = __commonJS({
        * Determines the AvroType from the Avro Schema.
        */
       // eslint-disable-next-line @typescript-eslint/no-wrapper-object-types
-      static fromSchema(schema2) {
-        if (typeof schema2 === "string") {
-          return _AvroType.fromStringSchema(schema2);
-        } else if (Array.isArray(schema2)) {
-          return _AvroType.fromArraySchema(schema2);
+      static fromSchema(schema) {
+        if (typeof schema === "string") {
+          return _AvroType.fromStringSchema(schema);
+        } else if (Array.isArray(schema)) {
+          return _AvroType.fromArraySchema(schema);
         } else {
-          return _AvroType.fromObjectSchema(schema2);
+          return _AvroType.fromObjectSchema(schema);
         }
       }
-      static fromStringSchema(schema2) {
-        switch (schema2) {
+      static fromStringSchema(schema) {
+        switch (schema) {
           case AvroPrimitive.NULL:
           case AvroPrimitive.BOOLEAN:
           case AvroPrimitive.INT:
@@ -65951,55 +65951,55 @@ var require_AvroParser = __commonJS({
           case AvroPrimitive.DOUBLE:
           case AvroPrimitive.BYTES:
           case AvroPrimitive.STRING:
-            return new AvroPrimitiveType(schema2);
+            return new AvroPrimitiveType(schema);
           default:
-            throw new Error(`Unexpected Avro type ${schema2}`);
+            throw new Error(`Unexpected Avro type ${schema}`);
         }
       }
-      static fromArraySchema(schema2) {
-        return new AvroUnionType(schema2.map(_AvroType.fromSchema));
+      static fromArraySchema(schema) {
+        return new AvroUnionType(schema.map(_AvroType.fromSchema));
       }
-      static fromObjectSchema(schema2) {
-        const type2 = schema2.type;
+      static fromObjectSchema(schema) {
+        const type = schema.type;
         try {
-          return _AvroType.fromStringSchema(type2);
+          return _AvroType.fromStringSchema(type);
         } catch {
         }
-        switch (type2) {
+        switch (type) {
           case AvroComplex.RECORD:
-            if (schema2.aliases) {
-              throw new Error(`aliases currently is not supported, schema: ${schema2}`);
+            if (schema.aliases) {
+              throw new Error(`aliases currently is not supported, schema: ${schema}`);
             }
-            if (!schema2.name) {
-              throw new Error(`Required attribute 'name' doesn't exist on schema: ${schema2}`);
+            if (!schema.name) {
+              throw new Error(`Required attribute 'name' doesn't exist on schema: ${schema}`);
             }
             const fields = {};
-            if (!schema2.fields) {
-              throw new Error(`Required attribute 'fields' doesn't exist on schema: ${schema2}`);
+            if (!schema.fields) {
+              throw new Error(`Required attribute 'fields' doesn't exist on schema: ${schema}`);
             }
-            for (const field of schema2.fields) {
+            for (const field of schema.fields) {
               fields[field.name] = _AvroType.fromSchema(field.type);
             }
-            return new AvroRecordType(fields, schema2.name);
+            return new AvroRecordType(fields, schema.name);
           case AvroComplex.ENUM:
-            if (schema2.aliases) {
-              throw new Error(`aliases currently is not supported, schema: ${schema2}`);
+            if (schema.aliases) {
+              throw new Error(`aliases currently is not supported, schema: ${schema}`);
             }
-            if (!schema2.symbols) {
-              throw new Error(`Required attribute 'symbols' doesn't exist on schema: ${schema2}`);
+            if (!schema.symbols) {
+              throw new Error(`Required attribute 'symbols' doesn't exist on schema: ${schema}`);
             }
-            return new AvroEnumType(schema2.symbols);
+            return new AvroEnumType(schema.symbols);
           case AvroComplex.MAP:
-            if (!schema2.values) {
-              throw new Error(`Required attribute 'values' doesn't exist on schema: ${schema2}`);
+            if (!schema.values) {
+              throw new Error(`Required attribute 'values' doesn't exist on schema: ${schema}`);
             }
-            return new AvroMapType(_AvroType.fromSchema(schema2.values));
+            return new AvroMapType(_AvroType.fromSchema(schema.values));
           case AvroComplex.ARRAY:
           // Unused today
           case AvroComplex.FIXED:
           // Unused today
           default:
-            throw new Error(`Unexpected Avro type ${type2} in ${schema2}`);
+            throw new Error(`Unexpected Avro type ${type} in ${schema}`);
         }
       }
     };
@@ -66048,9 +66048,9 @@ var require_AvroParser = __commonJS({
     };
     var AvroUnionType = class extends AvroType {
       _types;
-      constructor(types) {
+      constructor(types2) {
         super();
-        this._types = types;
+        this._types = types2;
       }
       async read(stream2, options = {}) {
         const typeIndex = await AvroParser.readInt(stream2, options);
@@ -66170,8 +66170,8 @@ var require_AvroReader = __commonJS({
         this._syncMarker = await AvroParser_js_1.AvroParser.readFixedBytes(this._headerStream, AvroConstants_js_1.AVRO_SYNC_MARKER_SIZE, {
           abortSignal: options.abortSignal
         });
-        const schema2 = JSON.parse(this._metadata[AvroConstants_js_1.AVRO_SCHEMA_KEY]);
-        this._itemType = AvroParser_js_1.AvroType.fromSchema(schema2);
+        const schema = JSON.parse(this._metadata[AvroConstants_js_1.AVRO_SCHEMA_KEY]);
+        this._itemType = AvroParser_js_1.AvroType.fromSchema(schema);
         if (this._blockOffset === 0) {
           this._blockOffset = this._initialBlockOffset + this._dataStream.position;
         }
@@ -66392,11 +66392,11 @@ var require_BlobQuickQueryStream = __commonJS({
             break;
           }
           const obj = avroNext.value;
-          const schema2 = obj.$schema;
-          if (typeof schema2 !== "string") {
+          const schema = obj.$schema;
+          if (typeof schema !== "string") {
             throw Error("Missing schema in avro record.");
           }
-          switch (schema2) {
+          switch (schema) {
             case "com.microsoft.azure.storage.queryBlobContents.resultData":
               {
                 const data = obj.data;
@@ -66456,7 +66456,7 @@ var require_BlobQuickQueryStream = __commonJS({
               }
               break;
             default:
-              throw Error(`Unknown schema ${schema2} in avro progress record.`);
+              throw Error(`Unknown schema ${schema} in avro progress record.`);
           }
         } while (!avroNext.done && !this.avroPaused);
       }
@@ -68163,7 +68163,7 @@ var require_BlobStartCopyFromUrlPoller = __commonJS({
       }
       return makeBlobBeginCopyFromURLPollOperation(state);
     };
-    var toString3 = function toString4() {
+    var toString2 = function toString3() {
       return JSON.stringify({ state: this.state }, (key, value) => {
         if (key === "blobClient") {
           return void 0;
@@ -68175,7 +68175,7 @@ var require_BlobStartCopyFromUrlPoller = __commonJS({
       return {
         state: { ...state },
         cancel,
-        toString: toString3,
+        toString: toString2,
         update
       };
     }
@@ -71132,8 +71132,8 @@ var require_BatchUtils = __commonJS({
       buffer = buffer.slice(0, responseLength);
       return buffer.toString();
     }
-    function utf8ByteLength(str2) {
-      return Buffer.byteLength(str2);
+    function utf8ByteLength(str) {
+      return Buffer.byteLength(str);
     }
   }
 });
@@ -74370,7 +74370,7 @@ var require_uploadUtils = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.UploadProgress = void 0;
     exports2.uploadCacheArchiveSDK = uploadCacheArchiveSDK;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var storage_blob_1 = require_commonjs15();
     var errors_1 = require_errors2();
     var UploadProgress = class {
@@ -74412,7 +74412,7 @@ var require_uploadUtils = __commonJS({
         const percentage = (100 * (transferredBytes / this.contentLength)).toFixed(1);
         const elapsedTime = Date.now() - this.startTime;
         const uploadSpeed = (transferredBytes / (1024 * 1024) / (elapsedTime / 1e3)).toFixed(1);
-        core31.info(`Sent ${transferredBytes} of ${this.contentLength} (${percentage}%), ${uploadSpeed} MBs/sec`);
+        core30.info(`Sent ${transferredBytes} of ${this.contentLength} (${percentage}%), ${uploadSpeed} MBs/sec`);
         if (this.isDone()) {
           this.displayedComplete = true;
         }
@@ -74469,14 +74469,14 @@ var require_uploadUtils = __commonJS({
         };
         try {
           uploadProgress.startDisplayTimer();
-          core31.debug(`BlobClient: ${blobClient.name}:${blobClient.accountName}:${blobClient.containerName}`);
+          core30.debug(`BlobClient: ${blobClient.name}:${blobClient.accountName}:${blobClient.containerName}`);
           const response = yield blockBlobClient.uploadFile(archivePath, uploadOptions);
           if (response._response.status >= 400) {
             throw new errors_1.InvalidResponseError(`uploadCacheArchiveSDK: upload failed with status code ${response._response.status}`);
           }
           return response;
         } catch (error3) {
-          core31.warning(`uploadCacheArchiveSDK: internal error uploading cache archive: ${error3.message}`);
+          core30.warning(`uploadCacheArchiveSDK: internal error uploading cache archive: ${error3.message}`);
           throw error3;
         } finally {
           uploadProgress.stopDisplayTimer();
@@ -74561,7 +74561,7 @@ var require_requestUtils = __commonJS({
     exports2.retry = retry2;
     exports2.retryTypedResponse = retryTypedResponse;
     exports2.retryHttpClientResponse = retryHttpClientResponse;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var http_client_1 = require_lib();
     var constants_1 = require_constants7();
     function isSuccessStatusCode(statusCode) {
@@ -74619,9 +74619,9 @@ var require_requestUtils = __commonJS({
             isRetryable = isRetryableStatusCode(statusCode);
             errorMessage = `Cache service responded with ${statusCode}`;
           }
-          core31.debug(`${name} - Attempt ${attempt} of ${maxAttempts} failed with error: ${errorMessage}`);
+          core30.debug(`${name} - Attempt ${attempt} of ${maxAttempts} failed with error: ${errorMessage}`);
           if (!isRetryable) {
-            core31.debug(`${name} - Error is not retryable`);
+            core30.debug(`${name} - Error is not retryable`);
             break;
           }
           yield sleep(delay2);
@@ -74880,7 +74880,7 @@ var require_downloadUtils = __commonJS({
     exports2.downloadCacheHttpClient = downloadCacheHttpClient;
     exports2.downloadCacheHttpClientConcurrent = downloadCacheHttpClientConcurrent;
     exports2.downloadCacheStorageSDK = downloadCacheStorageSDK;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var http_client_1 = require_lib();
     var storage_blob_1 = require_commonjs15();
     var buffer = __importStar2(require("buffer"));
@@ -74918,7 +74918,7 @@ var require_downloadUtils = __commonJS({
         this.segmentIndex = this.segmentIndex + 1;
         this.segmentSize = segmentSize;
         this.receivedBytes = 0;
-        core31.debug(`Downloading segment at offset ${this.segmentOffset} with length ${this.segmentSize}...`);
+        core30.debug(`Downloading segment at offset ${this.segmentOffset} with length ${this.segmentSize}...`);
       }
       /**
        * Sets the number of bytes received for the current segment.
@@ -74952,7 +74952,7 @@ var require_downloadUtils = __commonJS({
         const percentage = (100 * (transferredBytes / this.contentLength)).toFixed(1);
         const elapsedTime = Date.now() - this.startTime;
         const downloadSpeed = (transferredBytes / (1024 * 1024) / (elapsedTime / 1e3)).toFixed(1);
-        core31.info(`Received ${transferredBytes} of ${this.contentLength} (${percentage}%), ${downloadSpeed} MBs/sec`);
+        core30.info(`Received ${transferredBytes} of ${this.contentLength} (${percentage}%), ${downloadSpeed} MBs/sec`);
         if (this.isDone()) {
           this.displayedComplete = true;
         }
@@ -75002,7 +75002,7 @@ var require_downloadUtils = __commonJS({
         }));
         downloadResponse.message.socket.setTimeout(constants_1.SocketTimeout, () => {
           downloadResponse.message.destroy();
-          core31.debug(`Aborting download, socket timed out after ${constants_1.SocketTimeout} ms`);
+          core30.debug(`Aborting download, socket timed out after ${constants_1.SocketTimeout} ms`);
         });
         yield pipeResponseToStream(downloadResponse, writeStream);
         const contentLengthHeader = downloadResponse.message.headers["content-length"];
@@ -75013,7 +75013,7 @@ var require_downloadUtils = __commonJS({
             throw new Error(`Incomplete download. Expected file size: ${expectedLength}, actual file size: ${actualLength}`);
           }
         } else {
-          core31.debug("Unable to validate download, no Content-Length header");
+          core30.debug("Unable to validate download, no Content-Length header");
         }
       });
     }
@@ -75131,7 +75131,7 @@ var require_downloadUtils = __commonJS({
         const properties = yield client.getProperties();
         const contentLength = (_a = properties.contentLength) !== null && _a !== void 0 ? _a : -1;
         if (contentLength < 0) {
-          core31.debug("Unable to determine content length, downloading file with http-client...");
+          core30.debug("Unable to determine content length, downloading file with http-client...");
           yield downloadCacheHttpClient(archiveLocation, archivePath);
         } else {
           const maxSegmentSize = Math.min(134217728, buffer.constants.MAX_LENGTH);
@@ -75221,7 +75221,7 @@ var require_options = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getUploadOptions = getUploadOptions;
     exports2.getDownloadOptions = getDownloadOptions;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     function getUploadOptions(copy) {
       const result = {
         useAzureSdk: false,
@@ -75241,9 +75241,9 @@ var require_options = __commonJS({
       }
       result.uploadConcurrency = !isNaN(Number(process.env["CACHE_UPLOAD_CONCURRENCY"])) ? Math.min(32, Number(process.env["CACHE_UPLOAD_CONCURRENCY"])) : result.uploadConcurrency;
       result.uploadChunkSize = !isNaN(Number(process.env["CACHE_UPLOAD_CHUNK_SIZE"])) ? Math.min(128 * 1024 * 1024, Number(process.env["CACHE_UPLOAD_CHUNK_SIZE"]) * 1024 * 1024) : result.uploadChunkSize;
-      core31.debug(`Use Azure SDK: ${result.useAzureSdk}`);
-      core31.debug(`Upload concurrency: ${result.uploadConcurrency}`);
-      core31.debug(`Upload chunk size: ${result.uploadChunkSize}`);
+      core30.debug(`Use Azure SDK: ${result.useAzureSdk}`);
+      core30.debug(`Upload concurrency: ${result.uploadConcurrency}`);
+      core30.debug(`Upload chunk size: ${result.uploadChunkSize}`);
       return result;
     }
     function getDownloadOptions(copy) {
@@ -75279,12 +75279,12 @@ var require_options = __commonJS({
       if (segmentDownloadTimeoutMins && !isNaN(Number(segmentDownloadTimeoutMins)) && isFinite(Number(segmentDownloadTimeoutMins))) {
         result.segmentTimeoutInMs = Number(segmentDownloadTimeoutMins) * 60 * 1e3;
       }
-      core31.debug(`Use Azure SDK: ${result.useAzureSdk}`);
-      core31.debug(`Download concurrency: ${result.downloadConcurrency}`);
-      core31.debug(`Request timeout (ms): ${result.timeoutInMs}`);
-      core31.debug(`Cache segment download timeout mins env var: ${process.env["SEGMENT_DOWNLOAD_TIMEOUT_MINS"]}`);
-      core31.debug(`Segment download timeout (ms): ${result.segmentTimeoutInMs}`);
-      core31.debug(`Lookup only: ${result.lookupOnly}`);
+      core30.debug(`Use Azure SDK: ${result.useAzureSdk}`);
+      core30.debug(`Download concurrency: ${result.downloadConcurrency}`);
+      core30.debug(`Request timeout (ms): ${result.timeoutInMs}`);
+      core30.debug(`Cache segment download timeout mins env var: ${process.env["SEGMENT_DOWNLOAD_TIMEOUT_MINS"]}`);
+      core30.debug(`Segment download timeout (ms): ${result.segmentTimeoutInMs}`);
+      core30.debug(`Lookup only: ${result.lookupOnly}`);
       return result;
     }
   }
@@ -75478,7 +75478,7 @@ var require_cacheHttpClient = __commonJS({
     exports2.downloadCache = downloadCache;
     exports2.reserveCache = reserveCache;
     exports2.saveCache = saveCache5;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var http_client_1 = require_lib();
     var auth_1 = require_auth();
     var fs30 = __importStar2(require("fs"));
@@ -75496,11 +75496,11 @@ var require_cacheHttpClient = __commonJS({
         throw new Error("Cache Service Url not found, unable to restore cache.");
       }
       const url2 = `${baseUrl}_apis/artifactcache/${resource}`;
-      core31.debug(`Resource Url: ${url2}`);
+      core30.debug(`Resource Url: ${url2}`);
       return url2;
     }
-    function createAcceptHeader(type2, apiVersion) {
-      return `${type2};api-version=${apiVersion}`;
+    function createAcceptHeader(type, apiVersion) {
+      return `${type};api-version=${apiVersion}`;
     }
     function getRequestOptions() {
       const requestOptions = {
@@ -75524,7 +75524,7 @@ var require_cacheHttpClient = __commonJS({
           return httpClient.getJson(getCacheApiUrl(resource));
         }));
         if (response.statusCode === 204) {
-          if (core31.isDebug()) {
+          if (core30.isDebug()) {
             yield printCachesListForDiagnostics(keys[0], httpClient, version);
           }
           return null;
@@ -75537,9 +75537,9 @@ var require_cacheHttpClient = __commonJS({
         if (!cacheDownloadUrl) {
           throw new Error("Cache not found.");
         }
-        core31.setSecret(cacheDownloadUrl);
-        core31.debug(`Cache Result:`);
-        core31.debug(JSON.stringify(cacheResult));
+        core30.setSecret(cacheDownloadUrl);
+        core30.debug(`Cache Result:`);
+        core30.debug(JSON.stringify(cacheResult));
         return cacheResult;
       });
     }
@@ -75553,10 +75553,10 @@ var require_cacheHttpClient = __commonJS({
           const cacheListResult = response.result;
           const totalCount = cacheListResult === null || cacheListResult === void 0 ? void 0 : cacheListResult.totalCount;
           if (totalCount && totalCount > 0) {
-            core31.debug(`No matching cache found for cache key '${key}', version '${version} and scope ${process.env["GITHUB_REF"]}. There exist one or more cache(s) with similar key but they have different version or scope. See more info on cache matching here: https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#matching-a-cache-key 
+            core30.debug(`No matching cache found for cache key '${key}', version '${version} and scope ${process.env["GITHUB_REF"]}. There exist one or more cache(s) with similar key but they have different version or scope. See more info on cache matching here: https://docs.github.com/en/actions/using-workflows/caching-dependencies-to-speed-up-workflows#matching-a-cache-key 
 Other caches with similar key:`);
             for (const cacheEntry of (cacheListResult === null || cacheListResult === void 0 ? void 0 : cacheListResult.artifactCaches) || []) {
-              core31.debug(`Cache Key: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.cacheKey}, Cache Version: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.cacheVersion}, Cache Scope: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.scope}, Cache Created: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.creationTime}`);
+              core30.debug(`Cache Key: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.cacheKey}, Cache Version: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.cacheVersion}, Cache Scope: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.scope}, Cache Created: ${cacheEntry === null || cacheEntry === void 0 ? void 0 : cacheEntry.creationTime}`);
             }
           }
         }
@@ -75599,7 +75599,7 @@ Other caches with similar key:`);
     }
     function uploadChunk(httpClient, resourceUrl, openStream, start, end) {
       return __awaiter2(this, void 0, void 0, function* () {
-        core31.debug(`Uploading chunk of size ${end - start + 1} bytes at offset ${start} with content range: ${getContentRange(start, end)}`);
+        core30.debug(`Uploading chunk of size ${end - start + 1} bytes at offset ${start} with content range: ${getContentRange(start, end)}`);
         const additionalHeaders = {
           "Content-Type": "application/octet-stream",
           "Content-Range": getContentRange(start, end)
@@ -75621,7 +75621,7 @@ Other caches with similar key:`);
         const concurrency = utils.assertDefined("uploadConcurrency", uploadOptions.uploadConcurrency);
         const maxChunkSize = utils.assertDefined("uploadChunkSize", uploadOptions.uploadChunkSize);
         const parallelUploads = [...new Array(concurrency).keys()];
-        core31.debug("Awaiting all uploads");
+        core30.debug("Awaiting all uploads");
         let offset = 0;
         try {
           yield Promise.all(parallelUploads.map(() => __awaiter2(this, void 0, void 0, function* () {
@@ -75664,16 +75664,16 @@ Other caches with similar key:`);
           yield (0, uploadUtils_1.uploadCacheArchiveSDK)(signedUploadURL, archivePath, options);
         } else {
           const httpClient = createHttpClient();
-          core31.debug("Upload cache");
+          core30.debug("Upload cache");
           yield uploadFile(httpClient, cacheId, archivePath, options);
-          core31.debug("Commiting cache");
+          core30.debug("Commiting cache");
           const cacheSize = utils.getArchiveFileSizeInBytes(archivePath);
-          core31.info(`Cache Size: ~${Math.round(cacheSize / (1024 * 1024))} MB (${cacheSize} B)`);
+          core30.info(`Cache Size: ~${Math.round(cacheSize / (1024 * 1024))} MB (${cacheSize} B)`);
           const commitCacheResponse = yield commitCache(httpClient, cacheId, cacheSize);
           if (!(0, requestUtils_1.isSuccessStatusCode)(commitCacheResponse.statusCode)) {
             throw new Error(`Cache service responded with ${commitCacheResponse.statusCode} during commit cache.`);
           }
-          core31.info("Cache saved successfully");
+          core30.info("Cache saved successfully");
         }
       });
     }
@@ -76583,8 +76583,8 @@ var require_binary_writer = __commonJS({
        *
        * Generated code should compute the tag ahead of time and call `uint32()`.
        */
-      tag(fieldNo, type2) {
-        return this.uint32((fieldNo << 3 | type2) >>> 0);
+      tag(fieldNo, type) {
+        return this.uint32((fieldNo << 3 | type) >>> 0);
       }
       /**
        * Write a chunk of raw bytes.
@@ -77088,31 +77088,31 @@ var require_reflection_type_check = __commonJS({
         }
         return true;
       }
-      message(arg, type2, allowExcessProperties, depth) {
+      message(arg, type, allowExcessProperties, depth) {
         if (allowExcessProperties) {
-          return type2.isAssignable(arg, depth);
+          return type.isAssignable(arg, depth);
         }
-        return type2.is(arg, depth);
+        return type.is(arg, depth);
       }
-      messages(arg, type2, allowExcessProperties, depth) {
+      messages(arg, type, allowExcessProperties, depth) {
         if (!Array.isArray(arg))
           return false;
         if (depth < 2)
           return true;
         if (allowExcessProperties) {
           for (let i = 0; i < arg.length && i < depth; i++)
-            if (!type2.isAssignable(arg[i], depth - 1))
+            if (!type.isAssignable(arg[i], depth - 1))
               return false;
         } else {
           for (let i = 0; i < arg.length && i < depth; i++)
-            if (!type2.is(arg[i], depth - 1))
+            if (!type.is(arg[i], depth - 1))
               return false;
         }
         return true;
       }
-      scalar(arg, type2, longType) {
+      scalar(arg, type, longType) {
         let argType = typeof arg;
-        switch (type2) {
+        switch (type) {
           case reflection_info_1.ScalarType.UINT64:
           case reflection_info_1.ScalarType.FIXED64:
           case reflection_info_1.ScalarType.INT64:
@@ -77139,31 +77139,31 @@ var require_reflection_type_check = __commonJS({
             return argType == "number" && Number.isInteger(arg);
         }
       }
-      scalars(arg, type2, depth, longType) {
+      scalars(arg, type, depth, longType) {
         if (!Array.isArray(arg))
           return false;
         if (depth < 2)
           return true;
         if (Array.isArray(arg)) {
           for (let i = 0; i < arg.length && i < depth; i++)
-            if (!this.scalar(arg[i], type2, longType))
+            if (!this.scalar(arg[i], type, longType))
               return false;
         }
         return true;
       }
-      mapKeys(map2, type2, depth) {
-        let keys = Object.keys(map2);
-        switch (type2) {
+      mapKeys(map, type, depth) {
+        let keys = Object.keys(map);
+        switch (type) {
           case reflection_info_1.ScalarType.INT32:
           case reflection_info_1.ScalarType.FIXED32:
           case reflection_info_1.ScalarType.SFIXED32:
           case reflection_info_1.ScalarType.SINT32:
           case reflection_info_1.ScalarType.UINT32:
-            return this.scalars(keys.slice(0, depth).map((k) => parseInt(k)), type2, depth);
+            return this.scalars(keys.slice(0, depth).map((k) => parseInt(k)), type, depth);
           case reflection_info_1.ScalarType.BOOL:
-            return this.scalars(keys.slice(0, depth).map((k) => k == "true" ? true : k == "false" ? false : k), type2, depth);
+            return this.scalars(keys.slice(0, depth).map((k) => k == "true" ? true : k == "false" ? false : k), type, depth);
           default:
-            return this.scalars(keys, type2, depth, reflection_info_1.LongType.STRING);
+            return this.scalars(keys, type, depth, reflection_info_1.LongType.STRING);
         }
       }
     };
@@ -77178,8 +77178,8 @@ var require_reflection_long_convert = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.reflectionLongConvert = void 0;
     var reflection_info_1 = require_reflection_info();
-    function reflectionLongConvert(long, type2) {
-      switch (type2) {
+    function reflectionLongConvert(long, type) {
+      switch (type) {
         case reflection_info_1.LongType.BIGINT:
           return long.toBigInt();
         case reflection_info_1.LongType.NUMBER:
@@ -77347,89 +77347,89 @@ var require_reflection_json_reader = __commonJS({
        *
        * google.protobuf.NullValue accepts only JSON `null` (or the old `"NULL_VALUE"`).
        */
-      enum(type2, json2, fieldName, ignoreUnknownFields) {
-        if (type2[0] == "google.protobuf.NullValue")
-          assert_1.assert(json2 === null || json2 === "NULL_VALUE", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type2[0]} only accepts null.`);
-        if (json2 === null)
+      enum(type, json, fieldName, ignoreUnknownFields) {
+        if (type[0] == "google.protobuf.NullValue")
+          assert_1.assert(json === null || json === "NULL_VALUE", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} only accepts null.`);
+        if (json === null)
           return 0;
-        switch (typeof json2) {
+        switch (typeof json) {
           case "number":
-            assert_1.assert(Number.isInteger(json2), `Unable to parse field ${this.info.typeName}#${fieldName}, enum can only be integral number, got ${json2}.`);
-            return json2;
+            assert_1.assert(Number.isInteger(json), `Unable to parse field ${this.info.typeName}#${fieldName}, enum can only be integral number, got ${json}.`);
+            return json;
           case "string":
-            let localEnumName = json2;
-            if (type2[2] && json2.substring(0, type2[2].length) === type2[2])
-              localEnumName = json2.substring(type2[2].length);
-            let enumNumber = type2[1][localEnumName];
+            let localEnumName = json;
+            if (type[2] && json.substring(0, type[2].length) === type[2])
+              localEnumName = json.substring(type[2].length);
+            let enumNumber = type[1][localEnumName];
             if (typeof enumNumber === "undefined" && ignoreUnknownFields) {
               return false;
             }
-            assert_1.assert(typeof enumNumber == "number", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type2[0]} has no value for "${json2}".`);
+            assert_1.assert(typeof enumNumber == "number", `Unable to parse field ${this.info.typeName}#${fieldName}, enum ${type[0]} has no value for "${json}".`);
             return enumNumber;
         }
-        assert_1.assert(false, `Unable to parse field ${this.info.typeName}#${fieldName}, cannot parse enum value from ${typeof json2}".`);
+        assert_1.assert(false, `Unable to parse field ${this.info.typeName}#${fieldName}, cannot parse enum value from ${typeof json}".`);
       }
-      scalar(json2, type2, longType, fieldName) {
+      scalar(json, type, longType, fieldName) {
         let e;
         try {
-          switch (type2) {
+          switch (type) {
             // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
             // Either numbers or strings are accepted. Exponent notation is also accepted.
             case reflection_info_1.ScalarType.DOUBLE:
             case reflection_info_1.ScalarType.FLOAT:
-              if (json2 === null)
+              if (json === null)
                 return 0;
-              if (json2 === "NaN")
+              if (json === "NaN")
                 return Number.NaN;
-              if (json2 === "Infinity")
+              if (json === "Infinity")
                 return Number.POSITIVE_INFINITY;
-              if (json2 === "-Infinity")
+              if (json === "-Infinity")
                 return Number.NEGATIVE_INFINITY;
-              if (json2 === "") {
+              if (json === "") {
                 e = "empty string";
                 break;
               }
-              if (typeof json2 == "string" && json2.trim().length !== json2.length) {
+              if (typeof json == "string" && json.trim().length !== json.length) {
                 e = "extra whitespace";
                 break;
               }
-              if (typeof json2 != "string" && typeof json2 != "number") {
+              if (typeof json != "string" && typeof json != "number") {
                 break;
               }
-              let float2 = Number(json2);
-              if (Number.isNaN(float2)) {
+              let float = Number(json);
+              if (Number.isNaN(float)) {
                 e = "not a number";
                 break;
               }
-              if (!Number.isFinite(float2)) {
+              if (!Number.isFinite(float)) {
                 e = "too large or small";
                 break;
               }
-              if (type2 == reflection_info_1.ScalarType.FLOAT)
-                assert_1.assertFloat32(float2);
-              return float2;
+              if (type == reflection_info_1.ScalarType.FLOAT)
+                assert_1.assertFloat32(float);
+              return float;
             // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
             case reflection_info_1.ScalarType.INT32:
             case reflection_info_1.ScalarType.FIXED32:
             case reflection_info_1.ScalarType.SFIXED32:
             case reflection_info_1.ScalarType.SINT32:
             case reflection_info_1.ScalarType.UINT32:
-              if (json2 === null)
+              if (json === null)
                 return 0;
               let int32;
-              if (typeof json2 == "number")
-                int32 = json2;
-              else if (json2 === "")
+              if (typeof json == "number")
+                int32 = json;
+              else if (json === "")
                 e = "empty string";
-              else if (typeof json2 == "string") {
-                if (json2.trim().length !== json2.length)
+              else if (typeof json == "string") {
+                if (json.trim().length !== json.length)
                   e = "extra whitespace";
                 else
-                  int32 = Number(json2);
+                  int32 = Number(json);
               }
               if (int32 === void 0)
                 break;
-              if (type2 == reflection_info_1.ScalarType.UINT32)
+              if (type == reflection_info_1.ScalarType.UINT32)
                 assert_1.assertUInt32(int32);
               else
                 assert_1.assertInt32(int32);
@@ -77438,53 +77438,53 @@ var require_reflection_json_reader = __commonJS({
             case reflection_info_1.ScalarType.INT64:
             case reflection_info_1.ScalarType.SFIXED64:
             case reflection_info_1.ScalarType.SINT64:
-              if (json2 === null)
+              if (json === null)
                 return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbLong.ZERO, longType);
-              if (typeof json2 != "number" && typeof json2 != "string")
+              if (typeof json != "number" && typeof json != "string")
                 break;
-              return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbLong.from(json2), longType);
+              return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbLong.from(json), longType);
             case reflection_info_1.ScalarType.FIXED64:
             case reflection_info_1.ScalarType.UINT64:
-              if (json2 === null)
+              if (json === null)
                 return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbULong.ZERO, longType);
-              if (typeof json2 != "number" && typeof json2 != "string")
+              if (typeof json != "number" && typeof json != "string")
                 break;
-              return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbULong.from(json2), longType);
+              return reflection_long_convert_1.reflectionLongConvert(pb_long_1.PbULong.from(json), longType);
             // bool:
             case reflection_info_1.ScalarType.BOOL:
-              if (json2 === null)
+              if (json === null)
                 return false;
-              if (typeof json2 !== "boolean")
+              if (typeof json !== "boolean")
                 break;
-              return json2;
+              return json;
             // string:
             case reflection_info_1.ScalarType.STRING:
-              if (json2 === null)
+              if (json === null)
                 return "";
-              if (typeof json2 !== "string") {
+              if (typeof json !== "string") {
                 e = "extra whitespace";
                 break;
               }
               try {
-                encodeURIComponent(json2);
+                encodeURIComponent(json);
               } catch (e2) {
                 e2 = "invalid UTF8";
                 break;
               }
-              return json2;
+              return json;
             // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
             // Either standard or URL-safe base64 encoding with/without paddings are accepted.
             case reflection_info_1.ScalarType.BYTES:
-              if (json2 === null || json2 === "")
+              if (json === null || json === "")
                 return new Uint8Array(0);
-              if (typeof json2 !== "string")
+              if (typeof json !== "string")
                 break;
-              return base64_1.base64decode(json2);
+              return base64_1.base64decode(json);
           }
         } catch (error3) {
           e = error3.message;
         }
-        this.assert(false, fieldName + (e ? " - " + e : ""), json2);
+        this.assert(false, fieldName + (e ? " - " + e : ""), json);
       }
     };
     exports2.ReflectionJsonReader = ReflectionJsonReader;
@@ -77510,12 +77510,12 @@ var require_reflection_json_writer = __commonJS({
        * Converts the message to a JSON object, based on the field descriptors.
        */
       write(message, options) {
-        const json2 = {}, source = message;
+        const json = {}, source = message;
         for (const field of this.fields) {
           if (!field.oneof) {
             let jsonValue2 = this.field(field, source[field.localName], options);
             if (jsonValue2 !== void 0)
-              json2[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue2;
+              json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue2;
             continue;
           }
           const group = source[field.oneof];
@@ -77524,9 +77524,9 @@ var require_reflection_json_writer = __commonJS({
           const opt = field.kind == "scalar" || field.kind == "enum" ? Object.assign(Object.assign({}, options), { emitDefaultValues: true }) : options;
           let jsonValue = this.field(field, group[field.localName], opt);
           assert_1.assert(jsonValue !== void 0);
-          json2[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue;
+          json[options.useProtoFieldName ? field.name : field.jsonName] = jsonValue;
         }
-        return json2;
+        return json;
       }
       field(field, value, options) {
         let jsonValue = void 0;
@@ -77610,8 +77610,8 @@ var require_reflection_json_writer = __commonJS({
       /**
        * Returns `null` as the default for google.protobuf.NullValue.
        */
-      enum(type2, value, fieldName, optional2, emitDefaultValues, enumAsInteger) {
-        if (type2[0] == "google.protobuf.NullValue")
+      enum(type, value, fieldName, optional2, emitDefaultValues, enumAsInteger) {
+        if (type[0] == "google.protobuf.NullValue")
           return !emitDefaultValues && !optional2 ? void 0 : null;
         if (value === void 0) {
           assert_1.assert(optional2);
@@ -77621,24 +77621,24 @@ var require_reflection_json_writer = __commonJS({
           return void 0;
         assert_1.assert(typeof value == "number");
         assert_1.assert(Number.isInteger(value));
-        if (enumAsInteger || !type2[1].hasOwnProperty(value))
+        if (enumAsInteger || !type[1].hasOwnProperty(value))
           return value;
-        if (type2[2])
-          return type2[2] + type2[1][value];
-        return type2[1][value];
+        if (type[2])
+          return type[2] + type[1][value];
+        return type[1][value];
       }
-      message(type2, value, fieldName, options) {
+      message(type, value, fieldName, options) {
         if (value === void 0)
           return options.emitDefaultValues ? null : void 0;
-        return type2.internalJsonWrite(value, options);
+        return type.internalJsonWrite(value, options);
       }
-      scalar(type2, value, fieldName, optional2, emitDefaultValues) {
+      scalar(type, value, fieldName, optional2, emitDefaultValues) {
         if (value === void 0) {
           assert_1.assert(optional2);
           return void 0;
         }
         const ed = emitDefaultValues || optional2;
-        switch (type2) {
+        switch (type) {
           // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
           case reflection_info_1.ScalarType.INT32:
           case reflection_info_1.ScalarType.SFIXED32:
@@ -77720,8 +77720,8 @@ var require_reflection_scalar_default = __commonJS({
     var reflection_info_1 = require_reflection_info();
     var reflection_long_convert_1 = require_reflection_long_convert();
     var pb_long_1 = require_pb_long();
-    function reflectionScalarDefault(type2, longType = reflection_info_1.LongType.STRING) {
-      switch (type2) {
+    function reflectionScalarDefault(type, longType = reflection_info_1.LongType.STRING) {
+      switch (type) {
         case reflection_info_1.ScalarType.BOOL:
           return false;
         case reflection_info_1.ScalarType.UINT64:
@@ -77881,8 +77881,8 @@ var require_reflection_binary_reader = __commonJS({
           }
         return [key, val];
       }
-      scalar(reader, type2, longType) {
-        switch (type2) {
+      scalar(reader, type, longType) {
+        switch (type) {
           case reflection_info_1.ScalarType.INT32:
             return reader.int32();
           case reflection_info_1.ScalarType.STRING:
@@ -78033,8 +78033,8 @@ var require_reflection_binary_writer = __commonJS({
       /**
        * Write a single scalar value.
        */
-      scalar(writer, type2, fieldNo, value, emitDefault) {
-        let [wireType, method, isDefault] = this.scalarInfo(type2, value);
+      scalar(writer, type, fieldNo, value, emitDefault) {
+        let [wireType, method, isDefault] = this.scalarInfo(type, value);
         if (!isDefault || emitDefault) {
           writer.tag(fieldNo, wireType);
           writer[method](value);
@@ -78043,13 +78043,13 @@ var require_reflection_binary_writer = __commonJS({
       /**
        * Write an array of scalar values in packed format.
        */
-      packed(writer, type2, fieldNo, value) {
+      packed(writer, type, fieldNo, value) {
         if (!value.length)
           return;
-        assert_1.assert(type2 !== reflection_info_1.ScalarType.BYTES && type2 !== reflection_info_1.ScalarType.STRING);
+        assert_1.assert(type !== reflection_info_1.ScalarType.BYTES && type !== reflection_info_1.ScalarType.STRING);
         writer.tag(fieldNo, binary_format_contract_1.WireType.LengthDelimited);
         writer.fork();
-        let [, method] = this.scalarInfo(type2);
+        let [, method] = this.scalarInfo(type);
         for (let i = 0; i < value.length; i++)
           writer[method](value[i]);
         writer.join();
@@ -78064,12 +78064,12 @@ var require_reflection_binary_writer = __commonJS({
        *
        * If argument `value` is omitted, [2] is always false.
        */
-      scalarInfo(type2, value) {
+      scalarInfo(type, value) {
         let t = binary_format_contract_1.WireType.Varint;
         let m;
         let i = value === void 0;
         let d = value === 0;
-        switch (type2) {
+        switch (type) {
           case reflection_info_1.ScalarType.INT32:
             m = "int32";
             break;
@@ -78147,9 +78147,9 @@ var require_reflection_create = __commonJS({
     exports2.reflectionCreate = void 0;
     var reflection_scalar_default_1 = require_reflection_scalar_default();
     var message_type_contract_1 = require_message_type_contract();
-    function reflectionCreate(type2) {
-      const msg = type2.messagePrototype ? Object.create(type2.messagePrototype) : Object.defineProperty({}, message_type_contract_1.MESSAGE_TYPE, { value: type2 });
-      for (let field of type2.fields) {
+    function reflectionCreate(type) {
+      const msg = type.messagePrototype ? Object.create(type.messagePrototype) : Object.defineProperty({}, message_type_contract_1.MESSAGE_TYPE, { value: type });
+      for (let field of type.fields) {
         let name = field.localName;
         if (field.opt)
           continue;
@@ -78284,10 +78284,10 @@ var require_reflection_equals = __commonJS({
     }
     exports2.reflectionEquals = reflectionEquals;
     var objectValues = Object.values;
-    function primitiveEq(type2, a, b) {
+    function primitiveEq(type, a, b) {
       if (a === b)
         return true;
-      if (type2 !== reflection_info_1.ScalarType.BYTES)
+      if (type !== reflection_info_1.ScalarType.BYTES)
         return false;
       let ba = a;
       let bb = b;
@@ -78298,19 +78298,19 @@ var require_reflection_equals = __commonJS({
           return false;
       return true;
     }
-    function repeatedPrimitiveEq(type2, a, b) {
+    function repeatedPrimitiveEq(type, a, b) {
       if (a.length !== b.length)
         return false;
       for (let i = 0; i < a.length; i++)
-        if (!primitiveEq(type2, a[i], b[i]))
+        if (!primitiveEq(type, a[i], b[i]))
           return false;
       return true;
     }
-    function repeatedMsgEq(type2, a, b) {
+    function repeatedMsgEq(type, a, b) {
       if (a.length !== b.length)
         return false;
       for (let i = 0; i < a.length; i++)
-        if (!type2.equals(a[i], b[i]))
+        if (!type.equals(a[i], b[i]))
           return false;
       return true;
     }
@@ -78409,15 +78409,15 @@ var require_message_type = __commonJS({
       /**
        * Read a new message from a JSON value.
        */
-      fromJson(json2, options) {
-        return this.internalJsonRead(json2, json_format_contract_1.jsonReadOptions(options));
+      fromJson(json, options) {
+        return this.internalJsonRead(json, json_format_contract_1.jsonReadOptions(options));
       }
       /**
        * Read a new message from a JSON string.
        * This is equivalent to `T.fromJson(JSON.parse(json))`.
        */
-      fromJsonString(json2, options) {
-        let value = JSON.parse(json2);
+      fromJsonString(json, options) {
+        let value = JSON.parse(json);
         return this.fromJson(value, options);
       }
       /**
@@ -78450,13 +78450,13 @@ var require_message_type = __commonJS({
        * according to protobuf rules. If the target is omitted,
        * a new instance is created first.
        */
-      internalJsonRead(json2, options, target) {
-        if (json2 !== null && typeof json2 == "object" && !Array.isArray(json2)) {
+      internalJsonRead(json, options, target) {
+        if (json !== null && typeof json == "object" && !Array.isArray(json)) {
           let message = target !== null && target !== void 0 ? target : this.create();
-          this.refJsonReader.read(json2, message, options);
+          this.refJsonReader.read(json, message, options);
           return message;
         }
-        throw new Error(`Unable to parse message ${this.typeName} from JSON ${json_typings_1.typeofJsonValue(json2)}.`);
+        throw new Error(`Unable to parse message ${this.typeName} from JSON ${json_typings_1.typeofJsonValue(json)}.`);
       }
       /**
        * This is an internal method. If you just want to write a message
@@ -80944,13 +80944,13 @@ var require_tar = __commonJS({
       });
     }
     function getTarArgs(tarPath_1, compressionMethod_1, type_1) {
-      return __awaiter2(this, arguments, void 0, function* (tarPath, compressionMethod, type2, archivePath = "") {
+      return __awaiter2(this, arguments, void 0, function* (tarPath, compressionMethod, type, archivePath = "") {
         const args = [`"${tarPath.path}"`];
         const cacheFileName = utils.getCacheFileName(compressionMethod);
         const tarFile = "cache.tar";
         const workingDirectory = getWorkingDirectory();
         const BSD_TAR_ZSTD = tarPath.type === constants_1.ArchiveToolType.BSD && compressionMethod !== constants_1.CompressionMethod.Gzip && IS_WINDOWS;
-        switch (type2) {
+        switch (type) {
           case "create":
             args.push("--posix", "-cf", BSD_TAR_ZSTD ? tarFile : cacheFileName.replace(new RegExp(`\\${path28.sep}`, "g"), "/"), "--exclude", BSD_TAR_ZSTD ? tarFile : cacheFileName.replace(new RegExp(`\\${path28.sep}`, "g"), "/"), "-P", "-C", workingDirectory.replace(new RegExp(`\\${path28.sep}`, "g"), "/"), "--files-from", constants_1.ManifestFilename);
             break;
@@ -80975,13 +80975,13 @@ var require_tar = __commonJS({
       });
     }
     function getCommands(compressionMethod_1, type_1) {
-      return __awaiter2(this, arguments, void 0, function* (compressionMethod, type2, archivePath = "") {
+      return __awaiter2(this, arguments, void 0, function* (compressionMethod, type, archivePath = "") {
         let args;
         const tarPath = yield getTarPath();
-        const tarArgs = yield getTarArgs(tarPath, compressionMethod, type2, archivePath);
-        const compressionArgs = type2 !== "create" ? yield getDecompressionProgram(tarPath, compressionMethod, archivePath) : yield getCompressionProgram(tarPath, compressionMethod);
+        const tarArgs = yield getTarArgs(tarPath, compressionMethod, type, archivePath);
+        const compressionArgs = type !== "create" ? yield getDecompressionProgram(tarPath, compressionMethod, archivePath) : yield getCompressionProgram(tarPath, compressionMethod);
         const BSD_TAR_ZSTD = tarPath.type === constants_1.ArchiveToolType.BSD && compressionMethod !== constants_1.CompressionMethod.Gzip && IS_WINDOWS;
-        if (BSD_TAR_ZSTD && type2 !== "create") {
+        if (BSD_TAR_ZSTD && type !== "create") {
           args = [[...compressionArgs].join(" "), [...tarArgs].join(" ")];
         } else {
           args = [[...tarArgs].join(" "), [...compressionArgs].join(" ")];
@@ -81156,7 +81156,7 @@ var require_cache4 = __commonJS({
     exports2.isFeatureAvailable = isFeatureAvailable;
     exports2.restoreCache = restoreCache5;
     exports2.saveCache = saveCache5;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var path28 = __importStar2(require("path"));
     var utils = __importStar2(require_cacheUtils());
     var cacheHttpClient = __importStar2(require_cacheHttpClient());
@@ -81215,7 +81215,7 @@ var require_cache4 = __commonJS({
     function restoreCache5(paths_1, primaryKey_1, restoreKeys_1, options_1) {
       return __awaiter2(this, arguments, void 0, function* (paths, primaryKey, restoreKeys, options, enableCrossOsArchive = false) {
         const cacheServiceVersion = (0, config_1.getCacheServiceVersion)();
-        core31.debug(`Cache service version: ${cacheServiceVersion}`);
+        core30.debug(`Cache service version: ${cacheServiceVersion}`);
         checkPaths(paths);
         switch (cacheServiceVersion) {
           case "v2":
@@ -81230,8 +81230,8 @@ var require_cache4 = __commonJS({
       return __awaiter2(this, arguments, void 0, function* (paths, primaryKey, restoreKeys, options, enableCrossOsArchive = false) {
         restoreKeys = restoreKeys || [];
         const keys = [primaryKey, ...restoreKeys];
-        core31.debug("Resolved Keys:");
-        core31.debug(JSON.stringify(keys));
+        core30.debug("Resolved Keys:");
+        core30.debug(JSON.stringify(keys));
         if (keys.length > 10) {
           throw new ValidationError(`Key Validation Error: Keys are limited to a maximum of 10.`);
         }
@@ -81249,19 +81249,19 @@ var require_cache4 = __commonJS({
             return void 0;
           }
           if (options === null || options === void 0 ? void 0 : options.lookupOnly) {
-            core31.info("Lookup only - skipping download");
+            core30.info("Lookup only - skipping download");
             return cacheEntry.cacheKey;
           }
           archivePath = path28.join(yield utils.createTempDirectory(), utils.getCacheFileName(compressionMethod));
-          core31.debug(`Archive Path: ${archivePath}`);
+          core30.debug(`Archive Path: ${archivePath}`);
           yield cacheHttpClient.downloadCache(cacheEntry.archiveLocation, archivePath, options);
-          if (core31.isDebug()) {
+          if (core30.isDebug()) {
             yield (0, tar_1.listTar)(archivePath, compressionMethod);
           }
           const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath);
-          core31.info(`Cache Size: ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B)`);
+          core30.info(`Cache Size: ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B)`);
           yield (0, tar_1.extractTar)(archivePath, compressionMethod);
-          core31.info("Cache restored successfully");
+          core30.info("Cache restored successfully");
           return cacheEntry.cacheKey;
         } catch (error3) {
           const typedError = error3;
@@ -81269,16 +81269,16 @@ var require_cache4 = __commonJS({
             throw error3;
           } else {
             if (typedError instanceof http_client_1.HttpClientError && typeof typedError.statusCode === "number" && typedError.statusCode >= 500) {
-              core31.error(`Failed to restore: ${error3.message}`);
+              core30.error(`Failed to restore: ${error3.message}`);
             } else {
-              core31.warning(`Failed to restore: ${error3.message}`);
+              core30.warning(`Failed to restore: ${error3.message}`);
             }
           }
         } finally {
           try {
             yield utils.unlinkFile(archivePath);
           } catch (error3) {
-            core31.debug(`Failed to delete archive: ${error3}`);
+            core30.debug(`Failed to delete archive: ${error3}`);
           }
         }
         return void 0;
@@ -81289,8 +81289,8 @@ var require_cache4 = __commonJS({
         options = Object.assign(Object.assign({}, options), { useAzureSdk: true });
         restoreKeys = restoreKeys || [];
         const keys = [primaryKey, ...restoreKeys];
-        core31.debug("Resolved Keys:");
-        core31.debug(JSON.stringify(keys));
+        core30.debug("Resolved Keys:");
+        core30.debug(JSON.stringify(keys));
         if (keys.length > 10) {
           throw new ValidationError(`Key Validation Error: Keys are limited to a maximum of 10.`);
         }
@@ -81308,30 +81308,30 @@ var require_cache4 = __commonJS({
           };
           const response = yield twirpClient.GetCacheEntryDownloadURL(request3);
           if (!response.ok) {
-            core31.debug(`Cache not found for version ${request3.version} of keys: ${keys.join(", ")}`);
+            core30.debug(`Cache not found for version ${request3.version} of keys: ${keys.join(", ")}`);
             return void 0;
           }
           const isRestoreKeyMatch = request3.key !== response.matchedKey;
           if (isRestoreKeyMatch) {
-            core31.info(`Cache hit for restore-key: ${response.matchedKey}`);
+            core30.info(`Cache hit for restore-key: ${response.matchedKey}`);
           } else {
-            core31.info(`Cache hit for: ${response.matchedKey}`);
+            core30.info(`Cache hit for: ${response.matchedKey}`);
           }
           if (options === null || options === void 0 ? void 0 : options.lookupOnly) {
-            core31.info("Lookup only - skipping download");
+            core30.info("Lookup only - skipping download");
             return response.matchedKey;
           }
           archivePath = path28.join(yield utils.createTempDirectory(), utils.getCacheFileName(compressionMethod));
-          core31.debug(`Archive path: ${archivePath}`);
-          core31.debug(`Starting download of archive to: ${archivePath}`);
+          core30.debug(`Archive path: ${archivePath}`);
+          core30.debug(`Starting download of archive to: ${archivePath}`);
           yield cacheHttpClient.downloadCache(response.signedDownloadUrl, archivePath, options);
           const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath);
-          core31.info(`Cache Size: ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B)`);
-          if (core31.isDebug()) {
+          core30.info(`Cache Size: ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B)`);
+          if (core30.isDebug()) {
             yield (0, tar_1.listTar)(archivePath, compressionMethod);
           }
           yield (0, tar_1.extractTar)(archivePath, compressionMethod);
-          core31.info("Cache restored successfully");
+          core30.info("Cache restored successfully");
           return response.matchedKey;
         } catch (error3) {
           const typedError = error3;
@@ -81339,9 +81339,9 @@ var require_cache4 = __commonJS({
             throw error3;
           } else {
             if (typedError instanceof http_client_1.HttpClientError && typeof typedError.statusCode === "number" && typedError.statusCode >= 500) {
-              core31.error(`Failed to restore: ${error3.message}`);
+              core30.error(`Failed to restore: ${error3.message}`);
             } else {
-              core31.warning(`Failed to restore: ${error3.message}`);
+              core30.warning(`Failed to restore: ${error3.message}`);
             }
           }
         } finally {
@@ -81350,7 +81350,7 @@ var require_cache4 = __commonJS({
               yield utils.unlinkFile(archivePath);
             }
           } catch (error3) {
-            core31.debug(`Failed to delete archive: ${error3}`);
+            core30.debug(`Failed to delete archive: ${error3}`);
           }
         }
         return void 0;
@@ -81359,7 +81359,7 @@ var require_cache4 = __commonJS({
     function saveCache5(paths_1, key_1, options_1) {
       return __awaiter2(this, arguments, void 0, function* (paths, key, options, enableCrossOsArchive = false) {
         const cacheServiceVersion = (0, config_1.getCacheServiceVersion)();
-        core31.debug(`Cache service version: ${cacheServiceVersion}`);
+        core30.debug(`Cache service version: ${cacheServiceVersion}`);
         checkPaths(paths);
         checkKey(key);
         switch (cacheServiceVersion) {
@@ -81377,26 +81377,26 @@ var require_cache4 = __commonJS({
         const compressionMethod = yield utils.getCompressionMethod();
         let cacheId = -1;
         const cachePaths = yield utils.resolvePaths(paths);
-        core31.debug("Cache Paths:");
-        core31.debug(`${JSON.stringify(cachePaths)}`);
+        core30.debug("Cache Paths:");
+        core30.debug(`${JSON.stringify(cachePaths)}`);
         if (cachePaths.length === 0) {
           throw new Error(`Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`);
         }
         const archiveFolder = yield utils.createTempDirectory();
         const archivePath = path28.join(archiveFolder, utils.getCacheFileName(compressionMethod));
-        core31.debug(`Archive Path: ${archivePath}`);
+        core30.debug(`Archive Path: ${archivePath}`);
         try {
           yield (0, tar_1.createTar)(archiveFolder, cachePaths, compressionMethod);
-          if (core31.isDebug()) {
+          if (core30.isDebug()) {
             yield (0, tar_1.listTar)(archivePath, compressionMethod);
           }
           const fileSizeLimit = 10 * 1024 * 1024 * 1024;
           const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath);
-          core31.debug(`File Size: ${archiveFileSize}`);
+          core30.debug(`File Size: ${archiveFileSize}`);
           if (archiveFileSize > fileSizeLimit && !(0, config_1.isGhes)()) {
             throw new Error(`Cache size of ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B) is over the 10GB limit, not saving cache.`);
           }
-          core31.debug("Reserving Cache");
+          core30.debug("Reserving Cache");
           const reserveCacheResponse = yield cacheHttpClient.reserveCache(key, paths, {
             compressionMethod,
             enableCrossOsArchive,
@@ -81409,26 +81409,26 @@ var require_cache4 = __commonJS({
           } else {
             throw new ReserveCacheError2(`Unable to reserve cache with key ${key}, another job may be creating this cache. More details: ${(_e = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.error) === null || _e === void 0 ? void 0 : _e.message}`);
           }
-          core31.debug(`Saving Cache (ID: ${cacheId})`);
+          core30.debug(`Saving Cache (ID: ${cacheId})`);
           yield cacheHttpClient.saveCache(cacheId, archivePath, "", options);
         } catch (error3) {
           const typedError = error3;
           if (typedError.name === ValidationError.name) {
             throw error3;
           } else if (typedError.name === ReserveCacheError2.name) {
-            core31.info(`Failed to save: ${typedError.message}`);
+            core30.info(`Failed to save: ${typedError.message}`);
           } else {
             if (typedError instanceof http_client_1.HttpClientError && typeof typedError.statusCode === "number" && typedError.statusCode >= 500) {
-              core31.error(`Failed to save: ${typedError.message}`);
+              core30.error(`Failed to save: ${typedError.message}`);
             } else {
-              core31.warning(`Failed to save: ${typedError.message}`);
+              core30.warning(`Failed to save: ${typedError.message}`);
             }
           }
         } finally {
           try {
             yield utils.unlinkFile(archivePath);
           } catch (error3) {
-            core31.debug(`Failed to delete archive: ${error3}`);
+            core30.debug(`Failed to delete archive: ${error3}`);
           }
         }
         return cacheId;
@@ -81441,23 +81441,23 @@ var require_cache4 = __commonJS({
         const twirpClient = cacheTwirpClient.internalCacheTwirpClient();
         let cacheId = -1;
         const cachePaths = yield utils.resolvePaths(paths);
-        core31.debug("Cache Paths:");
-        core31.debug(`${JSON.stringify(cachePaths)}`);
+        core30.debug("Cache Paths:");
+        core30.debug(`${JSON.stringify(cachePaths)}`);
         if (cachePaths.length === 0) {
           throw new Error(`Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`);
         }
         const archiveFolder = yield utils.createTempDirectory();
         const archivePath = path28.join(archiveFolder, utils.getCacheFileName(compressionMethod));
-        core31.debug(`Archive Path: ${archivePath}`);
+        core30.debug(`Archive Path: ${archivePath}`);
         try {
           yield (0, tar_1.createTar)(archiveFolder, cachePaths, compressionMethod);
-          if (core31.isDebug()) {
+          if (core30.isDebug()) {
             yield (0, tar_1.listTar)(archivePath, compressionMethod);
           }
           const archiveFileSize = utils.getArchiveFileSizeInBytes(archivePath);
-          core31.debug(`File Size: ${archiveFileSize}`);
+          core30.debug(`File Size: ${archiveFileSize}`);
           options.archiveSizeBytes = archiveFileSize;
-          core31.debug("Reserving Cache");
+          core30.debug("Reserving Cache");
           const version = utils.getCacheVersion(paths, compressionMethod, enableCrossOsArchive);
           const request3 = {
             key,
@@ -81468,16 +81468,16 @@ var require_cache4 = __commonJS({
             const response = yield twirpClient.CreateCacheEntry(request3);
             if (!response.ok) {
               if (response.message) {
-                core31.warning(`Cache reservation failed: ${response.message}`);
+                core30.warning(`Cache reservation failed: ${response.message}`);
               }
               throw new Error(response.message || "Response was not ok");
             }
             signedUploadUrl = response.signedUploadUrl;
           } catch (error3) {
-            core31.debug(`Failed to reserve cache: ${error3}`);
+            core30.debug(`Failed to reserve cache: ${error3}`);
             throw new ReserveCacheError2(`Unable to reserve cache with key ${key}, another job may be creating this cache.`);
           }
-          core31.debug(`Attempting to upload cache located at: ${archivePath}`);
+          core30.debug(`Attempting to upload cache located at: ${archivePath}`);
           yield cacheHttpClient.saveCache(cacheId, archivePath, signedUploadUrl, options);
           const finalizeRequest = {
             key,
@@ -81485,7 +81485,7 @@ var require_cache4 = __commonJS({
             sizeBytes: `${archiveFileSize}`
           };
           const finalizeResponse = yield twirpClient.FinalizeCacheEntryUpload(finalizeRequest);
-          core31.debug(`FinalizeCacheEntryUploadResponse: ${finalizeResponse.ok}`);
+          core30.debug(`FinalizeCacheEntryUploadResponse: ${finalizeResponse.ok}`);
           if (!finalizeResponse.ok) {
             if (finalizeResponse.message) {
               throw new FinalizeCacheError(finalizeResponse.message);
@@ -81498,21 +81498,21 @@ var require_cache4 = __commonJS({
           if (typedError.name === ValidationError.name) {
             throw error3;
           } else if (typedError.name === ReserveCacheError2.name) {
-            core31.info(`Failed to save: ${typedError.message}`);
+            core30.info(`Failed to save: ${typedError.message}`);
           } else if (typedError.name === FinalizeCacheError.name) {
-            core31.warning(typedError.message);
+            core30.warning(typedError.message);
           } else {
             if (typedError instanceof http_client_1.HttpClientError && typeof typedError.statusCode === "number" && typedError.statusCode >= 500) {
-              core31.error(`Failed to save: ${typedError.message}`);
+              core30.error(`Failed to save: ${typedError.message}`);
             } else {
-              core31.warning(`Failed to save: ${typedError.message}`);
+              core30.warning(`Failed to save: ${typedError.message}`);
             }
           }
         } finally {
           try {
             yield utils.unlinkFile(archivePath);
           } catch (error3) {
-            core31.debug(`Failed to delete archive: ${error3}`);
+            core30.debug(`Failed to delete archive: ${error3}`);
           }
         }
         return cacheId;
@@ -81739,7 +81739,7 @@ var require_retry_helper = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.RetryHelper = void 0;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var RetryHelper = class {
       constructor(maxAttempts, minSeconds, maxSeconds) {
         if (maxAttempts < 1) {
@@ -81762,10 +81762,10 @@ var require_retry_helper = __commonJS({
               if (isRetryable && !isRetryable(err)) {
                 throw err;
               }
-              core31.info(err.message);
+              core30.info(err.message);
             }
             const seconds = this.getSleepAmount();
-            core31.info(`Waiting ${seconds} seconds before trying again`);
+            core30.info(`Waiting ${seconds} seconds before trying again`);
             yield this.sleep(seconds);
             attempt++;
           }
@@ -81868,7 +81868,7 @@ var require_tool_cache = __commonJS({
     exports2.findFromManifest = findFromManifest;
     exports2.isExplicitVersion = isExplicitVersion;
     exports2.evaluateVersions = evaluateVersions;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var io9 = __importStar2(require_io());
     var crypto3 = __importStar2(require("crypto"));
     var fs30 = __importStar2(require("fs"));
@@ -81897,8 +81897,8 @@ var require_tool_cache = __commonJS({
       return __awaiter2(this, void 0, void 0, function* () {
         dest = dest || path28.join(_getTempDirectory(), crypto3.randomUUID());
         yield io9.mkdirP(path28.dirname(dest));
-        core31.debug(`Downloading ${url2}`);
-        core31.debug(`Destination ${dest}`);
+        core30.debug(`Downloading ${url2}`);
+        core30.debug(`Destination ${dest}`);
         const maxAttempts = 3;
         const minSeconds = _getGlobal("TEST_DOWNLOAD_TOOL_RETRY_MIN_SECONDS", 10);
         const maxSeconds = _getGlobal("TEST_DOWNLOAD_TOOL_RETRY_MAX_SECONDS", 20);
@@ -81924,7 +81924,7 @@ var require_tool_cache = __commonJS({
           allowRetries: false
         });
         if (auth2) {
-          core31.debug("set auth");
+          core30.debug("set auth");
           if (headers === void 0) {
             headers = {};
           }
@@ -81933,7 +81933,7 @@ var require_tool_cache = __commonJS({
         const response = yield http.get(url2, headers);
         if (response.message.statusCode !== 200) {
           const err = new HTTPError2(response.message.statusCode);
-          core31.debug(`Failed to download from "${url2}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`);
+          core30.debug(`Failed to download from "${url2}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`);
           throw err;
         }
         const pipeline = util.promisify(stream2.pipeline);
@@ -81942,16 +81942,16 @@ var require_tool_cache = __commonJS({
         let succeeded = false;
         try {
           yield pipeline(readStream, fs30.createWriteStream(dest));
-          core31.debug("download complete");
+          core30.debug("download complete");
           succeeded = true;
           return dest;
         } finally {
           if (!succeeded) {
-            core31.debug("download failed");
+            core30.debug("download failed");
             try {
               yield io9.rmRF(dest);
             } catch (err) {
-              core31.debug(`Failed to delete '${dest}'. ${err.message}`);
+              core30.debug(`Failed to delete '${dest}'. ${err.message}`);
             }
           }
         }
@@ -81966,7 +81966,7 @@ var require_tool_cache = __commonJS({
         process.chdir(dest);
         if (_7zPath) {
           try {
-            const logLevel = core31.isDebug() ? "-bb1" : "-bb0";
+            const logLevel = core30.isDebug() ? "-bb1" : "-bb0";
             const args = [
               "x",
               // eXtract files with full paths
@@ -82019,7 +82019,7 @@ var require_tool_cache = __commonJS({
           throw new Error("parameter 'file' is required");
         }
         dest = yield _createExtractFolder(dest);
-        core31.debug("Checking tar --version");
+        core30.debug("Checking tar --version");
         let versionOutput = "";
         yield (0, exec_1.exec)("tar --version", [], {
           ignoreReturnCode: true,
@@ -82029,7 +82029,7 @@ var require_tool_cache = __commonJS({
             stderr: (data) => versionOutput += data.toString()
           }
         });
-        core31.debug(versionOutput.trim());
+        core30.debug(versionOutput.trim());
         const isGnuTar = versionOutput.toUpperCase().includes("GNU TAR");
         let args;
         if (flags instanceof Array) {
@@ -82037,7 +82037,7 @@ var require_tool_cache = __commonJS({
         } else {
           args = [flags];
         }
-        if (core31.isDebug() && !flags.includes("v")) {
+        if (core30.isDebug() && !flags.includes("v")) {
           args.push("-v");
         }
         let destArg = dest;
@@ -82068,7 +82068,7 @@ var require_tool_cache = __commonJS({
           args = [flags];
         }
         args.push("-x", "-C", dest, "-f", file);
-        if (core31.isDebug()) {
+        if (core30.isDebug()) {
           args.push("-v");
         }
         const xarPath = yield io9.which("xar", true);
@@ -82111,7 +82111,7 @@ var require_tool_cache = __commonJS({
             "-Command",
             pwshCommand
           ];
-          core31.debug(`Using pwsh at path: ${pwshPath}`);
+          core30.debug(`Using pwsh at path: ${pwshPath}`);
           yield (0, exec_1.exec)(`"${pwshPath}"`, args);
         } else {
           const powershellCommand = [
@@ -82131,7 +82131,7 @@ var require_tool_cache = __commonJS({
             powershellCommand
           ];
           const powershellPath = yield io9.which("powershell", true);
-          core31.debug(`Using powershell at path: ${powershellPath}`);
+          core30.debug(`Using powershell at path: ${powershellPath}`);
           yield (0, exec_1.exec)(`"${powershellPath}"`, args);
         }
       });
@@ -82140,7 +82140,7 @@ var require_tool_cache = __commonJS({
       return __awaiter2(this, void 0, void 0, function* () {
         const unzipPath = yield io9.which("unzip", true);
         const args = [file];
-        if (!core31.isDebug()) {
+        if (!core30.isDebug()) {
           args.unshift("-q");
         }
         args.unshift("-o");
@@ -82151,8 +82151,8 @@ var require_tool_cache = __commonJS({
       return __awaiter2(this, void 0, void 0, function* () {
         version = semver11.clean(version) || version;
         arch2 = arch2 || os7.arch();
-        core31.debug(`Caching tool ${tool} ${version} ${arch2}`);
-        core31.debug(`source dir: ${sourceDir}`);
+        core30.debug(`Caching tool ${tool} ${version} ${arch2}`);
+        core30.debug(`source dir: ${sourceDir}`);
         if (!fs30.statSync(sourceDir).isDirectory()) {
           throw new Error("sourceDir is not a directory");
         }
@@ -82169,14 +82169,14 @@ var require_tool_cache = __commonJS({
       return __awaiter2(this, void 0, void 0, function* () {
         version = semver11.clean(version) || version;
         arch2 = arch2 || os7.arch();
-        core31.debug(`Caching tool ${tool} ${version} ${arch2}`);
-        core31.debug(`source file: ${sourceFile}`);
+        core30.debug(`Caching tool ${tool} ${version} ${arch2}`);
+        core30.debug(`source file: ${sourceFile}`);
         if (!fs30.statSync(sourceFile).isFile()) {
           throw new Error("sourceFile is not a file");
         }
         const destFolder = yield _createToolPath(tool, version, arch2);
         const destPath = path28.join(destFolder, targetFile);
-        core31.debug(`destination file ${destPath}`);
+        core30.debug(`destination file ${destPath}`);
         yield io9.cp(sourceFile, destPath);
         _completeToolPath(tool, version, arch2);
         return destFolder;
@@ -82199,12 +82199,12 @@ var require_tool_cache = __commonJS({
       if (versionSpec) {
         versionSpec = semver11.clean(versionSpec) || "";
         const cachePath = path28.join(_getCacheDirectory(), toolName, versionSpec, arch2);
-        core31.debug(`checking cache: ${cachePath}`);
+        core30.debug(`checking cache: ${cachePath}`);
         if (fs30.existsSync(cachePath) && fs30.existsSync(`${cachePath}.complete`)) {
-          core31.debug(`Found tool in cache ${toolName} ${versionSpec} ${arch2}`);
+          core30.debug(`Found tool in cache ${toolName} ${versionSpec} ${arch2}`);
           toolPath = cachePath;
         } else {
-          core31.debug("not found");
+          core30.debug("not found");
         }
       }
       return toolPath;
@@ -82233,7 +82233,7 @@ var require_tool_cache = __commonJS({
         const http = new httpm.HttpClient("tool-cache");
         const headers = {};
         if (auth2) {
-          core31.debug("set auth");
+          core30.debug("set auth");
           headers.authorization = auth2;
         }
         const response = yield http.getJson(treeUrl, headers);
@@ -82254,7 +82254,7 @@ var require_tool_cache = __commonJS({
           try {
             releases = JSON.parse(versionsRaw);
           } catch (_a) {
-            core31.debug("Invalid json");
+            core30.debug("Invalid json");
           }
         }
         return releases;
@@ -82278,7 +82278,7 @@ var require_tool_cache = __commonJS({
     function _createToolPath(tool, version, arch2) {
       return __awaiter2(this, void 0, void 0, function* () {
         const folderPath = path28.join(_getCacheDirectory(), tool, semver11.clean(version) || version, arch2 || "");
-        core31.debug(`destination ${folderPath}`);
+        core30.debug(`destination ${folderPath}`);
         const markerPath = `${folderPath}.complete`;
         yield io9.rmRF(folderPath);
         yield io9.rmRF(markerPath);
@@ -82290,18 +82290,18 @@ var require_tool_cache = __commonJS({
       const folderPath = path28.join(_getCacheDirectory(), tool, semver11.clean(version) || version, arch2 || "");
       const markerPath = `${folderPath}.complete`;
       fs30.writeFileSync(markerPath, "");
-      core31.debug("finished caching tool");
+      core30.debug("finished caching tool");
     }
     function isExplicitVersion(versionSpec) {
       const c = semver11.clean(versionSpec) || "";
-      core31.debug(`isExplicit: ${c}`);
+      core30.debug(`isExplicit: ${c}`);
       const valid4 = semver11.valid(c) != null;
-      core31.debug(`explicit? ${valid4}`);
+      core30.debug(`explicit? ${valid4}`);
       return valid4;
     }
     function evaluateVersions(versions, versionSpec) {
       let version = "";
-      core31.debug(`evaluating ${versions.length} versions`);
+      core30.debug(`evaluating ${versions.length} versions`);
       versions = versions.sort((a, b) => {
         if (semver11.gt(a, b)) {
           return 1;
@@ -82317,9 +82317,9 @@ var require_tool_cache = __commonJS({
         }
       }
       if (version) {
-        core31.debug(`matched: ${version}`);
+        core30.debug(`matched: ${version}`);
       } else {
-        core31.debug("match not found");
+        core30.debug("match not found");
       }
       return version;
     }
@@ -85901,7 +85901,7 @@ var require_config2 = __commonJS({
 });
 
 // node_modules/@actions/artifact/lib/generated/google/protobuf/timestamp.js
-var require_timestamp = __commonJS({
+var require_timestamp2 = __commonJS({
   "node_modules/@actions/artifact/lib/generated/google/protobuf/timestamp.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -85984,10 +85984,10 @@ var require_timestamp = __commonJS({
        * In JSON format, the `Timestamp` type is encoded as a string
        * in the RFC 3339 format.
        */
-      internalJsonRead(json2, options, target) {
-        if (typeof json2 !== "string")
-          throw new Error("Unable to parse Timestamp from JSON " + (0, runtime_5.typeofJsonValue)(json2) + ".");
-        let matches = json2.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
+      internalJsonRead(json, options, target) {
+        if (typeof json !== "string")
+          throw new Error("Unable to parse Timestamp from JSON " + (0, runtime_5.typeofJsonValue)(json) + ".");
+        let matches = json.match(/^([0-9]{4})-([0-9]{2})-([0-9]{2})T([0-9]{2}):([0-9]{2}):([0-9]{2})(?:Z|\.([0-9]{3,9})Z|([+-][0-9][0-9]:[0-9][0-9]))$/);
         if (!matches)
           throw new Error("Unable to parse Timestamp from JSON. Invalid format.");
         let ms = Date.parse(matches[1] + "-" + matches[2] + "-" + matches[3] + "T" + matches[4] + ":" + matches[5] + ":" + matches[6] + (matches[8] ? matches[8] : "Z"));
@@ -86083,10 +86083,10 @@ var require_wrappers = __commonJS({
       /**
        * Decode `DoubleValue` from JSON number.
        */
-      internalJsonRead(json2, options, target) {
+      internalJsonRead(json, options, target) {
         if (!target)
           target = this.create();
-        target.value = this.refJsonReader.scalar(json2, 1, void 0, "value");
+        target.value = this.refJsonReader.scalar(json, 1, void 0, "value");
         return target;
       }
       create(value) {
@@ -86147,10 +86147,10 @@ var require_wrappers = __commonJS({
       /**
        * Decode `FloatValue` from JSON number.
        */
-      internalJsonRead(json2, options, target) {
+      internalJsonRead(json, options, target) {
         if (!target)
           target = this.create();
-        target.value = this.refJsonReader.scalar(json2, 1, void 0, "value");
+        target.value = this.refJsonReader.scalar(json, 1, void 0, "value");
         return target;
       }
       create(value) {
@@ -86211,10 +86211,10 @@ var require_wrappers = __commonJS({
       /**
        * Decode `Int64Value` from JSON string.
        */
-      internalJsonRead(json2, options, target) {
+      internalJsonRead(json, options, target) {
         if (!target)
           target = this.create();
-        target.value = this.refJsonReader.scalar(json2, runtime_1.ScalarType.INT64, runtime_2.LongType.STRING, "value");
+        target.value = this.refJsonReader.scalar(json, runtime_1.ScalarType.INT64, runtime_2.LongType.STRING, "value");
         return target;
       }
       create(value) {
@@ -86275,10 +86275,10 @@ var require_wrappers = __commonJS({
       /**
        * Decode `UInt64Value` from JSON string.
        */
-      internalJsonRead(json2, options, target) {
+      internalJsonRead(json, options, target) {
         if (!target)
           target = this.create();
-        target.value = this.refJsonReader.scalar(json2, runtime_1.ScalarType.UINT64, runtime_2.LongType.STRING, "value");
+        target.value = this.refJsonReader.scalar(json, runtime_1.ScalarType.UINT64, runtime_2.LongType.STRING, "value");
         return target;
       }
       create(value) {
@@ -86339,10 +86339,10 @@ var require_wrappers = __commonJS({
       /**
        * Decode `Int32Value` from JSON string.
        */
-      internalJsonRead(json2, options, target) {
+      internalJsonRead(json, options, target) {
         if (!target)
           target = this.create();
-        target.value = this.refJsonReader.scalar(json2, 5, void 0, "value");
+        target.value = this.refJsonReader.scalar(json, 5, void 0, "value");
         return target;
       }
       create(value) {
@@ -86403,10 +86403,10 @@ var require_wrappers = __commonJS({
       /**
        * Decode `UInt32Value` from JSON string.
        */
-      internalJsonRead(json2, options, target) {
+      internalJsonRead(json, options, target) {
         if (!target)
           target = this.create();
-        target.value = this.refJsonReader.scalar(json2, 13, void 0, "value");
+        target.value = this.refJsonReader.scalar(json, 13, void 0, "value");
         return target;
       }
       create(value) {
@@ -86467,10 +86467,10 @@ var require_wrappers = __commonJS({
       /**
        * Decode `BoolValue` from JSON bool.
        */
-      internalJsonRead(json2, options, target) {
+      internalJsonRead(json, options, target) {
         if (!target)
           target = this.create();
-        target.value = this.refJsonReader.scalar(json2, 8, void 0, "value");
+        target.value = this.refJsonReader.scalar(json, 8, void 0, "value");
         return target;
       }
       create(value) {
@@ -86531,10 +86531,10 @@ var require_wrappers = __commonJS({
       /**
        * Decode `StringValue` from JSON string.
        */
-      internalJsonRead(json2, options, target) {
+      internalJsonRead(json, options, target) {
         if (!target)
           target = this.create();
-        target.value = this.refJsonReader.scalar(json2, 9, void 0, "value");
+        target.value = this.refJsonReader.scalar(json, 9, void 0, "value");
         return target;
       }
       create(value) {
@@ -86595,10 +86595,10 @@ var require_wrappers = __commonJS({
       /**
        * Decode `BytesValue` from JSON string.
        */
-      internalJsonRead(json2, options, target) {
+      internalJsonRead(json, options, target) {
         if (!target)
           target = this.create();
-        target.value = this.refJsonReader.scalar(json2, 12, void 0, "value");
+        target.value = this.refJsonReader.scalar(json, 12, void 0, "value");
         return target;
       }
       create(value) {
@@ -86655,7 +86655,7 @@ var require_artifact = __commonJS({
     var runtime_5 = require_commonjs16();
     var wrappers_1 = require_wrappers();
     var wrappers_2 = require_wrappers();
-    var timestamp_1 = require_timestamp();
+    var timestamp_1 = require_timestamp2();
     var MigrateArtifactRequest$Type = class extends runtime_5.MessageType {
       constructor() {
         super("github.actions.results.api.v1.MigrateArtifactRequest", [
@@ -87871,7 +87871,7 @@ var require_generated = __commonJS({
       for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding2(exports3, m, p);
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    __exportStar2(require_timestamp(), exports2);
+    __exportStar2(require_timestamp2(), exports2);
     __exportStar2(require_wrappers(), exports2);
     __exportStar2(require_artifact(), exports2);
     __exportStar2(require_artifact_twirp_client(), exports2);
@@ -87912,14 +87912,14 @@ var require_retention = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getExpiration = void 0;
     var generated_1 = require_generated();
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     function getExpiration(retentionDays) {
       if (!retentionDays) {
         return void 0;
       }
       const maxRetentionDays = getRetentionDays();
       if (maxRetentionDays && maxRetentionDays < retentionDays) {
-        core31.warning(`Retention days cannot be greater than the maximum allowed retention set within the repository. Using ${maxRetentionDays} instead.`);
+        core30.warning(`Retention days cannot be greater than the maximum allowed retention set within the repository. Using ${maxRetentionDays} instead.`);
         retentionDays = maxRetentionDays;
       }
       const expirationDate = /* @__PURE__ */ new Date();
@@ -88257,7 +88257,7 @@ var require_util11 = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.maskSecretUrls = exports2.maskSigUrl = exports2.getBackendIdsFromToken = void 0;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var config_1 = require_config2();
     var jwt_decode_1 = __importDefault2(require_jwt_decode_cjs());
     var core_1 = require_core();
@@ -88284,8 +88284,8 @@ var require_util11 = __commonJS({
           workflowRunBackendId: scopeParts[1],
           workflowJobRunBackendId: scopeParts[2]
         };
-        core31.debug(`Workflow Run Backend ID: ${ids.workflowRunBackendId}`);
-        core31.debug(`Workflow Job Run Backend ID: ${ids.workflowJobRunBackendId}`);
+        core30.debug(`Workflow Run Backend ID: ${ids.workflowRunBackendId}`);
+        core30.debug(`Workflow Job Run Backend ID: ${ids.workflowJobRunBackendId}`);
         return ids;
       }
       throw InvalidJwtError;
@@ -88645,7 +88645,7 @@ var require_blob_upload = __commonJS({
     exports2.uploadZipToBlobStorage = void 0;
     var storage_blob_1 = require_commonjs15();
     var config_1 = require_config2();
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var crypto3 = __importStar2(require("crypto"));
     var stream2 = __importStar2(require("stream"));
     var errors_1 = require_errors3();
@@ -88671,9 +88671,9 @@ var require_blob_upload = __commonJS({
         const bufferSize = (0, config_1.getUploadChunkSize)();
         const blobClient = new storage_blob_1.BlobClient(authenticatedUploadURL);
         const blockBlobClient = blobClient.getBlockBlobClient();
-        core31.debug(`Uploading artifact zip to blob storage with maxConcurrency: ${maxConcurrency}, bufferSize: ${bufferSize}`);
+        core30.debug(`Uploading artifact zip to blob storage with maxConcurrency: ${maxConcurrency}, bufferSize: ${bufferSize}`);
         const uploadCallback = (progress) => {
-          core31.info(`Uploaded bytes ${progress.loadedBytes}`);
+          core30.info(`Uploaded bytes ${progress.loadedBytes}`);
           uploadByteCount = progress.loadedBytes;
           lastProgressTime = Date.now();
         };
@@ -88687,7 +88687,7 @@ var require_blob_upload = __commonJS({
         const hashStream = crypto3.createHash("sha256");
         zipUploadStream.pipe(uploadStream);
         zipUploadStream.pipe(hashStream).setEncoding("hex");
-        core31.info("Beginning upload of artifact content to blob storage");
+        core30.info("Beginning upload of artifact content to blob storage");
         try {
           yield Promise.race([
             blockBlobClient.uploadStream(uploadStream, bufferSize, maxConcurrency, options),
@@ -88701,12 +88701,12 @@ var require_blob_upload = __commonJS({
         } finally {
           abortController.abort();
         }
-        core31.info("Finished uploading artifact content to blob storage!");
+        core30.info("Finished uploading artifact content to blob storage!");
         hashStream.end();
         sha256Hash = hashStream.read();
-        core31.info(`SHA256 digest of uploaded artifact zip is ${sha256Hash}`);
+        core30.info(`SHA256 digest of uploaded artifact zip is ${sha256Hash}`);
         if (uploadByteCount === 0) {
-          core31.warning(`No data was uploaded to blob storage. Reported upload byte count is 0.`);
+          core30.warning(`No data was uploaded to blob storage. Reported upload byte count is 0.`);
         }
         return {
           uploadSize: uploadByteCount,
@@ -88736,22 +88736,22 @@ var require_brace_expansion2 = __commonJS({
     var escClose = "\0CLOSE" + Math.random() + "\0";
     var escComma = "\0COMMA" + Math.random() + "\0";
     var escPeriod = "\0PERIOD" + Math.random() + "\0";
-    function numeric(str2) {
-      return parseInt(str2, 10) == str2 ? parseInt(str2, 10) : str2.charCodeAt(0);
+    function numeric(str) {
+      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
     }
-    function escapeBraces(str2) {
-      return str2.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+    function escapeBraces(str) {
+      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
     }
-    function unescapeBraces(str2) {
-      return str2.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+    function unescapeBraces(str) {
+      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
     }
-    function parseCommaParts(str2) {
-      if (!str2)
+    function parseCommaParts(str) {
+      if (!str)
         return [""];
       var parts = [];
-      var m = balanced("{", "}", str2);
+      var m = balanced("{", "}", str);
       if (!m)
-        return str2.split(",");
+        return str.split(",");
       var pre = m.pre;
       var body = m.body;
       var post = m.post;
@@ -88765,18 +88765,18 @@ var require_brace_expansion2 = __commonJS({
       parts.push.apply(parts, p);
       return parts;
     }
-    function expandTop(str2, options) {
-      if (!str2)
+    function expandTop(str, options) {
+      if (!str)
         return [];
       options = options || {};
       var max = options.max == null ? Infinity : options.max;
-      if (str2.substr(0, 2) === "{}") {
-        str2 = "\\{\\}" + str2.substr(2);
+      if (str.substr(0, 2) === "{}") {
+        str = "\\{\\}" + str.substr(2);
       }
-      return expand2(escapeBraces(str2), max, true).map(unescapeBraces);
+      return expand2(escapeBraces(str), max, true).map(unescapeBraces);
     }
-    function embrace(str2) {
-      return "{" + str2 + "}";
+    function embrace(str) {
+      return "{" + str + "}";
     }
     function isPadded(el) {
       return /^-?0\d/.test(el);
@@ -88787,10 +88787,10 @@ var require_brace_expansion2 = __commonJS({
     function gte6(i, y) {
       return i >= y;
     }
-    function expand2(str2, max, isTop) {
+    function expand2(str, max, isTop) {
       var expansions = [];
-      var m = balanced("{", "}", str2);
-      if (!m) return [str2];
+      var m = balanced("{", "}", str);
+      if (!m) return [str];
       var pre = m.pre;
       var post = m.post.length ? expand2(m.post, max, false) : [""];
       if (/\$$/.test(m.pre)) {
@@ -88805,10 +88805,10 @@ var require_brace_expansion2 = __commonJS({
         var isOptions = m.body.indexOf(",") >= 0;
         if (!isSequence && !isOptions) {
           if (m.post.match(/,(?!,).*\}/)) {
-            str2 = m.pre + "{" + m.body + escClose + m.post;
-            return expand2(str2, max, true);
+            str = m.pre + "{" + m.body + escClose + m.post;
+            return expand2(str, max, true);
           }
-          return [str2];
+          return [str];
         }
         var n;
         if (isSequence) {
@@ -88905,9 +88905,9 @@ var require_minimatch2 = __commonJS({
     var star = qmark + "*?";
     var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
     var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
-    var charSet = (s) => s.split("").reduce((set2, c) => {
-      set2[c] = true;
-      return set2;
+    var charSet = (s) => s.split("").reduce((set, c) => {
+      set[c] = true;
+      return set;
     }, {});
     var reSpecials = charSet("().*{}+?[]^$\\!");
     var addPatternStartSet = charSet("[.(");
@@ -89002,16 +89002,16 @@ var require_minimatch2 = __commonJS({
           return;
         }
         this.parseNegate();
-        let set2 = this.globSet = this.braceExpand();
+        let set = this.globSet = this.braceExpand();
         if (options.debug) this.debug = (...args) => console.error(...args);
-        this.debug(this.pattern, set2);
-        set2 = this.globParts = set2.map((s) => s.split(slashSplit));
-        this.debug(this.pattern, set2);
-        set2 = set2.map((s, si, set3) => s.map(this.parse, this));
-        this.debug(this.pattern, set2);
-        set2 = set2.filter((s) => s.indexOf(false) === -1);
-        this.debug(this.pattern, set2);
-        this.set = set2;
+        this.debug(this.pattern, set);
+        set = this.globParts = set.map((s) => s.split(slashSplit));
+        this.debug(this.pattern, set);
+        set = set.map((s, si, set2) => s.map(this.parse, this));
+        this.debug(this.pattern, set);
+        set = set.filter((s) => s.indexOf(false) === -1);
+        this.debug(this.pattern, set);
+        this.set = set;
       }
       parseNegate() {
         if (this.options.nonegate) return;
@@ -89445,22 +89445,22 @@ var require_minimatch2 = __commonJS({
       }
       makeRe() {
         if (this.regexp || this.regexp === false) return this.regexp;
-        const set2 = this.set;
-        if (!set2.length) {
+        const set = this.set;
+        if (!set.length) {
           this.regexp = false;
           return this.regexp;
         }
         const options = this.options;
         const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
         const flags = options.nocase ? "i" : "";
-        let re = set2.map((pattern) => {
+        let re = set.map((pattern) => {
           pattern = pattern.map(
             (p) => typeof p === "string" ? regExpEscape(p) : p === GLOBSTAR ? GLOBSTAR : p._src
-          ).reduce((set3, p) => {
-            if (!(set3[set3.length - 1] === GLOBSTAR && p === GLOBSTAR)) {
-              set3.push(p);
+          ).reduce((set2, p) => {
+            if (!(set2[set2.length - 1] === GLOBSTAR && p === GLOBSTAR)) {
+              set2.push(p);
             }
-            return set3;
+            return set2;
           }, []);
           pattern.forEach((p, i) => {
             if (p !== GLOBSTAR || pattern[i - 1] === GLOBSTAR) {
@@ -89501,15 +89501,15 @@ var require_minimatch2 = __commonJS({
         }
         f = f.split(slashSplit);
         this.debug(this.pattern, "split", f);
-        const set2 = this.set;
-        this.debug(this.pattern, "set", set2);
+        const set = this.set;
+        this.debug(this.pattern, "set", set);
         let filename;
         for (let i = f.length - 1; i >= 0; i--) {
           filename = f[i];
           if (filename) break;
         }
-        for (let i = 0; i < set2.length; i++) {
-          const pattern = set2[i];
+        for (let i = 0; i < set.length; i++) {
+          const pattern = set[i];
           let file = f;
           if (options.matchBase && pattern.length === 1) {
             file = [filename];
@@ -90080,10 +90080,10 @@ var require_async = __commonJS({
         return eachOfImplementation(coll, wrapAsync(iteratee), callback);
       }
       var eachOf$1 = awaitify(eachOf, 3);
-      function map2(coll, iteratee, callback) {
+      function map(coll, iteratee, callback) {
         return _asyncMap(eachOf$1, coll, iteratee, callback);
       }
-      var map$1 = awaitify(map2, 3);
+      var map$1 = awaitify(map, 3);
       var applyEach = applyEach$1(map$1);
       function eachOfSeries(coll, iteratee, callback) {
         return eachOfLimit$1(coll, 1, iteratee, callback);
@@ -90642,7 +90642,7 @@ var require_async = __commonJS({
         }, (err) => callback(err, memo));
       }
       var reduce$1 = awaitify(reduce, 4);
-      function seq2(...functions) {
+      function seq(...functions) {
         var _functions = functions.map(wrapAsync);
         return function(...args) {
           var that = this;
@@ -90666,7 +90666,7 @@ var require_async = __commonJS({
         };
       }
       function compose(...args) {
-        return seq2(...args.reverse());
+        return seq(...args.reverse());
       }
       function mapLimit(coll, limit, iteratee, callback) {
         return _asyncMap(eachOfLimit$2(limit), coll, iteratee, callback);
@@ -90726,15 +90726,15 @@ var require_async = __commonJS({
         };
       }
       function detect(coll, iteratee, callback) {
-        return _createTester((bool2) => bool2, (res, item) => item)(eachOf$1, coll, iteratee, callback);
+        return _createTester((bool) => bool, (res, item) => item)(eachOf$1, coll, iteratee, callback);
       }
       var detect$1 = awaitify(detect, 3);
       function detectLimit(coll, limit, iteratee, callback) {
-        return _createTester((bool2) => bool2, (res, item) => item)(eachOfLimit$2(limit), coll, iteratee, callback);
+        return _createTester((bool) => bool, (res, item) => item)(eachOfLimit$2(limit), coll, iteratee, callback);
       }
       var detectLimit$1 = awaitify(detectLimit, 4);
       function detectSeries(coll, iteratee, callback) {
-        return _createTester((bool2) => bool2, (res, item) => item)(eachOfLimit$2(1), coll, iteratee, callback);
+        return _createTester((bool) => bool, (res, item) => item)(eachOfLimit$2(1), coll, iteratee, callback);
       }
       var detectSeries$1 = awaitify(detectSeries, 3);
       function consoleFunc(name) {
@@ -90810,15 +90810,15 @@ var require_async = __commonJS({
         };
       }
       function every(coll, iteratee, callback) {
-        return _createTester((bool2) => !bool2, (res) => !res)(eachOf$1, coll, iteratee, callback);
+        return _createTester((bool) => !bool, (res) => !res)(eachOf$1, coll, iteratee, callback);
       }
       var every$1 = awaitify(every, 3);
       function everyLimit(coll, limit, iteratee, callback) {
-        return _createTester((bool2) => !bool2, (res) => !res)(eachOfLimit$2(limit), coll, iteratee, callback);
+        return _createTester((bool) => !bool, (res) => !res)(eachOfLimit$2(limit), coll, iteratee, callback);
       }
       var everyLimit$1 = awaitify(everyLimit, 4);
       function everySeries(coll, iteratee, callback) {
-        return _createTester((bool2) => !bool2, (res) => !res)(eachOfSeries$1, coll, iteratee, callback);
+        return _createTester((bool) => !bool, (res) => !res)(eachOfSeries$1, coll, iteratee, callback);
       }
       var everySeries$1 = awaitify(everySeries, 3);
       function filterArray(eachfn, arr, iteratee, callback) {
@@ -91458,7 +91458,7 @@ var require_async = __commonJS({
         rejectSeries: rejectSeries$1,
         retry: retry2,
         retryable,
-        seq: seq2,
+        seq,
         series,
         setImmediate: setImmediate$1,
         some: some$1,
@@ -91590,7 +91590,7 @@ var require_async = __commonJS({
       exports3.select = filter$1;
       exports3.selectLimit = filterLimit$1;
       exports3.selectSeries = filterSeries$1;
-      exports3.seq = seq2;
+      exports3.seq = seq;
       exports3.series = series;
       exports3.setImmediate = setImmediate$1;
       exports3.some = some$1;
@@ -92451,9 +92451,9 @@ var require_process_nextick_args = __commonJS({
 // node_modules/lazystream/node_modules/isarray/index.js
 var require_isarray = __commonJS({
   "node_modules/lazystream/node_modules/isarray/index.js"(exports2, module2) {
-    var toString3 = {}.toString;
+    var toString2 = {}.toString;
     module2.exports = Array.isArray || function(arr) {
-      return toString3.call(arr) == "[object Array]";
+      return toString2.call(arr) == "[object Array]";
     };
   }
 });
@@ -92532,14 +92532,14 @@ var require_util12 = __commonJS({
       return objectToString(arg) === "[object Array]";
     }
     exports2.isArray = isArray2;
-    function isBoolean2(arg) {
+    function isBoolean(arg) {
       return typeof arg === "boolean";
     }
-    exports2.isBoolean = isBoolean2;
-    function isNull2(arg) {
+    exports2.isBoolean = isBoolean;
+    function isNull(arg) {
       return arg === null;
     }
-    exports2.isNull = isNull2;
+    exports2.isNull = isNull;
     function isNullOrUndefined(arg) {
       return arg == null;
     }
@@ -92564,10 +92564,10 @@ var require_util12 = __commonJS({
       return objectToString(re) === "[object RegExp]";
     }
     exports2.isRegExp = isRegExp;
-    function isObject3(arg) {
+    function isObject2(arg) {
       return typeof arg === "object" && arg !== null;
     }
-    exports2.isObject = isObject3;
+    exports2.isObject = isObject2;
     function isDate(d) {
       return objectToString(d) === "[object Date]";
     }
@@ -93553,8 +93553,8 @@ var require_stream_readable = __commonJS({
     var Duplex;
     Readable2.ReadableState = ReadableState;
     var EE = require("events").EventEmitter;
-    var EElistenerCount = function(emitter, type2) {
-      return emitter.listeners(type2).length;
+    var EElistenerCount = function(emitter, type) {
+      return emitter.listeners(type).length;
     };
     var Stream = require_stream();
     var Buffer2 = require_safe_buffer().Buffer;
@@ -94157,19 +94157,19 @@ var require_stream_readable = __commonJS({
       var ret = p.data;
       n -= ret.length;
       while (p = p.next) {
-        var str2 = p.data;
-        var nb = n > str2.length ? str2.length : n;
-        if (nb === str2.length) ret += str2;
-        else ret += str2.slice(0, n);
+        var str = p.data;
+        var nb = n > str.length ? str.length : n;
+        if (nb === str.length) ret += str;
+        else ret += str.slice(0, n);
         n -= nb;
         if (n === 0) {
-          if (nb === str2.length) {
+          if (nb === str.length) {
             ++c;
             if (p.next) list.head = p.next;
             else list.head = list.tail = null;
           } else {
             list.head = p;
-            p.data = str2.slice(nb);
+            p.data = str.slice(nb);
           }
           break;
         }
@@ -94609,11 +94609,11 @@ var require_baseGetTag = __commonJS({
 // node_modules/lodash/isObject.js
 var require_isObject = __commonJS({
   "node_modules/lodash/isObject.js"(exports2, module2) {
-    function isObject3(value) {
-      var type2 = typeof value;
-      return value != null && (type2 == "object" || type2 == "function");
+    function isObject2(value) {
+      var type = typeof value;
+      return value != null && (type == "object" || type == "function");
     }
-    module2.exports = isObject3;
+    module2.exports = isObject2;
   }
 });
 
@@ -94621,13 +94621,13 @@ var require_isObject = __commonJS({
 var require_isFunction = __commonJS({
   "node_modules/lodash/isFunction.js"(exports2, module2) {
     var baseGetTag = require_baseGetTag();
-    var isObject3 = require_isObject();
+    var isObject2 = require_isObject();
     var asyncTag = "[object AsyncFunction]";
     var funcTag = "[object Function]";
     var genTag = "[object GeneratorFunction]";
     var proxyTag = "[object Proxy]";
     function isFunction(value) {
-      if (!isObject3(value)) {
+      if (!isObject2(value)) {
         return false;
       }
       var tag = baseGetTag(value);
@@ -94688,7 +94688,7 @@ var require_baseIsNative = __commonJS({
   "node_modules/lodash/_baseIsNative.js"(exports2, module2) {
     var isFunction = require_isFunction();
     var isMasked = require_isMasked();
-    var isObject3 = require_isObject();
+    var isObject2 = require_isObject();
     var toSource = require_toSource();
     var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
     var reIsHostCtor = /^\[object .+?Constructor\]$/;
@@ -94700,7 +94700,7 @@ var require_baseIsNative = __commonJS({
       "^" + funcToString.call(hasOwnProperty).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
     );
     function baseIsNative(value) {
-      if (!isObject3(value) || isMasked(value)) {
+      if (!isObject2(value) || isMasked(value)) {
         return false;
       }
       var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
@@ -94854,9 +94854,9 @@ var require_isIndex = __commonJS({
     var MAX_SAFE_INTEGER = 9007199254740991;
     var reIsUint = /^(?:0|[1-9]\d*)$/;
     function isIndex(value, length) {
-      var type2 = typeof value;
+      var type = typeof value;
       length = length == null ? MAX_SAFE_INTEGER : length;
-      return !!length && (type2 == "number" || type2 != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+      return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
     }
     module2.exports = isIndex;
   }
@@ -94868,13 +94868,13 @@ var require_isIterateeCall = __commonJS({
     var eq = require_eq2();
     var isArrayLike = require_isArrayLike();
     var isIndex = require_isIndex();
-    var isObject3 = require_isObject();
+    var isObject2 = require_isObject();
     function isIterateeCall(value, index, object) {
-      if (!isObject3(object)) {
+      if (!isObject2(object)) {
         return false;
       }
-      var type2 = typeof index;
-      if (type2 == "number" ? isArrayLike(object) && isIndex(index, object.length) : type2 == "string" && index in object) {
+      var type = typeof index;
+      if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
         return eq(object[index], value);
       }
       return false;
@@ -95032,9 +95032,9 @@ var require_nodeUtil = __commonJS({
     var freeProcess = moduleExports && freeGlobal.process;
     var nodeUtil = (function() {
       try {
-        var types = freeModule && freeModule.require && freeModule.require("util").types;
-        if (types) {
-          return types;
+        var types2 = freeModule && freeModule.require && freeModule.require("util").types;
+        if (types2) {
+          return types2;
         }
         return freeProcess && freeProcess.binding && freeProcess.binding("util");
       } catch (e) {
@@ -95115,13 +95115,13 @@ var require_nativeKeysIn = __commonJS({
 // node_modules/lodash/_baseKeysIn.js
 var require_baseKeysIn = __commonJS({
   "node_modules/lodash/_baseKeysIn.js"(exports2, module2) {
-    var isObject3 = require_isObject();
+    var isObject2 = require_isObject();
     var isPrototype = require_isPrototype();
     var nativeKeysIn = require_nativeKeysIn();
     var objectProto = Object.prototype;
     var hasOwnProperty = objectProto.hasOwnProperty;
     function baseKeysIn(object) {
-      if (!isObject3(object)) {
+      if (!isObject2(object)) {
         return nativeKeysIn(object);
       }
       var isProto = isPrototype(object), result = [];
@@ -95613,7 +95613,7 @@ var require_event_target_shim = __commonJS({
     var CAPTURE = 1;
     var BUBBLE = 2;
     var ATTRIBUTE = 3;
-    function isObject3(x) {
+    function isObject2(x) {
       return x !== null && typeof x === "object";
     }
     function getListeners(eventTarget) {
@@ -95639,7 +95639,7 @@ var require_event_target_shim = __commonJS({
           return null;
         },
         set(listener) {
-          if (typeof listener !== "function" && !isObject3(listener)) {
+          if (typeof listener !== "function" && !isObject2(listener)) {
             listener = null;
           }
           const listeners = getListeners(this);
@@ -95710,11 +95710,11 @@ var require_event_target_shim = __commonJS({
         return defineCustomEventTarget(arguments[0]);
       }
       if (arguments.length > 0) {
-        const types = new Array(arguments.length);
+        const types2 = new Array(arguments.length);
         for (let i = 0; i < arguments.length; ++i) {
-          types[i] = arguments[i];
+          types2[i] = arguments[i];
         }
-        return defineCustomEventTarget(types);
+        return defineCustomEventTarget(types2);
       }
       throw new TypeError("Cannot call a class as a function");
     }
@@ -95730,11 +95730,11 @@ var require_event_target_shim = __commonJS({
         if (listener == null) {
           return;
         }
-        if (typeof listener !== "function" && !isObject3(listener)) {
+        if (typeof listener !== "function" && !isObject2(listener)) {
           throw new TypeError("'listener' should be a function or an object.");
         }
         const listeners = getListeners(this);
-        const optionsIsObj = isObject3(options);
+        const optionsIsObj = isObject2(options);
         const capture = optionsIsObj ? Boolean(options.capture) : Boolean(options);
         const listenerType = capture ? CAPTURE : BUBBLE;
         const newNode = {
@@ -95771,7 +95771,7 @@ var require_event_target_shim = __commonJS({
           return;
         }
         const listeners = getListeners(this);
-        const capture = isObject3(options) ? Boolean(options.capture) : Boolean(options);
+        const capture = isObject2(options) ? Boolean(options.capture) : Boolean(options);
         const listenerType = capture ? CAPTURE : BUBBLE;
         let prev = null;
         let node = listeners.get(eventName);
@@ -96038,13 +96038,13 @@ var require_util13 = __commonJS({
         };
       },
       format(format, ...args) {
-        return format.replace(/%([sdifj])/g, function(...[_unused, type2]) {
+        return format.replace(/%([sdifj])/g, function(...[_unused, type]) {
           const replacement = args.shift();
-          if (type2 === "f") {
+          if (type === "f") {
             return replacement.toFixed(6);
-          } else if (type2 === "j") {
+          } else if (type === "j") {
             return JSON.stringify(replacement);
-          } else if (type2 === "s" && typeof replacement === "object") {
+          } else if (type === "s" && typeof replacement === "object") {
             const ctor = replacement.constructor !== Object ? replacement.constructor.name : "";
             return `${ctor} {}`.trim();
           } else {
@@ -96277,13 +96277,13 @@ var require_errors4 = __commonJS({
           msg += `"${name}" ${name.includes(".") ? "property" : "argument"} `;
         }
         msg += "must be ";
-        const types = [];
+        const types2 = [];
         const instances = [];
         const other = [];
         for (const value of expected) {
           assert(typeof value === "string", "All expected entries have to be of type string");
           if (kTypes.includes(value)) {
-            types.push(value.toLowerCase());
+            types2.push(value.toLowerCase());
           } else if (classRegExp.test(value)) {
             instances.push(value);
           } else {
@@ -96292,23 +96292,23 @@ var require_errors4 = __commonJS({
           }
         }
         if (instances.length > 0) {
-          const pos = types.indexOf("object");
+          const pos = types2.indexOf("object");
           if (pos !== -1) {
-            types.splice(types, pos, 1);
+            types2.splice(types2, pos, 1);
             instances.push("Object");
           }
         }
-        if (types.length > 0) {
-          switch (types.length) {
+        if (types2.length > 0) {
+          switch (types2.length) {
             case 1:
-              msg += `of type ${types[0]}`;
+              msg += `of type ${types2[0]}`;
               break;
             case 2:
-              msg += `one of type ${types[0]} or ${types[1]}`;
+              msg += `one of type ${types2[0]} or ${types2[1]}`;
               break;
             default: {
-              const last = types.pop();
-              msg += `one of type ${types.join(", ")}, or ${last}`;
+              const last = types2.pop();
+              msg += `one of type ${types2.join(", ")}, or ${last}`;
             }
           }
           if (instances.length > 0 || other.length > 0) {
@@ -96383,8 +96383,8 @@ var require_errors4 = __commonJS({
         if (inspected.length > 128) {
           inspected = inspected.slice(0, 128) + "...";
         }
-        const type2 = name.includes(".") ? "property" : "argument";
-        return `The ${type2} '${name}' ${reason}. Received ${inspected}`;
+        const type = name.includes(".") ? "property" : "argument";
+        return `The ${type} '${name}' ${reason}. Received ${inspected}`;
       },
       TypeError
     );
@@ -96392,8 +96392,8 @@ var require_errors4 = __commonJS({
       "ERR_INVALID_RETURN_VALUE",
       (input, name, value) => {
         var _value$constructor;
-        const type2 = value !== null && value !== void 0 && (_value$constructor = value.constructor) !== null && _value$constructor !== void 0 && _value$constructor.name ? `instance of ${value.constructor.name}` : `type ${typeof value}`;
-        return `Expected ${input} to be returned from the "${name}" function but got ${type2}.`;
+        const type = value !== null && value !== void 0 && (_value$constructor = value.constructor) !== null && _value$constructor !== void 0 && _value$constructor.name ? `instance of ${value.constructor.name}` : `type ${typeof value}`;
+        return `Expected ${input} to be returned from the "${name}" function but got ${type}.`;
       },
       TypeError
     );
@@ -96424,7 +96424,7 @@ var require_errors4 = __commonJS({
     );
     E(
       "ERR_OUT_OF_RANGE",
-      (str2, range, input) => {
+      (str, range, input) => {
         assert(range, 'Missing "range" argument');
         let received;
         if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
@@ -96438,7 +96438,7 @@ var require_errors4 = __commonJS({
         } else {
           received = inspect(input);
         }
-        return `The value of "${str2}" is out of range. It must be ${range}. Received ${received}`;
+        return `The value of "${str}" is out of range. It must be ${range}. Received ${received}`;
       },
       RangeError
     );
@@ -97677,20 +97677,20 @@ var require_buffer_list = __commonJS({
         let p = this.head;
         let c = 0;
         do {
-          const str2 = p.data;
-          if (n > str2.length) {
-            ret += str2;
-            n -= str2.length;
+          const str = p.data;
+          if (n > str.length) {
+            ret += str;
+            n -= str.length;
           } else {
-            if (n === str2.length) {
-              ret += str2;
+            if (n === str.length) {
+              ret += str;
               ++c;
               if (p.next) this.head = p.next;
               else this.head = this.tail = null;
             } else {
-              ret += StringPrototypeSlice(str2, 0, n);
+              ret += StringPrototypeSlice(str, 0, n);
               this.head = p;
-              p.data = StringPrototypeSlice(str2, n);
+              p.data = StringPrototypeSlice(str, n);
             }
             break;
           }
@@ -100717,7 +100717,7 @@ var require_operators = __commonJS({
       }
       return composedStream;
     }
-    function map2(fn, options) {
+    function map(fn, options) {
       if (typeof fn !== "function") {
         throw new ERR_INVALID_ARG_TYPE2("fn", ["Function", "AsyncFunction"], fn);
       }
@@ -100738,7 +100738,7 @@ var require_operators = __commonJS({
       validateInteger(concurrency, "options.concurrency", 1);
       validateInteger(highWaterMark, "options.highWaterMark", 0);
       highWaterMark += concurrency;
-      return async function* map3() {
+      return async function* map2() {
         const signal = require_util13().AbortSignalAny(
           [options === null || options === void 0 ? void 0 : options.signal].filter(Boolean2)
         );
@@ -100891,7 +100891,7 @@ var require_operators = __commonJS({
         await fn(value, options2);
         return kEmpty;
       }
-      for await (const unused of map2.call(this, forEachFn, options)) ;
+      for await (const unused of map.call(this, forEachFn, options)) ;
     }
     function filter(fn, options) {
       if (typeof fn !== "function") {
@@ -100903,7 +100903,7 @@ var require_operators = __commonJS({
         }
         return kEmpty;
       }
-      return map2.call(this, filterFn, options);
+      return map.call(this, filterFn, options);
     }
     var ReduceAwareErrMissingArgs = class extends ERR_MISSING_ARGS {
       constructor() {
@@ -100967,7 +100967,7 @@ var require_operators = __commonJS({
       }
       return initialValue;
     }
-    async function toArray2(options) {
+    async function toArray(options) {
       if (options != null) {
         validateObject(options, "options");
       }
@@ -100987,7 +100987,7 @@ var require_operators = __commonJS({
       return result;
     }
     function flatMap(fn, options) {
-      const values = map2.call(this, fn, options);
+      const values = map.call(this, fn, options);
       return async function* flatMap2() {
         for await (const val of values) {
           yield* val;
@@ -101060,7 +101060,7 @@ var require_operators = __commonJS({
       drop,
       filter,
       flatMap,
-      map: map2,
+      map,
       take,
       compose
     };
@@ -101068,7 +101068,7 @@ var require_operators = __commonJS({
       every,
       forEach,
       reduce,
-      toArray: toArray2,
+      toArray,
       some,
       find: find3
     };
@@ -101626,8 +101626,8 @@ var require_mapCacheClear = __commonJS({
 var require_isKeyable = __commonJS({
   "node_modules/lodash/_isKeyable.js"(exports2, module2) {
     function isKeyable(value) {
-      var type2 = typeof value;
-      return type2 == "string" || type2 == "number" || type2 == "symbol" || type2 == "boolean" ? value !== "__proto__" : value === null;
+      var type = typeof value;
+      return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
     }
     module2.exports = isKeyable;
   }
@@ -101637,8 +101637,8 @@ var require_isKeyable = __commonJS({
 var require_getMapData = __commonJS({
   "node_modules/lodash/_getMapData.js"(exports2, module2) {
     var isKeyable = require_isKeyable();
-    function getMapData(map2, key) {
-      var data = map2.__data__;
+    function getMapData(map, key) {
+      var data = map.__data__;
       return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
     }
     module2.exports = getMapData;
@@ -101963,9 +101963,9 @@ var require_noop = __commonJS({
 // node_modules/lodash/_setToArray.js
 var require_setToArray = __commonJS({
   "node_modules/lodash/_setToArray.js"(exports2, module2) {
-    function setToArray(set2) {
-      var index = -1, result = Array(set2.size);
-      set2.forEach(function(value) {
+    function setToArray(set) {
+      var index = -1, result = Array(set.size);
+      set.forEach(function(value) {
         result[++index] = value;
       });
       return result;
@@ -102004,9 +102004,9 @@ var require_baseUniq = __commonJS({
         isCommon = false;
         includes = arrayIncludesWith;
       } else if (length >= LARGE_ARRAY_SIZE) {
-        var set2 = iteratee ? null : createSet(array);
-        if (set2) {
-          return setToArray(set2);
+        var set = iteratee ? null : createSet(array);
+        if (set) {
+          return setToArray(set);
         }
         isCommon = false;
         includes = cacheHas;
@@ -102110,38 +102110,38 @@ var require_commonjs18 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.range = exports2.balanced = void 0;
-    var balanced = (a, b, str2) => {
-      const ma = a instanceof RegExp ? maybeMatch(a, str2) : a;
-      const mb = b instanceof RegExp ? maybeMatch(b, str2) : b;
-      const r = ma !== null && mb != null && (0, exports2.range)(ma, mb, str2);
+    var balanced = (a, b, str) => {
+      const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+      const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+      const r = ma !== null && mb != null && (0, exports2.range)(ma, mb, str);
       return r && {
         start: r[0],
         end: r[1],
-        pre: str2.slice(0, r[0]),
-        body: str2.slice(r[0] + ma.length, r[1]),
-        post: str2.slice(r[1] + mb.length)
+        pre: str.slice(0, r[0]),
+        body: str.slice(r[0] + ma.length, r[1]),
+        post: str.slice(r[1] + mb.length)
       };
     };
     exports2.balanced = balanced;
-    var maybeMatch = (reg, str2) => {
-      const m = str2.match(reg);
+    var maybeMatch = (reg, str) => {
+      const m = str.match(reg);
       return m ? m[0] : null;
     };
-    var range = (a, b, str2) => {
+    var range = (a, b, str) => {
       let begs, beg, left, right = void 0, result;
-      let ai = str2.indexOf(a);
-      let bi = str2.indexOf(b, ai + 1);
+      let ai = str.indexOf(a);
+      let bi = str.indexOf(b, ai + 1);
       let i = ai;
       if (ai >= 0 && bi > 0) {
         if (a === b) {
           return [ai, bi];
         }
         begs = [];
-        left = str2.length;
+        left = str.length;
         while (i >= 0 && !result) {
           if (i === ai) {
             begs.push(i);
-            ai = str2.indexOf(a, i + 1);
+            ai = str.indexOf(a, i + 1);
           } else if (begs.length === 1) {
             const r = begs.pop();
             if (r !== void 0)
@@ -102152,7 +102152,7 @@ var require_commonjs18 = __commonJS({
               left = beg;
               right = bi;
             }
-            bi = str2.indexOf(b, i + 1);
+            bi = str.indexOf(b, i + 1);
           }
           i = ai < bi && ai >= 0 ? ai : bi;
         }
@@ -102190,23 +102190,23 @@ var require_commonjs19 = __commonJS({
     var commaPattern = /\\,/g;
     var periodPattern = /\\\./g;
     exports2.EXPANSION_MAX = 1e5;
-    function numeric(str2) {
-      return !isNaN(str2) ? parseInt(str2, 10) : str2.charCodeAt(0);
+    function numeric(str) {
+      return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
     }
-    function escapeBraces(str2) {
-      return str2.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+    function escapeBraces(str) {
+      return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
     }
-    function unescapeBraces(str2) {
-      return str2.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+    function unescapeBraces(str) {
+      return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
     }
-    function parseCommaParts(str2) {
-      if (!str2) {
+    function parseCommaParts(str) {
+      if (!str) {
         return [""];
       }
       const parts = [];
-      const m = (0, balanced_match_1.balanced)("{", "}", str2);
+      const m = (0, balanced_match_1.balanced)("{", "}", str);
       if (!m) {
-        return str2.split(",");
+        return str.split(",");
       }
       const { pre, body, post } = m;
       const p = pre.split(",");
@@ -102220,18 +102220,18 @@ var require_commonjs19 = __commonJS({
       parts.push.apply(parts, p);
       return parts;
     }
-    function expand2(str2, options = {}) {
-      if (!str2) {
+    function expand2(str, options = {}) {
+      if (!str) {
         return [];
       }
       const { max = exports2.EXPANSION_MAX } = options;
-      if (str2.slice(0, 2) === "{}") {
-        str2 = "\\{\\}" + str2.slice(2);
+      if (str.slice(0, 2) === "{}") {
+        str = "\\{\\}" + str.slice(2);
       }
-      return expand_(escapeBraces(str2), max, true).map(unescapeBraces);
+      return expand_(escapeBraces(str), max, true).map(unescapeBraces);
     }
-    function embrace(str2) {
-      return "{" + str2 + "}";
+    function embrace(str) {
+      return "{" + str + "}";
     }
     function isPadded(el) {
       return /^-?0\d/.test(el);
@@ -102242,11 +102242,11 @@ var require_commonjs19 = __commonJS({
     function gte6(i, y) {
       return i >= y;
     }
-    function expand_(str2, max, isTop) {
+    function expand_(str, max, isTop) {
       const expansions = [];
-      const m = (0, balanced_match_1.balanced)("{", "}", str2);
+      const m = (0, balanced_match_1.balanced)("{", "}", str);
       if (!m)
-        return [str2];
+        return [str];
       const pre = m.pre;
       const post = m.post.length ? expand_(m.post, max, false) : [""];
       if (/\$$/.test(m.pre)) {
@@ -102261,10 +102261,10 @@ var require_commonjs19 = __commonJS({
         const isOptions = m.body.indexOf(",") >= 0;
         if (!isSequence && !isOptions) {
           if (m.post.match(/,(?!,).*\}/)) {
-            str2 = m.pre + "{" + m.body + escClose + m.post;
-            return expand_(str2, max, true);
+            str = m.pre + "{" + m.body + escClose + m.post;
+            return expand_(str, max, true);
           }
-          return [str2];
+          return [str];
         }
         let n;
         if (isSequence) {
@@ -102496,8 +102496,8 @@ var require_ast = __commonJS({
     exports2.AST = void 0;
     var brace_expressions_js_1 = require_brace_expressions();
     var unescape_js_1 = require_unescape();
-    var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
-    var isExtglobType = (c) => types.has(c);
+    var types2 = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
+    var isExtglobType = (c) => types2.has(c);
     var isExtglobAST = (c) => isExtglobType(c.type);
     var adoptionMap = /* @__PURE__ */ new Map([
       ["!", ["@"]],
@@ -102586,15 +102586,15 @@ var require_ast = __commonJS({
           parts: this.#parts
         };
       }
-      constructor(type2, parent, options = {}) {
-        this.type = type2;
-        if (type2)
+      constructor(type, parent, options = {}) {
+        this.type = type;
+        if (type)
           this.#hasMagic = true;
         this.#parent = parent;
         this.#root = this.#parent ? this.#parent.#root : this;
         this.#options = this.#root === this ? options : this.#root.#options;
         this.#negs = this.#root === this ? [] : this.#root.#negs;
-        if (type2 === "!" && !this.#root.#filledNegs)
+        if (type === "!" && !this.#root.#filledNegs)
           this.#negs.push(this);
         this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
       }
@@ -102707,7 +102707,7 @@ var require_ast = __commonJS({
         }
         return c;
       }
-      static #parseAST(str2, ast, pos, opt, extDepth) {
+      static #parseAST(str, ast, pos, opt, extDepth) {
         const maxDepth = opt.maxExtglobRecursion ?? 2;
         let escaping = false;
         let inBrace = false;
@@ -102716,8 +102716,8 @@ var require_ast = __commonJS({
         if (ast.type === null) {
           let i2 = pos;
           let acc2 = "";
-          while (i2 < str2.length) {
-            const c = str2.charAt(i2++);
+          while (i2 < str.length) {
+            const c = str.charAt(i2++);
             if (escaping || c === "\\") {
               escaping = !escaping;
               acc2 += c;
@@ -102740,12 +102740,12 @@ var require_ast = __commonJS({
               acc2 += c;
               continue;
             }
-            const doRecurse = !opt.noext && isExtglobType(c) && str2.charAt(i2) === "(" && extDepth <= maxDepth;
+            const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i2) === "(" && extDepth <= maxDepth;
             if (doRecurse) {
               ast.push(acc2);
               acc2 = "";
               const ext = new _a(c, ast);
-              i2 = _a.#parseAST(str2, ext, i2, opt, extDepth + 1);
+              i2 = _a.#parseAST(str, ext, i2, opt, extDepth + 1);
               ast.push(ext);
               continue;
             }
@@ -102758,8 +102758,8 @@ var require_ast = __commonJS({
         let part = new _a(null, ast);
         const parts = [];
         let acc = "";
-        while (i < str2.length) {
-          const c = str2.charAt(i++);
+        while (i < str.length) {
+          const c = str.charAt(i++);
           if (escaping || c === "\\") {
             escaping = !escaping;
             acc += c;
@@ -102782,7 +102782,7 @@ var require_ast = __commonJS({
             acc += c;
             continue;
           }
-          const doRecurse = !opt.noext && isExtglobType(c) && str2.charAt(i) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
+          const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
           (extDepth <= maxDepth || ast && ast.#canAdoptType(c));
           if (doRecurse) {
             const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
@@ -102790,7 +102790,7 @@ var require_ast = __commonJS({
             acc = "";
             const ext = new _a(c, part);
             part.push(ext);
-            i = _a.#parseAST(str2, ext, i, opt, extDepth + depthAdd);
+            i = _a.#parseAST(str, ext, i, opt, extDepth + depthAdd);
             continue;
           }
           if (c === "|") {
@@ -102813,13 +102813,13 @@ var require_ast = __commonJS({
         }
         ast.type = null;
         ast.#hasMagic = void 0;
-        ast.#parts = [str2.substring(pos - 1)];
+        ast.#parts = [str.substring(pos - 1)];
         return i;
       }
       #canAdoptWithSpace(child) {
         return this.#canAdopt(child, adoptionWithSpaceMap);
       }
-      #canAdopt(child, map2 = adoptionMap) {
+      #canAdopt(child, map = adoptionMap) {
         if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null) {
           return false;
         }
@@ -102827,10 +102827,10 @@ var require_ast = __commonJS({
         if (!gc || typeof gc !== "object" || gc.type === null) {
           return false;
         }
-        return this.#canAdoptType(gc.type, map2);
+        return this.#canAdoptType(gc.type, map);
       }
-      #canAdoptType(c, map2 = adoptionAnyMap) {
-        return !!map2.get(this.type)?.includes(c);
+      #canAdoptType(c, map = adoptionAnyMap) {
+        return !!map.get(this.type)?.includes(c);
       }
       #adoptWithSpace(child, index) {
         const gc = child.#parts[0];
@@ -103266,8 +103266,8 @@ var require_commonjs20 = __commonJS({
         },
         AST: class AST extends orig.AST {
           /* c8 ignore start */
-          constructor(type2, parent, options = {}) {
-            super(type2, parent, ext(def, options));
+          constructor(type, parent, options = {}) {
+            super(type, parent, ext(def, options));
           }
           /* c8 ignore stop */
           static fromGlob(pattern, options = {}) {
@@ -103391,7 +103391,7 @@ var require_commonjs20 = __commonJS({
         const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
         this.globParts = this.preprocess(rawGlobParts);
         this.debug(this.pattern, this.globParts);
-        let set2 = this.globParts.map((s, _2, __) => {
+        let set = this.globParts.map((s, _2, __) => {
           if (this.isWindows && this.windowsNoMagicRoot) {
             const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
             const isDrive = /^[a-z]:/i.test(s[0]);
@@ -103406,8 +103406,8 @@ var require_commonjs20 = __commonJS({
           }
           return s.map((ss) => this.parse(ss));
         });
-        this.debug(this.pattern, set2);
-        this.set = set2.filter((s) => s.indexOf(false) === -1);
+        this.debug(this.pattern, set);
+        this.set = set.filter((s) => s.indexOf(false) === -1);
         if (this.isWindows) {
           for (let i = 0; i < this.set.length; i++) {
             const p = this.set[i];
@@ -103463,19 +103463,19 @@ var require_commonjs20 = __commonJS({
       // get rid of adjascent ** and resolve .. portions
       levelOneOptimize(globParts) {
         return globParts.map((parts) => {
-          parts = parts.reduce((set2, part) => {
-            const prev = set2[set2.length - 1];
+          parts = parts.reduce((set, part) => {
+            const prev = set[set.length - 1];
             if (part === "**" && prev === "**") {
-              return set2;
+              return set;
             }
             if (part === "..") {
               if (prev && prev !== ".." && prev !== "." && prev !== "**") {
-                set2.pop();
-                return set2;
+                set.pop();
+                return set;
               }
             }
-            set2.push(part);
-            return set2;
+            set.push(part);
+            return set;
           }, []);
           return parts.length === 0 ? [""] : parts;
         });
@@ -103868,15 +103868,15 @@ var require_commonjs20 = __commonJS({
       makeRe() {
         if (this.regexp || this.regexp === false)
           return this.regexp;
-        const set2 = this.set;
-        if (!set2.length) {
+        const set = this.set;
+        if (!set.length) {
           this.regexp = false;
           return this.regexp;
         }
         const options = this.options;
         const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
         const flags = new Set(options.nocase ? ["i"] : []);
-        let re = set2.map((pattern) => {
+        let re = set.map((pattern) => {
           const pp = pattern.map((p) => {
             if (p instanceof RegExp) {
               for (const f of p.flags.split(""))
@@ -103913,7 +103913,7 @@ var require_commonjs20 = __commonJS({
           }
           return filtered.join("/");
         }).join("|");
-        const [open, close] = set2.length > 1 ? ["(?:", ")"] : ["", ""];
+        const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
         re = "^" + open + re + close + "$";
         if (this.partial) {
           re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
@@ -103953,16 +103953,16 @@ var require_commonjs20 = __commonJS({
         }
         const ff = this.slashSplit(f);
         this.debug(this.pattern, "split", ff);
-        const set2 = this.set;
-        this.debug(this.pattern, "set", set2);
+        const set = this.set;
+        this.debug(this.pattern, "set", set);
         let filename = ff[ff.length - 1];
         if (!filename) {
           for (let i = ff.length - 2; !filename && i >= 0; i--) {
             filename = ff[i];
           }
         }
-        for (let i = 0; i < set2.length; i++) {
-          const pattern = set2[i];
+        for (let i = 0; i < set.length; i++) {
+          const pattern = set[i];
           let file = ff;
           if (options.matchBase && pattern.length === 1) {
             file = [filename];
@@ -104013,8 +104013,8 @@ var require_commonjs21 = __commonJS({
     var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
     var warned = /* @__PURE__ */ new Set();
     var PROCESS = typeof process === "object" && !!process ? process : {};
-    var emitWarning = (msg, type2, code, fn) => {
-      typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type2, code, fn) : console.error(`[${code}] ${type2}: ${msg}`);
+    var emitWarning = (msg, type, code, fn) => {
+      typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
     };
     var AC = globalThis.AbortController;
     var AS = globalThis.AbortSignal;
@@ -106557,10 +106557,10 @@ var require_commonjs23 = __commonJS({
        *
        * @internal
        */
-      constructor(name, type2 = UNKNOWN, root, roots, nocase, children, opts) {
+      constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
         this.name = name;
         this.#matchName = nocase ? normalizeNocase(name) : normalize3(name);
-        this.#type = type2 & TYPEMASK;
+        this.#type = type & TYPEMASK;
         this.nocase = nocase;
         this.roots = roots;
         this.root = root || this;
@@ -106760,8 +106760,8 @@ var require_commonjs23 = __commonJS({
       isUnknown() {
         return (this.#type & IFMT) === UNKNOWN;
       }
-      isType(type2) {
-        return this[`is${type2}`]();
+      isType(type) {
+        return this[`is${type}`]();
       }
       getType() {
         return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : (
@@ -107023,8 +107023,8 @@ var require_commonjs23 = __commonJS({
         return this.#readdirMaybePromoteChild(e, c) || this.#readdirAddNewChild(e, c);
       }
       #readdirAddNewChild(e, c) {
-        const type2 = entToType(e);
-        const child = this.newChild(e.name, type2, { parent: this });
+        const type = entToType(e);
+        const child = this.newChild(e.name, type, { parent: this });
         const ifmt = child.#type & IFMT;
         if (ifmt !== IFDIR && ifmt !== IFLNK && ifmt !== UNKNOWN) {
           child.#type |= ENOTDIR;
@@ -107342,14 +107342,14 @@ var require_commonjs23 = __commonJS({
        *
        * @internal
        */
-      constructor(name, type2 = UNKNOWN, root, roots, nocase, children, opts) {
-        super(name, type2, root, roots, nocase, children, opts);
+      constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+        super(name, type, root, roots, nocase, children, opts);
       }
       /**
        * @internal
        */
-      newChild(name, type2 = UNKNOWN, opts = {}) {
-        return new _PathWin32(name, type2, this.root, this.roots, this.nocase, this.childrenCache(), opts);
+      newChild(name, type = UNKNOWN, opts = {}) {
+        return new _PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
       }
       /**
        * @internal
@@ -107396,8 +107396,8 @@ var require_commonjs23 = __commonJS({
        *
        * @internal
        */
-      constructor(name, type2 = UNKNOWN, root, roots, nocase, children, opts) {
-        super(name, type2, root, roots, nocase, children, opts);
+      constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
+        super(name, type, root, roots, nocase, children, opts);
       }
       /**
        * @internal
@@ -107414,8 +107414,8 @@ var require_commonjs23 = __commonJS({
       /**
        * @internal
        */
-      newChild(name, type2 = UNKNOWN, opts = {}) {
-        return new _PathPosix(name, type2, this.root, this.roots, this.nocase, this.childrenCache(), opts);
+      newChild(name, type = UNKNOWN, opts = {}) {
+        return new _PathPosix(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
       }
     };
     exports2.PathPosix = PathPosix;
@@ -109046,16 +109046,16 @@ var require_glob2 = __commonJS({
           debug: !!this.opts.debug
         };
         const mms = this.pattern.map((p) => new minimatch_1.Minimatch(p, mmo));
-        const [matchSet, globParts] = mms.reduce((set2, m) => {
-          set2[0].push(...m.set);
-          set2[1].push(...m.globParts);
-          return set2;
+        const [matchSet, globParts] = mms.reduce((set, m) => {
+          set[0].push(...m.set);
+          set[1].push(...m.globParts);
+          return set;
         }, [[], []]);
-        this.patterns = matchSet.map((set2, i) => {
+        this.patterns = matchSet.map((set, i) => {
           const g = globParts[i];
           if (!g)
             throw new Error("invalid pattern object");
-          return new pattern_js_1.Pattern(set2, g, 0, this.platform);
+          return new pattern_js_1.Pattern(set, g, 0, this.platform);
         });
       }
       async walk() {
@@ -109447,8 +109447,8 @@ var require_archiver_utils = __commonJS({
     utils.sanitizePath = function(filepath) {
       return normalizePath(filepath, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
     };
-    utils.trailingSlashIt = function(str2) {
-      return str2.slice(-1) !== "/" ? str2 + "/" : str2;
+    utils.trailingSlashIt = function(str) {
+      return str.slice(-1) !== "/" ? str + "/" : str;
     };
     utils.unixifyPath = function(filepath) {
       return normalizePath(filepath, false).replace(/^\w+:/, "");
@@ -109532,7 +109532,7 @@ var require_error3 = __commonJS({
 });
 
 // node_modules/archiver/lib/core.js
-var require_core2 = __commonJS({
+var require_core3 = __commonJS({
   "node_modules/archiver/lib/core.js"(exports2, module2) {
     var fs30 = require("fs");
     var glob2 = require_readdir_glob();
@@ -110708,10 +110708,10 @@ var require_crc32 = __commonJS({
         while (i < L) C = C >>> 8 ^ T0[(C ^ B[i++]) & 255];
         return ~C;
       }
-      function crc32_str(str2, seed) {
+      function crc32_str(str, seed) {
         var C = seed ^ -1;
-        for (var i = 0, L = str2.length, c = 0, d = 0; i < L; ) {
-          c = str2.charCodeAt(i++);
+        for (var i = 0, L = str.length, c = 0, d = 0; i < L; ) {
+          c = str.charCodeAt(i++);
           if (c < 128) {
             C = C >>> 8 ^ T0[(C ^ c) & 255];
           } else if (c < 2048) {
@@ -110719,7 +110719,7 @@ var require_crc32 = __commonJS({
             C = C >>> 8 ^ T0[(C ^ (128 | c & 63)) & 255];
           } else if (c >= 55296 && c < 57344) {
             c = (c & 1023) + 64;
-            d = str2.charCodeAt(i++) & 1023;
+            d = str.charCodeAt(i++) & 1023;
             C = C >>> 8 ^ T0[(C ^ (240 | c >> 8 & 7)) & 255];
             C = C >>> 8 ^ T0[(C ^ (128 | c >> 2 & 63)) & 255];
             C = C >>> 8 ^ T0[(C ^ (128 | d >> 6 & 15 | (c & 3) << 4)) & 255];
@@ -111436,7 +111436,7 @@ var require_b4a = __commonJS({
       if (Buffer.isBuffer(buffer)) return buffer;
       return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
     }
-    function toString3(buffer, encoding, start, end) {
+    function toString2(buffer, encoding, start, end) {
       return toBuffer(buffer).toString(encoding, start, end);
     }
     function write(buffer, string2, offset, length, encoding) {
@@ -111510,7 +111510,7 @@ var require_b4a = __commonJS({
       swap32,
       swap64,
       toBuffer,
-      toString: toString3,
+      toString: toString2,
       write,
       writeDoubleLE,
       writeFloatLE,
@@ -111794,7 +111794,7 @@ var require_streamx = __commonJS({
     var WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY;
     var asyncIterator = Symbol.asyncIterator || /* @__PURE__ */ Symbol("asyncIterator");
     var WritableState = class {
-      constructor(stream2, { highWaterMark = 16384, map: map2 = null, mapWritable, byteLength, byteLengthWritable } = {}) {
+      constructor(stream2, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {
         this.stream = stream2;
         this.queue = new FIFO();
         this.highWaterMark = highWaterMark;
@@ -111803,7 +111803,7 @@ var require_streamx = __commonJS({
         this.pipeline = null;
         this.drains = null;
         this.byteLength = byteLengthWritable || byteLength || defaultByteLength;
-        this.map = mapWritable || map2;
+        this.map = mapWritable || map;
         this.afterWrite = afterWrite.bind(this);
         this.afterUpdateNextTick = updateWriteNT.bind(this);
       }
@@ -111890,7 +111890,7 @@ var require_streamx = __commonJS({
       }
     };
     var ReadableState = class {
-      constructor(stream2, { highWaterMark = 16384, map: map2 = null, mapReadable, byteLength, byteLengthReadable } = {}) {
+      constructor(stream2, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {
         this.stream = stream2;
         this.queue = new FIFO();
         this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark;
@@ -111899,7 +111899,7 @@ var require_streamx = __commonJS({
         this.error = null;
         this.pipeline = null;
         this.byteLength = byteLengthReadable || byteLength || defaultByteLength;
-        this.map = mapReadable || map2;
+        this.map = mapReadable || map;
         this.pipeTo = null;
         this.afterRead = afterRead.bind(this);
         this.afterUpdateNextTick = updateReadNT.bind(this);
@@ -112260,12 +112260,12 @@ var require_streamx = __commonJS({
       }
       setEncoding(encoding) {
         const dec = new TextDecoder2(encoding);
-        const map2 = this._readableState.map || echo;
+        const map = this._readableState.map || echo;
         this._readableState.map = mapOrSkip;
         return this;
         function mapOrSkip(data) {
           const next = dec.push(data);
-          return next === "" && (data.byteLength !== 0 || dec.remaining > 0) ? null : map2(next);
+          return next === "" && (data.byteLength !== 0 || dec.remaining > 0) ? null : map(next);
         }
       }
       _read(cb) {
@@ -112730,7 +112730,7 @@ var require_headers2 = __commonJS({
       const gid = decodeOct(buf, 116, 8);
       const size = decodeOct(buf, 124, 12);
       const mtime = decodeOct(buf, 136, 12);
-      const type2 = toType(typeflag);
+      const type = toType(typeflag);
       const linkname = buf[157] === 0 ? null : decodeStr(buf, 157, 100, filenameEncoding);
       const uname = decodeStr(buf, 265, 32);
       const gname = decodeStr(buf, 297, 32);
@@ -112755,7 +112755,7 @@ var require_headers2 = __commonJS({
         gid,
         size,
         mtime: new Date(1e3 * mtime),
-        type: type2,
+        type,
         linkname,
         uname,
         gname,
@@ -112898,11 +112898,11 @@ var require_headers2 = __commonJS({
     function decodeStr(val, offset, length, encoding) {
       return b4a.toString(val.subarray(offset, indexOf(val, 0, offset, offset + length)), encoding);
     }
-    function addLength(str2) {
-      const len = b4a.byteLength(str2);
+    function addLength(str) {
+      const len = b4a.byteLength(str);
       let digits = Math.floor(Math.log(len) / Math.log(10)) + 1;
       if (len + digits >= Math.pow(10, digits)) digits++;
-      return len + digits + str2;
+      return len + digits + str;
     }
   }
 });
@@ -113890,7 +113890,7 @@ var require_dist5 = __commonJS({
 });
 
 // node_modules/archiver/lib/plugins/json.js
-var require_json = __commonJS({
+var require_json2 = __commonJS({
   "node_modules/archiver/lib/plugins/json.js"(exports2, module2) {
     var inherits = require("util").inherits;
     var Transform = require_ours().Transform;
@@ -113946,7 +113946,7 @@ var require_json = __commonJS({
 // node_modules/archiver/index.js
 var require_archiver = __commonJS({
   "node_modules/archiver/index.js"(exports2, module2) {
-    var Archiver = require_core2();
+    var Archiver = require_core3();
     var formats = {};
     var vending = function(format, options) {
       return vending.create(format, options);
@@ -113981,7 +113981,7 @@ var require_archiver = __commonJS({
     };
     vending.registerFormat("zip", require_zip());
     vending.registerFormat("tar", require_tar2());
-    vending.registerFormat("json", require_json());
+    vending.registerFormat("json", require_json2());
     module2.exports = vending;
   }
 });
@@ -114049,7 +114049,7 @@ var require_zip2 = __commonJS({
     var stream2 = __importStar2(require("stream"));
     var promises_1 = require("fs/promises");
     var archiver2 = __importStar2(require_archiver());
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var config_1 = require_config2();
     exports2.DEFAULT_COMPRESSION_LEVEL = 6;
     var ZipUploadStream = class extends stream2.Transform {
@@ -114066,7 +114066,7 @@ var require_zip2 = __commonJS({
     exports2.ZipUploadStream = ZipUploadStream;
     function createZipUploadStream(uploadSpecification_1) {
       return __awaiter2(this, arguments, void 0, function* (uploadSpecification, compressionLevel = exports2.DEFAULT_COMPRESSION_LEVEL) {
-        core31.debug(`Creating Artifact archive with compressionLevel: ${compressionLevel}`);
+        core30.debug(`Creating Artifact archive with compressionLevel: ${compressionLevel}`);
         const zip = archiver2.create("zip", {
           highWaterMark: (0, config_1.getUploadChunkSize)(),
           zlib: { level: compressionLevel }
@@ -114090,8 +114090,8 @@ var require_zip2 = __commonJS({
         }
         const bufferSize = (0, config_1.getUploadChunkSize)();
         const zipUploadStream = new ZipUploadStream(bufferSize);
-        core31.debug(`Zip write high watermark value ${zipUploadStream.writableHighWaterMark}`);
-        core31.debug(`Zip read high watermark value ${zipUploadStream.readableHighWaterMark}`);
+        core30.debug(`Zip write high watermark value ${zipUploadStream.writableHighWaterMark}`);
+        core30.debug(`Zip read high watermark value ${zipUploadStream.readableHighWaterMark}`);
         zip.pipe(zipUploadStream);
         zip.finalize();
         return zipUploadStream;
@@ -114099,24 +114099,24 @@ var require_zip2 = __commonJS({
     }
     exports2.createZipUploadStream = createZipUploadStream;
     var zipErrorCallback = (error3) => {
-      core31.error("An error has occurred while creating the zip file for upload");
-      core31.info(error3);
+      core30.error("An error has occurred while creating the zip file for upload");
+      core30.info(error3);
       throw new Error("An error has occurred during zip creation for the artifact");
     };
     var zipWarningCallback = (error3) => {
       if (error3.code === "ENOENT") {
-        core31.warning("ENOENT warning during artifact zip creation. No such file or directory");
-        core31.info(error3);
+        core30.warning("ENOENT warning during artifact zip creation. No such file or directory");
+        core30.info(error3);
       } else {
-        core31.warning(`A non-blocking warning has occurred during artifact zip creation: ${error3.code}`);
-        core31.info(error3);
+        core30.warning(`A non-blocking warning has occurred during artifact zip creation: ${error3.code}`);
+        core30.info(error3);
       }
     };
     var zipFinishCallback = () => {
-      core31.debug("Zip stream for upload has finished.");
+      core30.debug("Zip stream for upload has finished.");
     };
     var zipEndCallback = () => {
-      core31.debug("Zip stream for upload has ended.");
+      core30.debug("Zip stream for upload has ended.");
     };
   }
 });
@@ -114181,7 +114181,7 @@ var require_upload_artifact = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.uploadArtifact = void 0;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var retention_1 = require_retention();
     var path_and_artifact_name_validation_1 = require_path_and_artifact_name_validation();
     var artifact_twirp_client_1 = require_artifact_twirp_client2();
@@ -114228,13 +114228,13 @@ var require_upload_artifact = __commonJS({
             value: `sha256:${uploadResult.sha256Hash}`
           });
         }
-        core31.info(`Finalizing artifact upload`);
+        core30.info(`Finalizing artifact upload`);
         const finalizeArtifactResp = yield artifactClient.FinalizeArtifact(finalizeArtifactReq);
         if (!finalizeArtifactResp.ok) {
           throw new errors_1.InvalidResponseError("FinalizeArtifact: response from backend was not ok");
         }
         const artifactId = BigInt(finalizeArtifactResp.artifactId);
-        core31.info(`Artifact ${name}.zip successfully finalized. Artifact ID ${artifactId}`);
+        core30.info(`Artifact ${name}.zip successfully finalized. Artifact ID ${artifactId}`);
         return {
           size: uploadResult.uploadSize,
           digest: uploadResult.sha256Hash,
@@ -114864,12 +114864,12 @@ var require_lib4 = __commonJS({
         }
         return lowercaseKeys2(headers || {});
       }
-      _getExistingOrDefaultHeader(additionalHeaders, header, _default2) {
+      _getExistingOrDefaultHeader(additionalHeaders, header, _default) {
         let clientHeader;
         if (this.requestOptions && this.requestOptions.headers) {
           clientHeader = lowercaseKeys2(this.requestOptions.headers)[header];
         }
-        return additionalHeaders[header] || clientHeader || _default2;
+        return additionalHeaders[header] || clientHeader || _default;
       }
       _getAgent(parsedUrl) {
         let agent;
@@ -115267,23 +115267,23 @@ var require_before_after_hook = __commonJS({
 var require_dist_node2 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/endpoint/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __defProp3 = Object.defineProperty;
+    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames3 = Object.getOwnPropertyNames;
+    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
+        __defProp3(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps2 = (to, from, except, desc) => {
+    var __copyProps3 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames3(from))
+          if (!__hasOwnProp3.call(to, key) && key !== except)
+            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
     var dist_src_exports3 = {};
     __export2(dist_src_exports3, {
       endpoint: () => endpoint2
@@ -115345,7 +115345,7 @@ var require_dist_node2 = __commonJS({
       }
       return obj;
     }
-    function merge3(defaults, route, options) {
+    function merge2(defaults, route, options) {
       if (typeof route === "string") {
         let [method, url2] = route.split(" ");
         options = Object.assign(url2 ? { method, url: url2 } : { url: method }, options);
@@ -115399,16 +115399,16 @@ var require_dist_node2 = __commonJS({
       }
       return result;
     }
-    function encodeReserved2(str2) {
-      return str2.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) {
+    function encodeReserved2(str) {
+      return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part) {
         if (!/%[0-9A-Fa-f]/.test(part)) {
           part = encodeURI(part).replace(/%5B/g, "[").replace(/%5D/g, "]");
         }
         return part;
       }).join("");
     }
-    function encodeUnreserved2(str2) {
-      return encodeURIComponent(str2).replace(/[!'()*]/g, function(c) {
+    function encodeUnreserved2(str) {
+      return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
         return "%" + c.charCodeAt(0).toString(16).toUpperCase();
       });
     }
@@ -115593,15 +115593,15 @@ var require_dist_node2 = __commonJS({
       );
     }
     function endpointWithDefaults2(defaults, route, options) {
-      return parse2(merge3(defaults, route, options));
+      return parse2(merge2(defaults, route, options));
     }
     function withDefaults4(oldDefaults, newDefaults) {
-      const DEFAULTS22 = merge3(oldDefaults, newDefaults);
+      const DEFAULTS22 = merge2(oldDefaults, newDefaults);
       const endpoint22 = endpointWithDefaults2.bind(null, DEFAULTS22);
       return Object.assign(endpoint22, {
         DEFAULTS: DEFAULTS22,
         defaults: withDefaults4.bind(null, DEFAULTS22),
-        merge: merge3.bind(null, DEFAULTS22),
+        merge: merge2.bind(null, DEFAULTS22),
         parse: parse2
       });
     }
@@ -115705,40 +115705,40 @@ var require_once = __commonJS({
 var require_dist_node4 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/request-error/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __create2 = Object.create;
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __getProtoOf2 = Object.getPrototypeOf;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __create3 = Object.create;
+    var __defProp3 = Object.defineProperty;
+    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames3 = Object.getOwnPropertyNames;
+    var __getProtoOf3 = Object.getPrototypeOf;
+    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
+        __defProp3(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps2 = (to, from, except, desc) => {
+    var __copyProps3 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames3(from))
+          if (!__hasOwnProp3.call(to, key) && key !== except)
+            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+    var __toESM3 = (mod, isNodeMode, target) => (target = mod != null ? __create3(__getProtoOf3(mod)) : {}, __copyProps3(
       // If the importer is in node compatibility mode or this is not an ESM
       // file that has been converted to a CommonJS file using a Babel-
       // compatible transform (i.e. "__esModule" has not been set), then set
       // "default" to the CommonJS "module.exports" for node compatibility.
-      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target,
       mod
     ));
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
     var dist_src_exports3 = {};
     __export2(dist_src_exports3, {
       RequestError: () => RequestError2
     });
     module2.exports = __toCommonJS2(dist_src_exports3);
     var import_deprecation = require_dist_node3();
-    var import_once = __toESM2(require_once());
+    var import_once = __toESM3(require_once());
     var logOnceCode = (0, import_once.default)((deprecation) => console.warn(deprecation));
     var logOnceHeaders = (0, import_once.default)((deprecation) => console.warn(deprecation));
     var RequestError2 = class extends Error {
@@ -115797,23 +115797,23 @@ var require_dist_node4 = __commonJS({
 var require_dist_node5 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/request/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __defProp3 = Object.defineProperty;
+    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames3 = Object.getOwnPropertyNames;
+    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
+        __defProp3(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps2 = (to, from, except, desc) => {
+    var __copyProps3 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames3(from))
+          if (!__hasOwnProp3.call(to, key) && key !== except)
+            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
     var dist_src_exports3 = {};
     __export2(dist_src_exports3, {
       request: () => request3
@@ -116007,23 +116007,23 @@ var require_dist_node5 = __commonJS({
 var require_dist_node6 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/graphql/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __defProp3 = Object.defineProperty;
+    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames3 = Object.getOwnPropertyNames;
+    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
+        __defProp3(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps2 = (to, from, except, desc) => {
+    var __copyProps3 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames3(from))
+          if (!__hasOwnProp3.call(to, key) && key !== except)
+            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
     var index_exports = {};
     __export2(index_exports, {
       GraphqlResponseError: () => GraphqlResponseError2,
@@ -116144,23 +116144,23 @@ var require_dist_node6 = __commonJS({
 var require_dist_node7 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/auth-token/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __defProp3 = Object.defineProperty;
+    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames3 = Object.getOwnPropertyNames;
+    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
+        __defProp3(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps2 = (to, from, except, desc) => {
+    var __copyProps3 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames3(from))
+          if (!__hasOwnProp3.call(to, key) && key !== except)
+            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
     var dist_src_exports3 = {};
     __export2(dist_src_exports3, {
       createTokenAuth: () => createTokenAuth3
@@ -116215,23 +116215,23 @@ var require_dist_node7 = __commonJS({
 var require_dist_node8 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/core/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __defProp3 = Object.defineProperty;
+    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames3 = Object.getOwnPropertyNames;
+    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
+        __defProp3(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps2 = (to, from, except, desc) => {
+    var __copyProps3 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames3(from))
+          if (!__hasOwnProp3.call(to, key) && key !== except)
+            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
     var index_exports = {};
     __export2(index_exports, {
       Octokit: () => Octokit2
@@ -116381,23 +116381,23 @@ var require_dist_node8 = __commonJS({
 var require_dist_node9 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/plugin-rest-endpoint-methods/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __defProp3 = Object.defineProperty;
+    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames3 = Object.getOwnPropertyNames;
+    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
+        __defProp3(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps2 = (to, from, except, desc) => {
+    var __copyProps3 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames3(from))
+          if (!__hasOwnProp3.call(to, key) && key !== except)
+            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
     var dist_src_exports3 = {};
     __export2(dist_src_exports3, {
       legacyRestEndpointMethods: () => legacyRestEndpointMethods2,
@@ -118537,23 +118537,23 @@ var require_dist_node9 = __commonJS({
 var require_dist_node10 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/plugin-paginate-rest/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp2 = Object.defineProperty;
-    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames2 = Object.getOwnPropertyNames;
-    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __defProp3 = Object.defineProperty;
+    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames3 = Object.getOwnPropertyNames;
+    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp2(target, name, { get: all[name], enumerable: true });
+        __defProp3(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps2 = (to, from, except, desc) => {
+    var __copyProps3 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames3(from))
+          if (!__hasOwnProp3.call(to, key) && key !== except)
+            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
     var dist_src_exports3 = {};
     __export2(dist_src_exports3, {
       composePaginateRest: () => composePaginateRest2,
@@ -119543,7 +119543,7 @@ var require_buffers = __commonJS({
       var pos = this.pos(i);
       return this.buffers[pos.buf].get(pos.offset);
     };
-    Buffers.prototype.set = function set2(i, b) {
+    Buffers.prototype.set = function set(i, b) {
       var pos = this.pos(i);
       return this.buffers[pos.buf].set(pos.offset, b);
     };
@@ -119640,7 +119640,7 @@ var require_vars = __commonJS({
 });
 
 // node_modules/binary/index.js
-var require_binary = __commonJS({
+var require_binary2 = __commonJS({
   "node_modules/binary/index.js"(exports2, module2) {
     var Chainsaw = require_chainsaw();
     var EventEmitter = require("events").EventEmitter;
@@ -120073,7 +120073,7 @@ var require_entry = __commonJS({
 var require_unzip_stream = __commonJS({
   "node_modules/unzip-stream/lib/unzip-stream.js"(exports2, module2) {
     "use strict";
-    var binary2 = require_binary();
+    var binary = require_binary2();
     var stream2 = require("stream");
     var util = require("util");
     var zlib3 = require("zlib");
@@ -120398,7 +120398,7 @@ var require_unzip_stream = __commonJS({
       }
     };
     UnzipStream.prototype._readFile = function(data) {
-      var vars = binary2.parse(data).word16lu("versionsNeededToExtract").word16lu("flags").word16lu("compressionMethod").word16lu("lastModifiedTime").word16lu("lastModifiedDate").word32lu("crc32").word32lu("compressedSize").word32lu("uncompressedSize").word16lu("fileNameLength").word16lu("extraFieldLength").vars;
+      var vars = binary.parse(data).word16lu("versionsNeededToExtract").word16lu("flags").word16lu("compressionMethod").word16lu("lastModifiedTime").word16lu("lastModifiedDate").word32lu("crc32").word32lu("compressedSize").word32lu("uncompressedSize").word16lu("fileNameLength").word16lu("extraFieldLength").vars;
       return vars;
     };
     UnzipStream.prototype._readExtraFields = function(data) {
@@ -120409,13 +120409,13 @@ var require_unzip_stream = __commonJS({
       }
       var index = 0;
       while (index < data.length) {
-        var vars = binary2.parse(data).skip(index).word16lu("extraId").word16lu("extraSize").vars;
+        var vars = binary.parse(data).skip(index).word16lu("extraId").word16lu("extraSize").vars;
         index += 4;
         var fieldType = void 0;
         switch (vars.extraId) {
           case 1:
             fieldType = "Zip64 extended information extra field";
-            var z64vars = binary2.parse(data.slice(index, index + vars.extraSize)).word64lu("uncompressedSize").word64lu("compressedSize").word64lu("offsetToLocalHeader").word32lu("diskStartNumber").vars;
+            var z64vars = binary.parse(data.slice(index, index + vars.extraSize)).word64lu("uncompressedSize").word64lu("compressedSize").word64lu("offsetToLocalHeader").word32lu("diskStartNumber").vars;
             if (z64vars.uncompressedSize !== null) {
               extra.uncompressedSize = z64vars.uncompressedSize;
             }
@@ -120545,22 +120545,22 @@ var require_unzip_stream = __commonJS({
     };
     UnzipStream.prototype._readDataDescriptor = function(data, zip64Mode) {
       if (zip64Mode) {
-        var vars = binary2.parse(data).word32lu("dataDescriptorSignature").word32lu("crc32").word64lu("compressedSize").word64lu("uncompressedSize").vars;
+        var vars = binary.parse(data).word32lu("dataDescriptorSignature").word32lu("crc32").word64lu("compressedSize").word64lu("uncompressedSize").vars;
         return vars;
       }
-      var vars = binary2.parse(data).word32lu("dataDescriptorSignature").word32lu("crc32").word32lu("compressedSize").word32lu("uncompressedSize").vars;
+      var vars = binary.parse(data).word32lu("dataDescriptorSignature").word32lu("crc32").word32lu("compressedSize").word32lu("uncompressedSize").vars;
       return vars;
     };
     UnzipStream.prototype._readCentralDirectoryEntry = function(data) {
-      var vars = binary2.parse(data).word16lu("versionMadeBy").word16lu("versionsNeededToExtract").word16lu("flags").word16lu("compressionMethod").word16lu("lastModifiedTime").word16lu("lastModifiedDate").word32lu("crc32").word32lu("compressedSize").word32lu("uncompressedSize").word16lu("fileNameLength").word16lu("extraFieldLength").word16lu("fileCommentLength").word16lu("diskNumber").word16lu("internalFileAttributes").word32lu("externalFileAttributes").word32lu("offsetToLocalFileHeader").vars;
+      var vars = binary.parse(data).word16lu("versionMadeBy").word16lu("versionsNeededToExtract").word16lu("flags").word16lu("compressionMethod").word16lu("lastModifiedTime").word16lu("lastModifiedDate").word32lu("crc32").word32lu("compressedSize").word32lu("uncompressedSize").word16lu("fileNameLength").word16lu("extraFieldLength").word16lu("fileCommentLength").word16lu("diskNumber").word16lu("internalFileAttributes").word32lu("externalFileAttributes").word32lu("offsetToLocalFileHeader").vars;
       return vars;
     };
     UnzipStream.prototype._readEndOfCentralDirectory64 = function(data) {
-      var vars = binary2.parse(data).word64lu("centralDirectoryRecordSize").word16lu("versionMadeBy").word16lu("versionsNeededToExtract").word32lu("diskNumber").word32lu("diskNumberWithCentralDirectoryStart").word64lu("centralDirectoryEntries").word64lu("totalCentralDirectoryEntries").word64lu("sizeOfCentralDirectory").word64lu("offsetToStartOfCentralDirectory").vars;
+      var vars = binary.parse(data).word64lu("centralDirectoryRecordSize").word16lu("versionMadeBy").word16lu("versionsNeededToExtract").word32lu("diskNumber").word32lu("diskNumberWithCentralDirectoryStart").word64lu("centralDirectoryEntries").word64lu("totalCentralDirectoryEntries").word64lu("sizeOfCentralDirectory").word64lu("offsetToStartOfCentralDirectory").vars;
       return vars;
     };
     UnzipStream.prototype._readEndOfCentralDirectory = function(data) {
-      var vars = binary2.parse(data).word16lu("diskNumber").word16lu("diskStart").word16lu("centralDirectoryEntries").word16lu("totalCentralDirectoryEntries").word32lu("sizeOfCentralDirectory").word32lu("offsetToStartOfCentralDirectory").word16lu("commentLength").vars;
+      var vars = binary.parse(data).word16lu("diskNumber").word16lu("diskStart").word16lu("centralDirectoryEntries").word16lu("totalCentralDirectoryEntries").word32lu("sizeOfCentralDirectory").word32lu("offsetToStartOfCentralDirectory").word16lu("commentLength").vars;
       return vars;
     };
     var cp437 = "\0\u263A\u263B\u2665\u2666\u2663\u2660\u2022\u25D8\u25CB\u25D9\u2642\u2640\u266A\u266B\u263C\u25BA\u25C4\u2195\u203C\xB6\xA7\u25AC\u21A8\u2191\u2193\u2192\u2190\u221F\u2194\u25B2\u25BC !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u2302\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0 ";
@@ -120958,7 +120958,7 @@ var require_download_artifact = __commonJS({
     var crypto3 = __importStar2(require("crypto"));
     var stream2 = __importStar2(require("stream"));
     var github5 = __importStar2(require_github2());
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var httpClient = __importStar2(require_lib());
     var unzip_stream_1 = __importDefault2(require_unzip());
     var user_agent_1 = require_user_agent2();
@@ -120994,7 +120994,7 @@ var require_download_artifact = __commonJS({
             return yield streamExtractExternal(url2, directory);
           } catch (error3) {
             retryCount++;
-            core31.debug(`Failed to download artifact after ${retryCount} retries due to ${error3.message}. Retrying in 5 seconds...`);
+            core30.debug(`Failed to download artifact after ${retryCount} retries due to ${error3.message}. Retrying in 5 seconds...`);
             yield new Promise((resolve13) => setTimeout(resolve13, 5e3));
           }
         }
@@ -121024,7 +121024,7 @@ var require_download_artifact = __commonJS({
           extractStream.on("data", () => {
             timer.refresh();
           }).on("error", (error3) => {
-            core31.debug(`response.message: Artifact download failed: ${error3.message}`);
+            core30.debug(`response.message: Artifact download failed: ${error3.message}`);
             clearTimeout(timer);
             reject(error3);
           }).pipe(unzip_stream_1.default.Extract({ path: directory })).on("close", () => {
@@ -121032,7 +121032,7 @@ var require_download_artifact = __commonJS({
             if (hashStream) {
               hashStream.end();
               sha256Digest = hashStream.read();
-              core31.info(`SHA256 digest of downloaded artifact is ${sha256Digest}`);
+              core30.info(`SHA256 digest of downloaded artifact is ${sha256Digest}`);
             }
             resolve13({ sha256Digest: `sha256:${sha256Digest}` });
           }).on("error", (error3) => {
@@ -121047,7 +121047,7 @@ var require_download_artifact = __commonJS({
         const downloadPath = yield resolveOrCreateDirectory(options === null || options === void 0 ? void 0 : options.path);
         const api = github5.getOctokit(token);
         let digestMismatch = false;
-        core31.info(`Downloading artifact '${artifactId}' from '${repositoryOwner}/${repositoryName}'`);
+        core30.info(`Downloading artifact '${artifactId}' from '${repositoryOwner}/${repositoryName}'`);
         const { headers, status } = yield api.rest.actions.downloadArtifact({
           owner: repositoryOwner,
           repo: repositoryName,
@@ -121064,16 +121064,16 @@ var require_download_artifact = __commonJS({
         if (!location) {
           throw new Error(`Unable to redirect to artifact download url`);
         }
-        core31.info(`Redirecting to blob download url: ${scrubQueryParameters(location)}`);
+        core30.info(`Redirecting to blob download url: ${scrubQueryParameters(location)}`);
         try {
-          core31.info(`Starting download of artifact to: ${downloadPath}`);
+          core30.info(`Starting download of artifact to: ${downloadPath}`);
           const extractResponse = yield streamExtract(location, downloadPath);
-          core31.info(`Artifact download completed successfully.`);
+          core30.info(`Artifact download completed successfully.`);
           if (options === null || options === void 0 ? void 0 : options.expectedHash) {
             if ((options === null || options === void 0 ? void 0 : options.expectedHash) !== extractResponse.sha256Digest) {
               digestMismatch = true;
-              core31.debug(`Computed digest: ${extractResponse.sha256Digest}`);
-              core31.debug(`Expected digest: ${options.expectedHash}`);
+              core30.debug(`Computed digest: ${extractResponse.sha256Digest}`);
+              core30.debug(`Expected digest: ${options.expectedHash}`);
             }
           }
         } catch (error3) {
@@ -121100,7 +121100,7 @@ var require_download_artifact = __commonJS({
 Are you trying to download from a different run? Try specifying a github-token with \`actions:read\` scope.`);
         }
         if (artifacts.length > 1) {
-          core31.warning("Multiple artifacts found, defaulting to first.");
+          core30.warning("Multiple artifacts found, defaulting to first.");
         }
         const signedReq = {
           workflowRunBackendId: artifacts[0].workflowRunBackendId,
@@ -121108,16 +121108,16 @@ Are you trying to download from a different run? Try specifying a github-token w
           name: artifacts[0].name
         };
         const { signedUrl } = yield artifactClient.GetSignedArtifactURL(signedReq);
-        core31.info(`Redirecting to blob download url: ${scrubQueryParameters(signedUrl)}`);
+        core30.info(`Redirecting to blob download url: ${scrubQueryParameters(signedUrl)}`);
         try {
-          core31.info(`Starting download of artifact to: ${downloadPath}`);
+          core30.info(`Starting download of artifact to: ${downloadPath}`);
           const extractResponse = yield streamExtract(signedUrl, downloadPath);
-          core31.info(`Artifact download completed successfully.`);
+          core30.info(`Artifact download completed successfully.`);
           if (options === null || options === void 0 ? void 0 : options.expectedHash) {
             if ((options === null || options === void 0 ? void 0 : options.expectedHash) !== extractResponse.sha256Digest) {
               digestMismatch = true;
-              core31.debug(`Computed digest: ${extractResponse.sha256Digest}`);
-              core31.debug(`Expected digest: ${options.expectedHash}`);
+              core30.debug(`Computed digest: ${extractResponse.sha256Digest}`);
+              core30.debug(`Expected digest: ${options.expectedHash}`);
             }
           }
         } catch (error3) {
@@ -121130,10 +121130,10 @@ Are you trying to download from a different run? Try specifying a github-token w
     function resolveOrCreateDirectory() {
       return __awaiter2(this, arguments, void 0, function* (downloadPath = (0, config_1.getGitHubWorkspaceDir)()) {
         if (!(yield exists(downloadPath))) {
-          core31.debug(`Artifact destination folder does not exist, creating: ${downloadPath}`);
+          core30.debug(`Artifact destination folder does not exist, creating: ${downloadPath}`);
           yield promises_1.default.mkdir(downloadPath, { recursive: true });
         } else {
-          core31.debug(`Artifact destination folder already exists: ${downloadPath}`);
+          core30.debug(`Artifact destination folder already exists: ${downloadPath}`);
         }
         return downloadPath;
       });
@@ -121174,7 +121174,7 @@ var require_retry_options = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getRetryOptions = void 0;
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var defaultMaxRetryNumber = 5;
     var defaultExemptStatusCodes = [400, 401, 403, 404, 422];
     function getRetryOptions(defaultOptions, retries = defaultMaxRetryNumber, exemptStatusCodes = defaultExemptStatusCodes) {
@@ -121189,7 +121189,7 @@ var require_retry_options = __commonJS({
         retryOptions.doNotRetry = exemptStatusCodes;
       }
       const requestOptions = Object.assign(Object.assign({}, defaultOptions.request), { retries });
-      core31.debug(`GitHub client configured with: (retries: ${requestOptions.retries}, retry-exempt-status-code: ${(_a = retryOptions.doNotRetry) !== null && _a !== void 0 ? _a : "octokit default: [400, 401, 403, 404, 422]"})`);
+      core30.debug(`GitHub client configured with: (retries: ${requestOptions.retries}, retry-exempt-status-code: ${(_a = retryOptions.doNotRetry) !== null && _a !== void 0 ? _a : "octokit default: [400, 401, 403, 404, 422]"})`);
       return [retryOptions, requestOptions];
     }
     exports2.getRetryOptions = getRetryOptions;
@@ -121346,7 +121346,7 @@ var require_get_artifact = __commonJS({
     exports2.getArtifactInternal = exports2.getArtifactPublic = void 0;
     var github_1 = require_github2();
     var plugin_retry_1 = require_dist_node12();
-    var core31 = __importStar2(require_core());
+    var core30 = __importStar2(require_core());
     var utils_1 = require_utils9();
     var retry_options_1 = require_retry_options();
     var plugin_request_log_1 = require_dist_node11();
@@ -121384,7 +121384,7 @@ var require_get_artifact = __commonJS({
         let artifact2 = getArtifactResp.data.artifacts[0];
         if (getArtifactResp.data.artifacts.length > 1) {
           artifact2 = getArtifactResp.data.artifacts.sort((a, b) => b.id - a.id)[0];
-          core31.debug(`More than one artifact found for a single name, returning newest (id: ${artifact2.id})`);
+          core30.debug(`More than one artifact found for a single name, returning newest (id: ${artifact2.id})`);
         }
         return {
           artifact: {
@@ -121417,7 +121417,7 @@ var require_get_artifact = __commonJS({
         let artifact2 = res.artifacts[0];
         if (res.artifacts.length > 1) {
           artifact2 = res.artifacts.sort((a, b) => Number(b.databaseId) - Number(a.databaseId))[0];
-          core31.debug(`More than one artifact found for a single name, returning newest (id: ${artifact2.databaseId})`);
+          core30.debug(`More than one artifact found for a single name, returning newest (id: ${artifact2.databaseId})`);
         }
         return {
           artifact: {
@@ -122636,12 +122636,12 @@ var require_lib5 = __commonJS({
         }
         return lowercaseKeys2(headers || {});
       }
-      _getExistingOrDefaultHeader(additionalHeaders, header, _default2) {
+      _getExistingOrDefaultHeader(additionalHeaders, header, _default) {
         let clientHeader;
         if (this.requestOptions && this.requestOptions.headers) {
           clientHeader = lowercaseKeys2(this.requestOptions.headers)[header];
         }
-        return additionalHeaders[header] || clientHeader || _default2;
+        return additionalHeaders[header] || clientHeader || _default;
       }
       _getAgent(parsedUrl) {
         let agent;
@@ -122917,7 +122917,7 @@ var require_oidc_utils2 = __commonJS({
     exports2.OidcClient = void 0;
     var http_client_1 = require_lib5();
     var auth_1 = require_auth2();
-    var core_1 = require_core3();
+    var core_1 = require_core4();
     var OidcClient = class _OidcClient {
       static createHttpClient(allowRetry = true, maxRetry = 10) {
         const requestOptions = {
@@ -123890,8 +123890,8 @@ var require_toolrunner2 = __commonJS({
         }
         return this.args;
       }
-      _endsWith(str2, end) {
-        return str2.endsWith(end);
+      _endsWith(str, end) {
+        return str.endsWith(end);
       }
       _isCmdFile() {
         const upperToolPath = this.toolPath.toUpperCase();
@@ -124455,7 +124455,7 @@ var require_platform2 = __commonJS({
 });
 
 // node_modules/@actions/artifact-legacy/node_modules/@actions/core/lib/core.js
-var require_core3 = __commonJS({
+var require_core4 = __commonJS({
   "node_modules/@actions/artifact-legacy/node_modules/@actions/core/lib/core.js"(exports2) {
     "use strict";
     var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
@@ -124689,7 +124689,7 @@ var require_path_and_artifact_name_validation2 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.checkArtifactFilePath = exports2.checkArtifactName = void 0;
-    var core_1 = require_core3();
+    var core_1 = require_core4();
     var invalidArtifactFilePathCharacters = /* @__PURE__ */ new Map([
       ['"', ' Double quote "'],
       [":", " Colon :"],
@@ -124775,7 +124775,7 @@ var require_upload_specification = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getUploadSpecification = void 0;
     var fs30 = __importStar2(require("fs"));
-    var core_1 = require_core3();
+    var core_1 = require_core4();
     var path_1 = require("path");
     var path_and_artifact_name_validation_1 = require_path_and_artifact_name_validation2();
     function getUploadSpecification(artifactName, rootDirectory, artifactFiles) {
@@ -125642,7 +125642,7 @@ var require_utils11 = __commonJS({
     exports2.digestForStream = exports2.sleep = exports2.getProperRetention = exports2.rmFile = exports2.getFileSize = exports2.createEmptyFilesForArtifact = exports2.createDirectoriesForArtifact = exports2.displayHttpDiagnostics = exports2.getArtifactUrl = exports2.createHttpClient = exports2.getUploadHeaders = exports2.getDownloadHeaders = exports2.getContentRange = exports2.tryGetRetryAfterValueTimeInMilliseconds = exports2.isThrottledStatusCode = exports2.isRetryableStatusCode = exports2.isForbiddenStatusCode = exports2.isSuccessStatusCode = exports2.getApiVersion = exports2.parseEnvNumber = exports2.getExponentialRetryTimeInMilliseconds = void 0;
     var crypto_1 = __importDefault2(require("crypto"));
     var fs_1 = require("fs");
-    var core_1 = require_core3();
+    var core_1 = require_core4();
     var http_client_1 = require_lib5();
     var auth_1 = require_auth2();
     var config_variables_1 = require_config_variables();
@@ -125869,7 +125869,7 @@ var require_status_reporter = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.StatusReporter = void 0;
-    var core_1 = require_core3();
+    var core_1 = require_core4();
     var StatusReporter = class {
       constructor(displayFrequencyInMilliseconds) {
         this.totalNumberOfFilesToProcess = 0;
@@ -126171,7 +126171,7 @@ var require_requestUtils2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.retryHttpClientRequest = exports2.retry = void 0;
     var utils_1 = require_utils11();
-    var core31 = __importStar2(require_core3());
+    var core30 = __importStar2(require_core4());
     var config_variables_1 = require_config_variables();
     function retry2(name, operation, customErrorMessages, maxAttempts) {
       return __awaiter2(this, void 0, void 0, function* () {
@@ -126198,13 +126198,13 @@ var require_requestUtils2 = __commonJS({
             errorMessage = error3.message;
           }
           if (!isRetryable) {
-            core31.info(`${name} - Error is not retryable`);
+            core30.info(`${name} - Error is not retryable`);
             if (response) {
               (0, utils_1.displayHttpDiagnostics)(response);
             }
             break;
           }
-          core31.info(`${name} - Attempt ${attempt} of ${maxAttempts} failed with error: ${errorMessage}`);
+          core30.info(`${name} - Attempt ${attempt} of ${maxAttempts} failed with error: ${errorMessage}`);
           yield (0, utils_1.sleep)((0, utils_1.getExponentialRetryTimeInMilliseconds)(attempt));
           attempt++;
         }
@@ -126288,7 +126288,7 @@ var require_upload_http_client = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.UploadHttpClient = void 0;
     var fs30 = __importStar2(require("fs"));
-    var core31 = __importStar2(require_core3());
+    var core30 = __importStar2(require_core4());
     var tmp = __importStar2(require_tmp_promise());
     var stream2 = __importStar2(require("stream"));
     var utils_1 = require_utils11();
@@ -126353,7 +126353,7 @@ var require_upload_http_client = __commonJS({
         return __awaiter2(this, void 0, void 0, function* () {
           const FILE_CONCURRENCY = (0, config_variables_1.getUploadFileConcurrency)();
           const MAX_CHUNK_SIZE = (0, config_variables_1.getUploadChunkSize)();
-          core31.debug(`File Concurrency: ${FILE_CONCURRENCY}, and Chunk Size: ${MAX_CHUNK_SIZE}`);
+          core30.debug(`File Concurrency: ${FILE_CONCURRENCY}, and Chunk Size: ${MAX_CHUNK_SIZE}`);
           const parameters = [];
           let continueOnError = true;
           if (options) {
@@ -126390,15 +126390,15 @@ var require_upload_http_client = __commonJS({
               }
               const startTime = perf_hooks_1.performance.now();
               const uploadFileResult = yield this.uploadFileAsync(index, currentFileParameters);
-              if (core31.isDebug()) {
-                core31.debug(`File: ${++completedFiles}/${filesToUpload.length}. ${currentFileParameters.file} took ${(perf_hooks_1.performance.now() - startTime).toFixed(3)} milliseconds to finish upload`);
+              if (core30.isDebug()) {
+                core30.debug(`File: ${++completedFiles}/${filesToUpload.length}. ${currentFileParameters.file} took ${(perf_hooks_1.performance.now() - startTime).toFixed(3)} milliseconds to finish upload`);
               }
               uploadFileSize += uploadFileResult.successfulUploadSize;
               totalFileSize += uploadFileResult.totalSize;
               if (uploadFileResult.isSuccess === false) {
                 failedItemsToReport.push(currentFileParameters.file);
                 if (!continueOnError) {
-                  core31.error(`aborting artifact upload`);
+                  core30.error(`aborting artifact upload`);
                   abortPendingFileUploads = true;
                 }
               }
@@ -126407,7 +126407,7 @@ var require_upload_http_client = __commonJS({
           })));
           this.statusReporter.stop();
           this.uploadHttpManager.disposeAndReplaceAllClients();
-          core31.info(`Total size of all the files uploaded is ${uploadFileSize} bytes`);
+          core30.info(`Total size of all the files uploaded is ${uploadFileSize} bytes`);
           return {
             uploadSize: uploadFileSize,
             totalSize: totalFileSize,
@@ -126433,16 +126433,16 @@ var require_upload_http_client = __commonJS({
           let uploadFileSize = 0;
           let isGzip = true;
           if (!isFIFO && totalFileSize < 65536) {
-            core31.debug(`${parameters.file} is less than 64k in size. Creating a gzip file in-memory to potentially reduce the upload size`);
+            core30.debug(`${parameters.file} is less than 64k in size. Creating a gzip file in-memory to potentially reduce the upload size`);
             const buffer = yield (0, upload_gzip_1.createGZipFileInBuffer)(parameters.file);
             let openUploadStream;
             if (totalFileSize < buffer.byteLength) {
-              core31.debug(`The gzip file created for ${parameters.file} did not help with reducing the size of the file. The original file will be uploaded as-is`);
+              core30.debug(`The gzip file created for ${parameters.file} did not help with reducing the size of the file. The original file will be uploaded as-is`);
               openUploadStream = () => fs30.createReadStream(parameters.file);
               isGzip = false;
               uploadFileSize = totalFileSize;
             } else {
-              core31.debug(`A gzip file created for ${parameters.file} helped with reducing the size of the original file. The file will be uploaded using gzip.`);
+              core30.debug(`A gzip file created for ${parameters.file} helped with reducing the size of the original file. The file will be uploaded using gzip.`);
               openUploadStream = () => {
                 const passThrough = new stream2.PassThrough();
                 passThrough.end(buffer);
@@ -126454,7 +126454,7 @@ var require_upload_http_client = __commonJS({
             if (!result) {
               isUploadSuccessful = false;
               failedChunkSizes += uploadFileSize;
-              core31.warning(`Aborting upload for ${parameters.file} due to failure`);
+              core30.warning(`Aborting upload for ${parameters.file} due to failure`);
             }
             return {
               isSuccess: isUploadSuccessful,
@@ -126463,16 +126463,16 @@ var require_upload_http_client = __commonJS({
             };
           } else {
             const tempFile = yield tmp.file();
-            core31.debug(`${parameters.file} is greater than 64k in size. Creating a gzip file on-disk ${tempFile.path} to potentially reduce the upload size`);
+            core30.debug(`${parameters.file} is greater than 64k in size. Creating a gzip file on-disk ${tempFile.path} to potentially reduce the upload size`);
             uploadFileSize = yield (0, upload_gzip_1.createGZipFileOnDisk)(parameters.file, tempFile.path);
             let uploadFilePath = tempFile.path;
             if (!isFIFO && totalFileSize < uploadFileSize) {
-              core31.debug(`The gzip file created for ${parameters.file} did not help with reducing the size of the file. The original file will be uploaded as-is`);
+              core30.debug(`The gzip file created for ${parameters.file} did not help with reducing the size of the file. The original file will be uploaded as-is`);
               uploadFileSize = totalFileSize;
               uploadFilePath = parameters.file;
               isGzip = false;
             } else {
-              core31.debug(`The gzip file created for ${parameters.file} is smaller than the original file. The file will be uploaded using gzip.`);
+              core30.debug(`The gzip file created for ${parameters.file} is smaller than the original file. The file will be uploaded using gzip.`);
             }
             let abortFileUpload = false;
             while (offset < uploadFileSize) {
@@ -126492,7 +126492,7 @@ var require_upload_http_client = __commonJS({
               if (!result) {
                 isUploadSuccessful = false;
                 failedChunkSizes += chunkSize;
-                core31.warning(`Aborting upload for ${parameters.file} due to failure`);
+                core30.warning(`Aborting upload for ${parameters.file} due to failure`);
                 abortFileUpload = true;
               } else {
                 if (uploadFileSize > 8388608) {
@@ -126500,7 +126500,7 @@ var require_upload_http_client = __commonJS({
                 }
               }
             }
-            core31.debug(`deleting temporary gzip file ${tempFile.path}`);
+            core30.debug(`deleting temporary gzip file ${tempFile.path}`);
             yield tempFile.cleanup();
             return {
               isSuccess: isUploadSuccessful,
@@ -126539,7 +126539,7 @@ var require_upload_http_client = __commonJS({
               if (response) {
                 (0, utils_1.displayHttpDiagnostics)(response);
               }
-              core31.info(`Retry limit has been reached for chunk at offset ${start} to ${resourceUrl}`);
+              core30.info(`Retry limit has been reached for chunk at offset ${start} to ${resourceUrl}`);
               return true;
             }
             return false;
@@ -126547,14 +126547,14 @@ var require_upload_http_client = __commonJS({
           const backOff = (retryAfterValue) => __awaiter2(this, void 0, void 0, function* () {
             this.uploadHttpManager.disposeAndReplaceClient(httpClientIndex);
             if (retryAfterValue) {
-              core31.info(`Backoff due to too many requests, retry #${retryCount}. Waiting for ${retryAfterValue} milliseconds before continuing the upload`);
+              core30.info(`Backoff due to too many requests, retry #${retryCount}. Waiting for ${retryAfterValue} milliseconds before continuing the upload`);
               yield (0, utils_1.sleep)(retryAfterValue);
             } else {
               const backoffTime = (0, utils_1.getExponentialRetryTimeInMilliseconds)(retryCount);
-              core31.info(`Exponential backoff for retry #${retryCount}. Waiting for ${backoffTime} milliseconds before continuing the upload at offset ${start}`);
+              core30.info(`Exponential backoff for retry #${retryCount}. Waiting for ${backoffTime} milliseconds before continuing the upload at offset ${start}`);
               yield (0, utils_1.sleep)(backoffTime);
             }
-            core31.info(`Finished backoff for retry #${retryCount}, continuing with upload`);
+            core30.info(`Finished backoff for retry #${retryCount}, continuing with upload`);
             return;
           });
           while (retryCount <= retryLimit) {
@@ -126562,7 +126562,7 @@ var require_upload_http_client = __commonJS({
             try {
               response = yield uploadChunkRequest();
             } catch (error3) {
-              core31.info(`An error has been caught http-client index ${httpClientIndex}, retrying the upload`);
+              core30.info(`An error has been caught http-client index ${httpClientIndex}, retrying the upload`);
               console.log(error3);
               if (incrementAndCheckRetryLimit()) {
                 return false;
@@ -126574,13 +126574,13 @@ var require_upload_http_client = __commonJS({
             if ((0, utils_1.isSuccessStatusCode)(response.message.statusCode)) {
               return true;
             } else if ((0, utils_1.isRetryableStatusCode)(response.message.statusCode)) {
-              core31.info(`A ${response.message.statusCode} status code has been received, will attempt to retry the upload`);
+              core30.info(`A ${response.message.statusCode} status code has been received, will attempt to retry the upload`);
               if (incrementAndCheckRetryLimit(response)) {
                 return false;
               }
               (0, utils_1.isThrottledStatusCode)(response.message.statusCode) ? yield backOff((0, utils_1.tryGetRetryAfterValueTimeInMilliseconds)(response.message.headers)) : yield backOff();
             } else {
-              core31.error(`Unexpected response. Unable to upload chunk to ${resourceUrl}`);
+              core30.error(`Unexpected response. Unable to upload chunk to ${resourceUrl}`);
               (0, utils_1.displayHttpDiagnostics)(response);
               return false;
             }
@@ -126598,7 +126598,7 @@ var require_upload_http_client = __commonJS({
           resourceUrl.searchParams.append("artifactName", artifactName);
           const parameters = { Size: size };
           const data = JSON.stringify(parameters, null, 2);
-          core31.debug(`URL is ${resourceUrl.toString()}`);
+          core30.debug(`URL is ${resourceUrl.toString()}`);
           const client = this.uploadHttpManager.getClient(0);
           const headers = (0, utils_1.getUploadHeaders)("application/json", false);
           const customErrorMessages = /* @__PURE__ */ new Map([
@@ -126611,7 +126611,7 @@ var require_upload_http_client = __commonJS({
             return client.patch(resourceUrl.toString(), data, headers);
           }), customErrorMessages);
           yield response.readBody();
-          core31.debug(`Artifact ${artifactName} has been successfully uploaded, total size in bytes: ${size}`);
+          core30.debug(`Artifact ${artifactName} has been successfully uploaded, total size in bytes: ${size}`);
         });
       }
     };
@@ -126680,7 +126680,7 @@ var require_download_http_client = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DownloadHttpClient = void 0;
     var fs30 = __importStar2(require("fs"));
-    var core31 = __importStar2(require_core3());
+    var core30 = __importStar2(require_core4());
     var zlib3 = __importStar2(require("zlib"));
     var utils_1 = require_utils11();
     var url_1 = require("url");
@@ -126734,11 +126734,11 @@ var require_download_http_client = __commonJS({
       downloadSingleArtifact(downloadItems) {
         return __awaiter2(this, void 0, void 0, function* () {
           const DOWNLOAD_CONCURRENCY = (0, config_variables_1.getDownloadFileConcurrency)();
-          core31.debug(`Download file concurrency is set to ${DOWNLOAD_CONCURRENCY}`);
+          core30.debug(`Download file concurrency is set to ${DOWNLOAD_CONCURRENCY}`);
           const parallelDownloads = [...new Array(DOWNLOAD_CONCURRENCY).keys()];
           let currentFile = 0;
           let downloadedFiles = 0;
-          core31.info(`Total number of files that will be downloaded: ${downloadItems.length}`);
+          core30.info(`Total number of files that will be downloaded: ${downloadItems.length}`);
           this.statusReporter.setTotalNumberOfFilesToProcess(downloadItems.length);
           this.statusReporter.start();
           yield Promise.all(parallelDownloads.map((index) => __awaiter2(this, void 0, void 0, function* () {
@@ -126747,8 +126747,8 @@ var require_download_http_client = __commonJS({
               currentFile += 1;
               const startTime = perf_hooks_1.performance.now();
               yield this.downloadIndividualFile(index, currentFileToDownload.sourceLocation, currentFileToDownload.targetPath);
-              if (core31.isDebug()) {
-                core31.debug(`File: ${++downloadedFiles}/${downloadItems.length}. ${currentFileToDownload.targetPath} took ${(perf_hooks_1.performance.now() - startTime).toFixed(3)} milliseconds to finish downloading`);
+              if (core30.isDebug()) {
+                core30.debug(`File: ${++downloadedFiles}/${downloadItems.length}. ${currentFileToDownload.targetPath} took ${(perf_hooks_1.performance.now() - startTime).toFixed(3)} milliseconds to finish downloading`);
               }
               this.statusReporter.incrementProcessedCount();
             }
@@ -126786,19 +126786,19 @@ var require_download_http_client = __commonJS({
             } else {
               this.downloadHttpManager.disposeAndReplaceClient(httpClientIndex);
               if (retryAfterValue) {
-                core31.info(`Backoff due to too many requests, retry #${retryCount}. Waiting for ${retryAfterValue} milliseconds before continuing the download`);
+                core30.info(`Backoff due to too many requests, retry #${retryCount}. Waiting for ${retryAfterValue} milliseconds before continuing the download`);
                 yield (0, utils_1.sleep)(retryAfterValue);
               } else {
                 const backoffTime = (0, utils_1.getExponentialRetryTimeInMilliseconds)(retryCount);
-                core31.info(`Exponential backoff for retry #${retryCount}. Waiting for ${backoffTime} milliseconds before continuing the download`);
+                core30.info(`Exponential backoff for retry #${retryCount}. Waiting for ${backoffTime} milliseconds before continuing the download`);
                 yield (0, utils_1.sleep)(backoffTime);
               }
-              core31.info(`Finished backoff for retry #${retryCount}, continuing with download`);
+              core30.info(`Finished backoff for retry #${retryCount}, continuing with download`);
             }
           });
           const isAllBytesReceived = (expected, received) => {
             if (!expected || !received || process.env["ACTIONS_ARTIFACT_SKIP_DOWNLOAD_VALIDATION"]) {
-              core31.info("Skipping download validation.");
+              core30.info("Skipping download validation.");
               return true;
             }
             return parseInt(expected) === received;
@@ -126819,7 +126819,7 @@ var require_download_http_client = __commonJS({
             try {
               response = yield makeDownloadRequest();
             } catch (error3) {
-              core31.info("An error occurred while attempting to download a file");
+              core30.info("An error occurred while attempting to download a file");
               console.log(error3);
               yield backOff();
               continue;
@@ -126839,7 +126839,7 @@ var require_download_http_client = __commonJS({
               }
             }
             if (forceRetry || (0, utils_1.isRetryableStatusCode)(response.message.statusCode)) {
-              core31.info(`A ${response.message.statusCode} response code has been received while attempting to download an artifact`);
+              core30.info(`A ${response.message.statusCode} response code has been received while attempting to download an artifact`);
               resetDestinationStream(downloadPath);
               (0, utils_1.isThrottledStatusCode)(response.message.statusCode) ? yield backOff((0, utils_1.tryGetRetryAfterValueTimeInMilliseconds)(response.message.headers)) : yield backOff();
             } else {
@@ -126861,29 +126861,29 @@ var require_download_http_client = __commonJS({
             if (isGzip) {
               const gunzip = zlib3.createGunzip();
               response.message.on("error", (error3) => {
-                core31.info(`An error occurred while attempting to read the response stream`);
+                core30.info(`An error occurred while attempting to read the response stream`);
                 gunzip.close();
                 destinationStream.close();
                 reject(error3);
               }).pipe(gunzip).on("error", (error3) => {
-                core31.info(`An error occurred while attempting to decompress the response stream`);
+                core30.info(`An error occurred while attempting to decompress the response stream`);
                 destinationStream.close();
                 reject(error3);
               }).pipe(destinationStream).on("close", () => {
                 resolve13();
               }).on("error", (error3) => {
-                core31.info(`An error occurred while writing a downloaded file to ${destinationStream.path}`);
+                core30.info(`An error occurred while writing a downloaded file to ${destinationStream.path}`);
                 reject(error3);
               });
             } else {
               response.message.on("error", (error3) => {
-                core31.info(`An error occurred while attempting to read the response stream`);
+                core30.info(`An error occurred while attempting to read the response stream`);
                 destinationStream.close();
                 reject(error3);
               }).pipe(destinationStream).on("close", () => {
                 resolve13();
               }).on("error", (error3) => {
-                core31.info(`An error occurred while writing a downloaded file to ${destinationStream.path}`);
+                core30.info(`An error occurred while writing a downloaded file to ${destinationStream.path}`);
                 reject(error3);
               });
             }
@@ -127022,7 +127022,7 @@ var require_artifact_client = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DefaultArtifactClient = void 0;
-    var core31 = __importStar2(require_core3());
+    var core30 = __importStar2(require_core4());
     var upload_specification_1 = require_upload_specification();
     var upload_http_client_1 = require_upload_http_client();
     var utils_1 = require_utils11();
@@ -127043,7 +127043,7 @@ var require_artifact_client = __commonJS({
        */
       uploadArtifact(name, files, rootDirectory, options) {
         return __awaiter2(this, void 0, void 0, function* () {
-          core31.info(`Starting artifact upload
+          core30.info(`Starting artifact upload
 For more detailed logs during the artifact upload process, enable step-debugging: https://docs.github.com/actions/monitoring-and-troubleshooting-workflows/enabling-debug-logging#enabling-step-debug-logging`);
           (0, path_and_artifact_name_validation_1.checkArtifactName)(name);
           const uploadSpecification = (0, upload_specification_1.getUploadSpecification)(name, rootDirectory, files);
@@ -127055,24 +127055,24 @@ For more detailed logs during the artifact upload process, enable step-debugging
           };
           const uploadHttpClient = new upload_http_client_1.UploadHttpClient();
           if (uploadSpecification.length === 0) {
-            core31.warning(`No files found that can be uploaded`);
+            core30.warning(`No files found that can be uploaded`);
           } else {
             const response = yield uploadHttpClient.createArtifactInFileContainer(name, options);
             if (!response.fileContainerResourceUrl) {
-              core31.debug(response.toString());
+              core30.debug(response.toString());
               throw new Error("No URL provided by the Artifact Service to upload an artifact to");
             }
-            core31.debug(`Upload Resource URL: ${response.fileContainerResourceUrl}`);
-            core31.info(`Container for artifact "${name}" successfully created. Starting upload of file(s)`);
+            core30.debug(`Upload Resource URL: ${response.fileContainerResourceUrl}`);
+            core30.info(`Container for artifact "${name}" successfully created. Starting upload of file(s)`);
             const uploadResult = yield uploadHttpClient.uploadArtifactToFileContainer(response.fileContainerResourceUrl, uploadSpecification, options);
-            core31.info(`File upload process has finished. Finalizing the artifact upload`);
+            core30.info(`File upload process has finished. Finalizing the artifact upload`);
             yield uploadHttpClient.patchArtifactSize(uploadResult.totalSize, name);
             if (uploadResult.failedItems.length > 0) {
-              core31.info(`Upload finished. There were ${uploadResult.failedItems.length} items that failed to upload`);
+              core30.info(`Upload finished. There were ${uploadResult.failedItems.length} items that failed to upload`);
             } else {
-              core31.info(`Artifact has been finalized. All files have been successfully uploaded!`);
+              core30.info(`Artifact has been finalized. All files have been successfully uploaded!`);
             }
-            core31.info(`
+            core30.info(`
 The raw size of all the files that were specified for upload is ${uploadResult.totalSize} bytes
 The size of all the files that were uploaded is ${uploadResult.uploadSize} bytes. This takes into account any gzip compression used to reduce the upload size, time and storage
 
@@ -127106,10 +127106,10 @@ Note: The size of downloaded zips can differ significantly from the reported siz
           path28 = (0, path_1.resolve)(path28);
           const downloadSpecification = (0, download_specification_1.getDownloadSpecification)(name, items.value, path28, (options === null || options === void 0 ? void 0 : options.createArtifactFolder) || false);
           if (downloadSpecification.filesToDownload.length === 0) {
-            core31.info(`No downloadable files were found for the artifact: ${artifactToDownload.name}`);
+            core30.info(`No downloadable files were found for the artifact: ${artifactToDownload.name}`);
           } else {
             yield (0, utils_1.createDirectoriesForArtifact)(downloadSpecification.directoryStructure);
-            core31.info("Directory structure has been set up for the artifact");
+            core30.info("Directory structure has been set up for the artifact");
             yield (0, utils_1.createEmptyFilesForArtifact)(downloadSpecification.emptyFilesToCreate);
             yield downloadHttpClient.downloadSingleArtifact(downloadSpecification.filesToDownload);
           }
@@ -127125,7 +127125,7 @@ Note: The size of downloaded zips can differ significantly from the reported siz
           const response = [];
           const artifacts = yield downloadHttpClient.listArtifacts();
           if (artifacts.count === 0) {
-            core31.info("Unable to find any artifacts for the associated workflow");
+            core30.info("Unable to find any artifacts for the associated workflow");
             return response;
           }
           if (!path28) {
@@ -127137,11 +127137,11 @@ Note: The size of downloaded zips can differ significantly from the reported siz
           while (downloadedArtifacts < artifacts.count) {
             const currentArtifactToDownload = artifacts.value[downloadedArtifacts];
             downloadedArtifacts += 1;
-            core31.info(`starting download of artifact ${currentArtifactToDownload.name} : ${downloadedArtifacts}/${artifacts.count}`);
+            core30.info(`starting download of artifact ${currentArtifactToDownload.name} : ${downloadedArtifacts}/${artifacts.count}`);
             const items = yield downloadHttpClient.getContainerItems(currentArtifactToDownload.name, currentArtifactToDownload.fileContainerResourceUrl);
             const downloadSpecification = (0, download_specification_1.getDownloadSpecification)(currentArtifactToDownload.name, items.value, path28, true);
             if (downloadSpecification.filesToDownload.length === 0) {
-              core31.info(`No downloadable files were found for any artifact ${currentArtifactToDownload.name}`);
+              core30.info(`No downloadable files were found for any artifact ${currentArtifactToDownload.name}`);
             } else {
               yield (0, utils_1.createDirectoriesForArtifact)(downloadSpecification.directoryStructure);
               yield (0, utils_1.createEmptyFilesForArtifact)(downloadSpecification.emptyFilesToCreate);
@@ -127462,8 +127462,8 @@ var require_util16 = __commonJS({
       this._optimizeConstructedString(bytes.length);
       return this;
     };
-    util.ByteStringBuffer.prototype.putString = function(str2) {
-      return this.putBytes(util.encodeUtf8(str2));
+    util.ByteStringBuffer.prototype.putString = function(str) {
+      return this.putBytes(util.encodeUtf8(str));
     };
     util.ByteStringBuffer.prototype.putInt16 = function(i) {
       return this.putBytes(
@@ -127755,8 +127755,8 @@ var require_util16 = __commonJS({
       buffer.clear();
       return this;
     };
-    util.DataBuffer.prototype.putString = function(str2) {
-      return this.putBytes(str2, "utf16");
+    util.DataBuffer.prototype.putString = function(str) {
+      return this.putBytes(str, "utf16");
     };
     util.DataBuffer.prototype.putInt16 = function(i) {
       this.accommodate(2);
@@ -128143,11 +128143,11 @@ var require_util16 = __commonJS({
       }
       return output;
     };
-    util.encodeUtf8 = function(str2) {
-      return unescape(encodeURIComponent(str2));
+    util.encodeUtf8 = function(str) {
+      return unescape(encodeURIComponent(str));
     };
-    util.decodeUtf8 = function(str2) {
-      return decodeURIComponent(escape(str2));
+    util.decodeUtf8 = function(str) {
+      return decodeURIComponent(escape(str));
     };
     util.binary = {
       raw: {},
@@ -128162,15 +128162,15 @@ var require_util16 = __commonJS({
     util.binary.raw.encode = function(bytes) {
       return String.fromCharCode.apply(null, bytes);
     };
-    util.binary.raw.decode = function(str2, output, offset) {
+    util.binary.raw.decode = function(str, output, offset) {
       var out = output;
       if (!out) {
-        out = new Uint8Array(str2.length);
+        out = new Uint8Array(str.length);
       }
       offset = offset || 0;
       var j = offset;
-      for (var i = 0; i < str2.length; ++i) {
-        out[j++] = str2.charCodeAt(i);
+      for (var i = 0; i < str.length; ++i) {
+        out[j++] = str.charCodeAt(i);
       }
       return output ? j - offset : out;
     };
@@ -128250,33 +128250,33 @@ var require_util16 = __commonJS({
       utf8: {},
       utf16: {}
     };
-    util.text.utf8.encode = function(str2, output, offset) {
-      str2 = util.encodeUtf8(str2);
+    util.text.utf8.encode = function(str, output, offset) {
+      str = util.encodeUtf8(str);
       var out = output;
       if (!out) {
-        out = new Uint8Array(str2.length);
+        out = new Uint8Array(str.length);
       }
       offset = offset || 0;
       var j = offset;
-      for (var i = 0; i < str2.length; ++i) {
-        out[j++] = str2.charCodeAt(i);
+      for (var i = 0; i < str.length; ++i) {
+        out[j++] = str.charCodeAt(i);
       }
       return output ? j - offset : out;
     };
     util.text.utf8.decode = function(bytes) {
       return util.decodeUtf8(String.fromCharCode.apply(null, bytes));
     };
-    util.text.utf16.encode = function(str2, output, offset) {
+    util.text.utf16.encode = function(str, output, offset) {
       var out = output;
       if (!out) {
-        out = new Uint8Array(str2.length * 2);
+        out = new Uint8Array(str.length * 2);
       }
       var view = new Uint16Array(out.buffer);
       offset = offset || 0;
       var j = offset;
       var k = offset;
-      for (var i = 0; i < str2.length; ++i) {
-        view[k++] = str2.charCodeAt(i);
+      for (var i = 0; i < str.length; ++i) {
+        view[k++] = str.charCodeAt(i);
         j += 2;
       }
       return output ? j - offset : out;
@@ -128379,33 +128379,33 @@ var require_util16 = __commonJS({
       if (typeof location === "undefined") {
         location = ["web", "flash"];
       }
-      var type2;
+      var type;
       var done = false;
-      var exception2 = null;
+      var exception = null;
       for (var idx in location) {
-        type2 = location[idx];
+        type = location[idx];
         try {
-          if (type2 === "flash" || type2 === "both") {
+          if (type === "flash" || type === "both") {
             if (args[0] === null) {
               throw new Error("Flash local storage not available.");
             }
             rval = func.apply(this, args);
-            done = type2 === "flash";
+            done = type === "flash";
           }
-          if (type2 === "web" || type2 === "both") {
+          if (type === "web" || type === "both") {
             args[0] = localStorage;
             rval = func.apply(this, args);
             done = true;
           }
         } catch (ex) {
-          exception2 = ex;
+          exception = ex;
         }
         if (done) {
           break;
         }
       }
       if (!done) {
-        throw exception2;
+        throw exception;
       }
       return rval;
     };
@@ -128633,12 +128633,12 @@ var require_util16 = __commonJS({
           URL.revokeObjectURL(blobUrl);
           return callback(null, util.cores);
         }
-        map2(numWorkers, function(err, results) {
+        map(numWorkers, function(err, results) {
           max.push(reduce(numWorkers, results));
           sample(max, samples - 1, numWorkers);
         });
       }
-      function map2(numWorkers, callback2) {
+      function map(numWorkers, callback2) {
         var workers = [];
         var results = [];
         for (var i = 0; i < numWorkers; ++i) {
@@ -129905,7 +129905,7 @@ var require_asn1 = __commonJS({
       BMPSTRING: 30
     };
     asn1.maxDepth = 256;
-    asn1.create = function(tagClass, type2, constructed, value, options) {
+    asn1.create = function(tagClass, type, constructed, value, options) {
       if (forge.util.isArray(value)) {
         var tmp = [];
         for (var i = 0; i < value.length; ++i) {
@@ -129917,7 +129917,7 @@ var require_asn1 = __commonJS({
       }
       var obj = {
         tagClass,
-        type: type2,
+        type,
         constructed,
         composed: constructed || forge.util.isArray(value),
         value
@@ -130071,7 +130071,7 @@ var require_asn1 = __commonJS({
       var b1 = bytes.getByte();
       remaining--;
       var tagClass = b1 & 192;
-      var type2 = b1 & 31;
+      var type = b1 & 31;
       start = bytes.length();
       var length = _getValueLength(bytes, remaining);
       remaining -= start - bytes.length();
@@ -130111,16 +130111,16 @@ var require_asn1 = __commonJS({
           }
         }
       }
-      if (value === void 0 && tagClass === asn1.Class.UNIVERSAL && type2 === asn1.Type.BITSTRING) {
+      if (value === void 0 && tagClass === asn1.Class.UNIVERSAL && type === asn1.Type.BITSTRING) {
         bitStringContents = bytes.bytes(length);
       }
       if (value === void 0 && options.decodeBitStrings && tagClass === asn1.Class.UNIVERSAL && // FIXME: OCTET STRINGs not yet supported here
       // .. other parts of forge expect to decode OCTET STRINGs manually
-      type2 === asn1.Type.BITSTRING && length > 1) {
+      type === asn1.Type.BITSTRING && length > 1) {
         var savedRead = bytes.read;
         var savedRemaining = remaining;
         var unused = 0;
-        if (type2 === asn1.Type.BITSTRING) {
+        if (type === asn1.Type.BITSTRING) {
           _checkBufferLength(bytes, remaining, 1);
           unused = bytes.getByte();
           remaining--;
@@ -130136,7 +130136,7 @@ var require_asn1 = __commonJS({
             var composed = _fromDer(bytes, remaining, depth + 1, subOptions);
             var used = start - bytes.length();
             remaining -= used;
-            if (type2 == asn1.Type.BITSTRING) {
+            if (type == asn1.Type.BITSTRING) {
               used++;
             }
             var tc = composed.tagClass;
@@ -130158,7 +130158,7 @@ var require_asn1 = __commonJS({
           }
           length = remaining;
         }
-        if (type2 === asn1.Type.BMPSTRING) {
+        if (type === asn1.Type.BMPSTRING) {
           value = "";
           for (; length > 0; length -= 2) {
             _checkBufferLength(bytes, remaining, 2);
@@ -130173,7 +130173,7 @@ var require_asn1 = __commonJS({
       var asn1Options = bitStringContents === void 0 ? null : {
         bitStringContents
       };
-      return asn1.create(tagClass, type2, constructed, value, asn1Options);
+      return asn1.create(tagClass, type, constructed, value, asn1Options);
     }
     asn1.toDer = function(obj) {
       var bytes = forge.util.createBuffer();
@@ -131110,23 +131110,23 @@ var require_pem = __commonJS({
       rval += "-----END " + msg.type + "-----\r\n";
       return rval;
     };
-    pem.decode = function(str2) {
+    pem.decode = function(str) {
       var rval = [];
       var rMessage = /\s*-----BEGIN ([A-Z0-9- ]+)-----\r?\n?([\x21-\x7e\s]+?(?:\r?\n\r?\n))?([:A-Za-z0-9+\/=\s]+?)-----END \1-----/g;
       var rHeader = /([\x21-\x7e]+):\s*([\x21-\x7e\s^:]+)/;
       var rCRLF = /\r?\n/;
       var match;
       while (true) {
-        match = rMessage.exec(str2);
+        match = rMessage.exec(str);
         if (!match) {
           break;
         }
-        var type2 = match[1];
-        if (type2 === "NEW CERTIFICATE REQUEST") {
-          type2 = "CERTIFICATE REQUEST";
+        var type = match[1];
+        if (type === "NEW CERTIFICATE REQUEST") {
+          type = "CERTIFICATE REQUEST";
         }
         var msg = {
-          type: type2,
+          type,
           procType: null,
           contentDomain: null,
           dekInfo: null,
@@ -131215,8 +131215,8 @@ var require_pem = __commonJS({
       }
       return rval;
     }
-    function ltrim(str2) {
-      return str2.replace(/^\s+/, "");
+    function ltrim(str) {
+      return str.replace(/^\s+/, "");
     }
   }
 });
@@ -137145,12 +137145,12 @@ var require_x509 = __commonJS({
     };
     pki2.RDNAttributesAsArray = function(rdn, md2) {
       var rval = [];
-      var set2, attr, obj;
+      var set, attr, obj;
       for (var si = 0; si < rdn.value.length; ++si) {
-        set2 = rdn.value[si];
-        for (var i = 0; i < set2.value.length; ++i) {
+        set = rdn.value[si];
+        for (var i = 0; i < set.value.length; ++i) {
           obj = {};
-          attr = set2.value[i];
+          attr = set.value[i];
           obj.type = asn1.derToOid(attr.value[0].value);
           obj.value = attr.value[1].value;
           obj.valueTagClass = attr.value[1].type;
@@ -137172,12 +137172,12 @@ var require_x509 = __commonJS({
     pki2.CRIAttributesAsArray = function(attributes) {
       var rval = [];
       for (var si = 0; si < attributes.length; ++si) {
-        var seq2 = attributes[si];
-        var type2 = asn1.derToOid(seq2.value[0].value);
-        var values = seq2.value[1].value;
+        var seq = attributes[si];
+        var type = asn1.derToOid(seq.value[0].value);
+        var values = seq.value[1].value;
         for (var vi = 0; vi < values.length; ++vi) {
           var obj = {};
-          obj.type = type2;
+          obj.type = type;
           obj.value = values[vi].value;
           obj.valueTagClass = values[vi].type;
           if (obj.type in oids) {
@@ -137379,9 +137379,9 @@ var require_x509 = __commonJS({
     pki2.getPublicKeyFingerprint = function(key, options) {
       options = options || {};
       var md2 = options.md || forge.md.sha1.create();
-      var type2 = options.type || "RSAPublicKey";
+      var type = options.type || "RSAPublicKey";
       var bytes;
-      switch (type2) {
+      switch (type) {
         case "RSAPublicKey":
           bytes = asn1.toDer(pki2.publicKeyToRSAPublicKey(key)).getBytes();
           break;
@@ -137943,7 +137943,7 @@ var require_x509 = __commonJS({
         true,
         []
       );
-      var attr, set2;
+      var attr, set;
       var attrs = obj.attributes;
       for (var i = 0; i < attrs.length; ++i) {
         attr = attrs[i];
@@ -137955,7 +137955,7 @@ var require_x509 = __commonJS({
             value = forge.util.encodeUtf8(value);
           }
         }
-        set2 = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SET, true, [
+        set = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SET, true, [
           asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
             // AttributeType
             asn1.create(
@@ -137968,7 +137968,7 @@ var require_x509 = __commonJS({
             asn1.create(asn1.Class.UNIVERSAL, valueTagClass, false, value)
           ])
         ]);
-        rval.value.push(set2);
+        rval.value.push(set);
       }
       return rval;
     }
@@ -138117,20 +138117,20 @@ var require_x509 = __commonJS({
           true,
           []
         );
-        var seq2 = e.value.value;
+        var seq = e.value.value;
         for (var key in e) {
           if (e[key] !== true) {
             continue;
           }
           if (key in oids) {
-            seq2.push(asn1.create(
+            seq.push(asn1.create(
               asn1.Class.UNIVERSAL,
               asn1.Type.OID,
               false,
               asn1.oidToDer(oids[key]).getBytes()
             ));
           } else if (key.indexOf(".") !== -1) {
-            seq2.push(asn1.create(
+            seq.push(asn1.create(
               asn1.Class.UNIVERSAL,
               asn1.Type.OID,
               false,
@@ -138233,10 +138233,10 @@ var require_x509 = __commonJS({
         );
       } else if (e.name === "authorityKeyIdentifier" && options.cert) {
         e.value = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, []);
-        var seq2 = e.value.value;
+        var seq = e.value.value;
         if (e.keyIdentifier) {
           var keyIdentifier = e.keyIdentifier === true ? options.cert.generateSubjectKeyIdentifier().getBytes() : e.keyIdentifier;
-          seq2.push(
+          seq.push(
             asn1.create(asn1.Class.CONTEXT_SPECIFIC, 0, false, keyIdentifier)
           );
         }
@@ -138246,19 +138246,19 @@ var require_x509 = __commonJS({
               _dnToAsn1(e.authorityCertIssuer === true ? options.cert.issuer : e.authorityCertIssuer)
             ])
           ];
-          seq2.push(
+          seq.push(
             asn1.create(asn1.Class.CONTEXT_SPECIFIC, 1, true, authorityCertIssuer)
           );
         }
         if (e.serialNumber) {
           var serialNumber = forge.util.hexToBytes(e.serialNumber === true ? options.cert.serialNumber : e.serialNumber);
-          seq2.push(
+          seq.push(
             asn1.create(asn1.Class.CONTEXT_SPECIFIC, 2, false, serialNumber)
           );
         }
       } else if (e.name === "cRLDistributionPoints") {
         e.value = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, []);
-        var seq2 = e.value.value;
+        var seq = e.value.value;
         var subSeq = asn1.create(
           asn1.Class.UNIVERSAL,
           asn1.Type.SEQUENCE,
@@ -138304,7 +138304,7 @@ var require_x509 = __commonJS({
           true,
           [fullNameGeneralNames]
         ));
-        seq2.push(subSeq);
+        seq.push(subSeq);
       }
       if (typeof e.value === "undefined") {
         var error3 = new Error("Extension value not specified.");
@@ -138386,7 +138386,7 @@ var require_x509 = __commonJS({
         if ("valueConstructed" in attr) {
           valueConstructed = attr.valueConstructed;
         }
-        var seq2 = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
+        var seq = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, [
           // AttributeType
           asn1.create(
             asn1.Class.UNIVERSAL,
@@ -138404,7 +138404,7 @@ var require_x509 = __commonJS({
             )
           ])
         ]);
-        rval.value.push(seq2);
+        rval.value.push(seq);
       }
       return rval;
     }
@@ -138555,10 +138555,10 @@ var require_x509 = __commonJS({
     };
     pki2.certificateExtensionsToAsn1 = function(exts) {
       var rval = asn1.create(asn1.Class.CONTEXT_SPECIFIC, 3, true, []);
-      var seq2 = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, []);
-      rval.value.push(seq2);
+      var seq = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, []);
+      rval.value.push(seq);
       for (var i = 0; i < exts.length; ++i) {
-        seq2.value.push(pki2.certificateExtensionToAsn1(exts[i]));
+        seq.value.push(pki2.certificateExtensionToAsn1(exts[i]));
       }
       return rval;
     };
@@ -140720,7 +140720,7 @@ var require_tls = __commonJS({
     };
     tls.handleHandshake = function(c, record) {
       var b = record.fragment;
-      var type2 = b.getByte();
+      var type = b.getByte();
       var length = b.getInt24();
       if (length > b.length()) {
         c.fragmented = record;
@@ -140732,7 +140732,7 @@ var require_tls = __commonJS({
       b.read -= 4;
       var bytes = b.bytes(length + 4);
       b.read += 4;
-      if (type2 in hsTable[c.entity][c.expect]) {
+      if (type in hsTable[c.entity][c.expect]) {
         if (c.entity === tls.ConnectionEnd.server && !c.open && !c.fail) {
           c.handshaking = true;
           c.session = {
@@ -140750,11 +140750,11 @@ var require_tls = __commonJS({
             sha1: forge.md.sha1.create()
           };
         }
-        if (type2 !== tls.HandshakeType.hello_request && type2 !== tls.HandshakeType.certificate_verify && type2 !== tls.HandshakeType.finished) {
+        if (type !== tls.HandshakeType.hello_request && type !== tls.HandshakeType.certificate_verify && type !== tls.HandshakeType.finished) {
           c.session.md5.update(bytes);
           c.session.sha1.update(bytes);
         }
-        hsTable[c.entity][c.expect][type2](c, record, length);
+        hsTable[c.entity][c.expect][type](c, record, length);
       } else {
         tls.handleUnexpected(c, record);
       }
@@ -140766,10 +140766,10 @@ var require_tls = __commonJS({
     };
     tls.handleHeartbeat = function(c, record) {
       var b = record.fragment;
-      var type2 = b.getByte();
+      var type = b.getByte();
       var length = b.getInt16();
       var payload = b.getBytes(length);
-      if (type2 === tls.HeartbeatMessageType.heartbeat_request) {
+      if (type === tls.HeartbeatMessageType.heartbeat_request) {
         if (c.handshaking || length > payload.length) {
           return c.process();
         }
@@ -140781,7 +140781,7 @@ var require_tls = __commonJS({
           )
         }));
         tls.flush(c);
-      } else if (type2 === tls.HeartbeatMessageType.heartbeat_response) {
+      } else if (type === tls.HeartbeatMessageType.heartbeat_response) {
         if (payload !== c.expectedHeartbeatPayload) {
           return c.process();
         }
@@ -141321,12 +141321,12 @@ var require_tls = __commonJS({
       rval.putBuffer(b);
       return rval;
     };
-    tls.createHeartbeat = function(type2, payload, payloadLength) {
+    tls.createHeartbeat = function(type, payload, payloadLength) {
       if (typeof payloadLength === "undefined") {
         payloadLength = payload.length;
       }
       var rval = forge.util.createBuffer();
-      rval.putByte(type2);
+      rval.putByte(type);
       rval.putInt16(payloadLength);
       rval.putBytes(payload);
       var plaintextLength = rval.length();
@@ -144677,9 +144677,9 @@ var require_pkcs7 = __commonJS({
         var jan_1_2050 = /* @__PURE__ */ new Date("2050-01-01T00:00:00Z");
         var date = attr.value;
         if (typeof date === "string") {
-          var timestamp2 = Date.parse(date);
-          if (!isNaN(timestamp2)) {
-            date = new Date(timestamp2);
+          var timestamp = Date.parse(date);
+          if (!isNaN(timestamp)) {
+            date = new Date(timestamp);
           } else if (date.length === 13) {
             date = asn1.utcTimeToDate(date);
           } else {
@@ -144901,13 +144901,13 @@ var require_ssh = __commonJS({
       return ppk;
     };
     ssh.publicKeyToOpenSSH = function(key, comment) {
-      var type2 = "ssh-rsa";
+      var type = "ssh-rsa";
       comment = comment || "";
       var buffer = forge.util.createBuffer();
-      _addStringToBuffer(buffer, type2);
+      _addStringToBuffer(buffer, type);
       _addBigIntegerToBuffer(buffer, key.e);
       _addBigIntegerToBuffer(buffer, key.n);
-      return type2 + " " + forge.util.encode64(buffer.bytes()) + " " + comment;
+      return type + " " + forge.util.encode64(buffer.bytes()) + " " + comment;
     };
     ssh.privateKeyToOpenSSH = function(privateKey, passphrase) {
       if (!passphrase) {
@@ -144922,9 +144922,9 @@ var require_ssh = __commonJS({
     ssh.getPublicKeyFingerprint = function(key, options) {
       options = options || {};
       var md2 = options.md || forge.md.md5.create();
-      var type2 = "ssh-rsa";
+      var type = "ssh-rsa";
       var buffer = forge.util.createBuffer();
-      _addStringToBuffer(buffer, type2);
+      _addStringToBuffer(buffer, type);
       _addBigIntegerToBuffer(buffer, key.e);
       _addBigIntegerToBuffer(buffer, key.n);
       md2.start();
@@ -145021,12 +145021,12 @@ module.exports = __toCommonJS(entry_points_exports);
 var fs22 = __toESM(require("fs"));
 var import_path4 = __toESM(require("path"));
 var import_perf_hooks4 = require("perf_hooks");
-var core16 = __toESM(require_core());
+var core15 = __toESM(require_core());
 
 // src/actions-util.ts
 var fs2 = __toESM(require("fs"));
 var path2 = __toESM(require("path"));
-var core4 = __toESM(require_core());
+var core3 = __toESM(require_core());
 var toolrunner = __toESM(require_toolrunner());
 var github = __toESM(require_github());
 var io2 = __toESM(require_io());
@@ -145036,7 +145036,7 @@ var fs = __toESM(require("fs"));
 var fsPromises = __toESM(require("fs/promises"));
 var os = __toESM(require("os"));
 var path = __toESM(require("path"));
-var core3 = __toESM(require_core());
+var core2 = __toESM(require_core());
 var io = __toESM(require_io());
 
 // node_modules/get-folder-size/index.js
@@ -145095,524 +145095,499 @@ async function core(rootItemPath, options = {}, returnType = {}) {
 }
 
 // node_modules/js-yaml/dist/js-yaml.mjs
-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(string2, count) {
-  var result = "", cycle;
-  for (cycle = 0; cycle < count; cycle += 1) {
-    result += string2;
-  }
-  return result;
-}
-function isNegativeZero(number) {
-  return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
-}
-var isNothing_1 = isNothing;
-var isObject_1 = isObject;
-var toArray_1 = toArray;
-var repeat_1 = repeat;
-var isNegativeZero_1 = isNegativeZero;
-var extend_1 = extend;
-var common = {
-  isNothing: isNothing_1,
-  isObject: isObject_1,
-  toArray: toArray_1,
-  repeat: repeat_1,
-  isNegativeZero: isNegativeZero_1,
-  extend: extend_1
-};
-function formatError(exception2, compact) {
-  var where = "", message = exception2.reason || "(unknown reason)";
-  if (!exception2.mark) return message;
-  if (exception2.mark.name) {
-    where += 'in "' + exception2.mark.name + '" ';
-  }
-  where += "(" + (exception2.mark.line + 1) + ":" + (exception2.mark.column + 1) + ")";
-  if (!compact && exception2.mark.snippet) {
-    where += "\n\n" + exception2.mark.snippet;
-  }
-  return message + " " + where;
-}
-function YAMLException$1(reason, mark) {
-  Error.call(this);
-  this.name = "YAMLException";
-  this.reason = reason;
-  this.mark = mark;
-  this.message = formatError(this, false);
-  if (Error.captureStackTrace) {
-    Error.captureStackTrace(this, this.constructor);
-  } else {
-    this.stack = new Error().stack || "";
+var __create2 = Object.create;
+var __defProp2 = Object.defineProperty;
+var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames2 = Object.getOwnPropertyNames;
+var __getProtoOf2 = Object.getPrototypeOf;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps2 = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames2(from), i = 0, n = keys.length, key; i < n; i++) {
+    key = keys[i];
+    if (!__hasOwnProp2.call(to, key) && key !== except) __defProp2(to, key, {
+      get: ((k) => from[k]).bind(null, key),
+      enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
+    });
   }
-}
-YAMLException$1.prototype = Object.create(Error.prototype);
-YAMLException$1.prototype.constructor = YAMLException$1;
-YAMLException$1.prototype.toString = function toString(compact) {
-  return this.name + ": " + formatError(this, compact);
+  return to;
 };
-var exception = YAMLException$1;
-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;
+var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var require_common = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  function isNothing(subject) {
+    return typeof subject === "undefined" || subject === null;
+  }
+  function isObject2(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) {
+    if (source) {
+      const sourceKeys = Object.keys(source);
+      for (let index = 0, length = sourceKeys.length; index < length; index += 1) {
+        const key = sourceKeys[index];
+        target[key] = source[key];
+      }
+    }
+    return target;
+  }
+  function repeat(string2, count) {
+    let result = "";
+    for (let cycle = 0; cycle < count; cycle += 1) result += string2;
+    return result;
   }
-  return {
-    str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "\u2192") + tail,
-    pos: position - lineStart + head.length
-    // relative position
+  function isNegativeZero(number) {
+    return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
+  }
+  module2.exports.isNothing = isNothing;
+  module2.exports.isObject = isObject2;
+  module2.exports.toArray = toArray;
+  module2.exports.repeat = repeat;
+  module2.exports.isNegativeZero = isNegativeZero;
+  module2.exports.extend = extend;
+}));
+var require_exception = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  function formatError(exception, compact) {
+    let where = "";
+    const 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 YAMLException2(reason, mark) {
+    Error.call(this);
+    this.name = "YAMLException";
+    this.reason = reason;
+    this.mark = mark;
+    this.message = formatError(this, false);
+    if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+    else this.stack = (/* @__PURE__ */ new Error()).stack || "";
+  }
+  YAMLException2.prototype = Object.create(Error.prototype);
+  YAMLException2.prototype.constructor = YAMLException2;
+  YAMLException2.prototype.toString = function toString2(compact) {
+    return this.name + ": " + formatError(this, compact);
   };
-}
-function padStart(string2, max) {
-  return common.repeat(" ", max - string2.length) + string2;
-}
-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$/, "");
-}
-var snippet = makeSnippet;
-var TYPE_CONSTRUCTOR_OPTIONS = [
-  "kind",
-  "multi",
-  "resolve",
-  "construct",
-  "instanceOf",
-  "predicate",
-  "represent",
-  "representName",
-  "defaultStyle",
-  "styleAliases"
-];
-var YAML_NODE_KINDS = [
-  "scalar",
-  "sequence",
-  "mapping"
-];
-function compileStyleAliases(map2) {
-  var result = {};
-  if (map2 !== null) {
-    Object.keys(map2).forEach(function(style) {
-      map2[style].forEach(function(alias) {
+  module2.exports = YAMLException2;
+}));
+var require_snippet = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var common = require_common();
+  function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
+    let head = "";
+    let tail = "";
+    const 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, "\u2192") + tail,
+      pos: position - lineStart + head.length
+    };
+  }
+  function padStart(string2, max) {
+    return common.repeat(" ", max - string2.length) + string2;
+  }
+  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;
+    const re = /\r?\n|\r|\0/g;
+    const lineStarts = [0];
+    const lineEnds = [];
+    let match;
+    let 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;
+    let result = "";
+    const lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
+    const maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
+    for (let i = 1; i <= options.linesBefore; i++) {
+      if (foundLineNo - i < 0) break;
+      const line2 = 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) + " | " + line2.str + "\n" + result;
+    }
+    const 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 (let i = 1; i <= options.linesAfter; i++) {
+      if (foundLineNo + i >= lineEnds.length) break;
+      const line2 = 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) + " | " + line2.str + "\n";
+    }
+    return result.replace(/\n$/, "");
+  }
+  module2.exports = makeSnippet;
+}));
+var require_type = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var YAMLException2 = require_exception();
+  var TYPE_CONSTRUCTOR_OPTIONS = [
+    "kind",
+    "multi",
+    "resolve",
+    "construct",
+    "instanceOf",
+    "predicate",
+    "represent",
+    "representName",
+    "defaultStyle",
+    "styleAliases"
+  ];
+  var YAML_NODE_KINDS = [
+    "scalar",
+    "sequence",
+    "mapping"
+  ];
+  function compileStyleAliases(map) {
+    const result = {};
+    if (map !== null) Object.keys(map).forEach(function(style) {
+      map[style].forEach(function(alias) {
         result[String(alias)] = style;
       });
     });
+    return result;
   }
-  return result;
-}
-function Type$1(tag, options) {
-  options = options || {};
-  Object.keys(options).forEach(function(name) {
-    if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) {
-      throw new exception('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
-    }
-  });
-  this.options = options;
-  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 exception('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
-  }
-}
-var type = Type$1;
-function compileList(schema2, name) {
-  var result = [];
-  schema2[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;
-      }
+  function Type2(tag, options) {
+    options = options || {};
+    Object.keys(options).forEach(function(name) {
+      if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) throw new YAMLException2('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
     });
-    result[newIndex] = currentType;
-  });
-  return result;
-}
-function compileMap() {
-  var result = {
-    scalar: {},
-    sequence: {},
-    mapping: {},
-    fallback: {},
-    multi: {
-      scalar: [],
-      sequence: [],
-      mapping: [],
-      fallback: []
-    }
-  }, index, length;
-  function collectType(type2) {
-    if (type2.multi) {
-      result.multi[type2.kind].push(type2);
-      result.multi["fallback"].push(type2);
-    } else {
-      result[type2.kind][type2.tag] = result["fallback"][type2.tag] = type2;
-    }
-  }
-  for (index = 0, length = arguments.length; index < length; index += 1) {
-    arguments[index].forEach(collectType);
+    this.options = options;
+    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 YAMLException2('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
+  }
+  module2.exports = Type2;
+}));
+var require_schema = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var YAMLException2 = require_exception();
+  var Type2 = require_type();
+  function compileList(schema, name) {
+    const result = [];
+    schema[name].forEach(function(currentType) {
+      let 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;
   }
-  return result;
-}
-function Schema$1(definition) {
-  return this.extend(definition);
-}
-Schema$1.prototype.extend = function extend2(definition) {
-  var implicit = [];
-  var explicit = [];
-  if (definition instanceof type) {
-    explicit.push(definition);
-  } else if (Array.isArray(definition)) {
-    explicit = explicit.concat(definition);
-  } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
-    if (definition.implicit) implicit = implicit.concat(definition.implicit);
-    if (definition.explicit) explicit = explicit.concat(definition.explicit);
-  } else {
-    throw new exception("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
+  function compileMap() {
+    const result = {
+      scalar: {},
+      sequence: {},
+      mapping: {},
+      fallback: {},
+      multi: {
+        scalar: [],
+        sequence: [],
+        mapping: [],
+        fallback: []
+      }
+    };
+    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 (let index = 0, length = arguments.length; index < length; index += 1) arguments[index].forEach(collectType);
+    return result;
   }
-  implicit.forEach(function(type$1) {
-    if (!(type$1 instanceof type)) {
-      throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object.");
-    }
-    if (type$1.loadKind && type$1.loadKind !== "scalar") {
-      throw new exception("There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.");
-    }
-    if (type$1.multi) {
-      throw new exception("There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.");
+  function Schema2(definition) {
+    return this.extend(definition);
+  }
+  Schema2.prototype.extend = function extend(definition) {
+    let implicit = [];
+    let explicit = [];
+    if (definition instanceof Type2) explicit.push(definition);
+    else if (Array.isArray(definition)) explicit = explicit.concat(definition);
+    else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
+      if (definition.implicit) implicit = implicit.concat(definition.implicit);
+      if (definition.explicit) explicit = explicit.concat(definition.explicit);
+    } else throw new YAMLException2("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
+    implicit.forEach(function(type) {
+      if (!(type instanceof Type2)) throw new YAMLException2("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+      if (type.loadKind && type.loadKind !== "scalar") throw new YAMLException2("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 YAMLException2("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 Type2)) throw new YAMLException2("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+    });
+    const result = Object.create(Schema2.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;
+  };
+  module2.exports = Schema2;
+}));
+var require_str = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  module2.exports = new (require_type())("tag:yaml.org,2002:str", {
+    kind: "scalar",
+    construct: function(data) {
+      return data !== null ? data : "";
     }
   });
-  explicit.forEach(function(type$1) {
-    if (!(type$1 instanceof type)) {
-      throw new exception("Specified list of YAML types (or a single Type object) contains a non-Type object.");
+}));
+var require_seq = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  module2.exports = new (require_type())("tag:yaml.org,2002:seq", {
+    kind: "sequence",
+    construct: function(data) {
+      return data !== null ? data : [];
     }
   });
-  var result = Object.create(Schema$1.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;
-};
-var schema = Schema$1;
-var str = new type("tag:yaml.org,2002:str", {
-  kind: "scalar",
-  construct: function(data) {
-    return data !== null ? data : "";
-  }
-});
-var seq = new type("tag:yaml.org,2002:seq", {
-  kind: "sequence",
-  construct: function(data) {
-    return data !== null ? data : [];
-  }
-});
-var map = new type("tag:yaml.org,2002:map", {
-  kind: "mapping",
-  construct: function(data) {
-    return data !== null ? data : {};
-  }
-});
-var failsafe = new schema({
-  explicit: [
-    str,
-    seq,
-    map
-  ]
-});
-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;
-}
-var _null = 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"
-});
-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]";
-}
-var bool = 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"
-});
-function isHexCode(c) {
-  return 48 <= c && c <= 57 || 65 <= c && c <= 70 || 97 <= c && c <= 102;
-}
-function isOctCode(c) {
-  return 48 <= c && c <= 55;
-}
-function isDecCode(c) {
-  return 48 <= c && c <= 57;
-}
-function resolveYamlInteger(data) {
-  if (data === null) return false;
-  var max = data.length, index = 0, hasDigits = false, ch;
-  if (!max) return false;
-  ch = data[index];
-  if (ch === "-" || ch === "+") {
-    ch = data[++index];
-  }
-  if (ch === "0") {
-    if (index + 1 === max) return true;
-    ch = data[++index];
-    if (ch === "b") {
-      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") {
-      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") {
-      index++;
-      for (; index < max; index++) {
-        ch = data[index];
-        if (ch === "_") continue;
-        if (!isOctCode(data.charCodeAt(index))) return false;
-        hasDigits = true;
-      }
-      return hasDigits && ch !== "_";
-    }
-  }
-  if (ch === "_") return false;
-  for (; index < max; index++) {
-    ch = data[index];
-    if (ch === "_") continue;
-    if (!isDecCode(data.charCodeAt(index))) {
-      return false;
+}));
+var require_map = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  module2.exports = new (require_type())("tag:yaml.org,2002:map", {
+    kind: "mapping",
+    construct: function(data) {
+      return data !== null ? data : {};
     }
-    hasDigits = true;
-  }
-  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));
-}
-var int = 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);
+  });
+}));
+var require_failsafe = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  module2.exports = new (require_schema())({ explicit: [
+    require_str(),
+    require_seq(),
+    require_map()
+  ] });
+}));
+var require_null = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var Type2 = require_type();
+  function resolveYamlNull(data) {
+    if (data === null) return true;
+    const 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;
+  }
+  module2.exports = new Type2("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 "";
+      }
     },
-    octal: function(obj) {
-      return obj >= 0 ? "0o" + obj.toString(8) : "-0o" + obj.toString(8).slice(1);
+    defaultStyle: "lowercase"
+  });
+}));
+var require_bool = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var Type2 = require_type();
+  function resolveYamlBoolean(data) {
+    if (data === null) return false;
+    const 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]";
+  }
+  module2.exports = new Type2("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";
+      }
     },
-    decimal: function(obj) {
-      return obj.toString(10);
+    defaultStyle: "lowercase"
+  });
+}));
+var require_int = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var common = require_common();
+  var Type2 = require_type();
+  function isHexCode(c) {
+    return c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
+  }
+  function isOctCode(c) {
+    return c >= 48 && c <= 55;
+  }
+  function isDecCode(c) {
+    return c >= 48 && c <= 57;
+  }
+  function resolveYamlInteger(data) {
+    if (data === null) return false;
+    const max = data.length;
+    let index = 0;
+    let hasDigits = false;
+    if (!max) return false;
+    let ch = data[index];
+    if (ch === "-" || ch === "+") ch = data[++index];
+    if (ch === "0") {
+      if (index + 1 === max) return true;
+      ch = data[++index];
+      if (ch === "b") {
+        index++;
+        for (; index < max; index++) {
+          ch = data[index];
+          if (ch !== "0" && ch !== "1") return false;
+          hasDigits = true;
+        }
+        return hasDigits && Number.isFinite(parseYamlInteger(data));
+      }
+      if (ch === "x") {
+        index++;
+        for (; index < max; index++) {
+          if (!isHexCode(data.charCodeAt(index))) return false;
+          hasDigits = true;
+        }
+        return hasDigits && Number.isFinite(parseYamlInteger(data));
+      }
+      if (ch === "o") {
+        index++;
+        for (; index < max; index++) {
+          if (!isOctCode(data.charCodeAt(index))) return false;
+          hasDigits = true;
+        }
+        return hasDigits && Number.isFinite(parseYamlInteger(data));
+      }
+    }
+    for (; index < max; index++) {
+      if (!isDecCode(data.charCodeAt(index))) return false;
+      hasDigits = true;
+    }
+    if (!hasDigits) return false;
+    return Number.isFinite(parseYamlInteger(data));
+  }
+  function parseYamlInteger(data) {
+    let value = data;
+    let sign = 1;
+    let 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 constructYamlInteger(data) {
+    return parseYamlInteger(data);
+  }
+  function isInteger(object) {
+    return Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !common.isNegativeZero(object);
+  }
+  module2.exports = new Type2("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);
+      },
+      hexadecimal: function(obj) {
+        return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
+      }
     },
-    /* 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"]
     }
-  },
-  defaultStyle: "decimal",
-  styleAliases: {
-    binary: [2, "bin"],
-    octal: [8, "oct"],
-    decimal: [10, "dec"],
-    hexadecimal: [16, "hex"]
-  }
-});
-var YAML_FLOAT_PATTERN = new RegExp(
-  // 2.5e4, 2.5 and integers
-  "^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?: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) {
+  });
+}));
+var require_float = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var common = require_common();
+  var Type2 = require_type();
+  var YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:[0-9]+)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+  var YAML_FLOAT_SPECIAL_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+  function resolveYamlFloat(data) {
+    if (data === null) return false;
+    if (!YAML_FLOAT_PATTERN.test(data)) return false;
+    if (Number.isFinite(parseFloat(data, 10))) return true;
+    return YAML_FLOAT_SPECIAL_PATTERN.test(data);
+  }
+  function constructYamlFloat(data) {
+    let value = data.toLowerCase();
+    const 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) {
+    if (isNaN(object)) switch (style) {
       case "lowercase":
         return ".nan";
       case "uppercase":
@@ -145620,8 +145595,7 @@ function representYamlFloat(object, style) {
       case "camelcase":
         return ".NaN";
     }
-  } else if (Number.POSITIVE_INFINITY === object) {
-    switch (style) {
+    else if (Number.POSITIVE_INFINITY === object) switch (style) {
       case "lowercase":
         return ".inf";
       case "uppercase":
@@ -145629,8 +145603,7 @@ function representYamlFloat(object, style) {
       case "camelcase":
         return ".Inf";
     }
-  } else if (Number.NEGATIVE_INFINITY === object) {
-    switch (style) {
+    else if (Number.NEGATIVE_INFINITY === object) switch (style) {
       case "lowercase":
         return "-.inf";
       case "uppercase":
@@ -145638,2048 +145611,1850 @@ function representYamlFloat(object, style) {
       case "camelcase":
         return "-.Inf";
     }
-  } else if (common.isNegativeZero(object)) {
-    return "-0.0";
-  }
-  res = object.toString(10);
-  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));
-}
-var float = new type("tag:yaml.org,2002:float", {
-  kind: "scalar",
-  resolve: resolveYamlFloat,
-  construct: constructYamlFloat,
-  predicate: isFloat,
-  represent: representYamlFloat,
-  defaultStyle: "lowercase"
-});
-var json = failsafe.extend({
-  implicit: [
-    _null,
-    bool,
-    int,
-    float
-  ]
-});
-var core2 = json;
-var YAML_DATE_REGEXP = new RegExp(
-  "^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$"
-);
-var YAML_TIMESTAMP_REGEXP = new RegExp(
-  "^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$"
-);
-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");
-  year = +match[1];
-  month = +match[2] - 1;
-  day = +match[3];
-  if (!match[4]) {
-    return new Date(Date.UTC(year, month, day));
-  }
-  hour = +match[4];
-  minute = +match[5];
-  second = +match[6];
-  if (match[7]) {
-    fraction = match[7].slice(0, 3);
-    while (fraction.length < 3) {
-      fraction += "0";
-    }
-    fraction = +fraction;
-  }
-  if (match[9]) {
-    tz_hour = +match[10];
-    tz_minute = +(match[11] || 0);
-    delta = (tz_hour * 60 + tz_minute) * 6e4;
-    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) {
-  return object.toISOString();
-}
-var timestamp = new type("tag:yaml.org,2002:timestamp", {
-  kind: "scalar",
-  resolve: resolveYamlTimestamp,
-  construct: constructYamlTimestamp,
-  instanceOf: Date,
-  represent: representYamlTimestamp
-});
-function resolveYamlMerge(data) {
-  return data === "<<" || data === null;
-}
-var merge2 = new type("tag:yaml.org,2002:merge", {
-  kind: "scalar",
-  resolve: resolveYamlMerge
-});
-var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
-function resolveYamlBinary(data) {
-  if (data === null) return false;
-  var code, idx, bitlen = 0, max = data.length, map2 = BASE64_MAP;
-  for (idx = 0; idx < max; idx++) {
-    code = map2.indexOf(data.charAt(idx));
-    if (code > 64) continue;
-    if (code < 0) return false;
-    bitlen += 6;
-  }
-  return bitlen % 8 === 0;
-}
-function constructYamlBinary(data) {
-  var idx, tailbits, input = data.replace(/[\r\n=]/g, ""), max = input.length, map2 = BASE64_MAP, bits = 0, result = [];
-  for (idx = 0; idx < max; idx++) {
-    if (idx % 4 === 0 && idx) {
+    else if (common.isNegativeZero(object)) return "-0.0";
+    const res = object.toString(10);
+    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));
+  }
+  module2.exports = new Type2("tag:yaml.org,2002:float", {
+    kind: "scalar",
+    resolve: resolveYamlFloat,
+    construct: constructYamlFloat,
+    predicate: isFloat,
+    represent: representYamlFloat,
+    defaultStyle: "lowercase"
+  });
+}));
+var require_json = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  module2.exports = require_failsafe().extend({ implicit: [
+    require_null(),
+    require_bool(),
+    require_int(),
+    require_float()
+  ] });
+}));
+var require_core2 = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  module2.exports = require_json();
+}));
+var require_timestamp = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var Type2 = require_type();
+  var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+  var YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+  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) {
+    let fraction = 0;
+    let delta = null;
+    let match = YAML_DATE_REGEXP.exec(data);
+    if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
+    if (match === null) throw new Error("Date resolve error");
+    const year = +match[1];
+    const month = +match[2] - 1;
+    const day = +match[3];
+    if (!match[4]) return new Date(Date.UTC(year, month, day));
+    const hour = +match[4];
+    const minute = +match[5];
+    const second = +match[6];
+    if (match[7]) {
+      fraction = match[7].slice(0, 3);
+      while (fraction.length < 3) fraction += "0";
+      fraction = +fraction;
+    }
+    if (match[9]) {
+      const tzHour = +match[10];
+      const tzMinute = +(match[11] || 0);
+      delta = (tzHour * 60 + tzMinute) * 6e4;
+      if (match[9] === "-") delta = -delta;
+    }
+    const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+    if (delta) date.setTime(date.getTime() - delta);
+    return date;
+  }
+  function representYamlTimestamp(object) {
+    return object.toISOString();
+  }
+  module2.exports = new Type2("tag:yaml.org,2002:timestamp", {
+    kind: "scalar",
+    resolve: resolveYamlTimestamp,
+    construct: constructYamlTimestamp,
+    instanceOf: Date,
+    represent: representYamlTimestamp
+  });
+}));
+var require_merge = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var Type2 = require_type();
+  function resolveYamlMerge(data) {
+    return data === "<<" || data === null;
+  }
+  module2.exports = new Type2("tag:yaml.org,2002:merge", {
+    kind: "scalar",
+    resolve: resolveYamlMerge
+  });
+}));
+var require_binary = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var Type2 = require_type();
+  var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
+  function resolveYamlBinary(data) {
+    if (data === null) return false;
+    let bitlen = 0;
+    const max = data.length;
+    const map = BASE64_MAP;
+    for (let idx = 0; idx < max; idx++) {
+      const code = map.indexOf(data.charAt(idx));
+      if (code > 64) continue;
+      if (code < 0) return false;
+      bitlen += 6;
+    }
+    return bitlen % 8 === 0;
+  }
+  function constructYamlBinary(data) {
+    const input = data.replace(/[\r\n=]/g, "");
+    const max = input.length;
+    const map = BASE64_MAP;
+    let bits = 0;
+    const result = [];
+    for (let idx = 0; idx < max; idx++) {
+      if (idx % 4 === 0 && idx) {
+        result.push(bits >> 16 & 255);
+        result.push(bits >> 8 & 255);
+        result.push(bits & 255);
+      }
+      bits = bits << 6 | map.indexOf(input.charAt(idx));
+    }
+    const tailbits = max % 4 * 6;
+    if (tailbits === 0) {
       result.push(bits >> 16 & 255);
       result.push(bits >> 8 & 255);
       result.push(bits & 255);
+    } else if (tailbits === 18) {
+      result.push(bits >> 10 & 255);
+      result.push(bits >> 2 & 255);
+    } else if (tailbits === 12) result.push(bits >> 4 & 255);
+    return new Uint8Array(result);
+  }
+  function representYamlBinary(object) {
+    let result = "";
+    let bits = 0;
+    const max = object.length;
+    const map = BASE64_MAP;
+    for (let idx = 0; idx < max; idx++) {
+      if (idx % 3 === 0 && idx) {
+        result += map[bits >> 18 & 63];
+        result += map[bits >> 12 & 63];
+        result += map[bits >> 6 & 63];
+        result += map[bits & 63];
+      }
+      bits = (bits << 8) + object[idx];
+    }
+    const tail = max % 3;
+    if (tail === 0) {
+      result += map[bits >> 18 & 63];
+      result += map[bits >> 12 & 63];
+      result += map[bits >> 6 & 63];
+      result += map[bits & 63];
+    } else if (tail === 2) {
+      result += map[bits >> 10 & 63];
+      result += map[bits >> 4 & 63];
+      result += map[bits << 2 & 63];
+      result += map[64];
+    } else if (tail === 1) {
+      result += map[bits >> 2 & 63];
+      result += map[bits << 4 & 63];
+      result += map[64];
+      result += map[64];
     }
-    bits = bits << 6 | map2.indexOf(input.charAt(idx));
-  }
-  tailbits = max % 4 * 6;
-  if (tailbits === 0) {
-    result.push(bits >> 16 & 255);
-    result.push(bits >> 8 & 255);
-    result.push(bits & 255);
-  } else if (tailbits === 18) {
-    result.push(bits >> 10 & 255);
-    result.push(bits >> 2 & 255);
-  } else if (tailbits === 12) {
-    result.push(bits >> 4 & 255);
-  }
-  return new Uint8Array(result);
-}
-function representYamlBinary(object) {
-  var result = "", bits = 0, idx, tail, max = object.length, map2 = BASE64_MAP;
-  for (idx = 0; idx < max; idx++) {
-    if (idx % 3 === 0 && idx) {
-      result += map2[bits >> 18 & 63];
-      result += map2[bits >> 12 & 63];
-      result += map2[bits >> 6 & 63];
-      result += map2[bits & 63];
-    }
-    bits = (bits << 8) + object[idx];
-  }
-  tail = max % 3;
-  if (tail === 0) {
-    result += map2[bits >> 18 & 63];
-    result += map2[bits >> 12 & 63];
-    result += map2[bits >> 6 & 63];
-    result += map2[bits & 63];
-  } else if (tail === 2) {
-    result += map2[bits >> 10 & 63];
-    result += map2[bits >> 4 & 63];
-    result += map2[bits << 2 & 63];
-    result += map2[64];
-  } else if (tail === 1) {
-    result += map2[bits >> 2 & 63];
-    result += map2[bits << 4 & 63];
-    result += map2[64];
-    result += map2[64];
-  }
-  return result;
-}
-function isBinary(obj) {
-  return Object.prototype.toString.call(obj) === "[object Uint8Array]";
-}
-var binary = new type("tag:yaml.org,2002:binary", {
-  kind: "scalar",
-  resolve: resolveYamlBinary,
-  construct: constructYamlBinary,
-  predicate: isBinary,
-  represent: representYamlBinary
-});
-var _hasOwnProperty$3 = Object.prototype.hasOwnProperty;
-var _toString$2 = 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$2.call(pair) !== "[object Object]") return false;
-    for (pairKey in pair) {
-      if (_hasOwnProperty$3.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 : [];
-}
-var omap = new type("tag:yaml.org,2002:omap", {
-  kind: "sequence",
-  resolve: resolveYamlOmap,
-  construct: constructYamlOmap
-});
-var _toString$1 = 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$1.call(pair) !== "[object Object]") return false;
-    keys = Object.keys(pair);
-    if (keys.length !== 1) return false;
-    result[index] = [keys[0], pair[keys[0]]];
+    return result;
   }
-  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]]];
+  function isBinary(obj) {
+    return Object.prototype.toString.call(obj) === "[object Uint8Array]";
   }
-  return result;
-}
-var pairs = new type("tag:yaml.org,2002:pairs", {
-  kind: "sequence",
-  resolve: resolveYamlPairs,
-  construct: constructYamlPairs
-});
-var _hasOwnProperty$2 = Object.prototype.hasOwnProperty;
-function resolveYamlSet(data) {
-  if (data === null) return true;
-  var key, object = data;
-  for (key in object) {
-    if (_hasOwnProperty$2.call(object, key)) {
-      if (object[key] !== null) return false;
+  module2.exports = new Type2("tag:yaml.org,2002:binary", {
+    kind: "scalar",
+    resolve: resolveYamlBinary,
+    construct: constructYamlBinary,
+    predicate: isBinary,
+    represent: representYamlBinary
+  });
+}));
+var require_omap = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var Type2 = require_type();
+  var _hasOwnProperty = Object.prototype.hasOwnProperty;
+  var _toString = Object.prototype.toString;
+  function resolveYamlOmap(data) {
+    if (data === null) return true;
+    const objectKeys = [];
+    const object = data;
+    for (let index = 0, length = object.length; index < length; index += 1) {
+      const pair = object[index];
+      let pairHasKey = false;
+      if (_toString.call(pair) !== "[object Object]") return false;
+      let pairKey;
+      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;
   }
-  return true;
-}
-function constructYamlSet(data) {
-  return data !== null ? data : {};
-}
-var set = new type("tag:yaml.org,2002:set", {
-  kind: "mapping",
-  resolve: resolveYamlSet,
-  construct: constructYamlSet
-});
-var _default = core2.extend({
-  implicit: [
-    timestamp,
-    merge2
-  ],
-  explicit: [
-    binary,
-    omap,
-    pairs,
-    set
-  ]
-});
-var _hasOwnProperty$1 = 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 === 10 || c === 13;
-}
-function is_WHITE_SPACE(c) {
-  return c === 9 || c === 32;
-}
-function is_WS_OR_EOL(c) {
-  return c === 9 || c === 32 || c === 10 || c === 13;
-}
-function is_FLOW_INDICATOR(c) {
-  return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
-}
-function fromHexCode(c) {
-  var lc;
-  if (48 <= c && c <= 57) {
-    return c - 48;
-  }
-  lc = c | 32;
-  if (97 <= lc && lc <= 102) {
-    return lc - 97 + 10;
-  }
-  return -1;
-}
-function escapedHexLen(c) {
-  if (c === 120) {
-    return 2;
-  }
-  if (c === 117) {
-    return 4;
-  }
-  if (c === 85) {
-    return 8;
-  }
-  return 0;
-}
-function fromDecimalCode(c) {
-  if (48 <= c && c <= 57) {
-    return c - 48;
-  }
-  return -1;
-}
-function simpleEscapeSequence(c) {
-  return c === 48 ? "\0" : c === 97 ? "\x07" : c === 98 ? "\b" : c === 116 ? "	" : c === 9 ? "	" : c === 110 ? "\n" : c === 118 ? "\v" : c === 102 ? "\f" : c === 114 ? "\r" : c === 101 ? "\x1B" : c === 32 ? " " : c === 34 ? '"' : c === 47 ? "/" : c === 92 ? "\\" : c === 78 ? "\x85" : c === 95 ? "\xA0" : c === 76 ? "\u2028" : c === 80 ? "\u2029" : "";
-}
-function charFromCodepoint(c) {
-  if (c <= 65535) {
-    return String.fromCharCode(c);
-  }
-  return String.fromCharCode(
-    (c - 65536 >> 10) + 55296,
-    (c - 65536 & 1023) + 56320
-  );
-}
-function setProperty(object, key, value) {
-  if (key === "__proto__") {
-    Object.defineProperty(object, key, {
-      configurable: true,
-      enumerable: true,
-      writable: true,
-      value
-    });
-  } else {
-    object[key] = value;
-  }
-}
-var simpleEscapeCheck = new Array(256);
-var simpleEscapeMap = new Array(256);
-for (i = 0; i < 256; i++) {
-  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
-  simpleEscapeMap[i] = simpleEscapeSequence(i);
-}
-var i;
-function State$1(input, options) {
-  this.input = input;
-  this.filename = options["filename"] || null;
-  this.schema = options["schema"] || _default;
-  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.firstTabInLine = -1;
-  this.documents = [];
-}
-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 = snippet(mark);
-  return new exception(message, mark);
-}
-function throwError(state, message) {
-  throw generateError(state, message);
-}
-function throwWarning(state, message) {
-  if (state.onWarning) {
-    state.onWarning.call(null, generateError(state, message));
+  function constructYamlOmap(data) {
+    return data !== null ? data : [];
   }
-}
-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$1.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);
+  module2.exports = new Type2("tag:yaml.org,2002:omap", {
+    kind: "sequence",
+    resolve: resolveYamlOmap,
+    construct: constructYamlOmap
+  });
+}));
+var require_pairs = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var Type2 = require_type();
+  var _toString = Object.prototype.toString;
+  function resolveYamlPairs(data) {
+    if (data === null) return true;
+    const object = data;
+    const result = new Array(object.length);
+    for (let index = 0, length = object.length; index < length; index += 1) {
+      const pair = object[index];
+      if (_toString.call(pair) !== "[object Object]") return false;
+      const keys = Object.keys(pair);
+      if (keys.length !== 1) return false;
+      result[index] = [keys[0], pair[keys[0]]];
     }
-    state.tagMap[handle] = prefix;
+    return true;
   }
-};
-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 === 9 || 32 <= _character && _character <= 1114111)) {
-          throwError(state, "expected valid JSON character");
-        }
-      }
-    } else if (PATTERN_NON_PRINTABLE.test(_result)) {
-      throwError(state, "the stream contains non-printable characters");
+  function constructYamlPairs(data) {
+    if (data === null) return [];
+    const object = data;
+    const result = new Array(object.length);
+    for (let index = 0, length = object.length; index < length; index += 1) {
+      const pair = object[index];
+      const keys = Object.keys(pair);
+      result[index] = [keys[0], pair[keys[0]]];
     }
-    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");
+    return result;
   }
-  sourceKeys = Object.keys(source);
-  for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
-    key = sourceKeys[index];
-    if (!_hasOwnProperty$1.call(destination, key)) {
-      setProperty(destination, key, source[key]);
-      overridableKeys[key] = true;
+  module2.exports = new Type2("tag:yaml.org,2002:pairs", {
+    kind: "sequence",
+    resolve: resolveYamlPairs,
+    construct: constructYamlPairs
+  });
+}));
+var require_set = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var Type2 = require_type();
+  var _hasOwnProperty = Object.prototype.hasOwnProperty;
+  function resolveYamlSet(data) {
+    if (data === null) return true;
+    const object = data;
+    for (const key in object) if (_hasOwnProperty.call(object, key)) {
+      if (object[key] !== null) return false;
     }
+    return true;
   }
-}
-function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
-  var index, quantity;
-  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]";
-      }
-    }
+  function constructYamlSet(data) {
+    return data !== null ? data : {};
   }
-  if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") {
-    keyNode = "[object Object]";
+  module2.exports = new Type2("tag:yaml.org,2002:set", {
+    kind: "mapping",
+    resolve: resolveYamlSet,
+    construct: constructYamlSet
+  });
+}));
+var require_default = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  module2.exports = require_core2().extend({
+    implicit: [require_timestamp(), require_merge()],
+    explicit: [
+      require_binary(),
+      require_omap(),
+      require_pairs(),
+      require_set()
+    ]
+  });
+}));
+var require_loader = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var common = require_common();
+  var YAMLException2 = require_exception();
+  var makeSnippet = require_snippet();
+  var DEFAULT_SCHEMA2 = require_default();
+  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 = /^(?:!|!!|![0-9A-Za-z-]+!)$/;
+  var PATTERN_TAG_URI = /^(?:!|[^,\[\]{}])(?:%[0-9a-f]{2}|[0-9a-z\-#;/?:@&=+$,_.!~*'()\[\]])*$/i;
+  function _class(obj) {
+    return Object.prototype.toString.call(obj);
+  }
+  function isEol(c) {
+    return c === 10 || c === 13;
+  }
+  function isWhiteSpace(c) {
+    return c === 9 || c === 32;
+  }
+  function isWsOrEol(c) {
+    return c === 9 || c === 32 || c === 10 || c === 13;
+  }
+  function isFlowIndicator(c) {
+    return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
+  }
+  function fromHexCode(c) {
+    if (c >= 48 && c <= 57) return c - 48;
+    const lc = c | 32;
+    if (lc >= 97 && lc <= 102) return lc - 97 + 10;
+    return -1;
+  }
+  function escapedHexLen(c) {
+    if (c === 120) return 2;
+    if (c === 117) return 4;
+    if (c === 85) return 8;
+    return 0;
+  }
+  function fromDecimalCode(c) {
+    if (c >= 48 && c <= 57) return c - 48;
+    return -1;
+  }
+  function simpleEscapeSequence(c) {
+    switch (c) {
+      case 48:
+        return "\0";
+      case 97:
+        return "\x07";
+      case 98:
+        return "\b";
+      case 116:
+        return "	";
+      case 9:
+        return "	";
+      case 110:
+        return "\n";
+      case 118:
+        return "\v";
+      case 102:
+        return "\f";
+      case 114:
+        return "\r";
+      case 101:
+        return "\x1B";
+      case 32:
+        return " ";
+      case 34:
+        return '"';
+      case 47:
+        return "/";
+      case 92:
+        return "\\";
+      case 78:
+        return "\x85";
+      case 95:
+        return "\xA0";
+      case 76:
+        return "\u2028";
+      case 80:
+        return "\u2029";
+      default:
+        return "";
+    }
   }
-  keyNode = String(keyNode);
-  if (_result === null) {
-    _result = {};
+  function charFromCodepoint(c) {
+    if (c <= 65535) return String.fromCharCode(c);
+    return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
   }
-  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);
+  function setProperty2(object, key, value) {
+    if (key === "__proto__") Object.defineProperty(object, key, {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value
+    });
+    else object[key] = value;
+  }
+  var simpleEscapeCheck = new Array(256);
+  var simpleEscapeMap = new Array(256);
+  for (let 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_SCHEMA2;
+    this.onWarning = options["onWarning"] || null;
+    this.legacy = options["legacy"] || false;
+    this.json = options["json"] || false;
+    this.listener = options["listener"] || null;
+    this.maxDepth = typeof options["maxDepth"] === "number" ? options["maxDepth"] : 100;
+    this.maxMergeSeqLength = typeof options["maxMergeSeqLength"] === "number" ? options["maxMergeSeqLength"] : 20;
+    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.depth = 0;
+    this.firstTabInLine = -1;
+    this.documents = [];
+    this.anchorMapTransactions = [];
+  }
+  function generateError(state, message) {
+    const mark = {
+      name: state.filename,
+      buffer: state.input.slice(0, -1),
+      position: state.position,
+      line: state.line,
+      column: state.position - state.lineStart
+    };
+    mark.snippet = makeSnippet(mark);
+    return new YAMLException2(message, mark);
+  }
+  function throwError(state, message) {
+    throw generateError(state, message);
+  }
+  function throwWarning(state, message) {
+    if (state.onWarning) state.onWarning.call(null, generateError(state, message));
+  }
+  function storeAnchor(state, name, value) {
+    const transactions = state.anchorMapTransactions;
+    if (transactions.length !== 0) {
+      const transaction = transactions[transactions.length - 1];
+      if (!_hasOwnProperty.call(transaction, name)) transaction[name] = {
+        existed: _hasOwnProperty.call(state.anchorMap, name),
+        value: state.anchorMap[name]
+      };
+    }
+    state.anchorMap[name] = value;
+  }
+  function beginAnchorTransaction(state) {
+    state.anchorMapTransactions.push(/* @__PURE__ */ Object.create(null));
+  }
+  function commitAnchorTransaction(state) {
+    const transaction = state.anchorMapTransactions.pop();
+    const transactions = state.anchorMapTransactions;
+    if (transactions.length === 0) return;
+    const parent = transactions[transactions.length - 1];
+    const names = Object.keys(transaction);
+    for (let index = 0, length = names.length; index < length; index += 1) {
+      const name = names[index];
+      if (!_hasOwnProperty.call(parent, name)) parent[name] = transaction[name];
+    }
+  }
+  function rollbackAnchorTransaction(state) {
+    const transaction = state.anchorMapTransactions.pop();
+    const names = Object.keys(transaction);
+    for (let index = names.length - 1; index >= 0; index -= 1) {
+      const entry = transaction[names[index]];
+      if (entry.existed) state.anchorMap[names[index]] = entry.value;
+      else delete state.anchorMap[names[index]];
+    }
+  }
+  function snapshotState(state) {
+    return {
+      position: state.position,
+      line: state.line,
+      lineStart: state.lineStart,
+      lineIndent: state.lineIndent,
+      firstTabInLine: state.firstTabInLine,
+      tag: state.tag,
+      anchor: state.anchor,
+      kind: state.kind,
+      result: state.result
+    };
+  }
+  function restoreState(state, snapshot) {
+    state.position = snapshot.position;
+    state.line = snapshot.line;
+    state.lineStart = snapshot.lineStart;
+    state.lineIndent = snapshot.lineIndent;
+    state.firstTabInLine = snapshot.firstTabInLine;
+    state.tag = snapshot.tag;
+    state.anchor = snapshot.anchor;
+    state.kind = snapshot.kind;
+    state.result = snapshot.result;
+  }
+  var directiveHandlers = {
+    YAML: function handleYamlDirective(state, name, args) {
+      if (state.version !== null) throwError(state, "duplication of %YAML directive");
+      if (args.length !== 1) throwError(state, "YAML directive accepts exactly one argument");
+      const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+      if (match === null) throwError(state, "ill-formed argument of the YAML directive");
+      const major = parseInt(match[1], 10);
+      const 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) {
+      let prefix;
+      if (args.length !== 2) throwError(state, "TAG directive accepts exactly two arguments");
+      const 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);
       }
-    } else {
-      mergeMappings(state, _result, valueNode, overridableKeys);
+      state.tagMap[handle] = prefix;
     }
-  } else {
-    if (!state.json && !_hasOwnProperty$1.call(overridableKeys, keyNode) && _hasOwnProperty$1.call(_result, keyNode)) {
-      state.line = startLine || state.line;
-      state.lineStart = startLineStart || state.lineStart;
-      state.position = startPos || state.position;
-      throwError(state, "duplicated mapping key");
+  };
+  function captureSegment(state, start, end, checkJson) {
+    if (start < end) {
+      const _result = state.input.slice(start, end);
+      if (checkJson) for (let _position = 0, _length = _result.length; _position < _length; _position += 1) {
+        const _character = _result.charCodeAt(_position);
+        if (!(_character === 9 || _character >= 32 && _character <= 1114111)) 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) {
+    if (!common.isObject(source)) throwError(state, "cannot merge mappings; the provided source object is unacceptable");
+    const sourceKeys = Object.keys(source);
+    for (let index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
+      const key = sourceKeys[index];
+      if (!_hasOwnProperty.call(destination, key)) {
+        setProperty2(destination, key, source[key]);
+        overridableKeys[key] = true;
+      }
+    }
+  }
+  function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
+    if (Array.isArray(keyNode)) {
+      keyNode = Array.prototype.slice.call(keyNode);
+      for (let 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]";
+      }
+    }
+    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)) {
+      if (valueNode.length > state.maxMergeSeqLength) throwError(state, "merge sequence length exceeded maxMergeSeqLength (" + state.maxMergeSeqLength + ")");
+      const seen = /* @__PURE__ */ new Set();
+      for (let index = 0, quantity = valueNode.length; index < quantity; index += 1) {
+        const src = valueNode[index];
+        if (seen.has(src)) continue;
+        seen.add(src);
+        mergeMappings(state, _result, src, 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");
+      }
+      setProperty2(_result, keyNode, valueNode);
+      delete overridableKeys[keyNode];
     }
-    setProperty(_result, keyNode, valueNode);
-    delete overridableKeys[keyNode];
+    return _result;
   }
-  return _result;
-}
-function readLineBreak(state) {
-  var ch;
-  ch = state.input.charCodeAt(state.position);
-  if (ch === 10) {
-    state.position++;
-  } else if (ch === 13) {
-    state.position++;
-    if (state.input.charCodeAt(state.position) === 10) {
+  function readLineBreak(state) {
+    const ch = state.input.charCodeAt(state.position);
+    if (ch === 10) state.position++;
+    else if (ch === 13) {
       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 === 9 && state.firstTabInLine === -1) {
-        state.firstTabInLine = state.position;
-      }
-      ch = state.input.charCodeAt(++state.position);
-    }
-    if (allowComments && ch === 35) {
-      do {
-        ch = state.input.charCodeAt(++state.position);
-      } while (ch !== 10 && ch !== 13 && ch !== 0);
-    }
-    if (is_EOL(ch)) {
-      readLineBreak(state);
-      ch = state.input.charCodeAt(state.position);
-      lineBreaks++;
-      state.lineIndent = 0;
-      while (ch === 32) {
-        state.lineIndent++;
+      if (state.input.charCodeAt(state.position) === 10) 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) {
+    let lineBreaks = 0;
+    let ch = state.input.charCodeAt(state.position);
+    while (ch !== 0) {
+      while (isWhiteSpace(ch)) {
+        if (ch === 9 && state.firstTabInLine === -1) state.firstTabInLine = state.position;
         ch = state.input.charCodeAt(++state.position);
       }
-    } else {
-      break;
+      if (allowComments && ch === 35) do
+        ch = state.input.charCodeAt(++state.position);
+      while (ch !== 10 && ch !== 13 && ch !== 0);
+      if (isEol(ch)) {
+        readLineBreak(state);
+        ch = state.input.charCodeAt(state.position);
+        lineBreaks++;
+        state.lineIndent = 0;
+        while (ch === 32) {
+          state.lineIndent++;
+          ch = state.input.charCodeAt(++state.position);
+        }
+      } else break;
     }
+    if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) throwWarning(state, "deficient indentation");
+    return lineBreaks;
   }
-  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);
-  if ((ch === 45 || ch === 46) && 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;
+  function testDocumentSeparator(state) {
+    let _position = state.position;
+    let ch = state.input.charCodeAt(_position);
+    if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
+      _position += 3;
+      ch = state.input.charCodeAt(_position);
+      if (ch === 0 || isWsOrEol(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 === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) {
     return false;
   }
-  if (ch === 63 || ch === 45) {
-    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 === 58) {
-      following = state.input.charCodeAt(state.position + 1);
-      if (is_WS_OR_EOL(following) || withinFlowCollection && is_FLOW_INDICATOR(following)) {
-        break;
-      }
-    } else if (ch === 35) {
-      preceding = state.input.charCodeAt(state.position - 1);
-      if (is_WS_OR_EOL(preceding)) {
-        break;
+  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) {
+    let captureStart;
+    let captureEnd;
+    let hasPendingContent;
+    let _line;
+    let _lineStart;
+    let _lineIndent;
+    const _kind = state.kind;
+    const _result = state.result;
+    let ch = state.input.charCodeAt(state.position);
+    if (isWsOrEol(ch) || isFlowIndicator(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) return false;
+    if (ch === 63 || ch === 45) {
+      const following = state.input.charCodeAt(state.position + 1);
+      if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) return false;
+    }
+    state.kind = "scalar";
+    state.result = "";
+    captureStart = captureEnd = state.position;
+    hasPendingContent = false;
+    while (ch !== 0) {
+      if (ch === 58) {
+        const following = state.input.charCodeAt(state.position + 1);
+        if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) break;
+      } else if (ch === 35) {
+        if (isWsOrEol(state.input.charCodeAt(state.position - 1))) break;
+      } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && isFlowIndicator(ch)) break;
+      else if (isEol(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;
+        }
       }
-    } 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 (!isWhiteSpace(ch)) captureEnd = state.position + 1;
+      ch = state.input.charCodeAt(++state.position);
     }
-    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 !== 39) {
+    captureSegment(state, captureStart, captureEnd, false);
+    if (state.result) return true;
+    state.kind = _kind;
+    state.result = _result;
     return false;
   }
-  state.kind = "scalar";
-  state.result = "";
-  state.position++;
-  captureStart = captureEnd = state.position;
-  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
-    if (ch === 39) {
+  function readSingleQuotedScalar(state, nodeIndent) {
+    let captureStart;
+    let captureEnd;
+    let ch = state.input.charCodeAt(state.position);
+    if (ch !== 39) return false;
+    state.kind = "scalar";
+    state.result = "";
+    state.position++;
+    captureStart = captureEnd = state.position;
+    while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 39) {
       captureSegment(state, captureStart, state.position, true);
       ch = state.input.charCodeAt(++state.position);
       if (ch === 39) {
         captureStart = state.position;
         state.position++;
         captureEnd = state.position;
-      } else {
-        return true;
-      }
-    } else if (is_EOL(ch)) {
+      } else return true;
+    } else if (isEol(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 {
+    } 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 !== 34) {
-    return false;
-  }
-  state.kind = "scalar";
-  state.result = "";
-  state.position++;
-  captureStart = captureEnd = state.position;
-  while ((ch = state.input.charCodeAt(state.position)) !== 0) {
-    if (ch === 34) {
+      if (!isWhiteSpace(ch)) captureEnd = state.position;
+    }
+    throwError(state, "unexpected end of the stream within a single quoted scalar");
+  }
+  function readDoubleQuotedScalar(state, nodeIndent) {
+    let captureStart;
+    let captureEnd;
+    let tmp;
+    let ch = state.input.charCodeAt(state.position);
+    if (ch !== 34) return false;
+    state.kind = "scalar";
+    state.result = "";
+    state.position++;
+    captureStart = captureEnd = state.position;
+    while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 34) {
       captureSegment(state, captureStart, state.position, true);
       state.position++;
       return true;
     } else if (ch === 92) {
       captureSegment(state, captureStart, state.position, true);
       ch = state.input.charCodeAt(++state.position);
-      if (is_EOL(ch)) {
-        skipSeparationSpace(state, false, nodeIndent);
-      } else if (ch < 256 && simpleEscapeCheck[ch]) {
+      if (isEol(ch)) skipSeparationSpace(state, false, nodeIndent);
+      else if (ch < 256 && simpleEscapeCheck[ch]) {
         state.result += simpleEscapeMap[ch];
         state.position++;
       } else if ((tmp = escapedHexLen(ch)) > 0) {
-        hexLength = tmp;
-        hexResult = 0;
+        let hexLength = tmp;
+        let 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");
-          }
+          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");
-      }
+      } else throwError(state, "unknown escape sequence");
       captureStart = captureEnd = state.position;
-    } else if (is_EOL(ch)) {
+    } else if (isEol(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 = /* @__PURE__ */ Object.create(null), keyNode, keyTag, valueNode, ch;
-  ch = state.input.charCodeAt(state.position);
-  if (ch === 91) {
-    terminator = 93;
-    isMapping = false;
-    _result = [];
-  } else if (ch === 123) {
-    terminator = 125;
-    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) {
+    } else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a double quoted scalar");
+    else {
       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 === 44) {
-      throwError(state, "expected the node content, but found ','");
-    }
-    keyTag = keyNode = valueNode = null;
-    isPair = isExplicitPair = false;
-    if (ch === 63) {
-      following = state.input.charCodeAt(state.position + 1);
-      if (is_WS_OR_EOL(following)) {
-        isPair = isExplicitPair = true;
+      if (!isWhiteSpace(ch)) captureEnd = state.position;
+    }
+    throwError(state, "unexpected end of the stream within a double quoted scalar");
+  }
+  function readFlowCollection(state, nodeIndent) {
+    let readNext = true;
+    let _line;
+    let _lineStart;
+    let _pos;
+    const _tag = state.tag;
+    let _result;
+    const _anchor = state.anchor;
+    let terminator;
+    let isPair;
+    let isExplicitPair;
+    let isMapping;
+    const overridableKeys = /* @__PURE__ */ Object.create(null);
+    let keyNode;
+    let keyTag;
+    let valueNode;
+    let ch = state.input.charCodeAt(state.position);
+    if (ch === 91) {
+      terminator = 93;
+      isMapping = false;
+      _result = [];
+    } else if (ch === 123) {
+      terminator = 125;
+      isMapping = true;
+      _result = {};
+    } else return false;
+    if (state.anchor !== null) storeAnchor(state, 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 === 44) throwError(state, "expected the node content, but found ','");
+      keyTag = keyNode = valueNode = null;
+      isPair = isExplicitPair = false;
+      if (ch === 63) {
+        if (isWsOrEol(state.input.charCodeAt(state.position + 1))) {
+          isPair = isExplicitPair = true;
+          state.position++;
+          skipSeparationSpace(state, true, nodeIndent);
+        }
+      }
+      _line = state.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 === 58) {
+        isPair = true;
+        ch = state.input.charCodeAt(++state.position);
         skipSeparationSpace(state, true, nodeIndent);
+        composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+        valueNode = state.result;
       }
-    }
-    _line = state.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 === 58) {
-      isPair = true;
-      ch = state.input.charCodeAt(++state.position);
+      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);
-      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 === 44) {
-      readNext = true;
+      ch = state.input.charCodeAt(state.position);
+      if (ch === 44) {
+        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) {
+    let folding;
+    let chomping = CHOMPING_CLIP;
+    let didReadContent = false;
+    let detectedIndent = false;
+    let textIndent = nodeIndent;
+    let emptyLines = 0;
+    let atMoreIndented = false;
+    let tmp;
+    let ch = state.input.charCodeAt(state.position);
+    if (ch === 124) folding = false;
+    else if (ch === 62) folding = true;
+    else return false;
+    state.kind = "scalar";
+    state.result = "";
+    while (ch !== 0) {
       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 === 124) {
-    folding = false;
-  } else if (ch === 62) {
-    folding = true;
-  } else {
-    return false;
-  }
-  state.kind = "scalar";
-  state.result = "";
-  while (ch !== 0) {
-    ch = state.input.charCodeAt(++state.position);
-    if (ch === 43 || ch === 45) {
-      if (CHOMPING_CLIP === chomping) {
-        chomping = ch === 43 ? 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) {
+      if (ch === 43 || ch === 45) if (CHOMPING_CLIP === chomping) chomping = ch === 43 ? 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;
+      } 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 === 35) {
-      do {
+    if (isWhiteSpace(ch)) {
+      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 === 32) {
-      state.lineIndent++;
-      ch = state.input.charCodeAt(++state.position);
-    }
-    if (!detectedIndent && state.lineIndent > textIndent) {
-      textIndent = state.lineIndent;
-    }
-    if (is_EOL(ch)) {
-      emptyLines++;
-      continue;
+      while (isWhiteSpace(ch));
+      if (ch === 35) do
+        ch = state.input.charCodeAt(++state.position);
+      while (!isEol(ch) && ch !== 0);
     }
-    if (state.lineIndent < textIndent) {
-      if (chomping === CHOMPING_KEEP) {
-        state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
-      } else if (chomping === CHOMPING_CLIP) {
-        if (didReadContent) {
-          state.result += "\n";
+    while (ch !== 0) {
+      readLineBreak(state);
+      state.lineIndent = 0;
+      ch = state.input.charCodeAt(state.position);
+      while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
+        state.lineIndent++;
+        ch = state.input.charCodeAt(++state.position);
+      }
+      if (!detectedIndent && state.lineIndent > textIndent) textIndent = state.lineIndent;
+      if (isEol(ch)) {
+        emptyLines++;
+        continue;
+      }
+      if (!detectedIndent && textIndent === 0) throwError(state, "missing indentation for block scalar");
+      if (state.lineIndent < textIndent) {
+        if (chomping === CHOMPING_KEEP) state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+        else if (chomping === CHOMPING_CLIP) {
+          if (didReadContent) state.result += "\n";
         }
+        break;
       }
-      break;
-    }
-    if (folding) {
-      if (is_WHITE_SPACE(ch)) {
+      if (folding) if (isWhiteSpace(ch)) {
         atMoreIndented = true;
         state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
       } else if (atMoreIndented) {
         atMoreIndented = false;
         state.result += common.repeat("\n", emptyLines + 1);
       } else if (emptyLines === 0) {
-        if (didReadContent) {
-          state.result += " ";
-        }
-      } else {
-        state.result += common.repeat("\n", emptyLines);
-      }
-    } else {
-      state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+        if (didReadContent) state.result += " ";
+      } else state.result += common.repeat("\n", emptyLines);
+      else state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
+      didReadContent = true;
+      detectedIndent = true;
+      emptyLines = 0;
+      const captureStart = state.position;
+      while (!isEol(ch) && ch !== 0) ch = state.input.charCodeAt(++state.position);
+      captureSegment(state, captureStart, state.position, false);
     }
-    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.firstTabInLine !== -1) return false;
-  if (state.anchor !== null) {
-    state.anchorMap[state.anchor] = _result;
+    return true;
   }
-  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 !== 45) {
-      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;
+  function readBlockSequence(state, nodeIndent) {
+    const _tag = state.tag;
+    const _anchor = state.anchor;
+    const _result = [];
+    let detected = false;
+    if (state.firstTabInLine !== -1) return false;
+    if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
+    let 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 !== 45) break;
+      if (!isWsOrEol(state.input.charCodeAt(state.position + 1))) break;
+      detected = true;
+      state.position++;
+      if (skipSeparationSpace(state, true, -1)) {
+        if (state.lineIndent <= nodeIndent) {
+          _result.push(null);
+          ch = state.input.charCodeAt(state.position);
+          continue;
+        }
+      }
+      const _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;
     }
-    _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;
   }
-  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 = /* @__PURE__ */ Object.create(null), keyTag = null, keyNode = null, valueNode = null, atExplicitKey = false, detected = false, ch;
-  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;
-    if ((ch === 63 || ch === 58) && is_WS_OR_EOL(following)) {
-      if (ch === 63) {
-        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) {
-        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;
-    } else {
-      _keyLine = state.line;
-      _keyLineStart = state.lineStart;
-      _keyPos = state.position;
-      if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) {
-        break;
-      }
-      if (state.line === _line) {
-        ch = state.input.charCodeAt(state.position);
-        while (is_WHITE_SPACE(ch)) {
-          ch = state.input.charCodeAt(++state.position);
-        }
-        if (ch === 58) {
-          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");
-          }
+  function readBlockMapping(state, nodeIndent, flowIndent) {
+    let allowCompact;
+    let _keyLine;
+    let _keyLineStart;
+    let _keyPos;
+    const _tag = state.tag;
+    const _anchor = state.anchor;
+    const _result = {};
+    const overridableKeys = /* @__PURE__ */ Object.create(null);
+    let keyTag = null;
+    let keyNode = null;
+    let valueNode = null;
+    let atExplicitKey = false;
+    let detected = false;
+    if (state.firstTabInLine !== -1) return false;
+    if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
+    let 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");
+      }
+      const following = state.input.charCodeAt(state.position + 1);
+      const _line = state.line;
+      if ((ch === 63 || ch === 58) && isWsOrEol(following)) {
+        if (ch === 63) {
           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) {
           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;
-        }
-      } else if (detected) {
-        throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
+          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;
       } else {
-        state.tag = _tag;
-        state.anchor = _anchor;
-        return true;
-      }
-    }
-    if (state.line === _line || state.lineIndent > nodeIndent) {
-      if (atExplicitKey) {
         _keyLine = state.line;
         _keyLineStart = state.lineStart;
         _keyPos = state.position;
+        if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) break;
+        if (state.line === _line) {
+          ch = state.input.charCodeAt(state.position);
+          while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position);
+          if (ch === 58) {
+            ch = state.input.charCodeAt(++state.position);
+            if (!isWsOrEol(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;
+          }
+        } 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;
+        }
       }
-      if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
+      if (state.line === _line || state.lineIndent > nodeIndent) {
         if (atExplicitKey) {
-          keyNode = state.result;
-        } else {
-          valueNode = state.result;
+          _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 (!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;
     }
-    if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) {
-      throwError(state, "bad indentation of a mapping entry");
-    } else if (state.lineIndent < nodeIndent) {
-      break;
+    if (atExplicitKey) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
+    if (detected) {
+      state.tag = _tag;
+      state.anchor = _anchor;
+      state.kind = "mapping";
+      state.result = _result;
     }
+    return detected;
   }
-  if (atExplicitKey) {
-    storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
-  }
-  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 !== 33) return false;
-  if (state.tag !== null) {
-    throwError(state, "duplication of a tag property");
-  }
-  ch = state.input.charCodeAt(++state.position);
-  if (ch === 60) {
-    isVerbatim = true;
+  function readTagProperty(state) {
+    let isVerbatim = false;
+    let isNamed = false;
+    let tagHandle;
+    let tagName;
+    let ch = state.input.charCodeAt(state.position);
+    if (ch !== 33) return false;
+    if (state.tag !== null) throwError(state, "duplication of a tag property");
     ch = state.input.charCodeAt(++state.position);
-  } else if (ch === 33) {
-    isNamed = true;
-    tagHandle = "!!";
-    ch = state.input.charCodeAt(++state.position);
-  } else {
-    tagHandle = "!";
-  }
-  _position = state.position;
-  if (isVerbatim) {
-    do {
+    if (ch === 60) {
+      isVerbatim = true;
       ch = state.input.charCodeAt(++state.position);
-    } while (ch !== 0 && ch !== 62);
-    if (state.position < state.length) {
-      tagName = state.input.slice(_position, state.position);
+    } else if (ch === 33) {
+      isNamed = true;
+      tagHandle = "!!";
       ch = state.input.charCodeAt(++state.position);
+    } else tagHandle = "!";
+    let _position = state.position;
+    if (isVerbatim) {
+      do
+        ch = state.input.charCodeAt(++state.position);
+      while (ch !== 0 && ch !== 62);
+      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 {
-      throwError(state, "unexpected end of the stream within a verbatim tag");
-    }
-  } else {
-    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
-      if (ch === 33) {
-        if (!isNamed) {
+      while (ch !== 0 && !isWsOrEol(ch)) {
+        if (ch === 33) 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");
-          }
+          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");
-        }
+        } else throwError(state, "tag suffix cannot contain exclamation marks");
+        ch = state.input.charCodeAt(++state.position);
       }
-      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");
     }
-    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;
   }
-  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$1.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 !== 38) 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)) {
+  function readAnchorProperty(state) {
+    let ch = state.input.charCodeAt(state.position);
+    if (ch !== 38) return false;
+    if (state.anchor !== null) throwError(state, "duplication of an anchor property");
     ch = state.input.charCodeAt(++state.position);
+    const _position = state.position;
+    while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(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;
   }
-  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 !== 42) return false;
-  ch = state.input.charCodeAt(++state.position);
-  _position = state.position;
-  while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) {
+  function readAlias(state) {
+    let ch = state.input.charCodeAt(state.position);
+    if (ch !== 42) return false;
     ch = state.input.charCodeAt(++state.position);
+    const _position = state.position;
+    while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) ch = state.input.charCodeAt(++state.position);
+    if (state.position === _position) throwError(state, "name of an alias node must contain at least one character");
+    const 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;
   }
-  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$1.call(state.anchorMap, alias)) {
-    throwError(state, 'unidentified alias "' + alias + '"');
+  function tryReadBlockMappingFromProperty(state, propertyStart, nodeIndent, flowIndent) {
+    const fallbackState = snapshotState(state);
+    beginAnchorTransaction(state);
+    restoreState(state, propertyStart);
+    state.tag = null;
+    state.anchor = null;
+    state.kind = null;
+    state.result = null;
+    if (readBlockMapping(state, nodeIndent, flowIndent) && state.kind === "mapping") {
+      commitAnchorTransaction(state);
+      return true;
+    }
+    rollbackAnchorTransaction(state);
+    restoreState(state, fallbackState);
+    return false;
   }
-  state.result = state.anchorMap[alias];
-  skipSeparationSpace(state, true, -1);
-  return true;
-}
-function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
-  var allowBlockStyles, allowBlockScalars, allowBlockCollections, indentStatus = 1, atNewLine = false, hasContent = false, typeIndex, typeQuantity, typeList, type2, 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)) {
+  function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
+    let allowBlockScalars;
+    let allowBlockCollections;
+    let indentStatus = 1;
+    let atNewLine = false;
+    let hasContent = false;
+    let propertyStart = null;
+    let type;
+    let flowIndent;
+    let blockIndent;
+    if (state.depth >= state.maxDepth) throwError(state, "nesting exceeded maxDepth (" + state.maxDepth + ")");
+    state.depth += 1;
+    if (state.listener !== null) state.listener("open", state);
+    state.tag = null;
+    state.anchor = null;
+    state.kind = null;
+    state.result = null;
+    const allowBlockStyles = allowBlockScalars = allowBlockCollections = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
+    if (allowToSeek) {
       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 (state.lineIndent > parentIndent) indentStatus = 1;
+        else if (state.lineIndent === parentIndent) indentStatus = 0;
+        else if (state.lineIndent < parentIndent) indentStatus = -1;
       }
     }
-  }
-  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)) {
+    if (indentStatus === 1) while (true) {
+      const ch = state.input.charCodeAt(state.position);
+      const propertyState = snapshotState(state);
+      if (atNewLine && (ch === 33 && state.tag !== null || ch === 38 && state.anchor !== null)) break;
+      if (!readTagProperty(state) && !readAnchorProperty(state)) break;
+      if (propertyStart === null) propertyStart = propertyState;
+      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 {
+        const ch = state.input.charCodeAt(state.position);
+        if (propertyStart !== null && allowBlockStyles && !allowBlockCollections && ch !== 124 && ch !== 62 && tryReadBlockMappingFromProperty(state, propertyStart, propertyStart.position - propertyStart.lineStart, 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");
-          }
+          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) {
-      hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
-    }
-  }
-  if (state.tag === null) {
-    if (state.anchor !== null) {
-      state.anchorMap[state.anchor] = state.result;
-    }
-  } else if (state.tag === "?") {
-    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) {
-      type2 = state.implicitTypes[typeIndex];
-      if (type2.resolve(state.result)) {
-        state.result = type2.construct(state.result);
-        state.tag = type2.tag;
-        if (state.anchor !== null) {
-          state.anchorMap[state.anchor] = state.result;
+          if (state.tag === null) state.tag = "?";
+        }
+        if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+      }
+      else if (indentStatus === 0) hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
+    }
+    if (state.tag === null) {
+      if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+    } else if (state.tag === "?") {
+      if (state.result !== null && state.kind !== "scalar") throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
+      for (let typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
+        type = state.implicitTypes[typeIndex];
+        if (type.resolve(state.result)) {
+          state.result = type.construct(state.result);
+          state.tag = type.tag;
+          if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+          break;
         }
-        break;
       }
-    }
-  } else if (state.tag !== "!") {
-    if (_hasOwnProperty$1.call(state.typeMap[state.kind || "fallback"], state.tag)) {
-      type2 = state.typeMap[state.kind || "fallback"][state.tag];
-    } else {
-      type2 = 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) {
-          type2 = typeList[typeIndex];
+    } else if (state.tag !== "!") {
+      if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag)) type = state.typeMap[state.kind || "fallback"][state.tag];
+      else {
+        type = null;
+        const typeList = state.typeMap.multi[state.kind || "fallback"];
+        for (let 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 (!type2) {
-      throwError(state, "unknown tag !<" + state.tag + ">");
-    }
-    if (state.result !== null && type2.kind !== state.kind) {
-      throwError(state, "unacceptable node kind for !<" + state.tag + '> tag; it should be "' + type2.kind + '", not "' + state.kind + '"');
-    }
-    if (!type2.resolve(state.result, state.tag)) {
-      throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
-    } else {
-      state.result = type2.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 = /* @__PURE__ */ Object.create(null);
-  state.anchorMap = /* @__PURE__ */ 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 !== 37) {
-      break;
-    }
-    hasDirectives = true;
-    ch = state.input.charCodeAt(++state.position);
-    _position = state.position;
-    while (ch !== 0 && !is_WS_OR_EOL(ch)) {
+      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)) throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
+      else {
+        state.result = type.construct(state.result, state.tag);
+        if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+      }
+    }
+    if (state.listener !== null) state.listener("close", state);
+    state.depth -= 1;
+    return state.tag !== null || state.anchor !== null || hasContent;
+  }
+  function readDocument(state) {
+    const documentStart = state.position;
+    let hasDirectives = false;
+    let ch;
+    state.version = null;
+    state.checkLineBreaks = state.legacy;
+    state.tagMap = /* @__PURE__ */ Object.create(null);
+    state.anchorMap = /* @__PURE__ */ 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 !== 37) break;
+      hasDirectives = true;
       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 === 35) {
-        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);
+      let _position = state.position;
+      while (ch !== 0 && !isWsOrEol(ch)) ch = state.input.charCodeAt(++state.position);
+      const directiveName = state.input.slice(_position, state.position);
+      const directiveArgs = [];
+      if (directiveName.length < 1) throwError(state, "directive name must not be less than one character in length");
+      while (ch !== 0) {
+        while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position);
+        if (ch === 35) {
+          do
+            ch = state.input.charCodeAt(++state.position);
+          while (ch !== 0 && !isEol(ch));
+          break;
+        }
+        if (isEol(ch)) break;
+        _position = state.position;
+        while (ch !== 0 && !isWsOrEol(ch)) ch = state.input.charCodeAt(++state.position);
+        directiveArgs.push(state.input.slice(_position, state.position));
       }
-      directiveArgs.push(state.input.slice(_position, state.position));
-    }
-    if (ch !== 0) readLineBreak(state);
-    if (_hasOwnProperty$1.call(directiveHandlers, directiveName)) {
-      directiveHandlers[directiveName](state, directiveName, directiveArgs);
-    } else {
-      throwWarning(state, 'unknown document directive "' + directiveName + '"');
+      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) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
-    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) === 46) {
+    if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
       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) === 46) {
+        state.position += 3;
+        skipSeparationSpace(state, true, -1);
+      }
+      return;
     }
-    return;
-  }
-  if (state.position < state.length - 1) {
-    throwError(state, "end of the stream or a document separator is expected");
-  } else {
-    return;
+    if (state.position < state.length - 1) throwError(state, "end of the stream or a document separator is expected");
   }
-}
-function loadDocuments(input, options) {
-  input = String(input);
-  options = options || {};
-  if (input.length !== 0) {
-    if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) {
-      input += "\n";
+  function loadDocuments(input, options) {
+    input = String(input);
+    options = options || {};
+    if (input.length !== 0) {
+      if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) input += "\n";
+      if (input.charCodeAt(0) === 65279) input = input.slice(1);
     }
-    if (input.charCodeAt(0) === 65279) {
-      input = input.slice(1);
+    const state = new State(input, options);
+    const nullpos = input.indexOf("\0");
+    if (nullpos !== -1) {
+      state.position = nullpos;
+      throwError(state, "null byte is not allowed in input");
     }
-  }
-  var state = new State$1(input, options);
-  var nullpos = input.indexOf("\0");
-  if (nullpos !== -1) {
-    state.position = nullpos;
-    throwError(state, "null byte is not allowed in input");
-  }
-  state.input += "\0";
-  while (state.input.charCodeAt(state.position) === 32) {
-    state.lineIndent += 1;
-    state.position += 1;
-  }
-  while (state.position < state.length - 1) {
-    readDocument(state);
-  }
-  return state.documents;
-}
-function loadAll$1(input, iterator2, options) {
-  if (iterator2 !== null && typeof iterator2 === "object" && typeof options === "undefined") {
-    options = iterator2;
-    iterator2 = null;
-  }
-  var documents = loadDocuments(input, options);
-  if (typeof iterator2 !== "function") {
-    return documents;
-  }
-  for (var index = 0, length = documents.length; index < length; index += 1) {
-    iterator2(documents[index]);
-  }
-}
-function load$1(input, options) {
-  var documents = loadDocuments(input, options);
-  if (documents.length === 0) {
-    return void 0;
-  } else if (documents.length === 1) {
-    return documents[0];
-  }
-  throw new exception("expected a single document in the stream, but found more");
-}
-var loadAll_1 = loadAll$1;
-var load_1 = load$1;
-var loader = {
-  loadAll: loadAll_1,
-  load: load_1
-};
-var _toString = Object.prototype.toString;
-var _hasOwnProperty = Object.prototype.hasOwnProperty;
-var CHAR_BOM = 65279;
-var CHAR_TAB = 9;
-var CHAR_LINE_FEED = 10;
-var CHAR_CARRIAGE_RETURN = 13;
-var CHAR_SPACE = 32;
-var CHAR_EXCLAMATION = 33;
-var CHAR_DOUBLE_QUOTE = 34;
-var CHAR_SHARP = 35;
-var CHAR_PERCENT = 37;
-var CHAR_AMPERSAND = 38;
-var CHAR_SINGLE_QUOTE = 39;
-var CHAR_ASTERISK = 42;
-var CHAR_COMMA = 44;
-var CHAR_MINUS = 45;
-var CHAR_COLON = 58;
-var CHAR_EQUALS = 61;
-var CHAR_GREATER_THAN = 62;
-var CHAR_QUESTION = 63;
-var CHAR_COMMERCIAL_AT = 64;
-var CHAR_LEFT_SQUARE_BRACKET = 91;
-var CHAR_RIGHT_SQUARE_BRACKET = 93;
-var CHAR_GRAVE_ACCENT = 96;
-var CHAR_LEFT_CURLY_BRACKET = 123;
-var CHAR_VERTICAL_LINE = 124;
-var CHAR_RIGHT_CURLY_BRACKET = 125;
-var ESCAPE_SEQUENCES = {};
-ESCAPE_SEQUENCES[0] = "\\0";
-ESCAPE_SEQUENCES[7] = "\\a";
-ESCAPE_SEQUENCES[8] = "\\b";
-ESCAPE_SEQUENCES[9] = "\\t";
-ESCAPE_SEQUENCES[10] = "\\n";
-ESCAPE_SEQUENCES[11] = "\\v";
-ESCAPE_SEQUENCES[12] = "\\f";
-ESCAPE_SEQUENCES[13] = "\\r";
-ESCAPE_SEQUENCES[27] = "\\e";
-ESCAPE_SEQUENCES[34] = '\\"';
-ESCAPE_SEQUENCES[92] = "\\\\";
-ESCAPE_SEQUENCES[133] = "\\N";
-ESCAPE_SEQUENCES[160] = "\\_";
-ESCAPE_SEQUENCES[8232] = "\\L";
-ESCAPE_SEQUENCES[8233] = "\\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(schema2, map2) {
-  var result, keys, index, length, tag, style, type2;
-  if (map2 === null) return {};
-  result = {};
-  keys = Object.keys(map2);
-  for (index = 0, length = keys.length; index < length; index += 1) {
-    tag = keys[index];
-    style = String(map2[tag]);
-    if (tag.slice(0, 2) === "!!") {
-      tag = "tag:yaml.org,2002:" + tag.slice(2);
-    }
-    type2 = schema2.compiledTypeMap["fallback"][tag];
-    if (type2 && _hasOwnProperty.call(type2.styleAliases, style)) {
-      style = type2.styleAliases[style];
-    }
-    result[tag] = style;
-  }
-  return result;
-}
-function encodeHex(character) {
-  var string2, handle, length;
-  string2 = character.toString(16).toUpperCase();
-  if (character <= 255) {
-    handle = "x";
-    length = 2;
-  } else if (character <= 65535) {
-    handle = "u";
-    length = 4;
-  } else if (character <= 4294967295) {
-    handle = "U";
-    length = 8;
-  } else {
-    throw new exception("code point within a string may not be greater than 0xFFFFFFFF");
-  }
-  return "\\" + handle + common.repeat("0", length - string2.length) + string2;
-}
-var QUOTING_TYPE_SINGLE = 1;
-var QUOTING_TYPE_DOUBLE = 2;
-function State(options) {
-  this.schema = options["schema"] || _default;
-  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;
-}
-function indentString(string2, spaces) {
-  var ind = common.repeat(" ", spaces), position = 0, next = -1, result = "", line, length = string2.length;
-  while (position < length) {
-    next = string2.indexOf("\n", position);
-    if (next === -1) {
-      line = string2.slice(position);
-      position = length;
-    } else {
-      line = string2.slice(position, next + 1);
-      position = next + 1;
+    state.input += "\0";
+    while (state.input.charCodeAt(state.position) === 32) {
+      state.lineIndent += 1;
+      state.position += 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, str2) {
-  var index, length, type2;
-  for (index = 0, length = state.implicitTypes.length; index < length; index += 1) {
-    type2 = state.implicitTypes[index];
-    if (type2.resolve(str2)) {
-      return true;
+    while (state.position < state.length - 1) readDocument(state);
+    return state.documents;
+  }
+  function loadAll2(input, iterator2, options) {
+    if (iterator2 !== null && typeof iterator2 === "object" && typeof options === "undefined") {
+      options = iterator2;
+      iterator2 = null;
+    }
+    const documents = loadDocuments(input, options);
+    if (typeof iterator2 !== "function") return documents;
+    for (let index = 0, length = documents.length; index < length; index += 1) iterator2(documents[index]);
+  }
+  function load2(input, options) {
+    const documents = loadDocuments(input, options);
+    if (documents.length === 0) return;
+    else if (documents.length === 1) return documents[0];
+    throw new YAMLException2("expected a single document in the stream, but found more");
+  }
+  module2.exports.loadAll = loadAll2;
+  module2.exports.load = load2;
+}));
+var require_dumper = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var common = require_common();
+  var YAMLException2 = require_exception();
+  var DEFAULT_SCHEMA2 = require_default();
+  var _toString = Object.prototype.toString;
+  var _hasOwnProperty = Object.prototype.hasOwnProperty;
+  var CHAR_BOM = 65279;
+  var CHAR_TAB = 9;
+  var CHAR_LINE_FEED = 10;
+  var CHAR_CARRIAGE_RETURN = 13;
+  var CHAR_SPACE = 32;
+  var CHAR_EXCLAMATION = 33;
+  var CHAR_DOUBLE_QUOTE = 34;
+  var CHAR_SHARP = 35;
+  var CHAR_PERCENT = 37;
+  var CHAR_AMPERSAND = 38;
+  var CHAR_SINGLE_QUOTE = 39;
+  var CHAR_ASTERISK = 42;
+  var CHAR_COMMA = 44;
+  var CHAR_MINUS = 45;
+  var CHAR_COLON = 58;
+  var CHAR_EQUALS = 61;
+  var CHAR_GREATER_THAN = 62;
+  var CHAR_QUESTION = 63;
+  var CHAR_COMMERCIAL_AT = 64;
+  var CHAR_LEFT_SQUARE_BRACKET = 91;
+  var CHAR_RIGHT_SQUARE_BRACKET = 93;
+  var CHAR_GRAVE_ACCENT = 96;
+  var CHAR_LEFT_CURLY_BRACKET = 123;
+  var CHAR_VERTICAL_LINE = 124;
+  var CHAR_RIGHT_CURLY_BRACKET = 125;
+  var ESCAPE_SEQUENCES = {};
+  ESCAPE_SEQUENCES[0] = "\\0";
+  ESCAPE_SEQUENCES[7] = "\\a";
+  ESCAPE_SEQUENCES[8] = "\\b";
+  ESCAPE_SEQUENCES[9] = "\\t";
+  ESCAPE_SEQUENCES[10] = "\\n";
+  ESCAPE_SEQUENCES[11] = "\\v";
+  ESCAPE_SEQUENCES[12] = "\\f";
+  ESCAPE_SEQUENCES[13] = "\\r";
+  ESCAPE_SEQUENCES[27] = "\\e";
+  ESCAPE_SEQUENCES[34] = '\\"';
+  ESCAPE_SEQUENCES[92] = "\\\\";
+  ESCAPE_SEQUENCES[133] = "\\N";
+  ESCAPE_SEQUENCES[160] = "\\_";
+  ESCAPE_SEQUENCES[8232] = "\\L";
+  ESCAPE_SEQUENCES[8233] = "\\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) {
+    if (map === null) return {};
+    const result = {};
+    const keys = Object.keys(map);
+    for (let index = 0, length = keys.length; index < length; index += 1) {
+      let tag = keys[index];
+      let style = String(map[tag]);
+      if (tag.slice(0, 2) === "!!") tag = "tag:yaml.org,2002:" + tag.slice(2);
+      const type = schema.compiledTypeMap["fallback"][tag];
+      if (type && _hasOwnProperty.call(type.styleAliases, style)) style = type.styleAliases[style];
+      result[tag] = style;
     }
+    return result;
   }
-  return false;
-}
-function isWhitespace(c) {
-  return c === CHAR_SPACE || c === CHAR_TAB;
-}
-function isPrintable(c) {
-  return 32 <= c && c <= 126 || 161 <= c && c <= 55295 && c !== 8232 && c !== 8233 || 57344 <= c && c <= 65533 && c !== CHAR_BOM || 65536 <= c && c <= 1114111;
-}
-function isNsCharOrWhitespace(c) {
-  return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
-}
-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 !== 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 && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar
-  );
-}
-function isPlainSafeFirst(c) {
-  return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && 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;
-}
-function isPlainSafeLast(c) {
-  return !isWhitespace(c) && c !== CHAR_COLON;
-}
-function codePointAt(string2, pos) {
-  var first = string2.charCodeAt(pos), second;
-  if (first >= 55296 && first <= 56319 && pos + 1 < string2.length) {
-    second = string2.charCodeAt(pos + 1);
-    if (second >= 56320 && second <= 57343) {
-      return (first - 55296) * 1024 + second - 56320 + 65536;
-    }
-  }
-  return first;
-}
-function needIndentIndicator(string2) {
-  var leadingSpaceRe = /^\n* /;
-  return leadingSpaceRe.test(string2);
-}
-var STYLE_PLAIN = 1;
-var STYLE_SINGLE = 2;
-var STYLE_LITERAL = 3;
-var STYLE_FOLDED = 4;
-var STYLE_DOUBLE = 5;
-function chooseScalarStyle(string2, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) {
-  var i;
-  var char = 0;
-  var prevChar = null;
-  var hasLineBreak = false;
-  var hasFoldableLine = false;
-  var shouldTrackWidth = lineWidth !== -1;
-  var previousLineBreak = -1;
-  var plain = isPlainSafeFirst(codePointAt(string2, 0)) && isPlainSafeLast(codePointAt(string2, string2.length - 1));
-  if (singleLineOnly || forceQuotes) {
-    for (i = 0; i < string2.length; char >= 65536 ? i += 2 : i++) {
-      char = codePointAt(string2, i);
-      if (!isPrintable(char)) {
-        return STYLE_DOUBLE;
+  function encodeHex(character) {
+    let handle;
+    let length;
+    const string2 = character.toString(16).toUpperCase();
+    if (character <= 255) {
+      handle = "x";
+      length = 2;
+    } else if (character <= 65535) {
+      handle = "u";
+      length = 4;
+    } else if (character <= 4294967295) {
+      handle = "U";
+      length = 8;
+    } else throw new YAMLException2("code point within a string may not be greater than 0xFFFFFFFF");
+    return "\\" + handle + common.repeat("0", length - string2.length) + string2;
+  }
+  var QUOTING_TYPE_SINGLE = 1;
+  var QUOTING_TYPE_DOUBLE = 2;
+  function State(options) {
+    this.schema = options["schema"] || DEFAULT_SCHEMA2;
+    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;
+  }
+  function indentString(string2, spaces) {
+    const ind = common.repeat(" ", spaces);
+    let position = 0;
+    let result = "";
+    const length = string2.length;
+    while (position < length) {
+      let line;
+      const next = string2.indexOf("\n", position);
+      if (next === -1) {
+        line = string2.slice(position);
+        position = length;
+      } else {
+        line = string2.slice(position, next + 1);
+        position = next + 1;
       }
-      plain = plain && isPlainSafe(char, prevChar, inblock);
-      prevChar = char;
+      if (line.length && line !== "\n") result += ind;
+      result += line;
     }
-  } else {
-    for (i = 0; i < string2.length; char >= 65536 ? i += 2 : i++) {
+    return result;
+  }
+  function generateNextLine(state, level) {
+    return "\n" + common.repeat(" ", state.indent * level);
+  }
+  function testImplicitResolving(state, str) {
+    for (let index = 0, length = state.implicitTypes.length; index < length; index += 1) if (state.implicitTypes[index].resolve(str)) return true;
+    return false;
+  }
+  function isWhitespace(c) {
+    return c === CHAR_SPACE || c === CHAR_TAB;
+  }
+  function isPrintable(c) {
+    return c >= 32 && c <= 126 || c >= 161 && c <= 55295 && c !== 8232 && c !== 8233 || c >= 57344 && c <= 65533 && c !== CHAR_BOM || c >= 65536 && c <= 1114111;
+  }
+  function isNsCharOrWhitespace(c) {
+    return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
+  }
+  function isPlainSafe(c, prev, inblock) {
+    const cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
+    const cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
+    return (inblock ? cIsNsCharOrWhitespace : cIsNsCharOrWhitespace && 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 && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar;
+  }
+  function isPlainSafeFirst(c) {
+    return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && 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;
+  }
+  function isPlainSafeLast(c) {
+    return !isWhitespace(c) && c !== CHAR_COLON;
+  }
+  function codePointAt(string2, pos) {
+    const first = string2.charCodeAt(pos);
+    let second;
+    if (first >= 55296 && first <= 56319 && pos + 1 < string2.length) {
+      second = string2.charCodeAt(pos + 1);
+      if (second >= 56320 && second <= 57343) return (first - 55296) * 1024 + second - 56320 + 65536;
+    }
+    return first;
+  }
+  function needIndentIndicator(string2) {
+    return /^\n* /.test(string2);
+  }
+  var STYLE_PLAIN = 1;
+  var STYLE_SINGLE = 2;
+  var STYLE_LITERAL = 3;
+  var STYLE_FOLDED = 4;
+  var STYLE_DOUBLE = 5;
+  function chooseScalarStyle(string2, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) {
+    let i;
+    let char = 0;
+    let prevChar = null;
+    let hasLineBreak = false;
+    let hasFoldableLine = false;
+    const shouldTrackWidth = lineWidth !== -1;
+    let previousLineBreak = -1;
+    let plain = isPlainSafeFirst(codePointAt(string2, 0)) && isPlainSafeLast(codePointAt(string2, string2.length - 1));
+    if (singleLineOnly || forceQuotes) for (i = 0; i < string2.length; char >= 65536 ? i += 2 : i++) {
       char = codePointAt(string2, i);
-      if (char === CHAR_LINE_FEED) {
-        hasLineBreak = true;
-        if (shouldTrackWidth) {
-          hasFoldableLine = hasFoldableLine || // Foldable line = too long, and not more-indented.
-          i - previousLineBreak - 1 > lineWidth && string2[previousLineBreak + 1] !== " ";
-          previousLineBreak = i;
-        }
-      } else if (!isPrintable(char)) {
-        return STYLE_DOUBLE;
-      }
+      if (!isPrintable(char)) return STYLE_DOUBLE;
       plain = plain && isPlainSafe(char, prevChar, inblock);
       prevChar = char;
     }
-    hasFoldableLine = hasFoldableLine || shouldTrackWidth && (i - previousLineBreak - 1 > lineWidth && string2[previousLineBreak + 1] !== " ");
-  }
-  if (!hasLineBreak && !hasFoldableLine) {
-    if (plain && !forceQuotes && !testAmbiguousType(string2)) {
-      return STYLE_PLAIN;
-    }
+    else {
+      for (i = 0; i < string2.length; char >= 65536 ? i += 2 : i++) {
+        char = codePointAt(string2, i);
+        if (char === CHAR_LINE_FEED) {
+          hasLineBreak = true;
+          if (shouldTrackWidth) {
+            hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string2[previousLineBreak + 1] !== " ";
+            previousLineBreak = i;
+          }
+        } else if (!isPrintable(char)) return STYLE_DOUBLE;
+        plain = plain && isPlainSafe(char, prevChar, inblock);
+        prevChar = char;
+      }
+      hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string2[previousLineBreak + 1] !== " ";
+    }
+    if (!hasLineBreak && !hasFoldableLine) {
+      if (plain && !forceQuotes && !testAmbiguousType(string2)) return STYLE_PLAIN;
+      return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
+    }
+    if (indentPerLevel > 9 && needIndentIndicator(string2)) return STYLE_DOUBLE;
+    if (!forceQuotes) return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
     return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
   }
-  if (indentPerLevel > 9 && needIndentIndicator(string2)) {
-    return STYLE_DOUBLE;
-  }
-  if (!forceQuotes) {
-    return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
-  }
-  return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
-}
-function writeScalar(state, string2, level, iskey, inblock) {
-  state.dump = (function() {
-    if (string2.length === 0) {
-      return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
-    }
-    if (!state.noCompatMode) {
-      if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string2) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string2)) {
-        return state.quotingType === QUOTING_TYPE_DOUBLE ? '"' + string2 + '"' : "'" + string2 + "'";
+  function writeScalar(state, string2, level, iskey, inblock) {
+    state.dump = (function() {
+      if (string2.length === 0) return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
+      if (!state.noCompatMode) {
+        if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string2) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string2)) return state.quotingType === QUOTING_TYPE_DOUBLE ? '"' + string2 + '"' : "'" + string2 + "'";
+      }
+      const indent = state.indent * Math.max(1, level);
+      const lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
+      const singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
+      function testAmbiguity(string3) {
+        return testImplicitResolving(state, string3);
+      }
+      switch (chooseScalarStyle(string2, singleLineOnly, state.indent, lineWidth, testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
+        case STYLE_PLAIN:
+          return string2;
+        case STYLE_SINGLE:
+          return "'" + string2.replace(/'/g, "''") + "'";
+        case STYLE_LITERAL:
+          return "|" + blockHeader(string2, state.indent) + dropEndingNewline(indentString(string2, indent));
+        case STYLE_FOLDED:
+          return ">" + blockHeader(string2, state.indent) + dropEndingNewline(indentString(foldString(string2, lineWidth), indent));
+        case STYLE_DOUBLE:
+          return '"' + escapeString(string2, lineWidth) + '"';
+        default:
+          throw new YAMLException2("impossible error: invalid scalar style");
       }
-    }
-    var indent = state.indent * Math.max(1, level);
-    var lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
-    var singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
-    function testAmbiguity(string3) {
-      return testImplicitResolving(state, string3);
-    }
-    switch (chooseScalarStyle(
-      string2,
-      singleLineOnly,
-      state.indent,
-      lineWidth,
-      testAmbiguity,
-      state.quotingType,
-      state.forceQuotes && !iskey,
-      inblock
-    )) {
-      case STYLE_PLAIN:
-        return string2;
-      case STYLE_SINGLE:
-        return "'" + string2.replace(/'/g, "''") + "'";
-      case STYLE_LITERAL:
-        return "|" + blockHeader(string2, state.indent) + dropEndingNewline(indentString(string2, indent));
-      case STYLE_FOLDED:
-        return ">" + blockHeader(string2, state.indent) + dropEndingNewline(indentString(foldString(string2, lineWidth), indent));
-      case STYLE_DOUBLE:
-        return '"' + escapeString(string2) + '"';
-      default:
-        throw new exception("impossible error: invalid scalar style");
-    }
-  })();
-}
-function blockHeader(string2, indentPerLevel) {
-  var indentIndicator = needIndentIndicator(string2) ? String(indentPerLevel) : "";
-  var clip = string2[string2.length - 1] === "\n";
-  var keep = clip && (string2[string2.length - 2] === "\n" || string2 === "\n");
-  var chomp = keep ? "+" : clip ? "" : "-";
-  return indentIndicator + chomp + "\n";
-}
-function dropEndingNewline(string2) {
-  return string2[string2.length - 1] === "\n" ? string2.slice(0, -1) : string2;
-}
-function foldString(string2, width) {
-  var lineRe = /(\n+)([^\n]*)/g;
-  var result = (function() {
-    var nextLF = string2.indexOf("\n");
-    nextLF = nextLF !== -1 ? nextLF : string2.length;
-    lineRe.lastIndex = nextLF;
-    return foldLine(string2.slice(0, nextLF), width);
-  })();
-  var prevMoreIndented = string2[0] === "\n" || string2[0] === " ";
-  var moreIndented;
-  var match;
-  while (match = lineRe.exec(string2)) {
-    var prefix = match[1], line = match[2];
-    moreIndented = line[0] === " ";
-    result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
-    prevMoreIndented = moreIndented;
-  }
-  return result;
-}
-function foldLine(line, width) {
-  if (line === "" || line[0] === " ") return line;
-  var breakRe = / [^ ]/g;
-  var match;
-  var start = 0, end, curr = 0, next = 0;
-  var result = "";
-  while (match = breakRe.exec(line)) {
-    next = match.index;
-    if (next - start > width) {
-      end = curr > start ? curr : next;
-      result += "\n" + line.slice(start, end);
-      start = end + 1;
-    }
-    curr = next;
-  }
-  result += "\n";
-  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);
-}
-function escapeString(string2) {
-  var result = "";
-  var char = 0;
-  var escapeSeq;
-  for (var i = 0; i < string2.length; char >= 65536 ? i += 2 : i++) {
-    char = codePointAt(string2, i);
-    escapeSeq = ESCAPE_SEQUENCES[char];
-    if (!escapeSeq && isPrintable(char)) {
-      result += string2[i];
-      if (char >= 65536) result += string2[i + 1];
-    } else {
-      result += escapeSeq || encodeHex(char);
+  function blockHeader(string2, indentPerLevel) {
+    const indentIndicator = needIndentIndicator(string2) ? String(indentPerLevel) : "";
+    const clip = string2[string2.length - 1] === "\n";
+    return indentIndicator + (clip && (string2[string2.length - 2] === "\n" || string2 === "\n") ? "+" : clip ? "" : "-") + "\n";
+  }
+  function dropEndingNewline(string2) {
+    return string2[string2.length - 1] === "\n" ? string2.slice(0, -1) : string2;
+  }
+  function foldString(string2, width) {
+    const lineRe = /(\n+)([^\n]*)/g;
+    let result = (function() {
+      let nextLF = string2.indexOf("\n");
+      nextLF = nextLF !== -1 ? nextLF : string2.length;
+      lineRe.lastIndex = nextLF;
+      return foldLine(string2.slice(0, nextLF), width);
+    })();
+    let prevMoreIndented = string2[0] === "\n" || string2[0] === " ";
+    let moreIndented;
+    let match;
+    while (match = lineRe.exec(string2)) {
+      const prefix = match[1];
+      const line = match[2];
+      moreIndented = line[0] === " ";
+      result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
+      prevMoreIndented = moreIndented;
     }
+    return result;
   }
-  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);
-    }
-    if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) {
-      if (_result !== "") _result += "," + (!state.condenseFlow ? " " : "");
-      _result += state.dump;
+  function foldLine(line, width) {
+    if (line === "" || line[0] === " ") return line;
+    const breakRe = / [^ ]/g;
+    let match;
+    let start = 0;
+    let end;
+    let curr = 0;
+    let next = 0;
+    let result = "";
+    while (match = breakRe.exec(line)) {
+      next = match.index;
+      if (next - start > width) {
+        end = curr > start ? curr : next;
+        result += "\n" + line.slice(start, end);
+        start = end + 1;
+      }
+      curr = next;
+    }
+    result += "\n";
+    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);
+  }
+  function escapeString(string2) {
+    let result = "";
+    let char = 0;
+    for (let i = 0; i < string2.length; char >= 65536 ? i += 2 : i++) {
+      char = codePointAt(string2, i);
+      const escapeSeq = ESCAPE_SEQUENCES[char];
+      if (!escapeSeq && isPrintable(char)) {
+        result += string2[i];
+        if (char >= 65536) result += string2[i + 1];
+      } else result += escapeSeq || encodeHex(char);
     }
+    return result;
   }
-  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);
-    }
-    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 += "- ";
+  function writeFlowSequence(state, level, object) {
+    let _result = "";
+    const _tag = state.tag;
+    for (let index = 0, length = object.length; index < length; index += 1) {
+      let value = object[index];
+      if (state.replacer) value = state.replacer.call(object, String(index), value);
+      if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) {
+        if (_result !== "") _result += "," + (!state.condenseFlow ? " " : "");
+        _result += state.dump;
       }
-      _result += state.dump;
-    }
-  }
-  state.tag = _tag;
-  state.dump = _result || "[]";
-}
-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;
-    }
-    if (state.dump.length > 1024) pairBuffer += "? ";
-    pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " ");
-    if (!writeNode(state, level, objectValue, false, false)) {
-      continue;
-    }
-    pairBuffer += state.dump;
-    _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;
-  if (state.sortKeys === true) {
-    objectKeyList.sort();
-  } else if (typeof state.sortKeys === "function") {
-    objectKeyList.sort(state.sortKeys);
-  } else if (state.sortKeys) {
-    throw new exception("sortKeys must be a boolean or a function");
+    state.tag = _tag;
+    state.dump = "[" + _result + "]";
   }
-  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;
-    }
-    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 += "? ";
+  function writeBlockSequence(state, level, object, compact) {
+    let _result = "";
+    const _tag = state.tag;
+    for (let index = 0, length = object.length; index < length; index += 1) {
+      let value = object[index];
+      if (state.replacer) value = state.replacer.call(object, String(index), value);
+      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;
       }
     }
-    pairBuffer += state.dump;
-    if (explicitPair) {
-      pairBuffer += generateNextLine(state, level);
+    state.tag = _tag;
+    state.dump = _result || "[]";
+  }
+  function writeFlowMapping(state, level, object) {
+    let _result = "";
+    const _tag = state.tag;
+    const objectKeyList = Object.keys(object);
+    for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
+      let pairBuffer = "";
+      if (_result !== "") pairBuffer += ", ";
+      if (state.condenseFlow) pairBuffer += '"';
+      const objectKey = objectKeyList[index];
+      let objectValue = object[objectKey];
+      if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
+      if (!writeNode(state, level, objectKey, false, false)) continue;
+      if (state.dump.length > 1024) pairBuffer += "? ";
+      pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " ");
+      if (!writeNode(state, level, objectValue, false, false)) continue;
+      pairBuffer += state.dump;
+      _result += pairBuffer;
     }
-    if (!writeNode(state, level + 1, objectValue, true, explicitPair)) {
-      continue;
+    state.tag = _tag;
+    state.dump = "{" + _result + "}";
+  }
+  function writeBlockMapping(state, level, object, compact) {
+    let _result = "";
+    const _tag = state.tag;
+    const objectKeyList = Object.keys(object);
+    if (state.sortKeys === true) objectKeyList.sort();
+    else if (typeof state.sortKeys === "function") objectKeyList.sort(state.sortKeys);
+    else if (state.sortKeys) throw new YAMLException2("sortKeys must be a boolean or a function");
+    for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
+      let pairBuffer = "";
+      if (!compact || _result !== "") pairBuffer += generateNextLine(state, level);
+      const objectKey = objectKeyList[index];
+      let objectValue = object[objectKey];
+      if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
+      if (!writeNode(state, level + 1, objectKey, true, true, true)) continue;
+      const 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;
+      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += ":";
+      else pairBuffer += ": ";
+      pairBuffer += state.dump;
+      _result += pairBuffer;
     }
-    if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) {
-      pairBuffer += ":";
-    } else {
-      pairBuffer += ": ";
-    }
-    pairBuffer += state.dump;
-    _result += pairBuffer;
-  }
-  state.tag = _tag;
-  state.dump = _result || "{}";
-}
-function detectType(state, object, explicit) {
-  var _result, typeList, index, length, type2, style;
-  typeList = explicit ? state.explicitTypes : state.implicitTypes;
-  for (index = 0, length = typeList.length; index < length; index += 1) {
-    type2 = typeList[index];
-    if ((type2.instanceOf || type2.predicate) && (!type2.instanceOf || typeof object === "object" && object instanceof type2.instanceOf) && (!type2.predicate || type2.predicate(object))) {
-      if (explicit) {
-        if (type2.multi && type2.representName) {
-          state.tag = type2.representName(object);
-        } else {
-          state.tag = type2.tag;
-        }
-      } else {
-        state.tag = "?";
-      }
-      if (type2.represent) {
-        style = state.styleMap[type2.tag] || type2.defaultStyle;
-        if (_toString.call(type2.represent) === "[object Function]") {
-          _result = type2.represent(object, style);
-        } else if (_hasOwnProperty.call(type2.represent, style)) {
-          _result = type2.represent[style](object, style);
-        } else {
-          throw new exception("!<" + type2.tag + '> tag resolver accepts not "' + style + '" style');
+    state.tag = _tag;
+    state.dump = _result || "{}";
+  }
+  function detectType(state, object, explicit) {
+    const typeList = explicit ? state.explicitTypes : state.implicitTypes;
+    for (let index = 0, length = typeList.length; index < length; index += 1) {
+      const 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) {
+          const style = state.styleMap[type.tag] || type.defaultStyle;
+          let _result;
+          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 YAMLException2("!<" + type.tag + '> tag resolver accepts not "' + style + '" style');
+          state.dump = _result;
         }
-        state.dump = _result;
+        return true;
       }
-      return true;
     }
+    return false;
   }
-  return false;
-}
-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 type2 = _toString.call(state.dump);
-  var inblock = block;
-  var tagStr;
-  if (block) {
-    block = state.flowLevel < 0 || state.flowLevel > level;
-  }
-  var objectOrArray = type2 === "[object Object]" || type2 === "[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 (type2 === "[object Object]") {
-      if (block && Object.keys(state.dump).length !== 0) {
+  function writeNode(state, level, object, block, compact, iskey, isblockseq) {
+    state.tag = null;
+    state.dump = object;
+    if (!detectType(state, object, false)) detectType(state, object, true);
+    const type = _toString.call(state.dump);
+    const inblock = block;
+    if (block) block = state.flowLevel < 0 || state.flowLevel > level;
+    const objectOrArray = type === "[object Object]" || type === "[object Array]";
+    let duplicateIndex;
+    let 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;
-        }
+        if (duplicate) state.dump = "&ref_" + duplicateIndex + state.dump;
       } else {
         writeFlowMapping(state, level, state.dump);
-        if (duplicate) {
-          state.dump = "&ref_" + duplicateIndex + " " + state.dump;
-        }
+        if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
       }
-    } else if (type2 === "[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 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;
-        }
+        if (duplicate) state.dump = "&ref_" + duplicateIndex + " " + state.dump;
       }
-    } else if (type2 === "[object String]") {
-      if (state.tag !== "?") {
-        writeScalar(state, state.dump, level, iskey, inblock);
+      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 YAMLException2("unacceptable kind of an object to dump " + type);
       }
-    } else if (type2 === "[object Undefined]") {
-      return false;
-    } else {
-      if (state.skipInvalid) return false;
-      throw new exception("unacceptable kind of an object to dump " + type2);
-    }
-    if (state.tag !== null && state.tag !== "?") {
-      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 + ">";
+      if (state.tag !== null && state.tag !== "?") {
+        let 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;
       }
-      state.dump = tagStr + " " + state.dump;
     }
+    return true;
   }
-  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);
-        }
+  function getDuplicateReferences(object, state) {
+    const objects = [];
+    const duplicatesIndexes = [];
+    inspectNode(object, objects, duplicatesIndexes);
+    const length = duplicatesIndexes.length;
+    for (let index = 0; index < length; index += 1) state.duplicates.push(objects[duplicatesIndexes[index]]);
+    state.usedDuplicates = new Array(length);
+  }
+  function inspectNode(object, objects, duplicatesIndexes) {
+    if (object !== null && typeof object === "object") {
+      const index = objects.indexOf(object);
+      if (index !== -1) {
+        if (duplicatesIndexes.indexOf(index) === -1) duplicatesIndexes.push(index);
       } else {
-        objectKeyList = Object.keys(object);
-        for (index = 0, length = objectKeyList.length; index < length; index += 1) {
-          inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes);
-        }
-      }
-    }
-  }
-}
-function dump$1(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 "";
-}
-var dump_1 = dump$1;
-var dumper = {
-  dump: dump_1
-};
-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.");
+        objects.push(object);
+        if (Array.isArray(object)) for (let i = 0, length = object.length; i < length; i += 1) inspectNode(object[i], objects, duplicatesIndexes);
+        else {
+          const objectKeyList = Object.keys(object);
+          for (let i = 0, length = objectKeyList.length; i < length; i += 1) inspectNode(object[objectKeyList[i]], objects, duplicatesIndexes);
+        }
+      }
+    }
+  }
+  function dump2(input, options) {
+    options = options || {};
+    const state = new State(options);
+    if (!state.noRefs) getDuplicateReferences(input, state);
+    let value = input;
+    if (state.replacer) value = state.replacer.call({ "": value }, "", value);
+    if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
+    return "";
+  }
+  module2.exports.dump = dump2;
+}));
+var import_js_yaml = /* @__PURE__ */ __toESM2((/* @__PURE__ */ __commonJSMin(((exports2, module2) => {
+  var loader = require_loader();
+  var dumper = require_dumper();
+  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.");
+    };
+  }
+  module2.exports.Type = require_type();
+  module2.exports.Schema = require_schema();
+  module2.exports.FAILSAFE_SCHEMA = require_failsafe();
+  module2.exports.JSON_SCHEMA = require_json();
+  module2.exports.CORE_SCHEMA = require_core2();
+  module2.exports.DEFAULT_SCHEMA = require_default();
+  module2.exports.load = loader.load;
+  module2.exports.loadAll = loader.loadAll;
+  module2.exports.dump = dumper.dump;
+  module2.exports.YAMLException = require_exception();
+  module2.exports.types = {
+    binary: require_binary(),
+    float: require_float(),
+    map: require_map(),
+    null: require_null(),
+    pairs: require_pairs(),
+    set: require_set(),
+    timestamp: require_timestamp(),
+    bool: require_bool(),
+    int: require_int(),
+    merge: require_merge(),
+    omap: require_omap(),
+    seq: require_seq(),
+    str: require_str()
   };
-}
-var load = loader.load;
-var loadAll = loader.loadAll;
-var dump = dumper.dump;
-var YAMLException = exception;
-var safeLoad = renamed("safeLoad", "load");
-var safeLoadAll = renamed("safeLoadAll", "loadAll");
-var safeDump = renamed("safeDump", "dump");
+  module2.exports.safeLoad = renamed("safeLoad", "load");
+  module2.exports.safeLoadAll = renamed("safeLoadAll", "loadAll");
+  module2.exports.safeDump = renamed("safeDump", "dump");
+})))(), 1);
+var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump } = import_js_yaml.default;
+var index_vite_proxy_tmp_default = import_js_yaml.default;
 
 // src/util.ts
 var semver = __toESM(require_semver2());
@@ -147692,7 +147467,7 @@ var minimumVersion = "3.16";
 function parseString(data) {
   return JSON.parse(data);
 }
-function isObject2(value) {
+function isObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isArray(value) {
@@ -147716,8 +147491,8 @@ function optional(validator) {
     required: false
   };
 }
-function validateSchema(schema2, obj) {
-  for (const [key, validator] of Object.entries(schema2)) {
+function validateSchema(schema, obj) {
+  for (const [key, validator] of Object.entries(schema)) {
     const hasKey = key in obj;
     if (validator.required && !hasKey) {
       return false;
@@ -148001,7 +147776,7 @@ function checkGitHubVersionInRange(version, logger) {
     );
   }
   hasBeenWarnedAboutVersion = true;
-  core3.exportVariable(CODEQL_ACTION_WARNED_ABOUT_VERSION_ENV_VAR, true);
+  core2.exportVariable(CODEQL_ACTION_WARNED_ABOUT_VERSION_ENV_VAR, true);
 }
 function apiVersionInRange(version, minimumVersion2, maximumVersion2) {
   if (!semver.satisfies(version, `>=${minimumVersion2}`)) {
@@ -148023,11 +147798,11 @@ function assertNever(value) {
   throw new ExhaustivityCheckingError(value);
 }
 function initializeEnvironment(version) {
-  core3.exportVariable("CODEQL_ACTION_FEATURE_MULTI_LANGUAGE" /* FEATURE_MULTI_LANGUAGE */, "false");
-  core3.exportVariable("CODEQL_ACTION_FEATURE_SANDWICH" /* FEATURE_SANDWICH */, "false");
-  core3.exportVariable("CODEQL_ACTION_FEATURE_SARIF_COMBINE" /* FEATURE_SARIF_COMBINE */, "true");
-  core3.exportVariable("CODEQL_ACTION_FEATURE_WILL_UPLOAD" /* FEATURE_WILL_UPLOAD */, "true");
-  core3.exportVariable("CODEQL_ACTION_VERSION" /* VERSION */, version);
+  core2.exportVariable("CODEQL_ACTION_FEATURE_MULTI_LANGUAGE" /* FEATURE_MULTI_LANGUAGE */, "false");
+  core2.exportVariable("CODEQL_ACTION_FEATURE_SANDWICH" /* FEATURE_SANDWICH */, "false");
+  core2.exportVariable("CODEQL_ACTION_FEATURE_SARIF_COMBINE" /* FEATURE_SARIF_COMBINE */, "true");
+  core2.exportVariable("CODEQL_ACTION_FEATURE_WILL_UPLOAD" /* FEATURE_WILL_UPLOAD */, "true");
+  core2.exportVariable("CODEQL_ACTION_VERSION" /* VERSION */, version);
 }
 function getRequiredEnvParam(paramName) {
   const value = process.env[paramName];
@@ -148053,7 +147828,7 @@ var HTTPError = class extends Error {
 var ConfigurationError = class extends Error {
 };
 function asHTTPError(arg) {
-  if (!isObject2(arg) || !isString(arg.message)) {
+  if (!isObject(arg) || !isString(arg.message)) {
     return void 0;
   }
   if (Number.isInteger(arg.status)) {
@@ -148078,7 +147853,7 @@ function cacheCodeQlVersion(cmd, version) {
     throw new Error("cacheCodeQlVersion() should be called only once");
   }
   cachedCodeQlVersion = version;
-  core3.exportVariable(
+  core2.exportVariable(
     "CODEQL_ACTION_CLI_VERSION_INFO" /* CODEQL_VERSION_INFO */,
     JSON.stringify({ cmd, version })
   );
@@ -148213,7 +147988,7 @@ async function waitForResultWithTimeLimit(timeoutMs, promise, onTimeout) {
 }
 async function checkForTimeout() {
   if (hadTimeout === true) {
-    core3.info(
+    core2.info(
       "A timeout occurred, force exiting the process after 30 seconds to prevent hanging."
     );
     await delay(3e4, { allowProcessExit: true });
@@ -148258,7 +148033,7 @@ async function checkDiskUsage(logger) {
       } else {
         logger.debug(message);
       }
-      core3.exportVariable("CODEQL_ACTION_HAS_WARNED_ABOUT_DISK_SPACE" /* HAS_WARNED_ABOUT_DISK_SPACE */, "true");
+      core2.exportVariable("CODEQL_ACTION_HAS_WARNED_ABOUT_DISK_SPACE" /* HAS_WARNED_ABOUT_DISK_SPACE */, "true");
     }
     return {
       numAvailableBytes: diskUsage.bavail * blockSizeInBytes,
@@ -148278,10 +148053,10 @@ function checkActionVersion(version, githubVersion) {
       semver.coerce(githubVersion.version) ?? "0.0.0",
       ">=3.20"
     )) {
-      core3.warning(
+      core2.warning(
         "CodeQL Action v3 will be deprecated in December 2026. Please update all occurrences of the CodeQL Action in your workflow files to v4. For more information, see https://github.blog/changelog/2025-10-28-upcoming-deprecation-of-codeql-action-v3/"
       );
-      core3.exportVariable("CODEQL_ACTION_DID_LOG_VERSION_DEPRECATION" /* LOG_VERSION_DEPRECATION */, "true");
+      core2.exportVariable("CODEQL_ACTION_DID_LOG_VERSION_DEPRECATION" /* LOG_VERSION_DEPRECATION */, "true");
     }
   }
 }
@@ -148313,13 +148088,13 @@ async function cleanUpPath(file, name, logger) {
     logger.warning(`Failed to clean up ${name}: ${e}.`);
   }
 }
-async function isBinaryAccessible(binary2, logger) {
+async function isBinaryAccessible(binary, logger) {
   try {
-    await io.which(binary2, true);
-    logger.debug(`Found ${binary2}.`);
+    await io.which(binary, true);
+    logger.debug(`Found ${binary}.`);
     return true;
   } catch (e) {
-    logger.debug(`Could not find ${binary2}: ${e}`);
+    logger.debug(`Could not find ${binary}: ${e}`);
     return false;
   }
 }
@@ -148379,14 +148154,14 @@ var Failure = class {
 
 // src/actions-util.ts
 var getRequiredInput = function(name) {
-  const value = core4.getInput(name);
+  const value = core3.getInput(name);
   if (!value) {
     throw new ConfigurationError(`Input required and not supplied: ${name}`);
   }
   return value;
 };
 var getOptionalInput = function(name) {
-  const value = core4.getInput(name);
+  const value = core3.getInput(name);
   return value.length > 0 ? value : void 0;
 };
 function getTemporaryDirectory() {
@@ -148427,22 +148202,22 @@ async function printDebugLogs(config) {
     const databaseDirectory = getCodeQLDatabasePath(config, language);
     const logsDirectory = path2.join(databaseDirectory, "log");
     if (!doesDirectoryExist(logsDirectory)) {
-      core4.info(`Directory ${logsDirectory} does not exist.`);
+      core3.info(`Directory ${logsDirectory} does not exist.`);
       continue;
     }
     const walkLogFiles = (dir) => {
       const entries = fs2.readdirSync(dir, { withFileTypes: true });
       if (entries.length === 0) {
-        core4.info(`No debug logs found at directory ${logsDirectory}.`);
+        core3.info(`No debug logs found at directory ${logsDirectory}.`);
       }
       for (const entry of entries) {
         if (entry.isFile()) {
           const absolutePath = path2.resolve(dir, entry.name);
-          core4.startGroup(
+          core3.startGroup(
             `CodeQL Debug Logs - ${language} - ${entry.name} from file at path ${absolutePath}`
           );
           process.stdout.write(fs2.readFileSync(absolutePath));
-          core4.endGroup();
+          core3.endGroup();
         } else if (entry.isDirectory()) {
           walkLogFiles(path2.resolve(dir, entry.name));
         }
@@ -148463,7 +148238,7 @@ function getUploadValue(input) {
     case "never":
       return "never";
     default:
-      core4.warning(
+      core3.warning(
         `Unrecognized 'upload' input to 'analyze' Action: ${input}. Defaulting to 'always'.`
       );
       return "always";
@@ -148530,7 +148305,7 @@ var getFileType = async (filePath) => {
     }).exec();
     return stdout.trim();
   } catch (e) {
-    core4.info(
+    core3.info(
       `Could not determine type of ${filePath} from ${stdout}. ${stderr}`
     );
     throw e;
@@ -148611,10 +148386,10 @@ var persistInputs = function() {
   const inputEnvironmentVariables = Object.entries(process.env).filter(
     ([name]) => name.startsWith("INPUT_")
   );
-  core4.saveState(persistedInputsKey, JSON.stringify(inputEnvironmentVariables));
+  core3.saveState(persistedInputsKey, JSON.stringify(inputEnvironmentVariables));
 };
 var restoreInputs = function() {
-  const persistedInputs = core4.getState(persistedInputsKey);
+  const persistedInputs = core3.getState(persistedInputsKey);
   if (persistedInputs) {
     for (const [name, value] of JSON.parse(persistedInputs)) {
       process.env[name] = value;
@@ -148678,7 +148453,7 @@ var path5 = __toESM(require("path"));
 var semver4 = __toESM(require_semver2());
 
 // src/api-client.ts
-var core5 = __toESM(require_core());
+var core4 = __toESM(require_core());
 var githubUtils = __toESM(require_utils4());
 
 // node_modules/@octokit/plugin-retry/dist-bundle/index.js
@@ -148791,10 +148566,10 @@ function createApiClientWithDetails(apiDetails, { allowExternal = false } = {})
       baseUrl: apiDetails.apiURL,
       userAgent: `CodeQL-Action/${getActionVersion()}`,
       log: {
-        debug: core5.debug,
-        info: core5.info,
-        warn: core5.warning,
-        error: core5.error
+        debug: core4.debug,
+        info: core4.info,
+        warn: core4.warning,
+        error: core4.error
       },
       retry: {
         doNotRetry: DO_NOT_RETRY_STATUSES
@@ -148875,7 +148650,7 @@ async function getAnalysisKey() {
   const workflowPath = await getWorkflowRelativePath();
   const jobName = getRequiredEnvParam("GITHUB_JOB");
   analysisKey = `${workflowPath}:${jobName}`;
-  core5.exportVariable("CODEQL_ACTION_ANALYSIS_KEY" /* ANALYSIS_KEY */, analysisKey);
+  core4.exportVariable("CODEQL_ACTION_ANALYSIS_KEY" /* ANALYSIS_KEY */, analysisKey);
   return analysisKey;
 }
 async function getAutomationID() {
@@ -148973,7 +148748,7 @@ var path4 = __toESM(require("path"));
 var fs3 = __toESM(require("fs"));
 var os2 = __toESM(require("os"));
 var path3 = __toESM(require("path"));
-var core6 = __toESM(require_core());
+var core5 = __toESM(require_core());
 var toolrunner2 = __toESM(require_toolrunner());
 var io3 = __toESM(require_io());
 var semver2 = __toESM(require_semver2());
@@ -149004,7 +148779,7 @@ async function getGitVersionOrThrow() {
 var runGitCommand = async function(workingDirectory, args, customErrorMessage, options) {
   let stdout = "";
   let stderr = "";
-  core6.debug(`Running git command: git ${args.join(" ")}`);
+  core5.debug(`Running git command: git ${args.join(" ")}`);
   try {
     await new toolrunner2.ToolRunner(await io3.which("git", true), args, {
       silent: true,
@@ -149025,7 +148800,7 @@ var runGitCommand = async function(workingDirectory, args, customErrorMessage, o
     if (stderr.includes("not a git repository")) {
       reason = "The checkout path provided to the action does not appear to be a git repository.";
     }
-    core6.info(`git call failed. ${customErrorMessage} Error: ${reason}`);
+    core5.info(`git call failed. ${customErrorMessage} Error: ${reason}`);
     throw error3;
   }
 };
@@ -149080,8 +148855,8 @@ var decodeGitFilePath = function(filePath) {
     filePath = filePath.substring(1, filePath.length - 1);
     return filePath.replace(
       /\\([abfnrtv\\"]|[0-7]{1,3})/g,
-      (_match, seq2) => {
-        switch (seq2[0]) {
+      (_match, seq) => {
+        switch (seq[0]) {
           case "a":
             return "\x07";
           case "b":
@@ -149101,7 +148876,7 @@ var decodeGitFilePath = function(filePath) {
           case '"':
             return '"';
           default:
-            return String.fromCharCode(parseInt(seq2, 8));
+            return String.fromCharCode(parseInt(seq, 8));
         }
       }
     );
@@ -149188,7 +148963,7 @@ async function getRef() {
   ) !== head;
   if (hasChangedRef) {
     const newRef = ref.replace(pull_ref_regex, "refs/pull/$1/head");
-    core6.debug(
+    core5.debug(
       `No longer on merge commit, rewriting ref from ${ref} to ${newRef}.`
     );
     return newRef;
@@ -150076,12 +149851,12 @@ var import_perf_hooks3 = require("perf_hooks");
 var io5 = __toESM(require_io());
 
 // src/autobuild.ts
-var core12 = __toESM(require_core());
+var core11 = __toESM(require_core());
 
 // src/codeql.ts
 var fs15 = __toESM(require("fs"));
 var path14 = __toESM(require("path"));
-var core11 = __toESM(require_core());
+var core10 = __toESM(require_core());
 var toolrunner3 = __toESM(require_toolrunner());
 
 // src/cli-errors.ts
@@ -150336,11 +150111,11 @@ function wrapCliConfigurationError(cliError) {
 var fs9 = __toESM(require("fs"));
 var path10 = __toESM(require("path"));
 var import_perf_hooks = require("perf_hooks");
-var core9 = __toESM(require_core());
+var core8 = __toESM(require_core());
 
 // src/caching-utils.ts
 var crypto2 = __toESM(require("crypto"));
-var core7 = __toESM(require_core());
+var core6 = __toESM(require_core());
 async function getTotalCacheSize(paths, logger, quiet = false) {
   const sizes = await Promise.all(
     paths.map((cacheDir2) => tryGetFolderBytes(cacheDir2, logger, quiet))
@@ -150369,7 +150144,7 @@ function getCachingKind(input) {
     case "restore":
       return "restore" /* Restore */;
     default:
-      core7.warning(
+      core6.warning(
         `Unrecognized 'dependency-caching' input: ${input}. Defaulting to 'none'.`
       );
       return "none" /* None */;
@@ -150492,7 +150267,7 @@ async function loadPropertiesFromApi(logger, repositoryNwo) {
         );
       }
       if (isKnownPropertyName(property.property_name)) {
-        setProperty2(properties, property.property_name, property.value, logger);
+        setProperty(properties, property.property_name, property.value, logger);
       } else if (property.property_name.startsWith(GITHUB_CODEQL_PROPERTY_PREFIX) && !isDynamicWorkflow()) {
         unrecognisedProperties.push(property.property_name);
       }
@@ -150522,7 +150297,7 @@ async function loadPropertiesFromApi(logger, repositoryNwo) {
     );
   }
 }
-function setProperty2(properties, name, value, logger) {
+function setProperty(properties, name, value, logger) {
   const propertyOptions = repositoryPropertyParsers[name];
   if (propertyOptions.validate(value)) {
     properties[name] = propertyOptions.parse(name, value, logger);
@@ -150759,13 +150534,13 @@ function generateCodeScanningConfig(logger, originalUserInput, augmentationPrope
 }
 function parseUserConfig(logger, pathInput, contents, validateConfig) {
   try {
-    const schema2 = (
+    const schema = (
       // eslint-disable-next-line @typescript-eslint/no-require-imports
       require_db_config_schema()
     );
     const doc = load(contents);
     if (validateConfig) {
-      const result = new jsonschema.Validator().validate(doc, schema2);
+      const result = new jsonschema.Validator().validate(doc, schema);
       if (result.errors.length > 0) {
         for (const error3 of result.errors) {
           logger.error(error3.stack);
@@ -150794,32 +150569,32 @@ var import_fs = require("fs");
 var import_path = __toESM(require("path"));
 
 // src/logging.ts
-var core8 = __toESM(require_core());
+var core7 = __toESM(require_core());
 function getActionsLogger() {
   return {
-    debug: core8.debug,
-    info: core8.info,
-    warning: core8.warning,
-    error: core8.error,
-    isDebug: core8.isDebug,
-    startGroup: core8.startGroup,
-    endGroup: core8.endGroup
+    debug: core7.debug,
+    info: core7.info,
+    warning: core7.warning,
+    error: core7.error,
+    isDebug: core7.isDebug,
+    startGroup: core7.startGroup,
+    endGroup: core7.endGroup
   };
 }
 function withGroup(groupName, f) {
-  core8.startGroup(groupName);
+  core7.startGroup(groupName);
   try {
     return f();
   } finally {
-    core8.endGroup();
+    core7.endGroup();
   }
 }
 async function withGroupAsync(groupName, f) {
-  core8.startGroup(groupName);
+  core7.startGroup(groupName);
   try {
     return await f();
   } finally {
-    core8.endGroup();
+    core7.endGroup();
   }
 }
 function formatDuration(durationMs) {
@@ -151302,7 +151077,7 @@ async function getOverlayStatus(codeql, languages, diskUsage, logger) {
     }
     const contents = await fs7.promises.readFile(statusFile, "utf-8");
     const parsed = JSON.parse(contents);
-    if (!isObject2(parsed) || typeof parsed["attemptedToBuildOverlayBaseDatabase"] !== "boolean" || typeof parsed["builtOverlayBaseDatabase"] !== "boolean") {
+    if (!isObject(parsed) || typeof parsed["attemptedToBuildOverlayBaseDatabase"] !== "boolean" || typeof parsed["builtOverlayBaseDatabase"] !== "boolean") {
       logger.debug(
         "Ignoring overlay status cache entry with unexpected format."
       );
@@ -152026,10 +151801,10 @@ async function setCppTrapCachingEnvironmentVariables(config, logger) {
       );
     } else if (config.trapCaches["cpp" /* cpp */]) {
       logger.info("Enabling TRAP caching for C/C++.");
-      core9.exportVariable(envVar, "true");
+      core8.exportVariable(envVar, "true");
     } else {
       logger.debug(`Disabling TRAP caching for C/C++.`);
-      core9.exportVariable(envVar, "false");
+      core8.exportVariable(envVar, "false");
     }
   }
 }
@@ -152842,9 +152617,9 @@ async function isZstdAvailable(logger) {
   const foundZstdBinary = await isBinaryAccessible("zstd", logger);
   try {
     const tarVersion = await getTarVersion();
-    const { type: type2, version } = tarVersion;
-    logger.info(`Found ${type2} tar version ${version}.`);
-    switch (type2) {
+    const { type, version } = tarVersion;
+    logger.info(`Found ${type} tar version ${version}.`);
+    switch (type) {
       case "gnu":
         return {
           available: foundZstdBinary && // GNU tar only uses major and minor version numbers
@@ -152864,7 +152639,7 @@ async function isZstdAvailable(logger) {
           version: tarVersion
         };
       default:
-        assertNever(type2);
+        assertNever(type);
     }
   } catch (e) {
     logger.warning(
@@ -152962,7 +152737,7 @@ var fs12 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
 var path11 = __toESM(require("path"));
 var import_perf_hooks2 = require("perf_hooks");
-var core10 = __toESM(require_core());
+var core9 = __toESM(require_core());
 var import_http_client = __toESM(require_lib());
 var toolcache2 = __toESM(require_tool_cache());
 var import_follow_redirects = __toESM(require_follow_redirects());
@@ -153016,10 +152791,10 @@ async function downloadAndExtract(codeqlURL, compressionMethod, dest, authorizat
       };
     }
   } catch (e) {
-    core10.warning(
+    core9.warning(
       `Failed to download and extract CodeQL bundle using streaming with error: ${getErrorMessage(e)}`
     );
-    core10.warning(`Falling back to downloading the bundle before extracting.`);
+    core9.warning(`Falling back to downloading the bundle before extracting.`);
     await cleanUpPath(dest, "CodeQL bundle", logger);
   }
   const toolsDownloadStart = import_perf_hooks2.performance.now();
@@ -153926,7 +153701,7 @@ async function getCodeQLForCmd(cmd, checkVersion) {
       return result;
     },
     async printVersion() {
-      core11.info(JSON.stringify(await this.getVersion(), null, 2));
+      core10.info(JSON.stringify(await this.getVersion(), null, 2));
     },
     async supportsFeature(feature) {
       return isSupportedToolsFeature(await this.getVersion(), feature);
@@ -154334,12 +154109,12 @@ ${output}`
     );
   } else if (checkVersion && process.env["CODEQL_ACTION_SUPPRESS_DEPRECATED_SOON_WARNING" /* SUPPRESS_DEPRECATED_SOON_WARNING */] !== "true" && !await codeQlVersionAtLeast(codeql, CODEQL_NEXT_MINIMUM_VERSION)) {
     const result = await codeql.getVersion();
-    core11.warning(
+    core10.warning(
       `CodeQL CLI version ${result.version} was discontinued on ${GHES_MOST_RECENT_DEPRECATION_DATE} alongside GitHub Enterprise Server ${GHES_VERSION_MOST_RECENTLY_DEPRECATED} and will not be supported by the next minor release of the CodeQL Action. Please update to CodeQL CLI version ${CODEQL_NEXT_MINIMUM_VERSION} or later. For instance, if you have specified a custom version of the CLI using the 'tools' input to the 'init' Action, you can remove this input to use the default version.
 
 Alternatively, if you want to continue using CodeQL CLI version ${result.version}, you can replace 'github/codeql-action/*@v${getActionVersion().split(".")[0]}' by 'github/codeql-action/*@v${getActionVersion()}' in your code scanning workflow to continue using this version of the CodeQL Action.`
     );
-    core11.exportVariable("CODEQL_ACTION_SUPPRESS_DEPRECATED_SOON_WARNING" /* SUPPRESS_DEPRECATED_SOON_WARNING */, "true");
+    core10.exportVariable("CODEQL_ACTION_SUPPRESS_DEPRECATED_SOON_WARNING" /* SUPPRESS_DEPRECATED_SOON_WARNING */, "true");
   }
   return codeql;
 }
@@ -154498,16 +154273,16 @@ async function setupCppAutobuild(codeql, logger) {
       logger.info(
         `Disabling ${featureName} as we are on a self-hosted runner.${getWorkflowEventName() !== "dynamic" ? ` To override this, set the ${envVar} environment variable to 'true' in your workflow. See ${"https://docs.github.com/en/actions/learn-github-actions/variables#defining-environment-variables-for-a-single-workflow" /* DEFINE_ENV_VARIABLES */} for more information.` : ""}`
       );
-      core12.exportVariable(envVar, "false");
+      core11.exportVariable(envVar, "false");
     } else {
       logger.info(
         `Enabling ${featureName}. This can be disabled by setting the ${envVar} environment variable to 'false'. See ${"https://docs.github.com/en/actions/learn-github-actions/variables#defining-environment-variables-for-a-single-workflow" /* DEFINE_ENV_VARIABLES */} for more information.`
       );
-      core12.exportVariable(envVar, "true");
+      core11.exportVariable(envVar, "true");
     }
   } else {
     logger.info(`Disabling ${featureName}.`);
-    core12.exportVariable(envVar, "false");
+    core11.exportVariable(envVar, "false");
   }
 }
 async function runAutobuild(config, language, logger) {
@@ -154522,7 +154297,7 @@ async function runAutobuild(config, language, logger) {
     await codeQL.runAutobuild(config, language);
   }
   if (language === "go" /* go */) {
-    core12.exportVariable("CODEQL_ACTION_DID_AUTOBUILD_GOLANG" /* DID_AUTOBUILD_GOLANG */, "true");
+    core11.exportVariable("CODEQL_ACTION_DID_AUTOBUILD_GOLANG" /* DID_AUTOBUILD_GOLANG */, "true");
   }
   logger.endGroup();
 }
@@ -155315,7 +155090,7 @@ async function uploadBundledDatabase(repositoryNwo, language, commitOid, bundled
 
 // src/status-report.ts
 var os5 = __toESM(require("os"));
-var core13 = __toESM(require_core());
+var core12 = __toESM(require_core());
 function isFirstPartyAnalysis(actionName) {
   if (actionName !== "upload-sarif" /* UploadSarif */) {
     return true;
@@ -155355,18 +155130,18 @@ function getJobStatusDisplayName(status) {
 }
 function setJobStatusIfUnsuccessful(actionStatus) {
   if (actionStatus === "user-error") {
-    core13.exportVariable(
+    core12.exportVariable(
       "CODEQL_ACTION_JOB_STATUS" /* JOB_STATUS */,
       process.env["CODEQL_ACTION_JOB_STATUS" /* JOB_STATUS */] ?? "JOB_STATUS_CONFIGURATION_ERROR" /* ConfigErrorStatus */
     );
   } else if (actionStatus === "failure" || actionStatus === "aborted") {
-    core13.exportVariable(
+    core12.exportVariable(
       "CODEQL_ACTION_JOB_STATUS" /* JOB_STATUS */,
       process.env["CODEQL_ACTION_JOB_STATUS" /* JOB_STATUS */] ?? "JOB_STATUS_FAILURE" /* FailureStatus */
     );
   }
 }
-async function createStatusReportBase(actionName, status, actionStartedAt, config, diskInfo, logger, cause, exception2) {
+async function createStatusReportBase(actionName, status, actionStartedAt, config, diskInfo, logger, cause, exception) {
   try {
     const commitOid = getOptionalInput("sha") || process.env["GITHUB_SHA"] || "";
     const ref = await getRef();
@@ -155379,14 +155154,14 @@ async function createStatusReportBase(actionName, status, actionStartedAt, confi
     let workflowStartedAt = process.env["CODEQL_WORKFLOW_STARTED_AT" /* WORKFLOW_STARTED_AT */];
     if (workflowStartedAt === void 0) {
       workflowStartedAt = actionStartedAt.toISOString();
-      core13.exportVariable("CODEQL_WORKFLOW_STARTED_AT" /* WORKFLOW_STARTED_AT */, workflowStartedAt);
+      core12.exportVariable("CODEQL_WORKFLOW_STARTED_AT" /* WORKFLOW_STARTED_AT */, workflowStartedAt);
     }
     const runnerOs = getRequiredEnvParam("RUNNER_OS");
     const codeQlCliVersion = getCachedCodeQlVersion();
     const actionRef = process.env["GITHUB_ACTION_REF"] || "";
     const testingEnvironment = getTestingEnvironment();
     if (testingEnvironment) {
-      core13.exportVariable("CODEQL_ACTION_TESTING_ENVIRONMENT" /* TESTING_ENVIRONMENT */, testingEnvironment);
+      core12.exportVariable("CODEQL_ACTION_TESTING_ENVIRONMENT" /* TESTING_ENVIRONMENT */, testingEnvironment);
     }
     const isSteadyStateDefaultSetupRun = process.env["CODE_SCANNING_IS_STEADY_STATE_DEFAULT_SETUP"] === "true";
     const statusReport = {
@@ -155430,8 +155205,8 @@ async function createStatusReportBase(actionName, status, actionStartedAt, confi
     if (cause) {
       statusReport.cause = cause;
     }
-    if (exception2) {
-      statusReport.exception = exception2;
+    if (exception) {
+      statusReport.exception = exception;
     }
     if (status === "success" || status === "failure" || status === "aborted" || status === "user-error") {
       statusReport.completed_at = (/* @__PURE__ */ new Date()).toISOString();
@@ -155469,9 +155244,9 @@ var INCOMPATIBLE_MSG = "CodeQL Action version is incompatible with the API endpo
 async function sendStatusReport(statusReport) {
   setJobStatusIfUnsuccessful(statusReport.status);
   const statusReportJSON = JSON.stringify(statusReport);
-  core13.debug(`Sending status report: ${statusReportJSON}`);
+  core12.debug(`Sending status report: ${statusReportJSON}`);
   if (isInTestMode()) {
-    core13.debug("In test mode. Status reports are not uploaded.");
+    core12.debug("In test mode. Status reports are not uploaded.");
     return;
   }
   const nwo = getRepositoryNwo();
@@ -155491,28 +155266,28 @@ async function sendStatusReport(statusReport) {
       switch (httpError.status) {
         case 403:
           if (getWorkflowEventName() === "push" && process.env["GITHUB_ACTOR"] === "dependabot[bot]") {
-            core13.warning(
+            core12.warning(
               `Workflows triggered by Dependabot on the "push" event run with read-only access. Uploading CodeQL results requires write access. To use CodeQL with Dependabot, please ensure you are using the "pull_request" event for this workflow and avoid triggering on the "push" event for Dependabot branches. See ${"https://docs.github.com/en/code-security/code-scanning/creating-an-advanced-setup-for-code-scanning/customizing-your-advanced-setup-for-code-scanning#scanning-on-push" /* SCANNING_ON_PUSH */} for more information on how to configure these events.`
             );
           } else {
-            core13.warning(
+            core12.warning(
               `This run of the CodeQL Action does not have permission to access the CodeQL Action API endpoints. This could be because the Action is running on a pull request from a fork. If not, please ensure the workflow has at least the 'security-events: read' permission. Details: ${httpError.message}`
             );
           }
           return;
         case 404:
-          core13.warning(httpError.message);
+          core12.warning(httpError.message);
           return;
         case 422:
           if (getRequiredEnvParam("GITHUB_SERVER_URL") !== GITHUB_DOTCOM_URL) {
-            core13.debug(INCOMPATIBLE_MSG);
+            core12.debug(INCOMPATIBLE_MSG);
           } else {
-            core13.debug(OUT_OF_DATE_MSG);
+            core12.debug(OUT_OF_DATE_MSG);
           }
           return;
       }
     }
-    core13.warning(
+    core12.warning(
       `An unexpected error occurred when sending a status report: ${getErrorMessage(
         e
       )}`
@@ -155616,7 +155391,7 @@ var fs21 = __toESM(require("fs"));
 var path18 = __toESM(require("path"));
 var url = __toESM(require("url"));
 var import_zlib = __toESM(require("zlib"));
-var core15 = __toESM(require_core());
+var core14 = __toESM(require_core());
 var jsonschema2 = __toESM(require_lib2());
 
 // src/fingerprints.ts
@@ -156011,27 +155786,27 @@ function fromBits(lowBits, highBits, unsigned) {
 }
 Long.fromBits = fromBits;
 var pow_dbl = Math.pow;
-function fromString(str2, unsigned, radix) {
-  if (str2.length === 0) throw Error("empty string");
+function fromString(str, unsigned, radix) {
+  if (str.length === 0) throw Error("empty string");
   if (typeof unsigned === "number") {
     radix = unsigned;
     unsigned = false;
   } else {
     unsigned = !!unsigned;
   }
-  if (str2 === "NaN" || str2 === "Infinity" || str2 === "+Infinity" || str2 === "-Infinity")
+  if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")
     return unsigned ? UZERO : ZERO;
   radix = radix || 10;
   if (radix < 2 || 36 < radix) throw RangeError("radix");
   var p;
-  if ((p = str2.indexOf("-")) > 0) throw Error("interior hyphen");
+  if ((p = str.indexOf("-")) > 0) throw Error("interior hyphen");
   else if (p === 0) {
-    return fromString(str2.substring(1), unsigned, radix).neg();
+    return fromString(str.substring(1), unsigned, radix).neg();
   }
   var radixToPower = fromNumber(pow_dbl(radix, 8));
   var result = ZERO;
-  for (var i = 0; i < str2.length; i += 8) {
-    var size = Math.min(8, str2.length - i), value = parseInt(str2.substring(i, i + size), radix);
+  for (var i = 0; i < str.length; i += 8) {
+    var size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix);
     if (size < 8) {
       var power = fromNumber(pow_dbl(radix, size));
       result = result.mul(power).add(fromNumber(value));
@@ -156085,7 +155860,7 @@ LongPrototype.toNumber = function toNumber() {
     return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
   return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
 };
-LongPrototype.toString = function toString2(radix) {
+LongPrototype.toString = function toString(radix) {
   radix = radix || 10;
   if (radix < 2 || 36 < radix) throw RangeError("radix");
   if (this.isZero()) return "0";
@@ -156646,7 +156421,7 @@ function locationUpdateCallback(result, location, logger) {
 }
 function resolveUriToFile(location, artifacts, sourceRoot, logger) {
   if (!location.uri && location.index !== void 0) {
-    if (typeof location.index !== "number" || location.index < 0 || location.index >= artifacts.length || !isObject2(artifacts[location.index].location)) {
+    if (typeof location.index !== "number" || location.index < 0 || location.index >= artifacts.length || !isObject(artifacts[location.index].location)) {
       logger.debug(`Ignoring location as index "${location.index}" is invalid`);
       return void 0;
     }
@@ -156744,7 +156519,7 @@ async function addFingerprints(sarifLog, sourceRoot, logger) {
 // src/init.ts
 var fs19 = __toESM(require("fs"));
 var path17 = __toESM(require("path"));
-var core14 = __toESM(require_core());
+var core13 = __toESM(require_core());
 var toolrunner4 = __toESM(require_toolrunner());
 var github2 = __toESM(require_github());
 var io6 = __toESM(require_io());
@@ -156974,7 +156749,7 @@ To opt out of this change, switch to an advanced setup workflow and ${envVarOptO
 To opt out of this change, ${envVarOptOut}`;
   }
   logger.warning(message);
-  core14.exportVariable("CODEQL_ACTION_DID_LOG_FILE_COVERAGE_ON_PRS_DEPRECATION" /* DID_LOG_FILE_COVERAGE_ON_PRS_DEPRECATION */, "true");
+  core13.exportVariable("CODEQL_ACTION_DID_LOG_FILE_COVERAGE_ON_PRS_DEPRECATION" /* DID_LOG_FILE_COVERAGE_ON_PRS_DEPRECATION */, "true");
 }
 
 // src/sarif/index.ts
@@ -157088,7 +156863,7 @@ async function combineSarifFilesUsingCLI(sarifFiles, gitHubVersion, features, lo
       logger.warning(
         `Uploading multiple SARIF runs with the same category is deprecated ${deprecationWarningMessage}. Please update your workflow to upload a single run per category. ${deprecationMoreInformationMessage}`
       );
-      core15.exportVariable("CODEQL_MERGE_SARIF_DEPRECATION_WARNING", "true");
+      core14.exportVariable("CODEQL_MERGE_SARIF_DEPRECATION_WARNING", "true");
     }
     return combineSarifFiles(sarifFiles, logger);
   }
@@ -157189,13 +156964,13 @@ async function uploadPayload(payload, repositoryNwo, logger, analysis) {
     if (httpError !== void 0) {
       switch (httpError.status) {
         case 403:
-          core15.warning(httpError.message || GENERIC_403_MSG);
+          core14.warning(httpError.message || GENERIC_403_MSG);
           break;
         case 404:
-          core15.warning(httpError.message || GENERIC_404_MSG);
+          core14.warning(httpError.message || GENERIC_404_MSG);
           break;
         default:
-          core15.warning(httpError.message);
+          core14.warning(httpError.message);
           break;
       }
     }
@@ -157316,8 +157091,8 @@ function validateSarifFileSchema(sarifLog, sarifFilePath, logger) {
     return true;
   }
   logger.info(`Validating ${sarifFilePath}`);
-  const schema2 = require_sarif_schema_2_1_0();
-  const result = new jsonschema2.Validator().validate(sarifLog, schema2);
+  const schema = require_sarif_schema_2_1_0();
+  const result = new jsonschema2.Validator().validate(sarifLog, schema);
   const warningAttributes = ["uri-reference", "uri"];
   const errors = (result.errors ?? []).filter(
     (err) => !(err.name === "format" && typeof err.argument === "string" && warningAttributes.includes(err.argument))
@@ -157633,11 +157408,11 @@ function validateUniqueCategory(sarifLog, sentinelPrefix) {
         `Aborting upload: only one run of the codeql/analyze or codeql/upload-sarif actions is allowed per job per tool/category. The easiest fix is to specify a unique value for the \`category\` input. If .runs[].automationDetails.id is specified in the sarif file, that will take precedence over your configured \`category\`. Category: (${id ? id : "none"}) Tool: (${tool ? tool : "none"})`
       );
     }
-    core15.exportVariable(sentinelEnvVar, sentinelEnvVar);
+    core14.exportVariable(sentinelEnvVar, sentinelEnvVar);
   }
 }
-function sanitize(str2) {
-  return (str2 ?? "_").replace(/[^a-zA-Z0-9_]/g, "_").toLocaleUpperCase();
+function sanitize(str) {
+  return (str ?? "_").replace(/[^a-zA-Z0-9_]/g, "_").toLocaleUpperCase();
 }
 function filterAlertsByDiffRange(logger, sarifLog) {
   const diffRanges = readDiffRangesJsonFile(logger);
@@ -157852,7 +157627,7 @@ async function run(startedAt) {
     }
     const apiDetails = getApiDetails();
     const outputDir = getRequiredInput("output");
-    core16.exportVariable("CODEQL_ACTION_SARIF_RESULTS_OUTPUT_DIR" /* SARIF_RESULTS_OUTPUT_DIR */, outputDir);
+    core15.exportVariable("CODEQL_ACTION_SARIF_RESULTS_OUTPUT_DIR" /* SARIF_RESULTS_OUTPUT_DIR */, outputDir);
     const threads = getThreadsFlag(
       getOptionalInput("threads") || process.env["CODEQL_THREADS"],
       logger
@@ -157904,8 +157679,8 @@ async function run(startedAt) {
     for (const language of config.languages) {
       dbLocations[language] = getCodeQLDatabasePath(config, language);
     }
-    core16.setOutput("db-locations", dbLocations);
-    core16.setOutput("sarif-output", import_path4.default.resolve(outputDir));
+    core15.setOutput("db-locations", dbLocations);
+    core15.setOutput("sarif-output", import_path4.default.resolve(outputDir));
     const uploadKind = getUploadValue(
       getOptionalInput("upload")
     );
@@ -157922,13 +157697,13 @@ async function run(startedAt) {
         getOptionalInput("post-processed-sarif-path")
       );
       if (uploadResults["code-scanning" /* CodeScanning */] !== void 0) {
-        core16.setOutput(
+        core15.setOutput(
           "sarif-id",
           uploadResults["code-scanning" /* CodeScanning */].sarifID
         );
       }
       if (uploadResults["code-quality" /* CodeQuality */] !== void 0) {
-        core16.setOutput(
+        core15.setOutput(
           "quality-sarif-id",
           uploadResults["code-quality" /* CodeQuality */].sarifID
         );
@@ -157971,15 +157746,15 @@ async function run(startedAt) {
       );
     }
     if (getOptionalInput("expect-error") === "true") {
-      core16.setFailed(
+      core15.setFailed(
         `expect-error input was set to true but no error was thrown.`
       );
     }
-    core16.exportVariable("CODEQL_ACTION_ANALYZE_DID_COMPLETE_SUCCESSFULLY" /* ANALYZE_DID_COMPLETE_SUCCESSFULLY */, "true");
+    core15.exportVariable("CODEQL_ACTION_ANALYZE_DID_COMPLETE_SUCCESSFULLY" /* ANALYZE_DID_COMPLETE_SUCCESSFULLY */, "true");
   } catch (unwrappedError) {
     const error3 = wrapError(unwrappedError);
     if (getOptionalInput("expect-error") !== "true" || hasBadExpectErrorInput()) {
-      core16.setFailed(error3.message);
+      core15.setFailed(error3.message);
     }
     await sendStatusReport2(
       startedAt,
@@ -158049,7 +157824,7 @@ async function runWrapper() {
   try {
     await run(startedAt);
   } catch (error3) {
-    core16.setFailed(`analyze action failed: ${getErrorMessage(error3)}`);
+    core15.setFailed(`analyze action failed: ${getErrorMessage(error3)}`);
     await sendUnhandledErrorStatusReport(
       "finish" /* Analyze */,
       startedAt,
@@ -158062,14 +157837,14 @@ async function runWrapper() {
 
 // src/analyze-action-post.ts
 var fs25 = __toESM(require("fs"));
-var core18 = __toESM(require_core());
+var core17 = __toESM(require_core());
 
 // src/debug-artifacts.ts
 var fs24 = __toESM(require("fs"));
 var path21 = __toESM(require("path"));
 var artifact = __toESM(require_artifact2());
 var artifactLegacy = __toESM(require_artifact_client2());
-var core17 = __toESM(require_core());
+var core16 = __toESM(require_core());
 var import_archiver = __toESM(require_archiver());
 
 // src/artifact-scanner.ts
@@ -158110,9 +157885,9 @@ var GITHUB_TOKEN_PATTERNS = [
   }
 ];
 function isAuthToken(value, patterns = GITHUB_TOKEN_PATTERNS) {
-  for (const { type: type2, pattern } of patterns) {
+  for (const { type, pattern } of patterns) {
     if (value.match(pattern)) {
-      return type2;
+      return type;
     }
   }
   return void 0;
@@ -158121,13 +157896,13 @@ function scanFileForTokens(filePath, relativePath, logger) {
   const findings = [];
   try {
     const content = fs23.readFileSync(filePath, "utf8");
-    for (const { type: type2, pattern } of GITHUB_TOKEN_PATTERNS) {
+    for (const { type, pattern } of GITHUB_TOKEN_PATTERNS) {
       const matches = content.match(pattern);
       if (matches) {
         for (let i = 0; i < matches.length; i++) {
-          findings.push({ tokenType: type2, filePath: relativePath });
+          findings.push({ tokenType: type, filePath: relativePath });
         }
-        logger.debug(`Found ${matches.length} ${type2}(s) in ${relativePath}`);
+        logger.debug(`Found ${matches.length} ${type}(s) in ${relativePath}`);
       }
     }
     return findings;
@@ -158307,7 +158082,7 @@ async function scanArtifactsForTokens(filesToScan, logger) {
       );
       filesWithTokens.add(finding.filePath);
     }
-    const tokenTypesSummary = Array.from(tokenTypesCounts.entries()).map(([type2, count]) => `${count} ${type2}${count > 1 ? "s" : ""}`).join(", ");
+    const tokenTypesSummary = Array.from(tokenTypesCounts.entries()).map(([type, count]) => `${count} ${type}${count > 1 ? "s" : ""}`).join(", ");
     const baseSummary = `scanned ${result.scannedFiles} files, found ${result.findings.length} potential token(s) in ${filesWithTokens.size} file(s)`;
     const summaryWithTypes = tokenTypesSummary ? `${baseSummary} (${tokenTypesSummary})` : baseSummary;
     logger.info(`Artifact check complete: ${summaryWithTypes}`);
@@ -158489,14 +158264,14 @@ function getArtifactSuffix(matrix) {
   if (matrix) {
     try {
       const matrixObject = JSON.parse(matrix);
-      if (isObject2(matrixObject)) {
+      if (isObject(matrixObject)) {
         for (const matrixKey of Object.keys(matrixObject).sort())
           suffix += `-${matrixObject[matrixKey]}`;
       } else {
-        core17.warning("User-specified `matrix` input is not an object.");
+        core16.warning("User-specified `matrix` input is not an object.");
       }
     } catch {
-      core17.warning(
+      core16.warning(
         "Could not parse user-specified `matrix` input into JSON. The debug artifact will not be named with the user's `matrix` input."
       );
     }
@@ -158506,7 +158281,7 @@ function getArtifactSuffix(matrix) {
 async function uploadDebugArtifacts(logger, toUpload, rootDir, artifactName, ghVariant, codeQlVersion) {
   const uploadSupported = isSafeArtifactUpload(codeQlVersion);
   if (!uploadSupported) {
-    core17.info(
+    core16.info(
       `Skipping debug artifact upload because the current CLI does not support safe upload. Please upgrade to CLI v${SafeArtifactUploadVersion} or later.`
     );
     return "upload-not-supported";
@@ -158519,7 +158294,7 @@ async function uploadArtifacts(logger, toUpload, rootDir, artifactName, ghVarian
   }
   if (isInTestMode()) {
     await scanArtifactsForTokens(toUpload, logger);
-    core17.exportVariable("CODEQL_ACTION_ARTIFACT_SCAN_FINISHED", "true");
+    core16.exportVariable("CODEQL_ACTION_ARTIFACT_SCAN_FINISHED", "true");
   }
   const suffix = getArtifactSuffix(getOptionalInput("matrix"));
   const artifactUploader = await getArtifactUploaderClient(logger, ghVariant);
@@ -158535,7 +158310,7 @@ async function uploadArtifacts(logger, toUpload, rootDir, artifactName, ghVarian
     );
     return "upload-successful";
   } catch (e) {
-    core17.warning(`Failed to upload debug artifacts: ${e}`);
+    core16.warning(`Failed to upload debug artifacts: ${e}`);
     return "upload-failed";
   }
 }
@@ -158558,7 +158333,7 @@ async function createPartialDatabaseBundle(config, language) {
     config.dbLocation,
     `${config.debugDatabaseName}-${language}-partial.zip`
   );
-  core17.info(
+  core16.info(
     `${config.debugDatabaseName}-${language} is not finalized. Uploading partial database bundle at ${databaseBundlePath}...`
   );
   if (fs24.existsSync(databaseBundlePath)) {
@@ -158628,14 +158403,14 @@ async function runWrapper2() {
       }
     }
   } catch (error3) {
-    core18.setFailed(
+    core17.setFailed(
       `analyze post-action step failed: ${getErrorMessage(error3)}`
     );
   }
 }
 
 // src/autobuild-action.ts
-var core19 = __toESM(require_core());
+var core18 = __toESM(require_core());
 async function sendCompletedStatusReport(config, logger, startedAt, allLanguages, failingLanguage, cause) {
   initializeEnvironment(getActionVersion());
   const status = getActionsStatus(cause, failingLanguage);
@@ -158702,7 +158477,7 @@ async function run2(startedAt) {
     await endTracingForCluster(codeql, config, logger);
   } catch (unwrappedError) {
     const error3 = wrapError(unwrappedError);
-    core19.setFailed(
+    core18.setFailed(
       `We were unable to automatically build your code. Please replace the call to the autobuild action with your custom build steps. ${error3.message}`
     );
     await sendCompletedStatusReport(
@@ -158715,7 +158490,7 @@ async function run2(startedAt) {
     );
     return;
   }
-  core19.exportVariable("CODEQL_ACTION_AUTOBUILD_DID_COMPLETE_SUCCESSFULLY" /* AUTOBUILD_DID_COMPLETE_SUCCESSFULLY */, "true");
+  core18.exportVariable("CODEQL_ACTION_AUTOBUILD_DID_COMPLETE_SUCCESSFULLY" /* AUTOBUILD_DID_COMPLETE_SUCCESSFULLY */, "true");
   await sendCompletedStatusReport(config, logger, startedAt, languages ?? []);
 }
 async function runWrapper3() {
@@ -158724,7 +158499,7 @@ async function runWrapper3() {
   try {
     await run2(startedAt);
   } catch (error3) {
-    core19.setFailed(`autobuild action failed. ${getErrorMessage(error3)}`);
+    core18.setFailed(`autobuild action failed. ${getErrorMessage(error3)}`);
     await sendUnhandledErrorStatusReport(
       "autobuild" /* Autobuild */,
       startedAt,
@@ -158737,7 +158512,7 @@ async function runWrapper3() {
 // src/init-action.ts
 var fs27 = __toESM(require("fs"));
 var path23 = __toESM(require("path"));
-var core21 = __toESM(require_core());
+var core20 = __toESM(require_core());
 var github3 = __toESM(require_github());
 var io7 = __toESM(require_io());
 var semver10 = __toESM(require_semver2());
@@ -158746,7 +158521,7 @@ var semver10 = __toESM(require_semver2());
 var fs26 = __toESM(require("fs"));
 var path22 = __toESM(require("path"));
 var import_zlib2 = __toESM(require("zlib"));
-var core20 = __toESM(require_core());
+var core19 = __toESM(require_core());
 function toCodedErrors(errors) {
   return Object.entries(errors).reduce(
     (acc, [code, message]) => {
@@ -158869,7 +158644,7 @@ async function validateWorkflow(codeql, logger) {
     } catch (e) {
       return `error: formatWorkflowErrors() failed: ${String(e)}`;
     }
-    core20.warning(message);
+    core19.warning(message);
   }
   return formatWorkflowCause(workflowErrors);
 }
@@ -158998,7 +158773,7 @@ function getCheckoutPathInputOrThrow(workflow, jobName, matrixVars) {
 }
 async function checkWorkflow(logger, codeql) {
   if (!isDynamicWorkflow() && process.env["CODEQL_ACTION_SKIP_WORKFLOW_VALIDATION" /* SKIP_WORKFLOW_VALIDATION */] !== "true") {
-    core20.startGroup("Validating workflow");
+    core19.startGroup("Validating workflow");
     const validateWorkflowResult = await internal2.validateWorkflow(
       codeql,
       logger
@@ -159010,7 +158785,7 @@ async function checkWorkflow(logger, codeql) {
         `Unable to validate code scanning workflow: ${validateWorkflowResult}`
       );
     }
-    core20.endGroup();
+    core19.endGroup();
   }
 }
 var internal2 = {
@@ -159118,8 +158893,8 @@ async function run3(startedAt) {
     );
     const jobRunUuid = v4_default();
     logger.info(`Job run UUID is ${jobRunUuid}.`);
-    core21.exportVariable("JOB_RUN_UUID" /* JOB_RUN_UUID */, jobRunUuid);
-    core21.exportVariable("CODEQL_ACTION_INIT_HAS_RUN" /* INIT_ACTION_HAS_RUN */, "true");
+    core20.exportVariable("JOB_RUN_UUID" /* JOB_RUN_UUID */, jobRunUuid);
+    core20.exportVariable("CODEQL_ACTION_INIT_HAS_RUN" /* INIT_ACTION_HAS_RUN */, "true");
     configFile = getOptionalInput("config-file");
     sourceRoot = path23.resolve(
       getRequiredEnvParam("GITHUB_WORKSPACE"),
@@ -159176,12 +158951,12 @@ async function run3(startedAt) {
         );
       }
       if (semver10.lt(actualVer, publicPreview)) {
-        core21.exportVariable("CODEQL_ENABLE_EXPERIMENTAL_FEATURES" /* EXPERIMENTAL_FEATURES */, "true");
+        core20.exportVariable("CODEQL_ENABLE_EXPERIMENTAL_FEATURES" /* EXPERIMENTAL_FEATURES */, "true");
         logger.info("Experimental Rust analysis enabled");
       }
     }
     analysisKinds = await getAnalysisKinds(logger, features);
-    const debugMode = getOptionalInput("debug") === "true" || core21.isDebug();
+    const debugMode = getOptionalInput("debug") === "true" || core20.isDebug();
     const repositoryProperties = repositoryPropertiesResult.orElse({});
     const fileCoverageResult = await getFileCoverageInformationEnabled(
       debugMode,
@@ -159252,7 +159027,7 @@ async function run3(startedAt) {
     await checkInstallPython311(config.languages, codeql);
   } catch (unwrappedError) {
     const error3 = wrapError(unwrappedError);
-    core21.setFailed(error3.message);
+    core20.setFailed(error3.message);
     const statusReportBase = await createStatusReportBase(
       "init" /* Init */,
       error3 instanceof ConfigurationError ? "user-error" : "aborted",
@@ -159307,8 +159082,8 @@ async function run3(startedAt) {
     }
     const goFlags = process.env["GOFLAGS"];
     if (goFlags) {
-      core21.exportVariable("GOFLAGS", goFlags);
-      core21.warning(
+      core20.exportVariable("GOFLAGS", goFlags);
+      core20.warning(
         "Passing the GOFLAGS env parameter to the init action is deprecated. Please move this to the analyze action."
       );
     }
@@ -159327,7 +159102,7 @@ async function run3(startedAt) {
               "bin"
             );
             fs27.mkdirSync(tempBinPath, { recursive: true });
-            core21.addPath(tempBinPath);
+            core20.addPath(tempBinPath);
             const goWrapperPath = path23.resolve(tempBinPath, "go");
             fs27.writeFileSync(
               goWrapperPath,
@@ -159336,14 +159111,14 @@ async function run3(startedAt) {
 exec ${goBinaryPath} "$@"`
             );
             fs27.chmodSync(goWrapperPath, "755");
-            core21.exportVariable("CODEQL_ACTION_GO_BINARY" /* GO_BINARY_LOCATION */, goWrapperPath);
+            core20.exportVariable("CODEQL_ACTION_GO_BINARY" /* GO_BINARY_LOCATION */, goWrapperPath);
           } catch (e) {
             logger.warning(
               `Analyzing Go on Linux, but failed to install wrapper script. Tracing custom builds may fail: ${e}`
             );
           }
         } else {
-          core21.exportVariable("CODEQL_ACTION_GO_BINARY" /* GO_BINARY_LOCATION */, goBinaryPath);
+          core20.exportVariable("CODEQL_ACTION_GO_BINARY" /* GO_BINARY_LOCATION */, goBinaryPath);
         }
       } catch (e) {
         logger.warning(
@@ -159370,23 +159145,23 @@ exec ${goBinaryPath} "$@"`
         }
       }
     }
-    core21.exportVariable(
+    core20.exportVariable(
       "CODEQL_RAM",
       process.env["CODEQL_RAM"] || getCodeQLMemoryLimit(getOptionalInput("ram"), logger).toString()
     );
-    core21.exportVariable(
+    core20.exportVariable(
       "CODEQL_THREADS",
       process.env["CODEQL_THREADS"] || getThreadsFlagValue(getOptionalInput("threads"), logger).toString()
     );
     if (await features.getValue("disable_kotlin_analysis_enabled" /* DisableKotlinAnalysisEnabled */)) {
-      core21.exportVariable("CODEQL_EXTRACTOR_JAVA_AGENT_DISABLE_KOTLIN", "true");
+      core20.exportVariable("CODEQL_EXTRACTOR_JAVA_AGENT_DISABLE_KOTLIN", "true");
     }
     if (await features.getValue("force_jgit" /* ForceJGit */)) {
-      core21.exportVariable("CODEQL_GIT_BACKEND", "jgit");
+      core20.exportVariable("CODEQL_GIT_BACKEND", "jgit");
     }
     const kotlinLimitVar = "CODEQL_EXTRACTOR_KOTLIN_OVERRIDE_MAXIMUM_VERSION_LIMIT";
     if (await codeQlVersionAtLeast(codeql, "2.20.3") && !await codeQlVersionAtLeast(codeql, "2.20.4")) {
-      core21.exportVariable(kotlinLimitVar, "2.1.20");
+      core20.exportVariable(kotlinLimitVar, "2.1.20");
     }
     if (shouldRestoreCache(config.dependencyCachingEnabled)) {
       const dependencyCachingResult = await downloadDependencyCaches(
@@ -159413,7 +159188,7 @@ exec ${goBinaryPath} "$@"`
         `${"CODEQL_EXTRACTOR_JAVA_OPTION_MINIMIZE_DEPENDENCY_JARS" /* JAVA_EXTRACTOR_MINIMIZE_DEPENDENCY_JARS */} is already set to '${process.env["CODEQL_EXTRACTOR_JAVA_OPTION_MINIMIZE_DEPENDENCY_JARS" /* JAVA_EXTRACTOR_MINIMIZE_DEPENDENCY_JARS */]}', so the Action will not override it.`
       );
     } else if (await codeQlVersionAtLeast(codeql, CODEQL_VERSION_JAR_MINIMIZATION) && config.dependencyCachingEnabled && config.buildMode === "none" /* None */ && config.languages.includes("java" /* java */)) {
-      core21.exportVariable(
+      core20.exportVariable(
         "CODEQL_EXTRACTOR_JAVA_OPTION_MINIMIZE_DEPENDENCY_JARS" /* JAVA_EXTRACTOR_MINIMIZE_DEPENDENCY_JARS */,
         "true"
       );
@@ -159457,23 +159232,23 @@ exec ${goBinaryPath} "$@"`
     const tracerConfig = await getCombinedTracerConfig(codeql, config);
     if (tracerConfig !== void 0) {
       for (const [key, value] of Object.entries(tracerConfig.env)) {
-        core21.exportVariable(key, value);
+        core20.exportVariable(key, value);
       }
     }
     if (await features.getValue("java_network_debugging" /* JavaNetworkDebugging */)) {
       const existingJavaToolOptions = getOptionalEnvVar("JAVA_TOOL_OPTIONS" /* JAVA_TOOL_OPTIONS */) || "";
-      core21.exportVariable(
+      core20.exportVariable(
         "JAVA_TOOL_OPTIONS" /* JAVA_TOOL_OPTIONS */,
         `${existingJavaToolOptions} -Djavax.net.debug=all`
       );
     }
     flushDiagnostics(config);
     await saveConfig(config, logger);
-    core21.setOutput("codeql-path", config.codeQLCmd);
-    core21.setOutput("codeql-version", (await codeql.getVersion()).version);
+    core20.setOutput("codeql-path", config.codeQLCmd);
+    core20.setOutput("codeql-version", (await codeql.getVersion()).version);
   } catch (unwrappedError) {
     const error3 = wrapError(unwrappedError);
-    core21.setFailed(error3.message);
+    core20.setFailed(error3.message);
     await sendCompletedStatusReport2(
       startedAt,
       config,
@@ -159541,7 +159316,7 @@ async function runWrapper4() {
   try {
     await run3(startedAt);
   } catch (error3) {
-    core21.setFailed(`init action failed: ${getErrorMessage(error3)}`);
+    core20.setFailed(`init action failed: ${getErrorMessage(error3)}`);
     await sendUnhandledErrorStatusReport(
       "init" /* Init */,
       startedAt,
@@ -159553,7 +159328,7 @@ async function runWrapper4() {
 }
 
 // src/init-action-post.ts
-var core22 = __toESM(require_core());
+var core21 = __toESM(require_core());
 
 // src/init-action-post-helper.ts
 var fs28 = __toESM(require("fs"));
@@ -159901,7 +159676,7 @@ async function run4(startedAt) {
     }
   } catch (unwrappedError) {
     const error3 = wrapError(unwrappedError);
-    core22.setFailed(error3.message);
+    core21.setFailed(error3.message);
     const statusReportBase2 = await createStatusReportBase(
       "init-post" /* InitPost */,
       getActionsStatus(error3),
@@ -159946,14 +159721,14 @@ function getFinalJobStatus(config) {
   }
   let jobStatus;
   if (process.env["CODEQL_ACTION_ANALYZE_DID_COMPLETE_SUCCESSFULLY" /* ANALYZE_DID_COMPLETE_SUCCESSFULLY */] === "true") {
-    core22.exportVariable("CODEQL_ACTION_JOB_STATUS" /* JOB_STATUS */, "JOB_STATUS_SUCCESS" /* SuccessStatus */);
+    core21.exportVariable("CODEQL_ACTION_JOB_STATUS" /* JOB_STATUS */, "JOB_STATUS_SUCCESS" /* SuccessStatus */);
     jobStatus = "JOB_STATUS_SUCCESS" /* SuccessStatus */;
   } else if (config !== void 0) {
     jobStatus = "JOB_STATUS_CONFIGURATION_ERROR" /* ConfigErrorStatus */;
   } else {
     jobStatus = "JOB_STATUS_UNKNOWN" /* UnknownStatus */;
   }
-  core22.exportVariable("CODEQL_ACTION_JOB_STATUS" /* JOB_STATUS */, jobStatus);
+  core21.exportVariable("CODEQL_ACTION_JOB_STATUS" /* JOB_STATUS */, jobStatus);
   return jobStatus;
 }
 function getJobStatusFromEnvironment() {
@@ -159972,7 +159747,7 @@ async function runWrapper5() {
   try {
     await run4(startedAt);
   } catch (error3) {
-    core22.setFailed(`init post action failed: ${wrapError(error3).message}`);
+    core21.setFailed(`init post action failed: ${wrapError(error3).message}`);
     await sendUnhandledErrorStatusReport(
       "init-post" /* InitPost */,
       startedAt,
@@ -159983,7 +159758,7 @@ async function runWrapper5() {
 }
 
 // src/resolve-environment-action.ts
-var core23 = __toESM(require_core());
+var core22 = __toESM(require_core());
 
 // src/resolve-environment.ts
 async function runResolveBuildEnvironment(cmd, logger, workingDir, language) {
@@ -160030,16 +159805,16 @@ async function run5(startedAt) {
       workingDirectory,
       getRequiredInput("language")
     );
-    core23.setOutput(ENVIRONMENT_OUTPUT_NAME, result);
+    core22.setOutput(ENVIRONMENT_OUTPUT_NAME, result);
   } catch (unwrappedError) {
     const error3 = wrapError(unwrappedError);
     if (error3 instanceof CliError) {
-      core23.setOutput(ENVIRONMENT_OUTPUT_NAME, {});
+      core22.setOutput(ENVIRONMENT_OUTPUT_NAME, {});
       logger.warning(
         `Failed to resolve a build environment suitable for automatically building your code. ${error3.message}`
       );
     } else {
-      core23.setFailed(
+      core22.setFailed(
         `Failed to resolve a build environment suitable for automatically building your code. ${error3.message}`
       );
       const statusReportBase2 = await createStatusReportBase(
@@ -160076,7 +159851,7 @@ async function runWrapper6() {
   try {
     await run5(startedAt);
   } catch (error3) {
-    core23.setFailed(
+    core22.setFailed(
       `${"resolve-environment" /* ResolveEnvironment */} action failed: ${getErrorMessage(
         error3
       )}`
@@ -160092,7 +159867,7 @@ async function runWrapper6() {
 }
 
 // src/setup-codeql-action.ts
-var core24 = __toESM(require_core());
+var core23 = __toESM(require_core());
 async function sendCompletedStatusReport3(startedAt, toolsDownloadStatusReport, toolsFeatureFlagsValid, toolsSource, toolsVersion, logger, error3) {
   const statusReportBase = await createStatusReportBase(
     "setup-codeql" /* SetupCodeQL */,
@@ -160150,7 +159925,7 @@ async function run6(startedAt) {
     );
     const jobRunUuid = v4_default();
     logger.info(`Job run UUID is ${jobRunUuid}.`);
-    core24.exportVariable("JOB_RUN_UUID" /* JOB_RUN_UUID */, jobRunUuid);
+    core23.exportVariable("JOB_RUN_UUID" /* JOB_RUN_UUID */, jobRunUuid);
     const statusReportBase = await createStatusReportBase(
       "setup-codeql" /* SetupCodeQL */,
       "starting",
@@ -160183,12 +159958,12 @@ async function run6(startedAt) {
     toolsDownloadStatusReport = initCodeQLResult.toolsDownloadStatusReport;
     toolsVersion = initCodeQLResult.toolsVersion;
     toolsSource = initCodeQLResult.toolsSource;
-    core24.setOutput("codeql-path", codeql.getPath());
-    core24.setOutput("codeql-version", (await codeql.getVersion()).version);
-    core24.exportVariable("CODEQL_ACTION_SETUP_CODEQL_HAS_RUN" /* SETUP_CODEQL_ACTION_HAS_RUN */, "true");
+    core23.setOutput("codeql-path", codeql.getPath());
+    core23.setOutput("codeql-version", (await codeql.getVersion()).version);
+    core23.exportVariable("CODEQL_ACTION_SETUP_CODEQL_HAS_RUN" /* SETUP_CODEQL_ACTION_HAS_RUN */, "true");
   } catch (unwrappedError) {
     const error3 = wrapError(unwrappedError);
-    core24.setFailed(error3.message);
+    core23.setFailed(error3.message);
     const statusReportBase = await createStatusReportBase(
       "setup-codeql" /* SetupCodeQL */,
       error3 instanceof ConfigurationError ? "user-error" : "failure",
@@ -160219,7 +159994,7 @@ async function runWrapper7() {
   try {
     await run6(startedAt);
   } catch (error3) {
-    core24.setFailed(`setup-codeql action failed: ${getErrorMessage(error3)}`);
+    core23.setFailed(`setup-codeql action failed: ${getErrorMessage(error3)}`);
     await sendUnhandledErrorStatusReport(
       "setup-codeql" /* SetupCodeQL */,
       startedAt,
@@ -160233,11 +160008,11 @@ async function runWrapper7() {
 // src/start-proxy-action.ts
 var import_child_process2 = require("child_process");
 var path27 = __toESM(require("path"));
-var core27 = __toESM(require_core());
+var core26 = __toESM(require_core());
 
 // src/start-proxy.ts
 var path25 = __toESM(require("path"));
-var core26 = __toESM(require_core());
+var core25 = __toESM(require_core());
 var toolcache4 = __toESM(require_tool_cache());
 
 // src/start-proxy/types.ts
@@ -160377,10 +160152,10 @@ function getAddressString(address) {
 }
 
 // src/start-proxy/validation.ts
-var core25 = __toESM(require_core());
-function cloneCredential(schema2, obj) {
+var core24 = __toESM(require_core());
+function cloneCredential(schema, obj) {
   const result = {};
-  for (const key of Object.keys(schema2)) {
+  for (const key of Object.keys(schema)) {
     if (!isDefined2(obj[key])) {
       continue;
     }
@@ -160396,14 +160171,14 @@ function getAuthConfig(config) {
   }
   if (isToken(config)) {
     if (isDefined2(config.token)) {
-      core25.setSecret(config.token);
+      core24.setSecret(config.token);
     }
     return cloneCredential(tokenSchema, config);
   } else {
     let username = void 0;
     let password = void 0;
     if ("password" in config && isString(config.password)) {
-      core25.setSecret(config.password);
+      core24.setSecret(config.password);
       password = config.password;
     }
     if ("username" in config && isString(config.username)) {
@@ -160459,7 +160234,7 @@ function getSafeErrorMessage(error3) {
 }
 async function sendFailedStatusReport(logger, startedAt, language, unwrappedError) {
   const error3 = wrapError(unwrappedError);
-  core26.setFailed(`start-proxy action failed: ${error3.message}`);
+  core25.setFailed(`start-proxy action failed: ${error3.message}`);
   const statusReportMessage = getSafeErrorMessage(error3);
   const errorStatusReportBase = await createStatusReportBase(
     "start-proxy" /* StartProxy */,
@@ -160551,7 +160326,7 @@ function getCredentials(logger, registrySecrets, registriesCredentials, language
   }
   const out = [];
   for (const e of parsed) {
-    if (e === null || !isObject2(e)) {
+    if (e === null || !isObject(e)) {
       throw new ConfigurationError("Invalid credentials - must be an object");
     }
     if (!isDefined2(e.type) || !isString(e.type)) {
@@ -160562,12 +160337,12 @@ function getCredentials(logger, registrySecrets, registriesCredentials, language
     if (registryTypeForLanguage && !registryTypeForLanguage.some((t) => t === e.type)) {
       continue;
     }
-    const isPrintable2 = (str2) => {
-      return str2 ? /^[\x20-\x7E]*$/.test(str2) : true;
+    const isPrintable = (str) => {
+      return str ? /^[\x20-\x7E]*$/.test(str) : true;
     };
     for (const key of Object.keys(e)) {
       const val = e[key];
-      if (typeof val === "string" && !isPrintable2(val)) {
+      if (typeof val === "string" && !isPrintable(val)) {
         throw new ConfigurationError(
           "Invalid credentials - fields must contain only printable characters"
         );
@@ -161038,7 +160813,7 @@ async function run7(startedAt) {
     persistInputs();
     const tempDir = getTemporaryDirectory();
     const proxyLogFilePath = path27.resolve(tempDir, "proxy.log");
-    core27.saveState("proxy-log-file", proxyLogFilePath);
+    core26.saveState("proxy-log-file", proxyLogFilePath);
     const repositoryNwo = getRepositoryNwo();
     const gitHubVersion = await getGitHubVersion();
     features = initFeatures(
@@ -161067,7 +160842,7 @@ async function run7(startedAt) {
       `Credentials loaded for the following registries:
  ${credentials.map((c) => credentialToStr(c)).join("\n")}`
     );
-    if (core27.isDebug() || isInTestMode()) {
+    if (core26.isDebug() || isInTestMode()) {
       try {
         await checkProxyEnvironment(logger, language);
       } catch (err) {
@@ -161107,7 +160882,7 @@ async function runWrapper8() {
   try {
     await run7(startedAt);
   } catch (error3) {
-    core27.setFailed(`start-proxy action failed: ${getErrorMessage(error3)}`);
+    core26.setFailed(`start-proxy action failed: ${getErrorMessage(error3)}`);
     await sendUnhandledErrorStatusReport(
       "start-proxy" /* StartProxy */,
       startedAt,
@@ -161133,7 +160908,7 @@ async function startProxy(binPath, config, logFilePath, logger) {
     );
     subprocess.unref();
     if (subprocess.pid) {
-      core27.saveState("proxy-process-pid", `${subprocess.pid}`);
+      core26.saveState("proxy-process-pid", `${subprocess.pid}`);
     }
     subprocess.on("error", (error3) => {
       subprocessError = error3;
@@ -161152,25 +160927,25 @@ async function startProxy(binPath, config, logFilePath, logger) {
     throw subprocessError;
   }
   logger.info(`Proxy started on ${host}:${port}`);
-  core27.setOutput("proxy_host", host);
-  core27.setOutput("proxy_port", port.toString());
-  core27.setOutput("proxy_ca_certificate", config.ca.cert);
+  core26.setOutput("proxy_host", host);
+  core26.setOutput("proxy_port", port.toString());
+  core26.setOutput("proxy_ca_certificate", config.ca.cert);
   const registry_urls = config.all_credentials.filter((credential) => credential.url !== void 0).map((credential) => ({
     type: credential.type,
     url: credential.url,
     "replaces-base": credential["replaces-base"]
   }));
-  core27.setOutput("proxy_urls", JSON.stringify(registry_urls));
+  core26.setOutput("proxy_urls", JSON.stringify(registry_urls));
   return { host, port, cert: config.ca.cert, registries: registry_urls };
 }
 
 // src/start-proxy-action-post.ts
-var core28 = __toESM(require_core());
+var core27 = __toESM(require_core());
 async function runWrapper9() {
   const logger = getActionsLogger();
   try {
     restoreInputs();
-    const pid = core28.getState("proxy-process-pid");
+    const pid = core27.getState("proxy-process-pid");
     if (pid) {
       process.kill(Number(pid));
     }
@@ -161178,8 +160953,8 @@ async function runWrapper9() {
       getTemporaryDirectory(),
       logger
     );
-    if (config?.debugMode || core28.isDebug()) {
-      const logFilePath = core28.getState("proxy-log-file");
+    if (config?.debugMode || core27.isDebug()) {
+      const logFilePath = core27.getState("proxy-log-file");
       logger.info(
         "Debug mode is on. Uploading proxy log as Actions debugging artifact..."
       );
@@ -161207,7 +160982,7 @@ async function runWrapper9() {
 }
 
 // src/upload-sarif-action.ts
-var core29 = __toESM(require_core());
+var core28 = __toESM(require_core());
 async function sendSuccessStatusReport2(startedAt, uploadStats, logger) {
   const statusReportBase = await createStatusReportBase(
     "upload-sarif" /* UploadSarif */,
@@ -161268,11 +161043,11 @@ async function run8(startedAt) {
     }
     const codeScanningResult = uploadResults["code-scanning" /* CodeScanning */];
     if (codeScanningResult !== void 0) {
-      core29.setOutput("sarif-id", codeScanningResult.sarifID);
+      core28.setOutput("sarif-id", codeScanningResult.sarifID);
     }
-    core29.setOutput("sarif-ids", JSON.stringify(uploadResults));
+    core28.setOutput("sarif-ids", JSON.stringify(uploadResults));
     if (shouldSkipSarifUpload()) {
-      core29.debug(
+      core28.debug(
         "SARIF upload disabled by an environment variable. Waiting for processing is disabled."
       );
     } else if (getRequiredInput("wait-for-processing") === "true") {
@@ -161292,7 +161067,7 @@ async function run8(startedAt) {
   } catch (unwrappedError) {
     const error3 = isThirdPartyAnalysis("upload-sarif" /* UploadSarif */) && unwrappedError instanceof InvalidSarifUploadError ? new ConfigurationError(unwrappedError.message) : wrapError(unwrappedError);
     const message = error3.message;
-    core29.setFailed(message);
+    core28.setFailed(message);
     const errorStatusReportBase = await createStatusReportBase(
       "upload-sarif" /* UploadSarif */,
       getActionsStatus(error3),
@@ -161315,7 +161090,7 @@ async function runWrapper10() {
   try {
     await run8(startedAt);
   } catch (error3) {
-    core29.setFailed(
+    core28.setFailed(
       `codeql/upload-sarif action failed: ${getErrorMessage(error3)}`
     );
     await sendUnhandledErrorStatusReport(
@@ -161328,7 +161103,7 @@ async function runWrapper10() {
 }
 
 // src/upload-sarif-action-post.ts
-var core30 = __toESM(require_core());
+var core29 = __toESM(require_core());
 async function runWrapper11() {
   try {
     restoreInputs();
@@ -161337,7 +161112,7 @@ async function runWrapper11() {
     checkGitHubVersionInRange(gitHubVersion, logger);
     if (process.env["CODEQL_ACTION_INIT_HAS_RUN" /* INIT_ACTION_HAS_RUN */] !== "true") {
       if (gitHubVersion.type === void 0) {
-        core30.warning(
+        core29.warning(
           `Did not upload debug artifacts because cannot determine the GitHub variant running.`
         );
         return;
@@ -161354,7 +161129,7 @@ async function runWrapper11() {
       );
     }
   } catch (error3) {
-    core30.setFailed(
+    core29.setFailed(
       `upload-sarif post-action step failed: ${getErrorMessage(error3)}`
     );
   }
@@ -161500,7 +161275,7 @@ tmp/lib/tmp.js:
    *)
 
 js-yaml/dist/js-yaml.mjs:
-  (*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT *)
+  (*! js-yaml 4.2.0 https://github.com/nodeca/js-yaml @license MIT *)
 
 long/index.js:
   (**

From c8f0aa4c67ebce6e4661bf6067d76ce7e95c817e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sat, 13 Jun 2026 06:41:55 +0000
Subject: [PATCH 26/65] Bump esbuild from 0.28.0 to 0.28.1

Bumps [esbuild](https://github.com/evanw/esbuild) from 0.28.0 to 0.28.1.
- [Release notes](https://github.com/evanw/esbuild/releases)
- [Changelog](https://github.com/evanw/esbuild/blob/main/CHANGELOG.md)
- [Commits](https://github.com/evanw/esbuild/compare/v0.28.0...v0.28.1)

---
updated-dependencies:
- dependency-name: esbuild
  dependency-version: 0.28.1
  dependency-type: direct:development
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 package-lock.json | 216 +++++++++++++++++++++++-----------------------
 package.json      |   2 +-
 2 files changed, 109 insertions(+), 109 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 2ccb2f360f..36d457400a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -49,7 +49,7 @@
         "@types/semver": "^7.7.1",
         "@types/sinon": "^21.0.1",
         "ava": "^6.4.1",
-        "esbuild": "^0.28.0",
+        "esbuild": "^0.28.1",
         "eslint": "^9.39.4",
         "eslint-import-resolver-typescript": "^4.4.5",
         "eslint-plugin-github": "^6.0.0",
@@ -845,9 +845,9 @@
       }
     },
     "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.0.tgz",
-      "integrity": "sha512-lhRUCeuOyJQURhTxl4WkpFTjIsbDayJHih5kZC1giwE+MhIzAb7mEsQMqMf18rHLsrb5qI1tafG20mLxEWcWlA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz",
+      "integrity": "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==",
       "cpu": [
         "ppc64"
       ],
@@ -862,9 +862,9 @@
       }
     },
     "node_modules/@esbuild/android-arm": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.0.tgz",
-      "integrity": "sha512-wqh0ByljabXLKHeWXYLqoJ5jKC4XBaw6Hk08OfMrCRd2nP2ZQ5eleDZC41XHyCNgktBGYMbqnrJKq/K/lzPMSQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.1.tgz",
+      "integrity": "sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==",
       "cpu": [
         "arm"
       ],
@@ -879,9 +879,9 @@
       }
     },
     "node_modules/@esbuild/android-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.0.tgz",
-      "integrity": "sha512-+WzIXQOSaGs33tLEgYPYe/yQHf0WTU0X42Jca3y8NWMbUVhp7rUnw+vAsRC/QiDrdD31IszMrZy+qwPOPjd+rw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.1.tgz",
+      "integrity": "sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==",
       "cpu": [
         "arm64"
       ],
@@ -896,9 +896,9 @@
       }
     },
     "node_modules/@esbuild/android-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.0.tgz",
-      "integrity": "sha512-+VJggoaKhk2VNNqVL7f6S189UzShHC/mR9EE8rDdSkdpN0KflSwWY/gWjDrNxxisg8Fp1ZCD9jLMo4m0OUfeUA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.1.tgz",
+      "integrity": "sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==",
       "cpu": [
         "x64"
       ],
@@ -913,9 +913,9 @@
       }
     },
     "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.0.tgz",
-      "integrity": "sha512-0T+A9WZm+bZ84nZBtk1ckYsOvyA3x7e2Acj1KdVfV4/2tdG4fzUp91YHx+GArWLtwqp77pBXVCPn2We7Letr0Q==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.1.tgz",
+      "integrity": "sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==",
       "cpu": [
         "arm64"
       ],
@@ -930,9 +930,9 @@
       }
     },
     "node_modules/@esbuild/darwin-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.0.tgz",
-      "integrity": "sha512-fyzLm/DLDl/84OCfp2f/XQ4flmORsjU7VKt8HLjvIXChJoFFOIL6pLJPH4Yhd1n1gGFF9mPwtlN5Wf82DZs+LQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.1.tgz",
+      "integrity": "sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==",
       "cpu": [
         "x64"
       ],
@@ -947,9 +947,9 @@
       }
     },
     "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.0.tgz",
-      "integrity": "sha512-l9GeW5UZBT9k9brBYI+0WDffcRxgHQD8ShN2Ur4xWq/NFzUKm3k5lsH4PdaRgb2w7mI9u61nr2gI2mLI27Nh3Q==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==",
       "cpu": [
         "arm64"
       ],
@@ -964,9 +964,9 @@
       }
     },
     "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.0.tgz",
-      "integrity": "sha512-BXoQai/A0wPO6Es3yFJ7APCiKGc1tdAEOgeTNy3SsB491S3aHn4S4r3e976eUnPdU+NbdtmBuLncYir2tMU9Nw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.1.tgz",
+      "integrity": "sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==",
       "cpu": [
         "x64"
       ],
@@ -981,9 +981,9 @@
       }
     },
     "node_modules/@esbuild/linux-arm": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.0.tgz",
-      "integrity": "sha512-CjaaREJagqJp7iTaNQjjidaNbCKYcd4IDkzbwwxtSvjI7NZm79qiHc8HqciMddQ6CKvJT6aBd8lO9kN/ZudLlw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.1.tgz",
+      "integrity": "sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==",
       "cpu": [
         "arm"
       ],
@@ -998,9 +998,9 @@
       }
     },
     "node_modules/@esbuild/linux-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.0.tgz",
-      "integrity": "sha512-RVyzfb3FWsGA55n6WY0MEIEPURL1FcbhFE6BffZEMEekfCzCIMtB5yyDcFnVbTnwk+CLAgTujmV/Lgvih56W+A==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.1.tgz",
+      "integrity": "sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==",
       "cpu": [
         "arm64"
       ],
@@ -1015,9 +1015,9 @@
       }
     },
     "node_modules/@esbuild/linux-ia32": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.0.tgz",
-      "integrity": "sha512-KBnSTt1kxl9x70q+ydterVdl+Cn0H18ngRMRCEQfrbqdUuntQQ0LoMZv47uB97NljZFzY6HcfqEZ2SAyIUTQBQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.1.tgz",
+      "integrity": "sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==",
       "cpu": [
         "ia32"
       ],
@@ -1032,9 +1032,9 @@
       }
     },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.0.tgz",
-      "integrity": "sha512-zpSlUce1mnxzgBADvxKXX5sl8aYQHo2ezvMNI8I0lbblJtp8V4odlm3Yzlj7gPyt3T8ReksE6bK+pT3WD+aJRg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.1.tgz",
+      "integrity": "sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==",
       "cpu": [
         "loong64"
       ],
@@ -1049,9 +1049,9 @@
       }
     },
     "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.0.tgz",
-      "integrity": "sha512-2jIfP6mmjkdmeTlsX/9vmdmhBmKADrWqN7zcdtHIeNSCH1SqIoNI63cYsjQR8J+wGa4Y5izRcSHSm8K3QWmk3w==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.1.tgz",
+      "integrity": "sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==",
       "cpu": [
         "mips64el"
       ],
@@ -1066,9 +1066,9 @@
       }
     },
     "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.0.tgz",
-      "integrity": "sha512-bc0FE9wWeC0WBm49IQMPSPILRocGTQt3j5KPCA8os6VprfuJ7KD+5PzESSrJ6GmPIPJK965ZJHTUlSA6GNYEhg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.1.tgz",
+      "integrity": "sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==",
       "cpu": [
         "ppc64"
       ],
@@ -1083,9 +1083,9 @@
       }
     },
     "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.0.tgz",
-      "integrity": "sha512-SQPZOwoTTT/HXFXQJG/vBX8sOFagGqvZyXcgLA3NhIqcBv1BJU1d46c0rGcrij2B56Z2rNiSLaZOYW5cUk7yLQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.1.tgz",
+      "integrity": "sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==",
       "cpu": [
         "riscv64"
       ],
@@ -1100,9 +1100,9 @@
       }
     },
     "node_modules/@esbuild/linux-s390x": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.0.tgz",
-      "integrity": "sha512-SCfR0HN8CEEjnYnySJTd2cw0k9OHB/YFzt5zgJEwa+wL/T/raGWYMBqwDNAC6dqFKmJYZoQBRfHjgwLHGSrn3Q==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.1.tgz",
+      "integrity": "sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==",
       "cpu": [
         "s390x"
       ],
@@ -1117,9 +1117,9 @@
       }
     },
     "node_modules/@esbuild/linux-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.0.tgz",
-      "integrity": "sha512-us0dSb9iFxIi8srnpl931Nvs65it/Jd2a2K3qs7fz2WfGPHqzfzZTfec7oxZJRNPXPnNYZtanmRc4AL/JwVzHQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz",
+      "integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==",
       "cpu": [
         "x64"
       ],
@@ -1134,9 +1134,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.0.tgz",
-      "integrity": "sha512-CR/RYotgtCKwtftMwJlUU7xCVNg3lMYZ0RzTmAHSfLCXw3NtZtNpswLEj/Kkf6kEL3Gw+BpOekRX0BYCtklhUw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==",
       "cpu": [
         "arm64"
       ],
@@ -1151,9 +1151,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.0.tgz",
-      "integrity": "sha512-nU1yhmYutL+fQ71Kxnhg8uEOdC0pwEW9entHykTgEbna2pw2dkbFSMeqjjyHZoCmt8SBkOSvV+yNmm94aUrrqw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.1.tgz",
+      "integrity": "sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==",
       "cpu": [
         "x64"
       ],
@@ -1168,9 +1168,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.0.tgz",
-      "integrity": "sha512-cXb5vApOsRsxsEl4mcZ1XY3D4DzcoMxR/nnc4IyqYs0rTI8ZKmW6kyyg+11Z8yvgMfAEldKzP7AdP64HnSC/6g==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==",
       "cpu": [
         "arm64"
       ],
@@ -1185,9 +1185,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.0.tgz",
-      "integrity": "sha512-8wZM2qqtv9UP3mzy7HiGYNH/zjTA355mpeuA+859TyR+e+Tc08IHYpLJuMsfpDJwoLo1ikIJI8jC3GFjnRClzA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.1.tgz",
+      "integrity": "sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==",
       "cpu": [
         "x64"
       ],
@@ -1202,9 +1202,9 @@
       }
     },
     "node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.0.tgz",
-      "integrity": "sha512-FLGfyizszcef5C3YtoyQDACyg95+dndv79i2EekILBofh5wpCa1KuBqOWKrEHZg3zrL3t5ouE5jgr94vA+Wb2w==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.1.tgz",
+      "integrity": "sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==",
       "cpu": [
         "arm64"
       ],
@@ -1219,9 +1219,9 @@
       }
     },
     "node_modules/@esbuild/sunos-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.0.tgz",
-      "integrity": "sha512-1ZgjUoEdHZZl/YlV76TSCz9Hqj9h9YmMGAgAPYd+q4SicWNX3G5GCyx9uhQWSLcbvPW8Ni7lj4gDa1T40akdlw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.1.tgz",
+      "integrity": "sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==",
       "cpu": [
         "x64"
       ],
@@ -1236,9 +1236,9 @@
       }
     },
     "node_modules/@esbuild/win32-arm64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.0.tgz",
-      "integrity": "sha512-Q9StnDmQ/enxnpxCCLSg0oo4+34B9TdXpuyPeTedN/6+iXBJ4J+zwfQI28u/Jl40nOYAxGoNi7mFP40RUtkmUA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.1.tgz",
+      "integrity": "sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==",
       "cpu": [
         "arm64"
       ],
@@ -1253,9 +1253,9 @@
       }
     },
     "node_modules/@esbuild/win32-ia32": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.0.tgz",
-      "integrity": "sha512-zF3ag/gfiCe6U2iczcRzSYJKH1DCI+ByzSENHlM2FcDbEeo5Zd2C86Aq0tKUYAJJ1obRP84ymxIAksZUcdztHA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.1.tgz",
+      "integrity": "sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==",
       "cpu": [
         "ia32"
       ],
@@ -1270,9 +1270,9 @@
       }
     },
     "node_modules/@esbuild/win32-x64": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.0.tgz",
-      "integrity": "sha512-pEl1bO9mfAmIC+tW5btTmrKaujg3zGtUmWNdCw/xs70FBjwAL3o9OEKNHvNmnyylD6ubxUERiEhdsL0xBQ9efw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.1.tgz",
+      "integrity": "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==",
       "cpu": [
         "x64"
       ],
@@ -4651,9 +4651,9 @@
       }
     },
     "node_modules/esbuild": {
-      "version": "0.28.0",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.0.tgz",
-      "integrity": "sha512-sNR9MHpXSUV/XB4zmsFKN+QgVG82Cc7+/aaxJ8Adi8hyOac+EXptIp45QBPaVyX3N70664wRbTcLTOemCAnyqw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz",
+      "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==",
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
@@ -4664,32 +4664,32 @@
         "node": ">=18"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.28.0",
-        "@esbuild/android-arm": "0.28.0",
-        "@esbuild/android-arm64": "0.28.0",
-        "@esbuild/android-x64": "0.28.0",
-        "@esbuild/darwin-arm64": "0.28.0",
-        "@esbuild/darwin-x64": "0.28.0",
-        "@esbuild/freebsd-arm64": "0.28.0",
-        "@esbuild/freebsd-x64": "0.28.0",
-        "@esbuild/linux-arm": "0.28.0",
-        "@esbuild/linux-arm64": "0.28.0",
-        "@esbuild/linux-ia32": "0.28.0",
-        "@esbuild/linux-loong64": "0.28.0",
-        "@esbuild/linux-mips64el": "0.28.0",
-        "@esbuild/linux-ppc64": "0.28.0",
-        "@esbuild/linux-riscv64": "0.28.0",
-        "@esbuild/linux-s390x": "0.28.0",
-        "@esbuild/linux-x64": "0.28.0",
-        "@esbuild/netbsd-arm64": "0.28.0",
-        "@esbuild/netbsd-x64": "0.28.0",
-        "@esbuild/openbsd-arm64": "0.28.0",
-        "@esbuild/openbsd-x64": "0.28.0",
-        "@esbuild/openharmony-arm64": "0.28.0",
-        "@esbuild/sunos-x64": "0.28.0",
-        "@esbuild/win32-arm64": "0.28.0",
-        "@esbuild/win32-ia32": "0.28.0",
-        "@esbuild/win32-x64": "0.28.0"
+        "@esbuild/aix-ppc64": "0.28.1",
+        "@esbuild/android-arm": "0.28.1",
+        "@esbuild/android-arm64": "0.28.1",
+        "@esbuild/android-x64": "0.28.1",
+        "@esbuild/darwin-arm64": "0.28.1",
+        "@esbuild/darwin-x64": "0.28.1",
+        "@esbuild/freebsd-arm64": "0.28.1",
+        "@esbuild/freebsd-x64": "0.28.1",
+        "@esbuild/linux-arm": "0.28.1",
+        "@esbuild/linux-arm64": "0.28.1",
+        "@esbuild/linux-ia32": "0.28.1",
+        "@esbuild/linux-loong64": "0.28.1",
+        "@esbuild/linux-mips64el": "0.28.1",
+        "@esbuild/linux-ppc64": "0.28.1",
+        "@esbuild/linux-riscv64": "0.28.1",
+        "@esbuild/linux-s390x": "0.28.1",
+        "@esbuild/linux-x64": "0.28.1",
+        "@esbuild/netbsd-arm64": "0.28.1",
+        "@esbuild/netbsd-x64": "0.28.1",
+        "@esbuild/openbsd-arm64": "0.28.1",
+        "@esbuild/openbsd-x64": "0.28.1",
+        "@esbuild/openharmony-arm64": "0.28.1",
+        "@esbuild/sunos-x64": "0.28.1",
+        "@esbuild/win32-arm64": "0.28.1",
+        "@esbuild/win32-ia32": "0.28.1",
+        "@esbuild/win32-x64": "0.28.1"
       }
     },
     "node_modules/escalade": {
diff --git a/package.json b/package.json
index df687912be..79006bd3c1 100644
--- a/package.json
+++ b/package.json
@@ -57,7 +57,7 @@
     "@types/semver": "^7.7.1",
     "@types/sinon": "^21.0.1",
     "ava": "^6.4.1",
-    "esbuild": "^0.28.0",
+    "esbuild": "^0.28.1",
     "eslint": "^9.39.4",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-github": "^6.0.0",

From 98dfd09d4a8e8a3215b817a5f71efaf55929f1b6 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Sat, 13 Jun 2026 06:43:46 +0000
Subject: [PATCH 27/65] Rebuild

---
 lib/entry-points.js | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 21cf78a4b9..c69fa78ff8 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -5,11 +5,20 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)

From 6f850b502237bf5898f4e43952b251686572768a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 15 Jun 2026 22:01:42 +0000
Subject: [PATCH 28/65] Bump tar from 7.5.15 to 7.5.16

Bumps [tar](https://github.com/isaacs/node-tar) from 7.5.15 to 7.5.16.
- [Release notes](https://github.com/isaacs/node-tar/releases)
- [Changelog](https://github.com/isaacs/node-tar/blob/main/CHANGELOG.md)
- [Commits](https://github.com/isaacs/node-tar/compare/v7.5.15...v7.5.16)

---
updated-dependencies:
- dependency-name: tar
  dependency-version: 7.5.16
  dependency-type: indirect
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 package-lock.json | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 36d457400a..a5d8bf9dbd 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8960,9 +8960,9 @@
       }
     },
     "node_modules/tar": {
-      "version": "7.5.15",
-      "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.15.tgz",
-      "integrity": "sha512-dzGK0boVlC4W5QFuQN1EFSl3bIDYsk7Tj40U6eIBnK2k/8ml7TZ5agbI5j5+qnoVcAA+rNtBml8SEiLxZpNqRQ==",
+      "version": "7.5.16",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.16.tgz",
+      "integrity": "sha512-56adEpPMouktRlBLXiaYFFzZ/3+JXa8P9n7WbR+ibIjtviN55mEaOkiysCnPnWm+7kkui1Dn8J9l+g6zV8731w==",
       "dev": true,
       "license": "BlueOak-1.0.0",
       "dependencies": {

From f57d3726c35cbd0f451b5f330eee2571def792b0 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 16 Jun 2026 12:02:08 +0200
Subject: [PATCH 29/65] Add `github-codeql-config-file` property

---
 lib/entry-points.js                  | 2 ++
 src/feature-flags/properties.test.ts | 6 +++++-
 src/feature-flags/properties.ts      | 4 ++++
 3 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index c69fa78ff8..1976920196 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -150233,6 +150233,7 @@ function getUnknownLanguagesError(languages) {
 // src/feature-flags/properties.ts
 var GITHUB_CODEQL_PROPERTY_PREFIX = "github-codeql-";
 var RepositoryPropertyName = /* @__PURE__ */ ((RepositoryPropertyName2) => {
+  RepositoryPropertyName2["CONFIG_FILE"] = "github-codeql-config-file";
   RepositoryPropertyName2["DISABLE_OVERLAY"] = "github-codeql-disable-overlay";
   RepositoryPropertyName2["EXTRA_QUERIES"] = "github-codeql-extra-queries";
   RepositoryPropertyName2["FILE_COVERAGE_ON_PRS"] = "github-codeql-file-coverage-on-prs";
@@ -150251,6 +150252,7 @@ var booleanProperty = {
   parse: parseBooleanRepositoryProperty
 };
 var repositoryPropertyParsers = {
+  ["github-codeql-config-file" /* CONFIG_FILE */]: stringProperty,
   ["github-codeql-disable-overlay" /* DISABLE_OVERLAY */]: booleanProperty,
   ["github-codeql-extra-queries" /* EXTRA_QUERIES */]: stringProperty,
   ["github-codeql-file-coverage-on-prs" /* FILE_COVERAGE_ON_PRS */]: booleanProperty
diff --git a/src/feature-flags/properties.test.ts b/src/feature-flags/properties.test.ts
index 2676c2dcda..66526b1fb2 100644
--- a/src/feature-flags/properties.test.ts
+++ b/src/feature-flags/properties.test.ts
@@ -77,6 +77,7 @@ test.serial("loadPropertiesFromApi loads known properties", async (t) => {
     status: 200,
     url: "",
     data: [
+      { property_name: "github-codeql-config-file", value: "owner/repo" },
       { property_name: "github-codeql-extra-queries", value: "+queries" },
       { property_name: "unknown-property", value: "something" },
     ] satisfies properties.GitHubPropertiesResponse,
@@ -87,7 +88,10 @@ test.serial("loadPropertiesFromApi loads known properties", async (t) => {
     logger,
     mockRepositoryNwo,
   );
-  t.deepEqual(response, { "github-codeql-extra-queries": "+queries" });
+  t.deepEqual(response, {
+    "github-codeql-config-file": "owner/repo",
+    "github-codeql-extra-queries": "+queries",
+  });
 });
 
 test.serial("loadPropertiesFromApi parses true boolean property", async (t) => {
diff --git a/src/feature-flags/properties.ts b/src/feature-flags/properties.ts
index 12ba280bec..e239c71947 100644
--- a/src/feature-flags/properties.ts
+++ b/src/feature-flags/properties.ts
@@ -10,6 +10,7 @@ export const GITHUB_CODEQL_PROPERTY_PREFIX = "github-codeql-";
  * Enumerates repository property names that have some meaning to us.
  */
 export enum RepositoryPropertyName {
+  CONFIG_FILE = "github-codeql-config-file",
   DISABLE_OVERLAY = "github-codeql-disable-overlay",
   EXTRA_QUERIES = "github-codeql-extra-queries",
   FILE_COVERAGE_ON_PRS = "github-codeql-file-coverage-on-prs",
@@ -17,6 +18,7 @@ export enum RepositoryPropertyName {
 
 /** Parsed types of the known repository properties. */
 export type AllRepositoryProperties = {
+  [RepositoryPropertyName.CONFIG_FILE]: string;
   [RepositoryPropertyName.DISABLE_OVERLAY]: boolean;
   [RepositoryPropertyName.EXTRA_QUERIES]: string;
   [RepositoryPropertyName.FILE_COVERAGE_ON_PRS]: boolean;
@@ -27,6 +29,7 @@ export type RepositoryProperties = Partial<AllRepositoryProperties>;
 
 /** Maps known repository properties to the type we expect to get from the API. */
 export type RepositoryPropertyApiType = {
+  [RepositoryPropertyName.CONFIG_FILE]: string;
   [RepositoryPropertyName.DISABLE_OVERLAY]: string;
   [RepositoryPropertyName.EXTRA_QUERIES]: string;
   [RepositoryPropertyName.FILE_COVERAGE_ON_PRS]: string;
@@ -74,6 +77,7 @@ const booleanProperty = {
 const repositoryPropertyParsers: {
   [K in RepositoryPropertyName]: PropertyInfo<K>;
 } = {
+  [RepositoryPropertyName.CONFIG_FILE]: stringProperty,
   [RepositoryPropertyName.DISABLE_OVERLAY]: booleanProperty,
   [RepositoryPropertyName.EXTRA_QUERIES]: stringProperty,
   [RepositoryPropertyName.FILE_COVERAGE_ON_PRS]: booleanProperty,

From a0276b7dc4ed407d422fc7c7d896a1f1515d7f8f Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 16 Jun 2026 12:19:30 +0200
Subject: [PATCH 30/65] Add initial `ActionsEnv` abstraction

---
 src/actions-util.ts  | 15 +++++++++++++++
 src/testing-utils.ts | 11 ++++++++++-
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/src/actions-util.ts b/src/actions-util.ts
index 592a70ace3..dea22d5c57 100644
--- a/src/actions-util.ts
+++ b/src/actions-util.ts
@@ -21,6 +21,21 @@ import {
  */
 declare const __CODEQL_ACTION_VERSION__: string;
 
+/**
+ * Abstracts over GitHub Actions functions so that we do not have to stub
+ * global functions in tests.
+ */
+export interface ActionsEnv {
+  getOptionalInput: (name: string) => string | undefined;
+}
+
+/**
+ * Gets the real `ActionsEnv` used by production code.
+ */
+export function getActionsEnv(): ActionsEnv {
+  return { getOptionalInput };
+}
+
 /**
  * Wrapper around core.getInput for inputs that always have a value.
  * Also see getOptionalInput.
diff --git a/src/testing-utils.ts b/src/testing-utils.ts
index 1702d6835a..2660c21a69 100644
--- a/src/testing-utils.ts
+++ b/src/testing-utils.ts
@@ -10,7 +10,7 @@ import test, {
 import nock from "nock";
 import * as sinon from "sinon";
 
-import { getActionVersion } from "./actions-util";
+import { ActionsEnv, getActionVersion } from "./actions-util";
 import { AnalysisKind } from "./analyses";
 import * as apiClient from "./api-client";
 import { GitHubApiDetails } from "./api-client";
@@ -172,6 +172,15 @@ export function makeMacro<Args extends unknown[]>(
   return wrapper;
 }
 
+/**
+ * Gets an `ActionsEnv` instance for use in tests.
+ */
+export function getTestActionsEnv(): ActionsEnv {
+  return {
+    getOptionalInput: () => undefined,
+  };
+}
+
 /**
  * Default values for environment variables typically set in an Actions
  * environment. Tests can override individual variables by passing them in the

From ae7c3ea645c88403e950046a7f5ba9f8475e6209 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 16 Jun 2026 12:21:33 +0200
Subject: [PATCH 31/65] Add `getConfigFileInput` function

---
 lib/entry-points.js     | 11 ++++++++++-
 src/config/file.test.ts | 26 ++++++++++++++++++++++++++
 src/config/file.ts      |  8 ++++++++
 src/init-action.ts      |  5 ++++-
 4 files changed, 48 insertions(+), 2 deletions(-)
 create mode 100644 src/config/file.test.ts
 create mode 100644 src/config/file.ts

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 1976920196..b29405b21d 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -148162,6 +148162,9 @@ var Failure = class {
 };
 
 // src/actions-util.ts
+function getActionsEnv() {
+  return { getOptionalInput };
+}
 var getRequiredInput = function(name) {
   const value = core3.getInput(name);
   if (!value) {
@@ -158528,6 +158531,11 @@ var github3 = __toESM(require_github());
 var io7 = __toESM(require_io());
 var semver10 = __toESM(require_semver2());
 
+// src/config/file.ts
+function getConfigFileInput(actions) {
+  return actions.getOptionalInput("config-file");
+}
+
 // src/workflow.ts
 var fs26 = __toESM(require("fs"));
 var path22 = __toESM(require("path"));
@@ -158868,6 +158876,7 @@ async function sendCompletedStatusReport2(startedAt, config, configFile, toolsDo
 }
 async function run3(startedAt) {
   const logger = getActionsLogger();
+  const actionsEnv = getActionsEnv();
   let apiDetails;
   let config;
   let configFile;
@@ -158906,7 +158915,7 @@ async function run3(startedAt) {
     logger.info(`Job run UUID is ${jobRunUuid}.`);
     core20.exportVariable("JOB_RUN_UUID" /* JOB_RUN_UUID */, jobRunUuid);
     core20.exportVariable("CODEQL_ACTION_INIT_HAS_RUN" /* INIT_ACTION_HAS_RUN */, "true");
-    configFile = getOptionalInput("config-file");
+    configFile = getConfigFileInput(actionsEnv);
     sourceRoot = path23.resolve(
       getRequiredEnvParam("GITHUB_WORKSPACE"),
       getOptionalInput("source-root") || ""
diff --git a/src/config/file.test.ts b/src/config/file.test.ts
new file mode 100644
index 0000000000..9a883cc6a8
--- /dev/null
+++ b/src/config/file.test.ts
@@ -0,0 +1,26 @@
+import test from "ava";
+import sinon from "sinon";
+
+import { getTestActionsEnv, setupTests } from "../testing-utils";
+
+import { getConfigFileInput } from "./file";
+
+setupTests(test);
+
+test("getConfigFileInput returns undefined by default", async (t) => {
+  const actionsEnv = getTestActionsEnv();
+  const result = getConfigFileInput(actionsEnv);
+  t.is(result, undefined);
+});
+
+test("getConfigFileInput returns input value", async (t) => {
+  const actionsEnv = getTestActionsEnv();
+  const testInput = "/some/path";
+  sinon
+    .stub(actionsEnv, "getOptionalInput")
+    .withArgs("config-file")
+    .returns(testInput);
+
+  const result = getConfigFileInput(actionsEnv);
+  t.is(result, testInput);
+});
diff --git a/src/config/file.ts b/src/config/file.ts
new file mode 100644
index 0000000000..89e0caf6df
--- /dev/null
+++ b/src/config/file.ts
@@ -0,0 +1,8 @@
+import { ActionsEnv } from "../actions-util";
+
+/**
+ * Gets the value that is configured for the configuration file, if any.
+ */
+export function getConfigFileInput(actions: ActionsEnv): string | undefined {
+  return actions.getOptionalInput("config-file");
+}
diff --git a/src/init-action.ts b/src/init-action.ts
index b7593a51cc..b533de1d42 100644
--- a/src/init-action.ts
+++ b/src/init-action.ts
@@ -9,6 +9,7 @@ import { v4 as uuidV4 } from "uuid";
 
 import {
   FileCmdNotFoundError,
+  getActionsEnv,
   getActionVersion,
   getFileType,
   getOptionalInput,
@@ -24,6 +25,7 @@ import {
   shouldRestoreCache,
 } from "./caching-utils";
 import { CodeQL } from "./codeql";
+import { getConfigFileInput } from "./config/file";
 import * as configUtils from "./config-utils";
 import {
   DependencyCacheRestoreStatusReport,
@@ -207,6 +209,7 @@ async function run(startedAt: Date) {
   // possible, and only use safe functions outside.
 
   const logger = getActionsLogger();
+  const actionsEnv = getActionsEnv();
 
   let apiDetails: GitHubApiCombinedDetails;
   let config: configUtils.Config | undefined;
@@ -259,7 +262,7 @@ async function run(startedAt: Date) {
 
     core.exportVariable(EnvVar.INIT_ACTION_HAS_RUN, "true");
 
-    configFile = getOptionalInput("config-file");
+    configFile = getConfigFileInput(actionsEnv);
 
     // path.resolve() respects the intended semantics of source-root. If
     // source-root is relative, it is relative to the GITHUB_WORKSPACE. If

From 82036913c81488b4794375fe22fab316133e88fa Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 16 Jun 2026 12:28:17 +0200
Subject: [PATCH 32/65] Accept repository property as fallback

---
 lib/entry-points.js     |  8 ++++----
 src/config/file.test.ts | 19 +++++++++++++++++--
 src/config/file.ts      | 14 ++++++++++++--
 src/init-action.ts      |  4 ++--
 4 files changed, 35 insertions(+), 10 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index b29405b21d..e2fe5d4a10 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -158532,8 +158532,8 @@ var io7 = __toESM(require_io());
 var semver10 = __toESM(require_semver2());
 
 // src/config/file.ts
-function getConfigFileInput(actions) {
-  return actions.getOptionalInput("config-file");
+function getConfigFileInput(actions, repositoryProperties) {
+  return actions.getOptionalInput("config-file") || repositoryProperties["github-codeql-config-file" /* CONFIG_FILE */];
 }
 
 // src/workflow.ts
@@ -158911,11 +158911,12 @@ async function run3(startedAt) {
       repositoryNwo,
       logger
     );
+    const repositoryProperties = repositoryPropertiesResult.orElse({});
     const jobRunUuid = v4_default();
     logger.info(`Job run UUID is ${jobRunUuid}.`);
     core20.exportVariable("JOB_RUN_UUID" /* JOB_RUN_UUID */, jobRunUuid);
     core20.exportVariable("CODEQL_ACTION_INIT_HAS_RUN" /* INIT_ACTION_HAS_RUN */, "true");
-    configFile = getConfigFileInput(actionsEnv);
+    configFile = getConfigFileInput(actionsEnv, repositoryProperties);
     sourceRoot = path23.resolve(
       getRequiredEnvParam("GITHUB_WORKSPACE"),
       getOptionalInput("source-root") || ""
@@ -158977,7 +158978,6 @@ async function run3(startedAt) {
     }
     analysisKinds = await getAnalysisKinds(logger, features);
     const debugMode = getOptionalInput("debug") === "true" || core20.isDebug();
-    const repositoryProperties = repositoryPropertiesResult.orElse({});
     const fileCoverageResult = await getFileCoverageInformationEnabled(
       debugMode,
       codeql,
diff --git a/src/config/file.test.ts b/src/config/file.test.ts
index 9a883cc6a8..2eee00c50b 100644
--- a/src/config/file.test.ts
+++ b/src/config/file.test.ts
@@ -1,6 +1,7 @@
 import test from "ava";
 import sinon from "sinon";
 
+import { RepositoryPropertyName } from "../feature-flags/properties";
 import { getTestActionsEnv, setupTests } from "../testing-utils";
 
 import { getConfigFileInput } from "./file";
@@ -9,10 +10,14 @@ setupTests(test);
 
 test("getConfigFileInput returns undefined by default", async (t) => {
   const actionsEnv = getTestActionsEnv();
-  const result = getConfigFileInput(actionsEnv);
+  const result = getConfigFileInput(actionsEnv, {});
   t.is(result, undefined);
 });
 
+const repositoryProperties = {
+  [RepositoryPropertyName.CONFIG_FILE]: "/path/from/property",
+};
+
 test("getConfigFileInput returns input value", async (t) => {
   const actionsEnv = getTestActionsEnv();
   const testInput = "/some/path";
@@ -21,6 +26,16 @@ test("getConfigFileInput returns input value", async (t) => {
     .withArgs("config-file")
     .returns(testInput);
 
-  const result = getConfigFileInput(actionsEnv);
+  // Even though both an input and repository property are configured,
+  // we prefer the direct input to the Action.
+  const result = getConfigFileInput(actionsEnv, repositoryProperties);
   t.is(result, testInput);
 });
+
+test("getConfigFileInput returns repository property value", async (t) => {
+  const actionsEnv = getTestActionsEnv();
+
+  // Since there is no direct input, we should use the repository property.
+  const result = getConfigFileInput(actionsEnv, repositoryProperties);
+  t.is(result, repositoryProperties[RepositoryPropertyName.CONFIG_FILE]);
+});
diff --git a/src/config/file.ts b/src/config/file.ts
index 89e0caf6df..0feddd1edb 100644
--- a/src/config/file.ts
+++ b/src/config/file.ts
@@ -1,8 +1,18 @@
 import { ActionsEnv } from "../actions-util";
+import {
+  RepositoryProperties,
+  RepositoryPropertyName,
+} from "../feature-flags/properties";
 
 /**
  * Gets the value that is configured for the configuration file, if any.
  */
-export function getConfigFileInput(actions: ActionsEnv): string | undefined {
-  return actions.getOptionalInput("config-file");
+export function getConfigFileInput(
+  actions: ActionsEnv,
+  repositoryProperties: Partial<RepositoryProperties>,
+): string | undefined {
+  return (
+    actions.getOptionalInput("config-file") ||
+    repositoryProperties[RepositoryPropertyName.CONFIG_FILE]
+  );
 }
diff --git a/src/init-action.ts b/src/init-action.ts
index b533de1d42..d8ad6580f5 100644
--- a/src/init-action.ts
+++ b/src/init-action.ts
@@ -254,6 +254,7 @@ async function run(startedAt: Date) {
       repositoryNwo,
       logger,
     );
+    const repositoryProperties = repositoryPropertiesResult.orElse({});
 
     // Create a unique identifier for this run.
     const jobRunUuid = uuidV4();
@@ -262,7 +263,7 @@ async function run(startedAt: Date) {
 
     core.exportVariable(EnvVar.INIT_ACTION_HAS_RUN, "true");
 
-    configFile = getConfigFileInput(actionsEnv);
+    configFile = getConfigFileInput(actionsEnv, repositoryProperties);
 
     // path.resolve() respects the intended semantics of source-root. If
     // source-root is relative, it is relative to the GITHUB_WORKSPACE. If
@@ -353,7 +354,6 @@ async function run(startedAt: Date) {
 
     analysisKinds = await getAnalysisKinds(logger, features);
     const debugMode = getOptionalInput("debug") === "true" || core.isDebug();
-    const repositoryProperties = repositoryPropertiesResult.orElse({});
     const fileCoverageResult = await getFileCoverageInformationEnabled(
       debugMode,
       codeql,

From b2cc23e25db2c17285003ae9591cf57f7c276006 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 16 Jun 2026 12:36:12 +0200
Subject: [PATCH 33/65] Log input choice

---
 lib/entry-points.js     | 18 +++++++++++++++---
 src/config/file.test.ts | 25 +++++++++++++++++++++----
 src/config/file.ts      | 24 ++++++++++++++++++++----
 src/init-action.ts      |  2 +-
 4 files changed, 57 insertions(+), 12 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index e2fe5d4a10..ff60cfa202 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -158532,8 +158532,20 @@ var io7 = __toESM(require_io());
 var semver10 = __toESM(require_semver2());
 
 // src/config/file.ts
-function getConfigFileInput(actions, repositoryProperties) {
-  return actions.getOptionalInput("config-file") || repositoryProperties["github-codeql-config-file" /* CONFIG_FILE */];
+function getConfigFileInput(logger, actions, repositoryProperties) {
+  const input = actions.getOptionalInput("config-file");
+  if (input !== void 0) {
+    logger.info(`Using configuration file input from workflow: ${input}`);
+    return input;
+  }
+  const propertyValue = repositoryProperties["github-codeql-config-file" /* CONFIG_FILE */];
+  if (propertyValue !== void 0) {
+    logger.info(
+      `Using configuration file input from repository property: ${propertyValue}`
+    );
+    return propertyValue;
+  }
+  return void 0;
 }
 
 // src/workflow.ts
@@ -158916,7 +158928,7 @@ async function run3(startedAt) {
     logger.info(`Job run UUID is ${jobRunUuid}.`);
     core20.exportVariable("JOB_RUN_UUID" /* JOB_RUN_UUID */, jobRunUuid);
     core20.exportVariable("CODEQL_ACTION_INIT_HAS_RUN" /* INIT_ACTION_HAS_RUN */, "true");
-    configFile = getConfigFileInput(actionsEnv, repositoryProperties);
+    configFile = getConfigFileInput(logger, actionsEnv, repositoryProperties);
     sourceRoot = path23.resolve(
       getRequiredEnvParam("GITHUB_WORKSPACE"),
       getOptionalInput("source-root") || ""
diff --git a/src/config/file.test.ts b/src/config/file.test.ts
index 2eee00c50b..c27a3ff5ce 100644
--- a/src/config/file.test.ts
+++ b/src/config/file.test.ts
@@ -2,15 +2,20 @@ import test from "ava";
 import sinon from "sinon";
 
 import { RepositoryPropertyName } from "../feature-flags/properties";
-import { getTestActionsEnv, setupTests } from "../testing-utils";
+import {
+  getTestActionsEnv,
+  RecordingLogger,
+  setupTests,
+} from "../testing-utils";
 
 import { getConfigFileInput } from "./file";
 
 setupTests(test);
 
 test("getConfigFileInput returns undefined by default", async (t) => {
+  const logger = new RecordingLogger();
   const actionsEnv = getTestActionsEnv();
-  const result = getConfigFileInput(actionsEnv, {});
+  const result = getConfigFileInput(logger, actionsEnv, {});
   t.is(result, undefined);
 });
 
@@ -19,6 +24,7 @@ const repositoryProperties = {
 };
 
 test("getConfigFileInput returns input value", async (t) => {
+  const logger = new RecordingLogger();
   const actionsEnv = getTestActionsEnv();
   const testInput = "/some/path";
   sinon
@@ -28,14 +34,25 @@ test("getConfigFileInput returns input value", async (t) => {
 
   // Even though both an input and repository property are configured,
   // we prefer the direct input to the Action.
-  const result = getConfigFileInput(actionsEnv, repositoryProperties);
+  const result = getConfigFileInput(logger, actionsEnv, repositoryProperties);
   t.is(result, testInput);
+
+  // Check for the expected log message.
+  t.true(logger.hasMessage("Using configuration file input from workflow"));
 });
 
 test("getConfigFileInput returns repository property value", async (t) => {
+  const logger = new RecordingLogger();
   const actionsEnv = getTestActionsEnv();
 
   // Since there is no direct input, we should use the repository property.
-  const result = getConfigFileInput(actionsEnv, repositoryProperties);
+  const result = getConfigFileInput(logger, actionsEnv, repositoryProperties);
   t.is(result, repositoryProperties[RepositoryPropertyName.CONFIG_FILE]);
+
+  // Check for the expected log message.
+  t.true(
+    logger.hasMessage(
+      "Using configuration file input from repository property",
+    ),
+  );
 });
diff --git a/src/config/file.ts b/src/config/file.ts
index 0feddd1edb..6197e50cca 100644
--- a/src/config/file.ts
+++ b/src/config/file.ts
@@ -3,16 +3,32 @@ import {
   RepositoryProperties,
   RepositoryPropertyName,
 } from "../feature-flags/properties";
+import { Logger } from "../logging";
 
 /**
  * Gets the value that is configured for the configuration file, if any.
  */
 export function getConfigFileInput(
+  logger: Logger,
   actions: ActionsEnv,
   repositoryProperties: Partial<RepositoryProperties>,
 ): string | undefined {
-  return (
-    actions.getOptionalInput("config-file") ||
-    repositoryProperties[RepositoryPropertyName.CONFIG_FILE]
-  );
+  const input = actions.getOptionalInput("config-file");
+
+  if (input !== undefined) {
+    logger.info(`Using configuration file input from workflow: ${input}`);
+    return input;
+  }
+
+  const propertyValue =
+    repositoryProperties[RepositoryPropertyName.CONFIG_FILE];
+
+  if (propertyValue !== undefined) {
+    logger.info(
+      `Using configuration file input from repository property: ${propertyValue}`,
+    );
+    return propertyValue;
+  }
+
+  return undefined;
 }
diff --git a/src/init-action.ts b/src/init-action.ts
index d8ad6580f5..9c9b45556b 100644
--- a/src/init-action.ts
+++ b/src/init-action.ts
@@ -263,7 +263,7 @@ async function run(startedAt: Date) {
 
     core.exportVariable(EnvVar.INIT_ACTION_HAS_RUN, "true");
 
-    configFile = getConfigFileInput(actionsEnv, repositoryProperties);
+    configFile = getConfigFileInput(logger, actionsEnv, repositoryProperties);
 
     // path.resolve() respects the intended semantics of source-root. If
     // source-root is relative, it is relative to the GITHUB_WORKSPACE. If

From 52077a03d9fb464e28a406fb151daff30a4cbd33 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Wed, 17 Jun 2026 15:18:09 +0100
Subject: [PATCH 34/65] Ignore empty repository property

---
 lib/entry-points.js     |  2 +-
 src/config/file.test.ts | 11 +++++++++++
 src/config/file.ts      |  2 +-
 3 files changed, 13 insertions(+), 2 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index ff60cfa202..32474afe42 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -158539,7 +158539,7 @@ function getConfigFileInput(logger, actions, repositoryProperties) {
     return input;
   }
   const propertyValue = repositoryProperties["github-codeql-config-file" /* CONFIG_FILE */];
-  if (propertyValue !== void 0) {
+  if (propertyValue !== void 0 && propertyValue.trim().length > 0) {
     logger.info(
       `Using configuration file input from repository property: ${propertyValue}`
     );
diff --git a/src/config/file.test.ts b/src/config/file.test.ts
index c27a3ff5ce..4c511c1a70 100644
--- a/src/config/file.test.ts
+++ b/src/config/file.test.ts
@@ -56,3 +56,14 @@ test("getConfigFileInput returns repository property value", async (t) => {
     ),
   );
 });
+
+test("getConfigFileInput ignores empty repository property value", async (t) => {
+  const logger = new RecordingLogger();
+  const actionsEnv = getTestActionsEnv();
+
+  // Since the repository property value is an empty/whitespace string, we should ignore it.
+  const result = getConfigFileInput(logger, actionsEnv, {
+    [RepositoryPropertyName.CONFIG_FILE]: "   ",
+  });
+  t.is(result, undefined);
+});
diff --git a/src/config/file.ts b/src/config/file.ts
index 6197e50cca..24613dc557 100644
--- a/src/config/file.ts
+++ b/src/config/file.ts
@@ -23,7 +23,7 @@ export function getConfigFileInput(
   const propertyValue =
     repositoryProperties[RepositoryPropertyName.CONFIG_FILE];
 
-  if (propertyValue !== undefined) {
+  if (propertyValue !== undefined && propertyValue.trim().length > 0) {
     logger.info(
       `Using configuration file input from repository property: ${propertyValue}`,
     );

From 3187067e937deadc34a9b177004e7714fc0979ea Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 17 Jun 2026 17:55:32 +0000
Subject: [PATCH 35/65] Bump the npm-minor group across 1 directory with 3
 updates

Bumps the npm-minor group with 3 updates in the / directory: [semver](https://github.com/npm/node-semver), [@types/node](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/node) and [typescript-eslint](https://github.com/typescript-eslint/typescript-eslint/tree/HEAD/packages/typescript-eslint).


Updates `semver` from 7.8.1 to 7.8.4
- [Release notes](https://github.com/npm/node-semver/releases)
- [Changelog](https://github.com/npm/node-semver/blob/main/CHANGELOG.md)
- [Commits](https://github.com/npm/node-semver/compare/v7.8.1...v7.8.4)

Updates `@types/node` from 20.19.41 to 20.19.42
- [Release notes](https://github.com/DefinitelyTyped/DefinitelyTyped/releases)
- [Commits](https://github.com/DefinitelyTyped/DefinitelyTyped/commits/HEAD/types/node)

Updates `typescript-eslint` from 8.60.1 to 8.61.0
- [Release notes](https://github.com/typescript-eslint/typescript-eslint/releases)
- [Changelog](https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/typescript-eslint/CHANGELOG.md)
- [Commits](https://github.com/typescript-eslint/typescript-eslint/commits/v8.61.0/packages/typescript-eslint)

---
updated-dependencies:
- dependency-name: semver
  dependency-version: 7.8.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
  dependency-group: npm-minor
- dependency-name: "@types/node"
  dependency-version: 20.19.42
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: npm-minor
- dependency-name: typescript-eslint
  dependency-version: 8.61.0
  dependency-type: direct:development
  update-type: version-update:semver-minor
  dependency-group: npm-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 package-lock.json      | 142 ++++++++++++++++++++---------------------
 package.json           |   6 +-
 pr-checks/package.json |   2 +-
 3 files changed, 75 insertions(+), 75 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index a5d8bf9dbd..96c8944700 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -32,7 +32,7 @@
         "jsonschema": "1.5.0",
         "long": "^5.3.2",
         "node-forge": "^1.4.0",
-        "semver": "^7.8.1",
+        "semver": "^7.8.4",
         "uuid": "^14.0.0"
       },
       "devDependencies": {
@@ -43,7 +43,7 @@
         "@types/archiver": "^7.0.0",
         "@types/follow-redirects": "^1.14.4",
         "@types/js-yaml": "^4.0.9",
-        "@types/node": "^20.19.41",
+        "@types/node": "^20.19.42",
         "@types/node-forge": "^1.3.14",
         "@types/sarif": "^2.1.7",
         "@types/semver": "^7.7.1",
@@ -61,7 +61,7 @@
         "nock": "^14.0.15",
         "sinon": "^22.0.0",
         "typescript": "^6.0.3",
-        "typescript-eslint": "^8.60.1"
+        "typescript-eslint": "^8.61.0"
       }
     },
     "node_modules/@aashutoshrathi/word-wrap": {
@@ -2469,9 +2469,9 @@
       "license": "MIT"
     },
     "node_modules/@types/node": {
-      "version": "20.19.41",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.41.tgz",
-      "integrity": "sha512-ECymXOukMnOoVkC2bb1Vc/w/836DXncOg5m8Xj1RH7xSHZJWNYY6Zh7EH477vcnD5egKNNfy2RpNOmuChhFPgQ==",
+      "version": "20.19.42",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.42.tgz",
+      "integrity": "sha512-5L7SUaFC1RyDraj2yRhyBzHTobyXHmohD100CChNtyPyleoq37Mqab5Gn8XEKI04dfN/oqPdpHk38MgcQWHbZg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2528,17 +2528,17 @@
       "license": "MIT"
     },
     "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "8.60.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.60.1.tgz",
-      "integrity": "sha512-JQ4S5GB0tfjO8BuJ4fcX+HodkzJjYBV+7OJ+wLygaX7OGQ7FudyHL4NSCA6ob+w3Yn+5MkKIozOwQhXeM7opVg==",
+      "version": "8.61.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.61.0.tgz",
+      "integrity": "sha512-bFNvl9ZczlVb+wR2Akszf3gHfKVj/8WanXaGJ3UstTA7brNKg0cNdk6X1Psu5V7MZ2oQtzZKOEzIUehaoxbDGw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/regexpp": "^4.12.2",
-        "@typescript-eslint/scope-manager": "8.60.1",
-        "@typescript-eslint/type-utils": "8.60.1",
-        "@typescript-eslint/utils": "8.60.1",
-        "@typescript-eslint/visitor-keys": "8.60.1",
+        "@typescript-eslint/scope-manager": "8.61.0",
+        "@typescript-eslint/type-utils": "8.61.0",
+        "@typescript-eslint/utils": "8.61.0",
+        "@typescript-eslint/visitor-keys": "8.61.0",
         "ignore": "^7.0.5",
         "natural-compare": "^1.4.0",
         "ts-api-utils": "^2.5.0"
@@ -2551,7 +2551,7 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "@typescript-eslint/parser": "^8.60.1",
+        "@typescript-eslint/parser": "^8.61.0",
         "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
         "typescript": ">=4.8.4 <6.1.0"
       }
@@ -2567,16 +2567,16 @@
       }
     },
     "node_modules/@typescript-eslint/parser": {
-      "version": "8.60.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.60.1.tgz",
-      "integrity": "sha512-A0M6ua6H252bVjPvvtSgl2QA4+ET9S5Mtkb2GDyTxIhH/C4qDItT7RQNO5PhMC6NXGYXOR9dIalcDDgBKT7oFA==",
+      "version": "8.61.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.61.0.tgz",
+      "integrity": "sha512-5B7PfA2e1NQGCnDHd/0lW7W3gvp3d59Ryw54FYO8Uswxo9f6ikw3AZV+Xj/TvpImmpsiYyUqAfhC6kJID1jF6w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/scope-manager": "8.60.1",
-        "@typescript-eslint/types": "8.60.1",
-        "@typescript-eslint/typescript-estree": "8.60.1",
-        "@typescript-eslint/visitor-keys": "8.60.1",
+        "@typescript-eslint/scope-manager": "8.61.0",
+        "@typescript-eslint/types": "8.61.0",
+        "@typescript-eslint/typescript-estree": "8.61.0",
+        "@typescript-eslint/visitor-keys": "8.61.0",
         "debug": "^4.4.3"
       },
       "engines": {
@@ -2610,14 +2610,14 @@
       }
     },
     "node_modules/@typescript-eslint/project-service": {
-      "version": "8.60.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.60.1.tgz",
-      "integrity": "sha512-eXkTH2bxmXlqD1RnOPmLZ9ZM9D3VwSx04JOwBnP9RQ+yUA5a2Mu7SfW8uaV2Aon53NJzZlZYuX7tn91Izf+xaw==",
+      "version": "8.61.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.61.0.tgz",
+      "integrity": "sha512-DV42F7MLJO6Rax7SK1yg43tcnEfGUrurSpSxKuVX+a3RCTzBlH3fuxprrOJXKCJGAaw82xXocikJ0uQaqwXgGA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/tsconfig-utils": "^8.60.1",
-        "@typescript-eslint/types": "^8.60.1",
+        "@typescript-eslint/tsconfig-utils": "^8.61.0",
+        "@typescript-eslint/types": "^8.61.0",
         "debug": "^4.4.3"
       },
       "engines": {
@@ -2650,14 +2650,14 @@
       }
     },
     "node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.60.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.60.1.tgz",
-      "integrity": "sha512-gvI5OQoptnxQnchOirukCuQ55svJSTuD/4k5+pC267xyBtYry748R9/c3tYUzb/iE6RZfllRz2lVulLCHkTm4w==",
+      "version": "8.61.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.61.0.tgz",
+      "integrity": "sha512-IWdXFHFSb6mlC3HPc7QsLDm5zYEbUla6trDEHf32D3/dnuUyXd87plScSNXSbm0/RxMvObpI17sv/EDTGrGZkA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.60.1",
-        "@typescript-eslint/visitor-keys": "8.60.1"
+        "@typescript-eslint/types": "8.61.0",
+        "@typescript-eslint/visitor-keys": "8.61.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2668,9 +2668,9 @@
       }
     },
     "node_modules/@typescript-eslint/tsconfig-utils": {
-      "version": "8.60.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.60.1.tgz",
-      "integrity": "sha512-nh8w4qAteiKuZu3pSSzG/yGKpw0OlkrKnzFmbVRenKaD4qc+7i1GrmZaLVkr8rk4uipiPGMOW4YsM6WmKZ5CvA==",
+      "version": "8.61.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.61.0.tgz",
+      "integrity": "sha512-O5Amvdv9ztMpxpf+vmFULGG78IE6Qwdr3bCGvqwG4nwc9H2qXkOYJJnRbRHyMkQTjv1d03olqwwwzHLMqpFePQ==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -2685,15 +2685,15 @@
       }
     },
     "node_modules/@typescript-eslint/type-utils": {
-      "version": "8.60.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.60.1.tgz",
-      "integrity": "sha512-sdwTrpjosW7ANQYJ39ZBF1ZyEMEGVB2UsikrserVM/30a/F1dTLnu9bGxEdosugyu5caigjLrR2qiD11asjI1A==",
+      "version": "8.61.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.61.0.tgz",
+      "integrity": "sha512-TuBiQYIkd97yBfInHCTKVYMbX4kvEmpOEuixIuzCU9p8BGT1SfyyO0d0IfDMbPIHcjn/hWnusUX5e8v5Xg+X8A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.60.1",
-        "@typescript-eslint/typescript-estree": "8.60.1",
-        "@typescript-eslint/utils": "8.60.1",
+        "@typescript-eslint/types": "8.61.0",
+        "@typescript-eslint/typescript-estree": "8.61.0",
+        "@typescript-eslint/utils": "8.61.0",
         "debug": "^4.4.3",
         "ts-api-utils": "^2.5.0"
       },
@@ -2728,9 +2728,9 @@
       }
     },
     "node_modules/@typescript-eslint/types": {
-      "version": "8.60.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.60.1.tgz",
-      "integrity": "sha512-4h0tY8ppCkdCzcrl2YM5M3my0xsE1Tf8om3owEu5oPWmXwkKRmk0j0LGDzYBGUcAlesEbxBhazqu/K4cu3Ug7w==",
+      "version": "8.61.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.61.0.tgz",
+      "integrity": "sha512-9QTQpZ5Iin4CdIodfbDQFSeiSJKidgYJYug1P9CC2xWgUTvlmixViqDZNciMjwLBZyJnG4tGmPl97rVAFb1AJg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -2742,16 +2742,16 @@
       }
     },
     "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.60.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.60.1.tgz",
-      "integrity": "sha512-alpRkfG8hlVE5kdJW2GkfgDgXxold3e8e4l6EnmhRmRLbekgAPCCGDVD++sABy9FcgPFroq+uFcCSM1vR57Cew==",
+      "version": "8.61.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.61.0.tgz",
+      "integrity": "sha512-42zatd5qSvvcV1JdDBCLxYRznvP4eIHpPoZXdkPFnAmanA4FuZ5dibSnCBggY8hQnqajPpoGjXFdZ7fIJKQnlA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/project-service": "8.60.1",
-        "@typescript-eslint/tsconfig-utils": "8.60.1",
-        "@typescript-eslint/types": "8.60.1",
-        "@typescript-eslint/visitor-keys": "8.60.1",
+        "@typescript-eslint/project-service": "8.61.0",
+        "@typescript-eslint/tsconfig-utils": "8.61.0",
+        "@typescript-eslint/types": "8.61.0",
+        "@typescript-eslint/visitor-keys": "8.61.0",
         "debug": "^4.4.3",
         "minimatch": "^10.2.2",
         "semver": "^7.7.3",
@@ -2827,16 +2827,16 @@
       }
     },
     "node_modules/@typescript-eslint/utils": {
-      "version": "8.60.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.60.1.tgz",
-      "integrity": "sha512-h2MPBLoNtjc3qZWfY3Tl51yPorQ2McHn8pJfcMNTcIvrrZrr90Ykffit0yjrPFWQcRcUxzH20+6OcVdW4yHtUg==",
+      "version": "8.61.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.61.0.tgz",
+      "integrity": "sha512-3bzFt7ImFMW/jVYwJamDoe/dMOdFLSC6pom6rRjdh4SZJEYupyMzem8e7vKZLclLfpHjlwSAXOUxtKxGXUiLqA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.9.1",
-        "@typescript-eslint/scope-manager": "8.60.1",
-        "@typescript-eslint/types": "8.60.1",
-        "@typescript-eslint/typescript-estree": "8.60.1"
+        "@typescript-eslint/scope-manager": "8.61.0",
+        "@typescript-eslint/types": "8.61.0",
+        "@typescript-eslint/typescript-estree": "8.61.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2851,13 +2851,13 @@
       }
     },
     "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.60.1",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.60.1.tgz",
-      "integrity": "sha512-EbGRQg4FhrmwLodl+t3JNAnXHWVr9Vp+Zl1QBZVPY4ByfkzIT8cX3K6QWODHtkIZqqJVEWvhHSx3v5PDHsaQag==",
+      "version": "8.61.0",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.61.0.tgz",
+      "integrity": "sha512-QVLZu3ZPQEE+HICQyAMZ2yLQhxf0meY/wx6Hx14YcTNj13JB3qHlX3lJ02L3fLGHgERRH71kvYDwiXIguT3AjQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.60.1",
+        "@typescript-eslint/types": "8.61.0",
         "eslint-visitor-keys": "^5.0.0"
       },
       "engines": {
@@ -8321,9 +8321,9 @@
       }
     },
     "node_modules/semver": {
-      "version": "7.8.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.1.tgz",
-      "integrity": "sha512-rkVq3IXh+4FDGch+KwzX3aV9W3kO54GyEgpvBzSyctDA6Xtd7RJQV1xmXbeQp5v7+VzLOfVqiutSE6GICgPFvg==",
+      "version": "7.8.4",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.4.tgz",
+      "integrity": "sha512-rUCObTnP32Q08R2uuIrt7r9PlEonuTmtuXYcW6s5kjdlj3xbnwe+21yXptAUYcMAABLkYYTtnmzb3w3EDZfueA==",
       "license": "ISC",
       "bin": {
         "semver": "bin/semver.js"
@@ -9302,16 +9302,16 @@
       }
     },
     "node_modules/typescript-eslint": {
-      "version": "8.60.1",
-      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.60.1.tgz",
-      "integrity": "sha512-6m5hkkRAp8lKvhVpcprAIn5KkehQEh+47oHH2VGnExEh7dhNxXlg6GPAOIu6TxbVQxhebrJDvjl3020ooiWCMA==",
+      "version": "8.61.0",
+      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.61.0.tgz",
+      "integrity": "sha512-8y31Rd0eGTrDKqhy6vT0HtzhN+YLjQizwX3aA3hPXP/ynSfnrBXcQY5IzsP9/DM7+klX4IUncZZjkchP0z+rUw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/eslint-plugin": "8.60.1",
-        "@typescript-eslint/parser": "8.60.1",
-        "@typescript-eslint/typescript-estree": "8.60.1",
-        "@typescript-eslint/utils": "8.60.1"
+        "@typescript-eslint/eslint-plugin": "8.61.0",
+        "@typescript-eslint/parser": "8.61.0",
+        "@typescript-eslint/typescript-estree": "8.61.0",
+        "@typescript-eslint/utils": "8.61.0"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -9830,7 +9830,7 @@
         "yaml": "^2.9.0"
       },
       "devDependencies": {
-        "@types/node": "^20.19.41",
+        "@types/node": "^20.19.42",
         "tsx": "^4.22.4"
       }
     }
diff --git a/package.json b/package.json
index 79006bd3c1..d24cfc08c2 100644
--- a/package.json
+++ b/package.json
@@ -40,7 +40,7 @@
     "jsonschema": "1.5.0",
     "long": "^5.3.2",
     "node-forge": "^1.4.0",
-    "semver": "^7.8.1",
+    "semver": "^7.8.4",
     "uuid": "^14.0.0"
   },
   "devDependencies": {
@@ -51,7 +51,7 @@
     "@types/archiver": "^7.0.0",
     "@types/follow-redirects": "^1.14.4",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^20.19.41",
+    "@types/node": "^20.19.42",
     "@types/node-forge": "^1.3.14",
     "@types/sarif": "^2.1.7",
     "@types/semver": "^7.7.1",
@@ -69,7 +69,7 @@
     "nock": "^14.0.15",
     "sinon": "^22.0.0",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.60.1"
+    "typescript-eslint": "^8.61.0"
   },
   "overrides": {
     "@actions/tool-cache": {
diff --git a/pr-checks/package.json b/pr-checks/package.json
index c79f818d4c..a426a01126 100644
--- a/pr-checks/package.json
+++ b/pr-checks/package.json
@@ -10,7 +10,7 @@
     "yaml": "^2.9.0"
   },
   "devDependencies": {
-    "@types/node": "^20.19.41",
+    "@types/node": "^20.19.42",
     "tsx": "^4.22.4"
   }
 }

From 03dfa6fb025078a1c948e03b6d5a1c819501e1a1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 17 Jun 2026 17:57:53 +0000
Subject: [PATCH 36/65] Bump the actions-minor group across 1 directory with 2
 updates

Bumps the actions-minor group with 2 updates in the /.github/workflows directory: [actions/setup-java](https://github.com/actions/setup-java) and [ruby/setup-ruby](https://github.com/ruby/setup-ruby).


Updates `actions/setup-java` from 5.2.0 to 5.3.0
- [Release notes](https://github.com/actions/setup-java/releases)
- [Commits](https://github.com/actions/setup-java/compare/be666c2fcd27ec809703dec50e508c2fdc7f6654...ad2b38190b15e4d6bdf0c97fb4fca8412226d287)

Updates `ruby/setup-ruby` from 1.310.0 to 1.312.0
- [Release notes](https://github.com/ruby/setup-ruby/releases)
- [Changelog](https://github.com/ruby/setup-ruby/blob/master/release.rb)
- [Commits](https://github.com/ruby/setup-ruby/compare/afeafc3d1ab54a631816aba4c914a0081c12ff2f...12fd324f1d0b43274fdc8130f6980590a667c455)

---
updated-dependencies:
- dependency-name: actions/setup-java
  dependency-version: 5.3.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: actions-minor
- dependency-name: ruby/setup-ruby
  dependency-version: 1.312.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: actions-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .../workflows/__autobuild-direct-tracing-with-working-dir.yml   | 2 +-
 .github/workflows/__build-mode-autobuild.yml                    | 2 +-
 .github/workflows/__rubocop-multi-language.yml                  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/__autobuild-direct-tracing-with-working-dir.yml b/.github/workflows/__autobuild-direct-tracing-with-working-dir.yml
index d0a4e7d783..01016165b3 100644
--- a/.github/workflows/__autobuild-direct-tracing-with-working-dir.yml
+++ b/.github/workflows/__autobuild-direct-tracing-with-working-dir.yml
@@ -68,7 +68,7 @@ jobs:
       - name: Check out repository
         uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
       - name: Install Java
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5.3.0
         with:
           java-version: ${{ inputs.java-version || '17' }}
           distribution: temurin
diff --git a/.github/workflows/__build-mode-autobuild.yml b/.github/workflows/__build-mode-autobuild.yml
index f22f642e6b..d2f129e848 100644
--- a/.github/workflows/__build-mode-autobuild.yml
+++ b/.github/workflows/__build-mode-autobuild.yml
@@ -68,7 +68,7 @@ jobs:
       - name: Check out repository
         uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
       - name: Install Java
-        uses: actions/setup-java@be666c2fcd27ec809703dec50e508c2fdc7f6654 # v5.2.0
+        uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5.3.0
         with:
           java-version: ${{ inputs.java-version || '17' }}
           distribution: temurin
diff --git a/.github/workflows/__rubocop-multi-language.yml b/.github/workflows/__rubocop-multi-language.yml
index 055aae50bc..9bee982be6 100644
--- a/.github/workflows/__rubocop-multi-language.yml
+++ b/.github/workflows/__rubocop-multi-language.yml
@@ -59,7 +59,7 @@ jobs:
           use-all-platform-bundle: 'false'
           setup-kotlin: 'true'
       - name: Set up Ruby
-        uses: ruby/setup-ruby@afeafc3d1ab54a631816aba4c914a0081c12ff2f # v1.310.0
+        uses: ruby/setup-ruby@12fd324f1d0b43274fdc8130f6980590a667c455 # v1.312.0
         with:
           ruby-version: 2.6
       - name: Install Code Scanning integration

From 80de83798400c09f7841812054ec42073a8d0301 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 17 Jun 2026 17:58:05 +0000
Subject: [PATCH 37/65] Rebuild

---
 lib/entry-points.js | 25 +++++++++++++++++++++----
 1 file changed, 21 insertions(+), 4 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index c69fa78ff8..0e620e3c04 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -26064,6 +26064,18 @@ var require_semver = __commonJS({
     var { safeRe: re, t } = require_re();
     var parseOptions = require_parse_options();
     var { compareIdentifiers } = require_identifiers();
+    var isPrereleaseIdentifier = (prerelease, identifier) => {
+      const identifiers = identifier.split(".");
+      if (identifiers.length > prerelease.length) {
+        return false;
+      }
+      for (let i = 0; i < identifiers.length; i++) {
+        if (compareIdentifiers(prerelease[i], identifiers[i]) !== 0) {
+          return false;
+        }
+      }
+      return true;
+    };
     var SemVer = class _SemVer {
       constructor(version, options) {
         options = parseOptions(options);
@@ -26310,8 +26322,9 @@ var require_semver = __commonJS({
               if (identifierBase === false) {
                 prerelease = [identifier];
               }
-              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
-                if (isNaN(this.prerelease[1])) {
+              if (isPrereleaseIdentifier(this.prerelease, identifier)) {
+                const prereleaseBase = this.prerelease[identifier.split(".").length];
+                if (isNaN(prereleaseBase)) {
                   this.prerelease = prerelease;
                 }
               } else {
@@ -26981,6 +26994,7 @@ var require_range = __commonJS({
       return comp;
     };
     var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
+    var invalidXRangeOrder = (M, m, p) => isX(M) && !isX(m) || isX(m) && p && !isX(p);
     var replaceTildes = (comp, options) => {
       return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
     };
@@ -27040,9 +27054,9 @@ var require_range = __commonJS({
           debug6("no pr");
           if (M === "0") {
             if (m === "0") {
-              ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+              ret = `>=${M}.${m}.${p} <${M}.${m}.${+p + 1}-0`;
             } else {
-              ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+              ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
             }
           } else {
             ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
@@ -27061,6 +27075,9 @@ var require_range = __commonJS({
       const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
       return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
         debug6("xRange", comp, ret, gtlt, M, m, p, pr);
+        if (invalidXRangeOrder(M, m, p)) {
+          return comp;
+        }
         const xM = isX(M);
         const xm = xM || isX(m);
         const xp = xm || isX(p);

From 18e8398a57edca5e0466acd146d100df89b6e97a Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 17 Jun 2026 17:59:57 +0000
Subject: [PATCH 38/65] Rebuild

---
 pr-checks/checks/rubocop-multi-language.yml | 2 +-
 pr-checks/sync.ts                           | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/pr-checks/checks/rubocop-multi-language.yml b/pr-checks/checks/rubocop-multi-language.yml
index 35135a545b..182816cb35 100644
--- a/pr-checks/checks/rubocop-multi-language.yml
+++ b/pr-checks/checks/rubocop-multi-language.yml
@@ -5,7 +5,7 @@ versions:
   - default
 steps:
   - name: Set up Ruby
-    uses: ruby/setup-ruby@afeafc3d1ab54a631816aba4c914a0081c12ff2f # v1.310.0
+    uses: ruby/setup-ruby@12fd324f1d0b43274fdc8130f6980590a667c455 # v1.312.0
     with:
       ruby-version: 2.6
   - name: Install Code Scanning integration
diff --git a/pr-checks/sync.ts b/pr-checks/sync.ts
index 4d7ae200a4..b969fcb937 100755
--- a/pr-checks/sync.ts
+++ b/pr-checks/sync.ts
@@ -246,8 +246,8 @@ const languageSetups: LanguageSetups = {
         name: "Install Java",
         uses: pinnedUses(
           "actions/setup-java",
-          "be666c2fcd27ec809703dec50e508c2fdc7f6654",
-          "v5.2.0",
+          "ad2b38190b15e4d6bdf0c97fb4fca8412226d287",
+          "v5.3.0",
         ),
         with: {
           "java-version": `\${{ inputs.java-version || '${defaultLanguageVersions.java}' }}`,

From 4138e5a7fec3bc0641f4c6944efdd90e0afa9f0c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 17 Jun 2026 19:10:07 +0000
Subject: [PATCH 39/65] Bump archiver and @types/archiver

Bumps [archiver](https://github.com/archiverjs/node-archiver) and [@types/archiver](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/archiver). These dependencies needed to be updated together.

Updates `archiver` from 7.0.1 to 8.0.0
- [Release notes](https://github.com/archiverjs/node-archiver/releases)
- [Changelog](https://github.com/archiverjs/node-archiver/blob/master/CHANGELOG.md)
- [Commits](https://github.com/archiverjs/node-archiver/compare/7.0.1...8.0.0)

Updates `@types/archiver` from 7.0.0 to 8.0.0
- [Release notes](https://github.com/DefinitelyTyped/DefinitelyTyped/releases)
- [Commits](https://github.com/DefinitelyTyped/DefinitelyTyped/commits/HEAD/types/archiver)

---
updated-dependencies:
- dependency-name: archiver
  dependency-version: 8.0.0
  dependency-type: direct:production
  update-type: version-update:semver-major
- dependency-name: "@types/archiver"
  dependency-version: 8.0.0
  dependency-type: direct:development
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 package-lock.json | 242 +++++++++++++++++++++++++++++++++++-----------
 package.json      |   4 +-
 2 files changed, 185 insertions(+), 61 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 96c8944700..32cee510b8 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -23,7 +23,7 @@
         "@actions/io": "^2.0.0",
         "@actions/tool-cache": "^3.0.1",
         "@octokit/plugin-retry": "^8.1.0",
-        "archiver": "^7.0.1",
+        "archiver": "^8.0.0",
         "fast-deep-equal": "^3.1.3",
         "follow-redirects": "^1.16.0",
         "get-folder-size": "^5.0.0",
@@ -40,7 +40,7 @@
         "@eslint/compat": "^2.1.0",
         "@microsoft/eslint-formatter-sarif": "^3.1.0",
         "@octokit/types": "^16.0.0",
-        "@types/archiver": "^7.0.0",
+        "@types/archiver": "^8.0.0",
         "@types/follow-redirects": "^1.14.4",
         "@types/js-yaml": "^4.0.9",
         "@types/node": "^20.19.42",
@@ -345,12 +345,115 @@
       "resolved": "https://registry.npmjs.org/@octokit/openapi-types/-/openapi-types-24.2.0.tgz",
       "integrity": "sha512-9sIH3nSUttelJSXUrmGzl7QUBFul0/mB8HRYl3fOlgHbIWG+WnYDXU3v/2zMtAvuzZ/ed00Ei6on975FhBfzrg=="
     },
+    "node_modules/@actions/artifact/node_modules/archiver": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/archiver/-/archiver-7.0.1.tgz",
+      "integrity": "sha512-ZcbTaIqJOfCc03QwD468Unz/5Ir8ATtvAHsK+FdXbDIbGfihqh9mrvdcYunQzqn4HrvWWaFyaxJhGZagaJJpPQ==",
+      "license": "MIT",
+      "dependencies": {
+        "archiver-utils": "^5.0.2",
+        "async": "^3.2.4",
+        "buffer-crc32": "^1.0.0",
+        "readable-stream": "^4.0.0",
+        "readdir-glob": "^1.1.2",
+        "tar-stream": "^3.0.0",
+        "zip-stream": "^6.0.1"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
     "node_modules/@actions/artifact/node_modules/before-after-hook": {
       "version": "2.2.3",
       "resolved": "https://registry.npmjs.org/before-after-hook/-/before-after-hook-2.2.3.tgz",
       "integrity": "sha512-NzUnlZexiaH/46WDhANlyR2bXRopNg4F/zuSA3OpZnllCUgRaOF2znDioDWrmbNVsuZk6l9pMquQB38cfBZwkQ==",
       "license": "Apache-2.0"
     },
+    "node_modules/@actions/artifact/node_modules/brace-expansion": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.1.tgz",
+      "integrity": "sha512-WR1cURNjuvBLMZBMbqM0UoE+WAfdUcEV1ccD8PVBVOI+Z3ND4+SZbN8RsfT2bMuG1qwz5RFvPukSZm5fF2D5eA==",
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
+      }
+    },
+    "node_modules/@actions/artifact/node_modules/compress-commons": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/compress-commons/-/compress-commons-6.0.2.tgz",
+      "integrity": "sha512-6FqVXeETqWPoGcfzrXb37E50NP0LXT8kAMu5ooZayhWWdgEY4lBEEcbQNXtkuKQsGduxiIcI4gOTsxTmuq/bSg==",
+      "license": "MIT",
+      "dependencies": {
+        "crc-32": "^1.2.0",
+        "crc32-stream": "^6.0.0",
+        "is-stream": "^2.0.1",
+        "normalize-path": "^3.0.0",
+        "readable-stream": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/@actions/artifact/node_modules/crc32-stream": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/crc32-stream/-/crc32-stream-6.0.0.tgz",
+      "integrity": "sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g==",
+      "license": "MIT",
+      "dependencies": {
+        "crc-32": "^1.2.0",
+        "readable-stream": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/@actions/artifact/node_modules/is-stream": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
+      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/@actions/artifact/node_modules/minimatch": {
+      "version": "5.1.9",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
+      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/@actions/artifact/node_modules/readdir-glob": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/readdir-glob/-/readdir-glob-1.1.3.tgz",
+      "integrity": "sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "minimatch": "^5.1.0"
+      }
+    },
+    "node_modules/@actions/artifact/node_modules/zip-stream": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/zip-stream/-/zip-stream-6.0.1.tgz",
+      "integrity": "sha512-zK7YHHz4ZXpW89AHXUPbQVGKI7uvkd3hzusTdotCg1UxyaVtg0zFJSTfW/Dq5f7OBBVnq6cZIaC8Ti4hb6dtCA==",
+      "license": "MIT",
+      "dependencies": {
+        "archiver-utils": "^5.0.0",
+        "compress-commons": "^6.0.2",
+        "readable-stream": "^4.0.0"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
     "node_modules/@actions/cache": {
       "version": "5.0.5",
       "resolved": "https://registry.npmjs.org/@actions/cache/-/cache-5.0.5.tgz",
@@ -2421,12 +2524,13 @@
       }
     },
     "node_modules/@types/archiver": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/@types/archiver/-/archiver-7.0.0.tgz",
-      "integrity": "sha512-/3vwGwx9n+mCQdYZ2IKGGHEFL30I96UgBlk8EtRDDFQ9uxM1l4O5Ci6r00EMAkiDaTqD9DQ6nVrWRICnBPtzzg==",
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/@types/archiver/-/archiver-8.0.0.tgz",
+      "integrity": "sha512-YpXPbEuv9+eUIPPQWUPahj3cvs9isWRuF+J4z+KbdYVDO3rWorWQFxUVHnwPu2AgKwvgpki5F2VMX0Xx+mX45A==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
+        "@types/node": "*",
         "@types/readdir-glob": "*"
       }
     },
@@ -3210,6 +3314,8 @@
     },
     "node_modules/abort-controller": {
       "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/abort-controller/-/abort-controller-3.0.0.tgz",
+      "integrity": "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg==",
       "license": "MIT",
       "dependencies": {
         "event-target-shim": "^5.0.0"
@@ -3307,21 +3413,23 @@
       }
     },
     "node_modules/archiver": {
-      "version": "7.0.1",
-      "resolved": "https://registry.npmjs.org/archiver/-/archiver-7.0.1.tgz",
-      "integrity": "sha512-ZcbTaIqJOfCc03QwD468Unz/5Ir8ATtvAHsK+FdXbDIbGfihqh9mrvdcYunQzqn4HrvWWaFyaxJhGZagaJJpPQ==",
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/archiver/-/archiver-8.0.0.tgz",
+      "integrity": "sha512-fV1orZfsnPn9BaSByR/qE67rJCLJEy2Ox5bq7nJh+jquWaNh6Sfec75kJ2T6PtdGUbPQlrVoSVCEOa5SdiTQ1g==",
       "license": "MIT",
       "dependencies": {
-        "archiver-utils": "^5.0.2",
         "async": "^3.2.4",
         "buffer-crc32": "^1.0.0",
+        "is-stream": "^4.0.0",
+        "lazystream": "^1.0.0",
+        "normalize-path": "^3.0.0",
         "readable-stream": "^4.0.0",
-        "readdir-glob": "^1.1.2",
+        "readdir-glob": "^3.0.0",
         "tar-stream": "^3.0.0",
-        "zip-stream": "^6.0.1"
+        "zip-stream": "^7.0.2"
       },
       "engines": {
-        "node": ">= 14"
+        "node": ">=18"
       }
     },
     "node_modules/archiver-utils": {
@@ -4174,31 +4282,19 @@
       "dev": true
     },
     "node_modules/compress-commons": {
-      "version": "6.0.2",
-      "resolved": "https://registry.npmjs.org/compress-commons/-/compress-commons-6.0.2.tgz",
-      "integrity": "sha512-6FqVXeETqWPoGcfzrXb37E50NP0LXT8kAMu5ooZayhWWdgEY4lBEEcbQNXtkuKQsGduxiIcI4gOTsxTmuq/bSg==",
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/compress-commons/-/compress-commons-7.0.1.tgz",
+      "integrity": "sha512-g0S8KAD8qf4+V//pr3BfB1aBnARLXNz2Gx+jmHU0LEriUuoQUOPOulVquHKTJ8+EAIIO7fhseNDr9wK5Q9FKBQ==",
       "license": "MIT",
       "dependencies": {
         "crc-32": "^1.2.0",
-        "crc32-stream": "^6.0.0",
-        "is-stream": "^2.0.1",
+        "crc32-stream": "^7.0.1",
+        "is-stream": "^4.0.0",
         "normalize-path": "^3.0.0",
         "readable-stream": "^4.0.0"
       },
       "engines": {
-        "node": ">= 14"
-      }
-    },
-    "node_modules/compress-commons/node_modules/is-stream": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-2.0.1.tgz",
-      "integrity": "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
+        "node": ">=18"
       }
     },
     "node_modules/concat-map": {
@@ -4262,16 +4358,16 @@
       }
     },
     "node_modules/crc32-stream": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/crc32-stream/-/crc32-stream-6.0.0.tgz",
-      "integrity": "sha512-piICUB6ei4IlTv1+653yq5+KoqfBYmj9bw6LqXoOneTMDXk5nM1qt12mFW1caG3LlJXEKW1Bp0WggEmIfQB34g==",
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/crc32-stream/-/crc32-stream-7.0.1.tgz",
+      "integrity": "sha512-IBWsY8xznyQrcHn8h4bC8/4ErNke5elzgG8GcqF4RFPw6aHkWWRc7Tgw6upjaTX/CT/yQgqYENkxYsTYN+hW2g==",
       "license": "MIT",
       "dependencies": {
         "crc-32": "^1.2.0",
         "readable-stream": "^4.0.0"
       },
       "engines": {
-        "node": ">= 14"
+        "node": ">=18"
       }
     },
     "node_modules/cross-spawn": {
@@ -5556,6 +5652,8 @@
     },
     "node_modules/event-target-shim": {
       "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/event-target-shim/-/event-target-shim-5.0.1.tgz",
+      "integrity": "sha512-i/2XbnSz/uxRCU6+NdVJgKWDTM427+MqYbkQzD321DuCQJUqOuJKIA0IM2+W2xtYHdKOmZ4dR6fExsd4SXL+WQ==",
       "license": "MIT",
       "engines": {
         "node": ">=6"
@@ -6423,7 +6521,9 @@
       }
     },
     "node_modules/inherits": {
-      "version": "2.0.3",
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
       "license": "ISC"
     },
     "node_modules/internal-slot": {
@@ -6806,7 +6906,6 @@
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-4.0.1.tgz",
       "integrity": "sha512-Dnz92NInDqYckGEUJv689RbRiTSEHCQ7wOVeALbkOz999YpqT46yMRIGtSNl2iCL1waAZSx40+h59NV/EwzV/A==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=18"
@@ -7516,6 +7615,8 @@
     },
     "node_modules/normalize-path": {
       "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/normalize-path/-/normalize-path-3.0.0.tgz",
+      "integrity": "sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==",
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -7977,6 +8078,8 @@
     },
     "node_modules/process": {
       "version": "0.11.10",
+      "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
+      "integrity": "sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==",
       "license": "MIT",
       "engines": {
         "node": ">= 0.6.0"
@@ -8030,9 +8133,9 @@
       "license": "MIT"
     },
     "node_modules/readable-stream": {
-      "version": "4.5.2",
-      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-4.5.2.tgz",
-      "integrity": "sha512-yjavECdqeZ3GLXNgRXgeQEdz9fvDDkNKyHnbHRFtOr7/LcfgBcmct7t/ET+HaCTqfh06OzoAxrkN/IfjJBVe+g==",
+      "version": "4.7.0",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-4.7.0.tgz",
+      "integrity": "sha512-oIGGmcpTLwPga8Bn6/Z75SVaH1z5dUut2ibSyAMVhmUggWpmDn2dapB0n7f8nwaSiRtepAsfJyfXIO5DCVAODg==",
       "license": "MIT",
       "dependencies": {
         "abort-controller": "^3.0.0",
@@ -8046,33 +8149,54 @@
       }
     },
     "node_modules/readdir-glob": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/readdir-glob/-/readdir-glob-1.1.3.tgz",
-      "integrity": "sha512-v05I2k7xN8zXvPD9N+z/uhXPaj0sUFCe2rcWZIpBsqxfP7xXFQ0tipAd/wjj1YxWyWtUS5IDJpOG82JKt2EAVA==",
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/readdir-glob/-/readdir-glob-3.0.0.tgz",
+      "integrity": "sha512-AhNB2KgKeVJr16nK9LLZbJNWnYoT23ZrumNKFDebHBdkC8KHSqWo871JAUhoWC/RtjEVdqNMFpM6qrwRbaUqpw==",
       "license": "Apache-2.0",
       "dependencies": {
-        "minimatch": "^5.1.0"
+        "minimatch": "^10.2.2"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/yqnn"
+      }
+    },
+    "node_modules/readdir-glob/node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
       }
     },
     "node_modules/readdir-glob/node_modules/brace-expansion": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.0.tgz",
-      "integrity": "sha512-TN1kCZAgdgweJhWWpgKYrQaMNHcDULHkWwQIspdtjV4Y5aurRdZpjAqn6yX3FPqTA9ngHCc4hJxMAMgGfve85w==",
+      "version": "5.0.6",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
+      "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
       "license": "MIT",
       "dependencies": {
-        "balanced-match": "^1.0.0"
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
       }
     },
     "node_modules/readdir-glob/node_modules/minimatch": {
-      "version": "5.1.9",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",
-      "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",
-      "license": "ISC",
+      "version": "10.2.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",
+      "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",
+      "license": "BlueOak-1.0.0",
       "dependencies": {
-        "brace-expansion": "^2.0.1"
+        "brace-expansion": "^5.0.5"
       },
       "engines": {
-        "node": ">=10"
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
       }
     },
     "node_modules/reflect.getprototypeof": {
@@ -9807,17 +9931,17 @@
       }
     },
     "node_modules/zip-stream": {
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/zip-stream/-/zip-stream-6.0.1.tgz",
-      "integrity": "sha512-zK7YHHz4ZXpW89AHXUPbQVGKI7uvkd3hzusTdotCg1UxyaVtg0zFJSTfW/Dq5f7OBBVnq6cZIaC8Ti4hb6dtCA==",
+      "version": "7.0.5",
+      "resolved": "https://registry.npmjs.org/zip-stream/-/zip-stream-7.0.5.tgz",
+      "integrity": "sha512-dSvYKdvLsAHCDqPOhIwk/q5CvuWtTB3Dgpoe0uVEFjTzIOAmsQpprX25InCvrvJsirEbu1OHyy67n/kAj1Sw/w==",
       "license": "MIT",
       "dependencies": {
-        "archiver-utils": "^5.0.0",
-        "compress-commons": "^6.0.2",
+        "compress-commons": "^7.0.0",
+        "normalize-path": "^3.0.0",
         "readable-stream": "^4.0.0"
       },
       "engines": {
-        "node": ">= 14"
+        "node": ">=18"
       }
     },
     "pr-checks": {
diff --git a/package.json b/package.json
index d24cfc08c2..5a0a1b0bf1 100644
--- a/package.json
+++ b/package.json
@@ -31,7 +31,7 @@
     "@actions/io": "^2.0.0",
     "@actions/tool-cache": "^3.0.1",
     "@octokit/plugin-retry": "^8.1.0",
-    "archiver": "^7.0.1",
+    "archiver": "^8.0.0",
     "fast-deep-equal": "^3.1.3",
     "follow-redirects": "^1.16.0",
     "get-folder-size": "^5.0.0",
@@ -48,7 +48,7 @@
     "@eslint/compat": "^2.1.0",
     "@microsoft/eslint-formatter-sarif": "^3.1.0",
     "@octokit/types": "^16.0.0",
-    "@types/archiver": "^7.0.0",
+    "@types/archiver": "^8.0.0",
     "@types/follow-redirects": "^1.14.4",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.19.42",

From 711c19c2dc56f250ec324d69b35d19b60a89d018 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Thu, 18 Jun 2026 14:23:54 +0100
Subject: [PATCH 40/65] Use `ZipArchive` instead of `archive("zip")`

---
 lib/entry-points.js    | 13170 ++++++++++++++++++++++++++-------------
 src/debug-artifacts.ts |     4 +-
 2 files changed, 8905 insertions(+), 4269 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 74a252e50c..3a1c05a4fd 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -213,7 +213,7 @@ var require_file_command = __commonJS({
     exports2.issueFileCommand = issueFileCommand;
     exports2.prepareKeyValueMessage = prepareKeyValueMessage;
     var crypto3 = __importStar2(require("crypto"));
-    var fs30 = __importStar2(require("fs"));
+    var fs31 = __importStar2(require("fs"));
     var os7 = __importStar2(require("os"));
     var utils_1 = require_utils();
     function issueFileCommand(command, message) {
@@ -221,10 +221,10 @@ var require_file_command = __commonJS({
       if (!filePath) {
         throw new Error(`Unable to find environment variable for file command ${command}`);
       }
-      if (!fs30.existsSync(filePath)) {
+      if (!fs31.existsSync(filePath)) {
         throw new Error(`Missing file at path: ${filePath}`);
       }
-      fs30.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os7.EOL}`, {
+      fs31.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os7.EOL}`, {
         encoding: "utf8"
       });
     }
@@ -264,7 +264,7 @@ var require_proxy = __commonJS({
       if (proxyVar) {
         try {
           return new DecodedURL(proxyVar);
-        } catch (_a) {
+        } catch (_a2) {
           if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://"))
             return new DecodedURL(`http://${proxyVar}`);
         }
@@ -333,7 +333,7 @@ var require_tunnel = __commonJS({
     var https3 = require("https");
     var events = require("events");
     var assert = require("assert");
-    var util = require("util");
+    var util3 = require("util");
     exports2.httpOverHttp = httpOverHttp;
     exports2.httpsOverHttp = httpsOverHttp;
     exports2.httpOverHttps = httpOverHttps;
@@ -383,7 +383,7 @@ var require_tunnel = __commonJS({
         self2.removeSocket(socket);
       });
     }
-    util.inherits(TunnelingAgent, events.EventEmitter);
+    util3.inherits(TunnelingAgent, events.EventEmitter);
     TunnelingAgent.prototype.addRequest = function addRequest(req, host, port, localAddress) {
       var self2 = this;
       var options = mergeOptions({ request: req }, self2.options, toOptions(host, port, localAddress));
@@ -1130,16 +1130,16 @@ var require_tree = __commonJS({
        * @param {any} value
        * @param {number} index
        */
-      constructor(key, value, index) {
-        if (index === void 0 || index >= key.length) {
+      constructor(key, value, index2) {
+        if (index2 === void 0 || index2 >= key.length) {
           throw new TypeError("Unreachable");
         }
-        const code = this.code = key.charCodeAt(index);
+        const code = this.code = key.charCodeAt(index2);
         if (code > 127) {
           throw new TypeError("key must be ascii string");
         }
-        if (key.length !== ++index) {
-          this.middle = new _TstNode(key, value, index);
+        if (key.length !== ++index2) {
+          this.middle = new _TstNode(key, value, index2);
         } else {
           this.value = value;
         }
@@ -1153,34 +1153,34 @@ var require_tree = __commonJS({
         if (length === 0) {
           throw new TypeError("Unreachable");
         }
-        let index = 0;
+        let index2 = 0;
         let node = this;
         while (true) {
-          const code = key.charCodeAt(index);
+          const code = key.charCodeAt(index2);
           if (code > 127) {
             throw new TypeError("key must be ascii string");
           }
           if (node.code === code) {
-            if (length === ++index) {
+            if (length === ++index2) {
               node.value = value;
               break;
             } else if (node.middle !== null) {
               node = node.middle;
             } else {
-              node.middle = new _TstNode(key, value, index);
+              node.middle = new _TstNode(key, value, index2);
               break;
             }
           } else if (node.code < code) {
             if (node.left !== null) {
               node = node.left;
             } else {
-              node.left = new _TstNode(key, value, index);
+              node.left = new _TstNode(key, value, index2);
               break;
             }
           } else if (node.right !== null) {
             node = node.right;
           } else {
-            node.right = new _TstNode(key, value, index);
+            node.right = new _TstNode(key, value, index2);
             break;
           }
         }
@@ -1191,16 +1191,16 @@ var require_tree = __commonJS({
        */
       search(key) {
         const keylength = key.length;
-        let index = 0;
+        let index2 = 0;
         let node = this;
-        while (node !== null && index < keylength) {
-          let code = key[index];
+        while (node !== null && index2 < keylength) {
+          let code = key[index2];
           if (code <= 90 && code >= 65) {
             code |= 32;
           }
           while (node !== null) {
             if (code === node.code) {
-              if (keylength === ++index) {
+              if (keylength === ++index2) {
                 return node;
               }
               node = node.middle;
@@ -1275,7 +1275,7 @@ var require_util = __commonJS({
       }
     };
     function wrapRequestBody(body) {
-      if (isStream(body)) {
+      if (isStream2(body)) {
         if (bodyLength(body) === 0) {
           body.on("data", function() {
             assert(false);
@@ -1298,7 +1298,7 @@ var require_util = __commonJS({
     }
     function nop() {
     }
-    function isStream(obj) {
+    function isStream2(obj) {
       return obj && typeof obj === "object" && typeof obj.pipe === "function" && typeof obj.on === "function";
     }
     function isBlobLike(object) {
@@ -1362,14 +1362,14 @@ var require_util = __commonJS({
         }
         const port = url2.port != null ? url2.port : url2.protocol === "https:" ? 443 : 80;
         let origin = url2.origin != null ? url2.origin : `${url2.protocol || ""}//${url2.hostname || ""}:${port}`;
-        let path28 = url2.path != null ? url2.path : `${url2.pathname || ""}${url2.search || ""}`;
+        let path29 = url2.path != null ? url2.path : `${url2.pathname || ""}${url2.search || ""}`;
         if (origin[origin.length - 1] === "/") {
           origin = origin.slice(0, origin.length - 1);
         }
-        if (path28 && path28[0] !== "/") {
-          path28 = `/${path28}`;
+        if (path29 && path29[0] !== "/") {
+          path29 = `/${path29}`;
         }
-        return new URL(`${origin}${path28}`);
+        return new URL(`${origin}${path29}`);
       }
       if (!isHttpOrHttpsPrefixed(url2.origin || url2.protocol)) {
         throw new InvalidArgumentError("Invalid URL protocol: the URL must start with `http:` or `https:`.");
@@ -1416,7 +1416,7 @@ var require_util = __commonJS({
     function bodyLength(body) {
       if (body == null) {
         return 0;
-      } else if (isStream(body)) {
+      } else if (isStream2(body)) {
         const state = body._readableState;
         return state && state.objectMode === false && state.ended === true && Number.isFinite(state.length) ? state.length : null;
       } else if (isBlobLike(body)) {
@@ -1430,7 +1430,7 @@ var require_util = __commonJS({
       return body && !!(body.destroyed || body[kDestroyed] || stream2.isDestroyed?.(body));
     }
     function destroy(stream3, err) {
-      if (stream3 == null || !isStream(stream3) || isDestroyed(stream3)) {
+      if (stream3 == null || !isStream2(stream3) || isDestroyed(stream3)) {
         return;
       }
       if (typeof stream3.destroy === "function") {
@@ -1650,9 +1650,9 @@ var require_util = __commonJS({
     function isValidHeaderValue(characters) {
       return !headerCharRegex.test(characters);
     }
-    function parseRangeHeader(range) {
-      if (range == null || range === "") return { start: 0, end: null, size: null };
-      const m = range ? range.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null;
+    function parseRangeHeader(range2) {
+      if (range2 == null || range2 === "") return { start: 0, end: null, size: null };
+      const m = range2 ? range2.match(/^bytes (\d+)-(\d+)\/(\d+)?$/) : null;
       return m ? {
         start: parseInt(m[1]),
         end: m[2] ? parseInt(m[2]) : null,
@@ -1714,7 +1714,7 @@ var require_util = __commonJS({
       parseOrigin,
       parseURL,
       getServerName,
-      isStream,
+      isStream: isStream2,
       isIterable,
       isAsyncIterable,
       isDestroyed,
@@ -1757,10 +1757,10 @@ var require_diagnostics = __commonJS({
   "node_modules/undici/lib/core/diagnostics.js"(exports2, module2) {
     "use strict";
     var diagnosticsChannel = require("node:diagnostics_channel");
-    var util = require("node:util");
-    var undiciDebugLog = util.debuglog("undici");
-    var fetchDebuglog = util.debuglog("fetch");
-    var websocketDebuglog = util.debuglog("websocket");
+    var util3 = require("node:util");
+    var undiciDebugLog = util3.debuglog("undici");
+    var fetchDebuglog = util3.debuglog("fetch");
+    var websocketDebuglog = util3.debuglog("websocket");
     var isClientSet = false;
     var channels = {
       // Client
@@ -1820,39 +1820,39 @@ var require_diagnostics = __commonJS({
       });
       diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => {
         const {
-          request: { method, path: path28, origin }
+          request: { method, path: path29, origin }
         } = evt;
-        debuglog("sending request to %s %s/%s", method, origin, path28);
+        debuglog("sending request to %s %s/%s", method, origin, path29);
       });
       diagnosticsChannel.channel("undici:request:headers").subscribe((evt) => {
         const {
-          request: { method, path: path28, origin },
+          request: { method, path: path29, origin },
           response: { statusCode }
         } = evt;
         debuglog(
           "received response to %s %s/%s - HTTP %d",
           method,
           origin,
-          path28,
+          path29,
           statusCode
         );
       });
       diagnosticsChannel.channel("undici:request:trailers").subscribe((evt) => {
         const {
-          request: { method, path: path28, origin }
+          request: { method, path: path29, origin }
         } = evt;
-        debuglog("trailers received from %s %s/%s", method, origin, path28);
+        debuglog("trailers received from %s %s/%s", method, origin, path29);
       });
       diagnosticsChannel.channel("undici:request:error").subscribe((evt) => {
         const {
-          request: { method, path: path28, origin },
+          request: { method, path: path29, origin },
           error: error3
         } = evt;
         debuglog(
           "request to %s %s/%s errored - %s",
           method,
           origin,
-          path28,
+          path29,
           error3.message
         );
       });
@@ -1901,9 +1901,9 @@ var require_diagnostics = __commonJS({
         });
         diagnosticsChannel.channel("undici:client:sendHeaders").subscribe((evt) => {
           const {
-            request: { method, path: path28, origin }
+            request: { method, path: path29, origin }
           } = evt;
-          debuglog("sending request to %s %s/%s", method, origin, path28);
+          debuglog("sending request to %s %s/%s", method, origin, path29);
         });
       }
       diagnosticsChannel.channel("undici:websocket:open").subscribe((evt) => {
@@ -1949,7 +1949,7 @@ var require_request = __commonJS({
     var {
       isValidHTTPToken,
       isValidHeaderValue,
-      isStream,
+      isStream: isStream2,
       destroy,
       isBuffer,
       isFormDataLike,
@@ -1966,7 +1966,7 @@ var require_request = __commonJS({
     var kHandler = /* @__PURE__ */ Symbol("handler");
     var Request = class {
       constructor(origin, {
-        path: path28,
+        path: path29,
         method,
         body,
         headers,
@@ -1981,11 +1981,11 @@ var require_request = __commonJS({
         expectContinue,
         servername
       }, handler2) {
-        if (typeof path28 !== "string") {
+        if (typeof path29 !== "string") {
           throw new InvalidArgumentError("path must be a string");
-        } else if (path28[0] !== "/" && !(path28.startsWith("http://") || path28.startsWith("https://")) && method !== "CONNECT") {
+        } else if (path29[0] !== "/" && !(path29.startsWith("http://") || path29.startsWith("https://")) && method !== "CONNECT") {
           throw new InvalidArgumentError("path must be an absolute URL or start with a slash");
-        } else if (invalidPathRegex.test(path28)) {
+        } else if (invalidPathRegex.test(path29)) {
           throw new InvalidArgumentError("invalid request path");
         }
         if (typeof method !== "string") {
@@ -2018,7 +2018,7 @@ var require_request = __commonJS({
         this.abort = null;
         if (body == null) {
           this.body = null;
-        } else if (isStream(body)) {
+        } else if (isStream2(body)) {
           this.body = body;
           const rState = this.body._readableState;
           if (!rState || !rState.autoDestroy) {
@@ -2051,7 +2051,7 @@ var require_request = __commonJS({
         this.completed = false;
         this.aborted = false;
         this.upgrade = upgrade || null;
-        this.path = query ? buildURL(path28, query) : path28;
+        this.path = query ? buildURL(path29, query) : path29;
         this.origin = origin;
         this.idempotent = idempotent == null ? method === "HEAD" || method === "GET" : idempotent;
         this.blocking = blocking == null ? false : blocking;
@@ -2274,8 +2274,8 @@ var require_request = __commonJS({
 var require_dispatcher = __commonJS({
   "node_modules/undici/lib/dispatcher/dispatcher.js"(exports2, module2) {
     "use strict";
-    var EventEmitter = require("node:events");
-    var Dispatcher = class extends EventEmitter {
+    var EventEmitter2 = require("node:events");
+    var Dispatcher = class extends EventEmitter2 {
       dispatch() {
         throw new Error("not implemented");
       }
@@ -2369,9 +2369,9 @@ var require_dispatcher_base = __commonJS({
       }
       close(callback) {
         if (callback === void 0) {
-          return new Promise((resolve13, reject) => {
+          return new Promise((resolve14, reject) => {
             this.close((err, data) => {
-              return err ? reject(err) : resolve13(data);
+              return err ? reject(err) : resolve14(data);
             });
           });
         }
@@ -2409,12 +2409,12 @@ var require_dispatcher_base = __commonJS({
           err = null;
         }
         if (callback === void 0) {
-          return new Promise((resolve13, reject) => {
+          return new Promise((resolve14, reject) => {
             this.destroy(err, (err2, data) => {
               return err2 ? (
                 /* istanbul ignore next: should never error */
                 reject(err2)
-              ) : resolve13(data);
+              ) : resolve14(data);
             });
           });
         }
@@ -2723,7 +2723,7 @@ var require_connect = __commonJS({
     "use strict";
     var net = require("node:net");
     var assert = require("node:assert");
-    var util = require_util();
+    var util3 = require_util();
     var { InvalidArgumentError, ConnectTimeoutError } = require_errors();
     var timers = require_timers();
     function noop3() {
@@ -2792,7 +2792,7 @@ var require_connect = __commonJS({
           if (!tls) {
             tls = require("node:tls");
           }
-          servername = servername || options.servername || util.getServerName(host) || null;
+          servername = servername || options.servername || util3.getServerName(host) || null;
           const sessionKey = servername || hostname;
           assert(sessionKey);
           const session = customSession || sessionCache.get(sessionKey) || null;
@@ -2891,7 +2891,7 @@ var require_connect = __commonJS({
         message += ` (attempted address: ${opts.hostname}:${opts.port},`;
       }
       message += ` timeout: ${opts.timeout}ms)`;
-      util.destroy(socket, new ConnectTimeoutError(message));
+      util3.destroy(socket, new ConnectTimeoutError(message));
     }
     module2.exports = buildConnector;
   }
@@ -3866,7 +3866,7 @@ var require_data_url = __commonJS({
 var require_webidl = __commonJS({
   "node_modules/undici/lib/web/fetch/webidl.js"(exports2, module2) {
     "use strict";
-    var { types: types2, inspect } = require("node:util");
+    var { types: types3, inspect } = require("node:util");
     var { markAsUncloneable } = require("node:worker_threads");
     var { toUSVString } = require_util();
     var webidl = {};
@@ -4030,7 +4030,7 @@ var require_webidl = __commonJS({
         }
         const method = typeof Iterable === "function" ? Iterable() : V?.[Symbol.iterator]?.();
         const seq = [];
-        let index = 0;
+        let index2 = 0;
         if (method === void 0 || typeof method.next !== "function") {
           throw webidl.errors.exception({
             header: prefix,
@@ -4042,7 +4042,7 @@ var require_webidl = __commonJS({
           if (done) {
             break;
           }
-          seq.push(converter(value, prefix, `${argument}[${index++}]`));
+          seq.push(converter(value, prefix, `${argument}[${index2++}]`));
         }
         return seq;
       };
@@ -4056,7 +4056,7 @@ var require_webidl = __commonJS({
           });
         }
         const result = {};
-        if (!types2.isProxy(O)) {
+        if (!types3.isProxy(O)) {
           const keys2 = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)];
           for (const key of keys2) {
             const typedKey = keyConverter(key, prefix, argument);
@@ -4151,10 +4151,10 @@ var require_webidl = __commonJS({
     };
     webidl.converters.ByteString = function(V, prefix, argument) {
       const x = webidl.converters.DOMString(V, prefix, argument);
-      for (let index = 0; index < x.length; index++) {
-        if (x.charCodeAt(index) > 255) {
+      for (let index2 = 0; index2 < x.length; index2++) {
+        if (x.charCodeAt(index2) > 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.`
+            `Cannot convert argument to a ByteString because the character at index ${index2} has a value of ${x.charCodeAt(index2)} which is greater than 255.`
           );
         }
       }
@@ -4185,14 +4185,14 @@ var require_webidl = __commonJS({
       return x;
     };
     webidl.converters.ArrayBuffer = function(V, prefix, argument, opts) {
-      if (webidl.util.Type(V) !== "Object" || !types2.isAnyArrayBuffer(V)) {
+      if (webidl.util.Type(V) !== "Object" || !types3.isAnyArrayBuffer(V)) {
         throw webidl.errors.conversionFailed({
           prefix,
           argument: `${argument} ("${webidl.util.Stringify(V)}")`,
           types: ["ArrayBuffer"]
         });
       }
-      if (opts?.allowShared === false && types2.isSharedArrayBuffer(V)) {
+      if (opts?.allowShared === false && types3.isSharedArrayBuffer(V)) {
         throw webidl.errors.exception({
           header: "ArrayBuffer",
           message: "SharedArrayBuffer is not allowed."
@@ -4207,14 +4207,14 @@ var require_webidl = __commonJS({
       return V;
     };
     webidl.converters.TypedArray = function(V, T, prefix, name, opts) {
-      if (webidl.util.Type(V) !== "Object" || !types2.isTypedArray(V) || V.constructor.name !== T.name) {
+      if (webidl.util.Type(V) !== "Object" || !types3.isTypedArray(V) || V.constructor.name !== T.name) {
         throw webidl.errors.conversionFailed({
           prefix,
           argument: `${name} ("${webidl.util.Stringify(V)}")`,
           types: [T.name]
         });
       }
-      if (opts?.allowShared === false && types2.isSharedArrayBuffer(V.buffer)) {
+      if (opts?.allowShared === false && types3.isSharedArrayBuffer(V.buffer)) {
         throw webidl.errors.exception({
           header: "ArrayBuffer",
           message: "SharedArrayBuffer is not allowed."
@@ -4229,13 +4229,13 @@ var require_webidl = __commonJS({
       return V;
     };
     webidl.converters.DataView = function(V, prefix, name, opts) {
-      if (webidl.util.Type(V) !== "Object" || !types2.isDataView(V)) {
+      if (webidl.util.Type(V) !== "Object" || !types3.isDataView(V)) {
         throw webidl.errors.exception({
           header: prefix,
           message: `${name} is not a DataView.`
         });
       }
-      if (opts?.allowShared === false && types2.isSharedArrayBuffer(V.buffer)) {
+      if (opts?.allowShared === false && types3.isSharedArrayBuffer(V.buffer)) {
         throw webidl.errors.exception({
           header: "ArrayBuffer",
           message: "SharedArrayBuffer is not allowed."
@@ -4250,13 +4250,13 @@ var require_webidl = __commonJS({
       return V;
     };
     webidl.converters.BufferSource = function(V, prefix, name, opts) {
-      if (types2.isAnyArrayBuffer(V)) {
+      if (types3.isAnyArrayBuffer(V)) {
         return webidl.converters.ArrayBuffer(V, prefix, name, { ...opts, allowShared: false });
       }
-      if (types2.isTypedArray(V)) {
+      if (types3.isTypedArray(V)) {
         return webidl.converters.TypedArray(V, V.constructor, prefix, name, { ...opts, allowShared: false });
       }
-      if (types2.isDataView(V)) {
+      if (types3.isDataView(V)) {
         return webidl.converters.DataView(V, prefix, name, { ...opts, allowShared: false });
       }
       throw webidl.errors.conversionFailed({
@@ -4285,7 +4285,7 @@ var require_webidl = __commonJS({
 var require_util2 = __commonJS({
   "node_modules/undici/lib/web/fetch/util.js"(exports2, module2) {
     "use strict";
-    var { Transform } = require("node:stream");
+    var { Transform: Transform5 } = require("node:stream");
     var zlib3 = require("node:zlib");
     var { redirectStatusSet, referrerPolicySet: referrerPolicyTokens, badPortsSet } = require_constants3();
     var { getGlobalOrigin } = require_global();
@@ -4681,8 +4681,8 @@ var require_util2 = __commonJS({
     function createDeferredPromise() {
       let res;
       let rej;
-      const promise = new Promise((resolve13, reject) => {
-        res = resolve13;
+      const promise = new Promise((resolve14, reject) => {
+        res = resolve14;
         rej = reject;
       });
       return { promise, resolve: res, reject: rej };
@@ -4729,17 +4729,17 @@ var require_util2 = __commonJS({
               `'next' called on an object that does not implement interface ${name} Iterator.`
             );
           }
-          const index = this.#index;
+          const index2 = this.#index;
           const values = this.#target[kInternalIterator];
           const len = values.length;
-          if (index >= len) {
+          if (index2 >= len) {
             return {
               value: void 0,
               done: true
             };
           }
-          const { [keyIndex]: key, [valueIndex]: value } = values[index];
-          this.#index = index + 1;
+          const { [keyIndex]: key, [valueIndex]: value } = values[index2];
+          this.#index = index2 + 1;
           let result;
           switch (this.#kind) {
             case "key":
@@ -4973,7 +4973,7 @@ var require_util2 = __commonJS({
       contentRange += isomorphicEncode(`${fullLength}`);
       return contentRange;
     }
-    var InflateStream = class extends Transform {
+    var InflateStream = class extends Transform5 {
       #zlibOptions;
       /** @param {zlib.ZlibOptions} [zlibOptions] */
       constructor(zlibOptions) {
@@ -5630,7 +5630,7 @@ var require_formdata_parser = __commonJS({
 var require_body = __commonJS({
   "node_modules/undici/lib/web/fetch/body.js"(exports2, module2) {
     "use strict";
-    var util = require_util();
+    var util3 = require_util();
     var {
       ReadableStreamFrom,
       isBlobLike,
@@ -5705,11 +5705,11 @@ var require_body = __commonJS({
         source = new Uint8Array(object.slice());
       } else if (ArrayBuffer.isView(object)) {
         source = new Uint8Array(object.buffer.slice(object.byteOffset, object.byteOffset + object.byteLength));
-      } else if (util.isFormDataLike(object)) {
+      } else if (util3.isFormDataLike(object)) {
         const boundary = `----formdata-undici-0${`${random(1e11)}`.padStart(11, "0")}`;
         const prefix = `--${boundary}\r
 Content-Disposition: form-data`;
-        const escape2 = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
+        const escape3 = (str) => str.replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
         const normalizeLinefeeds = (value) => value.replace(/\r?\n|\r/g, "\r\n");
         const blobParts = [];
         const rn = new Uint8Array([13, 10]);
@@ -5717,14 +5717,14 @@ Content-Disposition: form-data`;
         let hasUnknownSizeValue = false;
         for (const [name, value] of object) {
           if (typeof value === "string") {
-            const chunk2 = textEncoder.encode(prefix + `; name="${escape2(normalizeLinefeeds(name))}"\r
+            const chunk2 = textEncoder.encode(prefix + `; name="${escape3(normalizeLinefeeds(name))}"\r
 \r
 ${normalizeLinefeeds(value)}\r
 `);
             blobParts.push(chunk2);
             length += chunk2.byteLength;
           } else {
-            const chunk2 = textEncoder.encode(`${prefix}; name="${escape2(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape2(value.name)}"` : "") + `\r
+            const chunk2 = textEncoder.encode(`${prefix}; name="${escape3(normalizeLinefeeds(name))}"` + (value.name ? `; filename="${escape3(value.name)}"` : "") + `\r
 Content-Type: ${value.type || "application/octet-stream"}\r
 \r
 `);
@@ -5764,14 +5764,14 @@ Content-Type: ${value.type || "application/octet-stream"}\r
         if (keepalive) {
           throw new TypeError("keepalive");
         }
-        if (util.isDisturbed(object) || object.locked) {
+        if (util3.isDisturbed(object) || object.locked) {
           throw new TypeError(
             "Response body object should not be disturbed or locked"
           );
         }
         stream2 = object instanceof ReadableStream ? object : ReadableStreamFrom(object);
       }
-      if (typeof source === "string" || util.isBuffer(source)) {
+      if (typeof source === "string" || util3.isBuffer(source)) {
         length = Buffer.byteLength(source);
       }
       if (action != null) {
@@ -5808,7 +5808,7 @@ Content-Type: ${value.type || "application/octet-stream"}\r
     }
     function safelyExtractBody(object, keepalive = false) {
       if (object instanceof ReadableStream) {
-        assert(!util.isDisturbed(object), "The body has already been consumed.");
+        assert(!util3.isDisturbed(object), "The body has already been consumed.");
         assert(!object.locked, "The stream is locked.");
       }
       return extractBody(object, keepalive);
@@ -5915,7 +5915,7 @@ Content-Type: ${value.type || "application/octet-stream"}\r
     }
     function bodyUnusable(object) {
       const body = object[kState].body;
-      return body != null && (body.stream.locked || util.isDisturbed(body.stream));
+      return body != null && (body.stream.locked || util3.isDisturbed(body.stream));
     }
     function parseJSONFromBytes(bytes) {
       return JSON.parse(utf8DecodeBytes(bytes));
@@ -5945,7 +5945,7 @@ var require_client_h1 = __commonJS({
   "node_modules/undici/lib/dispatcher/client-h1.js"(exports2, module2) {
     "use strict";
     var assert = require("node:assert");
-    var util = require_util();
+    var util3 = require_util();
     var { channels } = require_diagnostics();
     var timers = require_timers();
     var {
@@ -5996,8 +5996,8 @@ var require_client_h1 = __commonJS({
     var constants = require_constants2();
     var EMPTY_BUF = Buffer.alloc(0);
     var FastBuffer = Buffer[Symbol.species];
-    var addListener = util.addListener;
-    var removeAllListeners = util.removeAllListeners;
+    var addListener = util3.addListener;
+    var removeAllListeners = util3.removeAllListeners;
     var extractBody;
     async function lazyllhttp() {
       const llhttpWasmData = process.env.JEST_WORKER_ID ? require_llhttp_wasm() : void 0;
@@ -6175,7 +6175,7 @@ var require_client_h1 = __commonJS({
             throw new HTTPParserError(message, constants.ERROR[ret], data.slice(offset));
           }
         } catch (err) {
-          util.destroy(socket, err);
+          util3.destroy(socket, err);
         }
       }
       destroy() {
@@ -6222,13 +6222,13 @@ var require_client_h1 = __commonJS({
         }
         const key = this.headers[len - 2];
         if (key.length === 10) {
-          const headerName = util.bufferToLowerCasedHeaderName(key);
+          const headerName = util3.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") {
+        } else if (key.length === 14 && util3.bufferToLowerCasedHeaderName(key) === "content-length") {
           this.contentLength += buf.toString();
         }
         this.trackHeader(buf.length);
@@ -6236,7 +6236,7 @@ var require_client_h1 = __commonJS({
       trackHeader(len) {
         this.headersSize += len;
         if (this.headersSize >= this.headersMaxSize) {
-          util.destroy(this.socket, new HeadersOverflowError());
+          util3.destroy(this.socket, new HeadersOverflowError());
         }
       }
       onUpgrade(head) {
@@ -6267,7 +6267,7 @@ var require_client_h1 = __commonJS({
         try {
           request3.onUpgrade(statusCode, headers, socket);
         } catch (err) {
-          util.destroy(socket, err);
+          util3.destroy(socket, err);
         }
         client[kResume]();
       }
@@ -6283,11 +6283,11 @@ var require_client_h1 = __commonJS({
         assert(!this.upgrade);
         assert(this.statusCode < 200);
         if (statusCode === 100) {
-          util.destroy(socket, new SocketError("bad response", util.getSocketInfo(socket)));
+          util3.destroy(socket, new SocketError("bad response", util3.getSocketInfo(socket)));
           return -1;
         }
         if (upgrade && !request3.upgrade) {
-          util.destroy(socket, new SocketError("bad upgrade", util.getSocketInfo(socket)));
+          util3.destroy(socket, new SocketError("bad upgrade", util3.getSocketInfo(socket)));
           return -1;
         }
         assert(this.timeoutType === TIMEOUT_HEADERS);
@@ -6316,7 +6316,7 @@ var require_client_h1 = __commonJS({
         this.headers = [];
         this.headersSize = 0;
         if (this.shouldKeepAlive && client[kPipelining]) {
-          const keepAliveTimeout = this.keepAlive ? util.parseKeepAliveTimeout(this.keepAlive) : null;
+          const keepAliveTimeout = this.keepAlive ? util3.parseKeepAliveTimeout(this.keepAlive) : null;
           if (keepAliveTimeout != null) {
             const timeout = Math.min(
               keepAliveTimeout - client[kKeepAliveTimeoutThreshold],
@@ -6364,7 +6364,7 @@ var require_client_h1 = __commonJS({
         }
         assert(statusCode >= 200);
         if (maxResponseSize > -1 && this.bytesRead + buf.length > maxResponseSize) {
-          util.destroy(socket, new ResponseExceededMaxSizeError());
+          util3.destroy(socket, new ResponseExceededMaxSizeError());
           return -1;
         }
         this.bytesRead += buf.length;
@@ -6396,20 +6396,20 @@ var require_client_h1 = __commonJS({
           return;
         }
         if (request3.method !== "HEAD" && contentLength && bytesRead !== parseInt(contentLength, 10)) {
-          util.destroy(socket, new ResponseContentLengthMismatchError());
+          util3.destroy(socket, new ResponseContentLengthMismatchError());
           return -1;
         }
         request3.onComplete(headers);
         client[kQueue][client[kRunningIdx]++] = null;
         if (socket[kWriting]) {
           assert(client[kRunning] === 0);
-          util.destroy(socket, new InformationalError("reset"));
+          util3.destroy(socket, new InformationalError("reset"));
           return constants.ERROR.PAUSED;
         } else if (!shouldKeepAlive) {
-          util.destroy(socket, new InformationalError("reset"));
+          util3.destroy(socket, new InformationalError("reset"));
           return constants.ERROR.PAUSED;
         } else if (socket[kReset] && client[kRunning] === 0) {
-          util.destroy(socket, new InformationalError("reset"));
+          util3.destroy(socket, new InformationalError("reset"));
           return constants.ERROR.PAUSED;
         } else if (client[kPipelining] == null || client[kPipelining] === 1) {
           setImmediate(() => client[kResume]());
@@ -6423,15 +6423,15 @@ var require_client_h1 = __commonJS({
       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());
+          util3.destroy(socket, new HeadersTimeoutError());
         }
       } else if (timeoutType === TIMEOUT_BODY) {
         if (!paused) {
-          util.destroy(socket, new BodyTimeoutError());
+          util3.destroy(socket, new BodyTimeoutError());
         }
       } else if (timeoutType === TIMEOUT_KEEP_ALIVE) {
         assert(client[kRunning] === 0 && client[kKeepAliveTimeoutValue]);
-        util.destroy(socket, new InformationalError("socket idle timeout"));
+        util3.destroy(socket, new InformationalError("socket idle timeout"));
       }
     }
     async function connectH1(client, socket) {
@@ -6467,7 +6467,7 @@ var require_client_h1 = __commonJS({
           parser.onMessageComplete();
           return;
         }
-        util.destroy(this, new SocketError("other side closed", util.getSocketInfo(this)));
+        util3.destroy(this, new SocketError("other side closed", util3.getSocketInfo(this)));
       });
       addListener(socket, "close", function() {
         const client2 = this[kClient];
@@ -6479,7 +6479,7 @@ var require_client_h1 = __commonJS({
           this[kParser].destroy();
           this[kParser] = null;
         }
-        const err = this[kError] || new SocketError("closed", util.getSocketInfo(this));
+        const err = this[kError] || new SocketError("closed", util3.getSocketInfo(this));
         client2[kSocket] = null;
         client2[kHTTPContext] = null;
         if (client2.destroyed) {
@@ -6487,12 +6487,12 @@ var require_client_h1 = __commonJS({
           const requests = client2[kQueue].splice(client2[kRunningIdx]);
           for (let i = 0; i < requests.length; i++) {
             const request3 = requests[i];
-            util.errorRequest(client2, request3, err);
+            util3.errorRequest(client2, request3, err);
           }
         } else if (client2[kRunning] > 0 && err.code !== "UND_ERR_INFO") {
           const request3 = client2[kQueue][client2[kRunningIdx]];
           client2[kQueue][client2[kRunningIdx]++] = null;
-          util.errorRequest(client2, request3, err);
+          util3.errorRequest(client2, request3, err);
         }
         client2[kPendingIdx] = client2[kRunningIdx];
         assert(client2[kRunning] === 0);
@@ -6533,7 +6533,7 @@ var require_client_h1 = __commonJS({
             if (client[kRunning] > 0 && (request3.upgrade || request3.method === "CONNECT")) {
               return true;
             }
-            if (client[kRunning] > 0 && util.bodyLength(request3.body) !== 0 && (util.isStream(request3.body) || util.isAsyncIterable(request3.body) || util.isFormDataLike(request3.body))) {
+            if (client[kRunning] > 0 && util3.bodyLength(request3.body) !== 0 && (util3.isStream(request3.body) || util3.isAsyncIterable(request3.body) || util3.isFormDataLike(request3.body))) {
               return true;
             }
           }
@@ -6570,10 +6570,10 @@ var require_client_h1 = __commonJS({
       return method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE" && method !== "CONNECT";
     }
     function writeH1(client, request3) {
-      const { method, path: path28, host, upgrade, blocking, reset } = request3;
+      const { method, path: path29, host, upgrade, blocking, reset } = request3;
       let { body, headers, contentLength } = request3;
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH" || method === "QUERY" || method === "PROPFIND" || method === "PROPPATCH";
-      if (util.isFormDataLike(body)) {
+      if (util3.isFormDataLike(body)) {
         if (!extractBody) {
           extractBody = require_body().extractBody;
         }
@@ -6583,13 +6583,13 @@ var require_client_h1 = __commonJS({
         }
         body = bodyStream.stream;
         contentLength = bodyStream.length;
-      } else if (util.isBlobLike(body) && request3.contentType == null && body.type) {
+      } else if (util3.isBlobLike(body) && request3.contentType == null && body.type) {
         headers.push("content-type", body.type);
       }
       if (body && typeof body.read === "function") {
         body.read(0);
       }
-      const bodyLength = util.bodyLength(body);
+      const bodyLength = util3.bodyLength(body);
       contentLength = bodyLength ?? contentLength;
       if (contentLength === null) {
         contentLength = request3.contentLength;
@@ -6599,7 +6599,7 @@ var require_client_h1 = __commonJS({
       }
       if (shouldSendContentLength(method) && contentLength > 0 && request3.contentLength !== null && request3.contentLength !== contentLength) {
         if (client[kStrictContentLength]) {
-          util.errorRequest(client, request3, new RequestContentLengthMismatchError());
+          util3.errorRequest(client, request3, new RequestContentLengthMismatchError());
           return false;
         }
         process.emitWarning(new RequestContentLengthMismatchError());
@@ -6609,14 +6609,14 @@ var require_client_h1 = __commonJS({
         if (request3.aborted || request3.completed) {
           return;
         }
-        util.errorRequest(client, request3, err || new RequestAbortedError());
-        util.destroy(body);
-        util.destroy(socket, new InformationalError("aborted"));
+        util3.errorRequest(client, request3, err || new RequestAbortedError());
+        util3.destroy(body);
+        util3.destroy(socket, new InformationalError("aborted"));
       };
       try {
         request3.onConnect(abort);
       } catch (err) {
-        util.errorRequest(client, request3, err);
+        util3.errorRequest(client, request3, err);
       }
       if (request3.aborted) {
         return false;
@@ -6636,7 +6636,7 @@ var require_client_h1 = __commonJS({
       if (blocking) {
         socket[kBlocking] = true;
       }
-      let header = `${method} ${path28} HTTP/1.1\r
+      let header = `${method} ${path29} HTTP/1.1\r
 `;
       if (typeof host === "string") {
         header += `host: ${host}\r
@@ -6673,17 +6673,17 @@ upgrade: ${upgrade}\r
       }
       if (!body || bodyLength === 0) {
         writeBuffer(abort, null, client, request3, socket, contentLength, header, expectsPayload);
-      } else if (util.isBuffer(body)) {
+      } else if (util3.isBuffer(body)) {
         writeBuffer(abort, body, client, request3, socket, contentLength, header, expectsPayload);
-      } else if (util.isBlobLike(body)) {
+      } else if (util3.isBlobLike(body)) {
         if (typeof body.stream === "function") {
           writeIterable(abort, body.stream(), client, request3, socket, contentLength, header, expectsPayload);
         } else {
           writeBlob(abort, body, client, request3, socket, contentLength, header, expectsPayload);
         }
-      } else if (util.isStream(body)) {
+      } else if (util3.isStream(body)) {
         writeStream(abort, body, client, request3, socket, contentLength, header, expectsPayload);
-      } else if (util.isIterable(body)) {
+      } else if (util3.isIterable(body)) {
         writeIterable(abort, body, client, request3, socket, contentLength, header, expectsPayload);
       } else {
         assert(false);
@@ -6703,7 +6703,7 @@ upgrade: ${upgrade}\r
             this.pause();
           }
         } catch (err) {
-          util.destroy(this, err);
+          util3.destroy(this, err);
         }
       };
       const onDrain = function() {
@@ -6740,9 +6740,9 @@ upgrade: ${upgrade}\r
         }
         writer.destroy(err);
         if (err && (err.code !== "UND_ERR_INFO" || err.message !== "reset")) {
-          util.destroy(body, err);
+          util3.destroy(body, err);
         } else {
-          util.destroy(body);
+          util3.destroy(body);
         }
       };
       body.on("data", onData).on("end", onFinished).on("error", onFinished).on("close", onClose);
@@ -6771,7 +6771,7 @@ upgrade: ${upgrade}\r
             socket.write(`${header}\r
 `, "latin1");
           }
-        } else if (util.isBuffer(body)) {
+        } else if (util3.isBuffer(body)) {
           assert(contentLength === body.byteLength, "buffer body must have content length");
           socket.cork();
           socket.write(`${header}content-length: ${contentLength}\r
@@ -6823,12 +6823,12 @@ upgrade: ${upgrade}\r
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve13, reject) => {
+      const waitForDrain = () => new Promise((resolve14, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve13;
+          callback = resolve14;
         }
       });
       socket.on("close", onDrain).on("drain", onDrain);
@@ -6966,7 +6966,7 @@ var require_client_h2 = __commonJS({
     "use strict";
     var assert = require("node:assert");
     var { pipeline } = require("node:stream");
-    var util = require_util();
+    var util3 = require_util();
     var {
       RequestContentLengthMismatchError,
       RequestAbortedError,
@@ -7040,37 +7040,37 @@ var require_client_h2 = __commonJS({
       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() {
+      util3.addListener(session, "error", onHttp2SessionError);
+      util3.addListener(session, "frameError", onHttp2FrameError);
+      util3.addListener(session, "end", onHttp2SessionEnd);
+      util3.addListener(session, "goaway", onHTTP2GoAway);
+      util3.addListener(session, "close", function() {
         const { [kClient]: client2 } = this;
         const { [kSocket]: socket2 } = client2;
-        const err = this[kSocket][kError] || this[kError] || new SocketError("closed", util.getSocketInfo(socket2));
+        const err = this[kSocket][kError] || this[kError] || new SocketError("closed", util3.getSocketInfo(socket2));
         client2[kHTTP2Session] = null;
         if (client2.destroyed) {
           assert(client2[kPending] === 0);
           const requests = client2[kQueue].splice(client2[kRunningIdx]);
           for (let i = 0; i < requests.length; i++) {
             const request3 = requests[i];
-            util.errorRequest(client2, request3, err);
+            util3.errorRequest(client2, request3, err);
           }
         }
       });
       session.unref();
       client[kHTTP2Session] = session;
       socket[kHTTP2Session] = session;
-      util.addListener(socket, "error", function(err) {
+      util3.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)));
+      util3.addListener(socket, "end", function() {
+        util3.destroy(this, new SocketError("other side closed", util3.getSocketInfo(this)));
       });
-      util.addListener(socket, "close", function() {
-        const err = this[kError] || new SocketError("closed", util.getSocketInfo(this));
+      util3.addListener(socket, "close", function() {
+        const err = this[kError] || new SocketError("closed", util3.getSocketInfo(this));
         client[kSocket] = null;
         if (this[kHTTP2Session] != null) {
           this[kHTTP2Session].destroy(err);
@@ -7133,12 +7133,12 @@ var require_client_h2 = __commonJS({
       }
     }
     function onHttp2SessionEnd() {
-      const err = new SocketError("other side closed", util.getSocketInfo(this[kSocket]));
+      const err = new SocketError("other side closed", util3.getSocketInfo(this[kSocket]));
       this.destroy(err);
-      util.destroy(this[kSocket], err);
+      util3.destroy(this[kSocket], err);
     }
     function onHTTP2GoAway(code) {
-      const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${code}`, util.getSocketInfo(this));
+      const err = this[kError] || new SocketError(`HTTP/2: "GOAWAY" frame received with code ${code}`, util3.getSocketInfo(this));
       const client = this[kClient];
       client[kSocket] = null;
       client[kHTTPContext] = null;
@@ -7146,11 +7146,11 @@ var require_client_h2 = __commonJS({
         this[kHTTP2Session].destroy(err);
         this[kHTTP2Session] = null;
       }
-      util.destroy(this[kSocket], err);
+      util3.destroy(this[kSocket], err);
       if (client[kRunningIdx] < client[kQueue].length) {
         const request3 = client[kQueue][client[kRunningIdx]];
         client[kQueue][client[kRunningIdx]++] = null;
-        util.errorRequest(client, request3, err);
+        util3.errorRequest(client, request3, err);
         client[kPendingIdx] = client[kRunningIdx];
       }
       assert(client[kRunning] === 0);
@@ -7162,10 +7162,10 @@ var require_client_h2 = __commonJS({
     }
     function writeH2(client, request3) {
       const session = client[kHTTP2Session];
-      const { method, path: path28, host, upgrade, expectContinue, signal, headers: reqHeaders } = request3;
+      const { method, path: path29, host, upgrade, expectContinue, signal, headers: reqHeaders } = request3;
       let { body } = request3;
       if (upgrade) {
-        util.errorRequest(client, request3, new Error("Upgrade not supported for H2"));
+        util3.errorRequest(client, request3, new Error("Upgrade not supported for H2"));
         return false;
       }
       const headers = {};
@@ -7193,18 +7193,18 @@ var require_client_h2 = __commonJS({
           return;
         }
         err = err || new RequestAbortedError();
-        util.errorRequest(client, request3, err);
+        util3.errorRequest(client, request3, err);
         if (stream2 != null) {
-          util.destroy(stream2, err);
+          util3.destroy(stream2, err);
         }
-        util.destroy(body, err);
+        util3.destroy(body, err);
         client[kQueue][client[kRunningIdx]++] = null;
         client[kResume]();
       };
       try {
         request3.onConnect(abort);
       } catch (err) {
-        util.errorRequest(client, request3, err);
+        util3.errorRequest(client, request3, err);
       }
       if (request3.aborted) {
         return false;
@@ -7229,14 +7229,14 @@ var require_client_h2 = __commonJS({
         });
         return true;
       }
-      headers[HTTP2_HEADER_PATH] = path28;
+      headers[HTTP2_HEADER_PATH] = path29;
       headers[HTTP2_HEADER_SCHEME] = "https";
       const expectsPayload = method === "PUT" || method === "POST" || method === "PATCH";
       if (body && typeof body.read === "function") {
         body.read(0);
       }
-      let contentLength = util.bodyLength(body);
-      if (util.isFormDataLike(body)) {
+      let contentLength = util3.bodyLength(body);
+      if (util3.isFormDataLike(body)) {
         extractBody ??= require_body().extractBody;
         const [bodyStream, contentType] = extractBody(body);
         headers["content-type"] = contentType;
@@ -7251,7 +7251,7 @@ var require_client_h2 = __commonJS({
       }
       if (shouldSendContentLength(method) && contentLength > 0 && request3.contentLength != null && request3.contentLength !== contentLength) {
         if (client[kStrictContentLength]) {
-          util.errorRequest(client, request3, new RequestContentLengthMismatchError());
+          util3.errorRequest(client, request3, new RequestContentLengthMismatchError());
           return false;
         }
         process.emitWarning(new RequestContentLengthMismatchError());
@@ -7279,8 +7279,8 @@ var require_client_h2 = __commonJS({
         request3.onResponseStarted();
         if (request3.aborted) {
           const err = new RequestAbortedError();
-          util.errorRequest(client, request3, err);
-          util.destroy(stream2, err);
+          util3.errorRequest(client, request3, err);
+          util3.destroy(stream2, err);
           return;
         }
         if (request3.onHeaders(Number(statusCode), parseH2Headers(realHeaders), stream2.resume.bind(stream2), "") === false) {
@@ -7329,7 +7329,7 @@ var require_client_h2 = __commonJS({
             contentLength,
             expectsPayload
           );
-        } else if (util.isBuffer(body)) {
+        } else if (util3.isBuffer(body)) {
           writeBuffer(
             abort,
             stream2,
@@ -7340,7 +7340,7 @@ var require_client_h2 = __commonJS({
             contentLength,
             expectsPayload
           );
-        } else if (util.isBlobLike(body)) {
+        } else if (util3.isBlobLike(body)) {
           if (typeof body.stream === "function") {
             writeIterable(
               abort,
@@ -7364,7 +7364,7 @@ var require_client_h2 = __commonJS({
               expectsPayload
             );
           }
-        } else if (util.isStream(body)) {
+        } else if (util3.isStream(body)) {
           writeStream(
             abort,
             client[kSocket],
@@ -7375,7 +7375,7 @@ var require_client_h2 = __commonJS({
             request3,
             contentLength
           );
-        } else if (util.isIterable(body)) {
+        } else if (util3.isIterable(body)) {
           writeIterable(
             abort,
             stream2,
@@ -7393,7 +7393,7 @@ var require_client_h2 = __commonJS({
     }
     function writeBuffer(abort, h2stream, body, client, request3, socket, contentLength, expectsPayload) {
       try {
-        if (body != null && util.isBuffer(body)) {
+        if (body != null && util3.isBuffer(body)) {
           assert(contentLength === body.byteLength, "buffer body must have content length");
           h2stream.cork();
           h2stream.write(body);
@@ -7417,10 +7417,10 @@ var require_client_h2 = __commonJS({
         h2stream,
         (err) => {
           if (err) {
-            util.destroy(pipe, err);
+            util3.destroy(pipe, err);
             abort(err);
           } else {
-            util.removeAllListeners(pipe);
+            util3.removeAllListeners(pipe);
             request3.onRequestSent();
             if (!expectsPayload) {
               socket[kReset] = true;
@@ -7429,7 +7429,7 @@ var require_client_h2 = __commonJS({
           }
         }
       );
-      util.addListener(pipe, "data", onPipeData);
+      util3.addListener(pipe, "data", onPipeData);
       function onPipeData(chunk) {
         request3.onBodySent(chunk);
       }
@@ -7465,12 +7465,12 @@ var require_client_h2 = __commonJS({
           cb();
         }
       }
-      const waitForDrain = () => new Promise((resolve13, reject) => {
+      const waitForDrain = () => new Promise((resolve14, reject) => {
         assert(callback === null);
         if (socket[kError]) {
           reject(socket[kError]);
         } else {
-          callback = resolve13;
+          callback = resolve14;
         }
       });
       h2stream.on("close", onDrain).on("drain", onDrain);
@@ -7505,7 +7505,7 @@ var require_client_h2 = __commonJS({
 var require_redirect_handler = __commonJS({
   "node_modules/undici/lib/handler/redirect-handler.js"(exports2, module2) {
     "use strict";
-    var util = require_util();
+    var util3 = require_util();
     var { kBodyUsed } = require_symbols();
     var assert = require("node:assert");
     var { InvalidArgumentError } = require_errors();
@@ -7528,7 +7528,7 @@ var require_redirect_handler = __commonJS({
         if (maxRedirections != null && (!Number.isInteger(maxRedirections) || maxRedirections < 0)) {
           throw new InvalidArgumentError("maxRedirections must be a positive number");
         }
-        util.validateHandler(handler2, opts.method, opts.upgrade);
+        util3.validateHandler(handler2, opts.method, opts.upgrade);
         this.dispatch = dispatch;
         this.location = null;
         this.abort = null;
@@ -7537,8 +7537,8 @@ var require_redirect_handler = __commonJS({
         this.handler = handler2;
         this.history = [];
         this.redirectionLimitReached = false;
-        if (util.isStream(this.opts.body)) {
-          if (util.bodyLength(this.opts.body) === 0) {
+        if (util3.isStream(this.opts.body)) {
+          if (util3.bodyLength(this.opts.body) === 0) {
             this.opts.body.on("data", function() {
               assert(false);
             });
@@ -7551,7 +7551,7 @@ var require_redirect_handler = __commonJS({
           }
         } else if (this.opts.body && typeof this.opts.body.pipeTo === "function") {
           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)) {
+        } else if (this.opts.body && typeof this.opts.body !== "string" && !ArrayBuffer.isView(this.opts.body) && util3.isIterable(this.opts.body)) {
           this.opts.body = new BodyAsyncIterable(this.opts.body);
         }
       }
@@ -7566,7 +7566,7 @@ var require_redirect_handler = __commonJS({
         this.handler.onError(error3);
       }
       onHeaders(statusCode, headers, resume, statusText) {
-        this.location = this.history.length >= this.maxRedirections || util.isDisturbed(this.opts.body) ? null : parseLocation(statusCode, headers);
+        this.location = this.history.length >= this.maxRedirections || util3.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"));
@@ -7581,10 +7581,10 @@ var require_redirect_handler = __commonJS({
         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 path28 = search ? `${pathname}${search}` : pathname;
+        const { origin, pathname, search } = util3.parseURL(new URL(this.location, this.opts.origin && new URL(this.opts.path, this.opts.origin)));
+        const path29 = search ? `${pathname}${search}` : pathname;
         this.opts.headers = cleanRequestHeaders(this.opts.headers, statusCode === 303, this.opts.origin !== origin);
-        this.opts.path = path28;
+        this.opts.path = path29;
         this.opts.origin = origin;
         this.opts.maxRedirections = 0;
         this.opts.query = null;
@@ -7619,20 +7619,20 @@ var require_redirect_handler = __commonJS({
         return null;
       }
       for (let i = 0; i < headers.length; i += 2) {
-        if (headers[i].length === 8 && util.headerNameToString(headers[i]) === "location") {
+        if (headers[i].length === 8 && util3.headerNameToString(headers[i]) === "location") {
           return headers[i + 1];
         }
       }
     }
     function shouldRemoveHeader(header, removeContent, unknownOrigin) {
       if (header.length === 4) {
-        return util.headerNameToString(header) === "host";
+        return util3.headerNameToString(header) === "host";
       }
-      if (removeContent && util.headerNameToString(header).startsWith("content-")) {
+      if (removeContent && util3.headerNameToString(header).startsWith("content-")) {
         return true;
       }
       if (unknownOrigin && (header.length === 13 || header.length === 6 || header.length === 19)) {
-        const name = util.headerNameToString(header);
+        const name = util3.headerNameToString(header);
         return name === "authorization" || name === "cookie" || name === "proxy-authorization";
       }
       return false;
@@ -7689,7 +7689,7 @@ var require_client = __commonJS({
     var assert = require("node:assert");
     var net = require("node:net");
     var http = require("node:http");
-    var util = require_util();
+    var util3 = require_util();
     var { channels } = require_diagnostics();
     var Request = require_request();
     var DispatcherBase = require_dispatcher_base();
@@ -7872,7 +7872,7 @@ var require_client = __commonJS({
         } else {
           this[kInterceptors] = [createRedirectInterceptor({ maxRedirections })];
         }
-        this[kUrl] = util.parseOrigin(url2);
+        this[kUrl] = util3.parseOrigin(url2);
         this[kConnector] = connect2;
         this[kPipelining] = pipelining != null ? pipelining : 1;
         this[kMaxHeadersSize] = maxHeaderSize || http.maxHeaderSize;
@@ -7935,7 +7935,7 @@ var require_client = __commonJS({
         const request3 = new Request(origin, opts, handler2);
         this[kQueue].push(request3);
         if (this[kResuming]) {
-        } else if (util.bodyLength(request3.body) == null && util.isIterable(request3.body)) {
+        } else if (util3.bodyLength(request3.body) == null && util3.isIterable(request3.body)) {
           this[kResuming] = 1;
           queueMicrotask(() => resume(this));
         } else {
@@ -7947,27 +7947,27 @@ var require_client = __commonJS({
         return this[kNeedDrain] < 2;
       }
       async [kClose]() {
-        return new Promise((resolve13) => {
+        return new Promise((resolve14) => {
           if (this[kSize]) {
-            this[kClosedResolve] = resolve13;
+            this[kClosedResolve] = resolve14;
           } else {
-            resolve13(null);
+            resolve14(null);
           }
         });
       }
       async [kDestroy](err) {
-        return new Promise((resolve13) => {
+        return new Promise((resolve14) => {
           const requests = this[kQueue].splice(this[kPendingIdx]);
           for (let i = 0; i < requests.length; i++) {
             const request3 = requests[i];
-            util.errorRequest(this, request3, err);
+            util3.errorRequest(this, request3, err);
           }
           const callback = () => {
             if (this[kClosedResolve]) {
               this[kClosedResolve]();
               this[kClosedResolve] = null;
             }
-            resolve13(null);
+            resolve14(null);
           };
           if (this[kHTTPContext]) {
             this[kHTTPContext].destroy(err, callback);
@@ -7986,7 +7986,7 @@ var require_client = __commonJS({
         const requests = client[kQueue].splice(client[kRunningIdx]);
         for (let i = 0; i < requests.length; i++) {
           const request3 = requests[i];
-          util.errorRequest(client, request3, err);
+          util3.errorRequest(client, request3, err);
         }
         assert(client[kSize] === 0);
       }
@@ -8018,7 +8018,7 @@ var require_client = __commonJS({
         });
       }
       try {
-        const socket = await new Promise((resolve13, reject) => {
+        const socket = await new Promise((resolve14, reject) => {
           client[kConnector]({
             host,
             hostname,
@@ -8030,12 +8030,12 @@ var require_client = __commonJS({
             if (err) {
               reject(err);
             } else {
-              resolve13(socket2);
+              resolve14(socket2);
             }
           });
         });
         if (client.destroyed) {
-          util.destroy(socket.on("error", noop3), new ClientDestroyedError());
+          util3.destroy(socket.on("error", noop3), new ClientDestroyedError());
           return;
         }
         assert(socket);
@@ -8090,7 +8090,7 @@ var require_client = __commonJS({
           assert(client[kRunning] === 0);
           while (client[kPending] > 0 && client[kQueue][client[kPendingIdx]].servername === client[kServerName]) {
             const request3 = client[kQueue][client[kPendingIdx]++];
-            util.errorRequest(client, request3, err);
+            util3.errorRequest(client, request3, err);
           }
         } else {
           onError(client, err);
@@ -8299,10 +8299,10 @@ var require_pool_base = __commonJS({
         this[kQueued] = 0;
         const pool = this;
         this[kOnDrain] = function onDrain(origin, targets) {
-          const queue = pool[kQueue];
+          const queue2 = pool[kQueue];
           let needDrain = false;
           while (!needDrain) {
-            const item = queue.shift();
+            const item = queue2.shift();
             if (!item) {
               break;
             }
@@ -8314,7 +8314,7 @@ var require_pool_base = __commonJS({
             pool[kNeedDrain] = false;
             pool.emit("drain", origin, [pool, ...targets]);
           }
-          if (pool[kClosedResolve] && queue.isEmpty()) {
+          if (pool[kClosedResolve] && queue2.isEmpty()) {
             Promise.all(pool[kClients].map((c) => c.close())).then(pool[kClosedResolve]);
           }
         };
@@ -8366,8 +8366,8 @@ var require_pool_base = __commonJS({
         if (this[kQueue].isEmpty()) {
           await Promise.all(this[kClients].map((c) => c.close()));
         } else {
-          await new Promise((resolve13) => {
-            this[kClosedResolve] = resolve13;
+          await new Promise((resolve14) => {
+            this[kClosedResolve] = resolve14;
           });
         }
       }
@@ -8441,7 +8441,7 @@ var require_pool = __commonJS({
     var {
       InvalidArgumentError
     } = require_errors();
-    var util = require_util();
+    var util3 = require_util();
     var { kUrl, kInterceptors } = require_symbols();
     var buildConnector = require_connect();
     var kOptions = /* @__PURE__ */ Symbol("options");
@@ -8487,8 +8487,8 @@ var require_pool = __commonJS({
         }
         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[kUrl] = util3.parseOrigin(origin);
+        this[kOptions] = { ...util3.deepClone(options), connect, allowH2 };
         this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
         this[kFactory] = factory;
         this.on("connectionError", (origin2, targets, error3) => {
@@ -8670,7 +8670,7 @@ var require_agent = __commonJS({
     var DispatcherBase = require_dispatcher_base();
     var Pool = require_pool();
     var Client = require_client();
-    var util = require_util();
+    var util3 = require_util();
     var createRedirectInterceptor = require_redirect_interceptor();
     var kOnConnect = /* @__PURE__ */ Symbol("onConnect");
     var kOnDisconnect = /* @__PURE__ */ Symbol("onDisconnect");
@@ -8698,7 +8698,7 @@ var require_agent = __commonJS({
           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] = { ...util3.deepClone(options), connect };
         this[kOptions].interceptors = options.interceptors ? { ...options.interceptors } : void 0;
         this[kMaxRedirections] = maxRedirections;
         this[kFactory] = factory;
@@ -8818,10 +8818,10 @@ var require_proxy_agent = __commonJS({
         };
         const {
           origin,
-          path: path28 = "/",
+          path: path29 = "/",
           headers = {}
         } = opts;
-        opts.path = origin + path28;
+        opts.path = origin + path29;
         if (!("host" in headers) && !("Host" in headers)) {
           const { host } = new URL2(origin);
           headers.host = host;
@@ -9314,8 +9314,8 @@ var require_retry_handler = __commonJS({
         }
         if (this.end == null) {
           if (statusCode === 206) {
-            const range = parseRangeHeader(headers["content-range"]);
-            if (range == null) {
+            const range2 = parseRangeHeader(headers["content-range"]);
+            if (range2 == null) {
               return this.handler.onHeaders(
                 statusCode,
                 rawHeaders,
@@ -9323,7 +9323,7 @@ var require_retry_handler = __commonJS({
                 statusMessage
               );
             }
-            const { start, size, end = size - 1 } = range;
+            const { start, size, end = size - 1 } = range2;
             assert(
               start != null && Number.isFinite(start),
               "content-range mismatch"
@@ -9455,9 +9455,9 @@ var require_readable = __commonJS({
   "node_modules/undici/lib/api/readable.js"(exports2, module2) {
     "use strict";
     var assert = require("node:assert");
-    var { Readable: Readable2 } = require("node:stream");
+    var { Readable: Readable3 } = require("node:stream");
     var { RequestAbortedError, NotSupportedError, InvalidArgumentError, AbortError } = require_errors();
-    var util = require_util();
+    var util3 = require_util();
     var { ReadableStreamFrom } = require_util();
     var kConsume = /* @__PURE__ */ Symbol("kConsume");
     var kReading = /* @__PURE__ */ Symbol("kReading");
@@ -9467,7 +9467,7 @@ var require_readable = __commonJS({
     var kContentLength = /* @__PURE__ */ Symbol("kContentLength");
     var noop3 = () => {
     };
-    var BodyReadable = class extends Readable2 {
+    var BodyReadable = class extends Readable3 {
       constructor({
         resume,
         abort,
@@ -9559,7 +9559,7 @@ var require_readable = __commonJS({
       }
       // https://fetch.spec.whatwg.org/#dom-body-bodyused
       get bodyUsed() {
-        return util.isDisturbed(this);
+        return util3.isDisturbed(this);
       }
       // https://fetch.spec.whatwg.org/#dom-body-body
       get body() {
@@ -9582,7 +9582,7 @@ var require_readable = __commonJS({
         if (this._readableState.closeEmitted) {
           return null;
         }
-        return await new Promise((resolve13, reject) => {
+        return await new Promise((resolve14, reject) => {
           if (this[kContentLength] > limit) {
             this.destroy(new AbortError());
           }
@@ -9595,7 +9595,7 @@ var require_readable = __commonJS({
             if (signal?.aborted) {
               reject(signal.reason ?? new AbortError());
             } else {
-              resolve13(null);
+              resolve14(null);
             }
           }).on("error", noop3).on("data", function(chunk) {
             limit -= chunk.length;
@@ -9610,11 +9610,11 @@ var require_readable = __commonJS({
       return self2[kBody] && self2[kBody].locked === true || self2[kConsume];
     }
     function isUnusable(self2) {
-      return util.isDisturbed(self2) || isLocked(self2);
+      return util3.isDisturbed(self2) || isLocked(self2);
     }
     async function consume(stream2, type) {
       assert(!stream2[kConsume]);
-      return new Promise((resolve13, reject) => {
+      return new Promise((resolve14, reject) => {
         if (isUnusable(stream2)) {
           const rState = stream2._readableState;
           if (rState.destroyed && rState.closeEmitted === false) {
@@ -9631,7 +9631,7 @@ var require_readable = __commonJS({
             stream2[kConsume] = {
               type,
               stream: stream2,
-              resolve: resolve13,
+              resolve: resolve14,
               reject,
               length: 0,
               body: []
@@ -9701,18 +9701,18 @@ var require_readable = __commonJS({
       return buffer;
     }
     function consumeEnd(consume2) {
-      const { type, body, resolve: resolve13, stream: stream2, length } = consume2;
+      const { type, body, resolve: resolve14, stream: stream2, length } = consume2;
       try {
         if (type === "text") {
-          resolve13(chunksDecode(body, length));
+          resolve14(chunksDecode(body, length));
         } else if (type === "json") {
-          resolve13(JSON.parse(chunksDecode(body, length)));
+          resolve14(JSON.parse(chunksDecode(body, length)));
         } else if (type === "arrayBuffer") {
-          resolve13(chunksConcat(body, length).buffer);
+          resolve14(chunksConcat(body, length).buffer);
         } else if (type === "blob") {
-          resolve13(new Blob(body, { type: stream2[kContentType] }));
+          resolve14(new Blob(body, { type: stream2[kContentType] }));
         } else if (type === "bytes") {
-          resolve13(chunksConcat(body, length));
+          resolve14(chunksConcat(body, length));
         }
         consumeFinish(consume2);
       } catch (err) {
@@ -9809,9 +9809,9 @@ var require_api_request = __commonJS({
   "node_modules/undici/lib/api/api-request.js"(exports2, module2) {
     "use strict";
     var assert = require("node:assert");
-    var { Readable: Readable2 } = require_readable();
+    var { Readable: Readable3 } = require_readable();
     var { InvalidArgumentError, RequestAbortedError } = require_errors();
-    var util = require_util();
+    var util3 = require_util();
     var { getResolveErrorBodyCallback } = require_util3();
     var { AsyncResource } = require("node:async_hooks");
     var RequestHandler = class extends AsyncResource {
@@ -9838,8 +9838,8 @@ var require_api_request = __commonJS({
           }
           super("UNDICI_REQUEST");
         } catch (err) {
-          if (util.isStream(body)) {
-            util.destroy(body.on("error", util.nop), err);
+          if (util3.isStream(body)) {
+            util3.destroy(body.on("error", util3.nop), err);
           }
           throw err;
         }
@@ -9858,7 +9858,7 @@ var require_api_request = __commonJS({
         this.signal = signal;
         this.reason = null;
         this.removeAbortListener = null;
-        if (util.isStream(body)) {
+        if (util3.isStream(body)) {
           body.on("error", (err) => {
             this.onError(err);
           });
@@ -9867,10 +9867,10 @@ var require_api_request = __commonJS({
           if (this.signal.aborted) {
             this.reason = this.signal.reason ?? new RequestAbortedError();
           } else {
-            this.removeAbortListener = util.addAbortListener(this.signal, () => {
+            this.removeAbortListener = util3.addAbortListener(this.signal, () => {
               this.reason = this.signal.reason ?? new RequestAbortedError();
               if (this.res) {
-                util.destroy(this.res.on("error", util.nop), this.reason);
+                util3.destroy(this.res.on("error", util3.nop), this.reason);
               } else if (this.abort) {
                 this.abort(this.reason);
               }
@@ -9894,17 +9894,17 @@ var require_api_request = __commonJS({
       }
       onHeaders(statusCode, rawHeaders, resume, statusMessage) {
         const { callback, opaque, abort, context: context5, responseHeaders, highWaterMark } = this;
-        const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
+        const headers = responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
         if (statusCode < 200) {
           if (this.onInfo) {
             this.onInfo({ statusCode, headers });
           }
           return;
         }
-        const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers;
+        const parsedHeaders = responseHeaders === "raw" ? util3.parseHeaders(rawHeaders) : headers;
         const contentType = parsedHeaders["content-type"];
         const contentLength = parsedHeaders["content-length"];
-        const res = new Readable2({
+        const res = new Readable3({
           resume,
           abort,
           contentType,
@@ -9939,7 +9939,7 @@ var require_api_request = __commonJS({
         return this.res.push(chunk);
       }
       onComplete(trailers) {
-        util.parseHeaders(trailers, this.trailers);
+        util3.parseHeaders(trailers, this.trailers);
         this.res.push(null);
       }
       onError(err) {
@@ -9953,12 +9953,12 @@ var require_api_request = __commonJS({
         if (res) {
           this.res = null;
           queueMicrotask(() => {
-            util.destroy(res, err);
+            util3.destroy(res, err);
           });
         }
         if (body) {
           this.body = null;
-          util.destroy(body, err);
+          util3.destroy(body, err);
         }
         if (this.removeAbortListener) {
           res?.off("close", this.removeAbortListener);
@@ -9969,9 +9969,9 @@ var require_api_request = __commonJS({
     };
     function request3(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve13, reject) => {
+        return new Promise((resolve14, reject) => {
           request3.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve13(data);
+            return err ? reject(err) : resolve14(data);
           });
         });
       }
@@ -10046,9 +10046,9 @@ var require_api_stream = __commonJS({
   "node_modules/undici/lib/api/api-stream.js"(exports2, module2) {
     "use strict";
     var assert = require("node:assert");
-    var { finished, PassThrough } = require("node:stream");
+    var { finished, PassThrough: PassThrough3 } = require("node:stream");
     var { InvalidArgumentError, InvalidReturnValueError } = require_errors();
-    var util = require_util();
+    var util3 = require_util();
     var { getResolveErrorBodyCallback } = require_util3();
     var { AsyncResource } = require("node:async_hooks");
     var { addSignal, removeSignal } = require_abort_signal();
@@ -10076,8 +10076,8 @@ var require_api_stream = __commonJS({
           }
           super("UNDICI_STREAM");
         } catch (err) {
-          if (util.isStream(body)) {
-            util.destroy(body.on("error", util.nop), err);
+          if (util3.isStream(body)) {
+            util3.destroy(body.on("error", util3.nop), err);
           }
           throw err;
         }
@@ -10092,7 +10092,7 @@ var require_api_stream = __commonJS({
         this.body = body;
         this.onInfo = onInfo || null;
         this.throwOnError = throwOnError || false;
-        if (util.isStream(body)) {
+        if (util3.isStream(body)) {
           body.on("error", (err) => {
             this.onError(err);
           });
@@ -10110,7 +10110,7 @@ var require_api_stream = __commonJS({
       }
       onHeaders(statusCode, rawHeaders, resume, statusMessage) {
         const { factory, opaque, context: context5, callback, responseHeaders } = this;
-        const headers = responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
+        const headers = responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
         if (statusCode < 200) {
           if (this.onInfo) {
             this.onInfo({ statusCode, headers });
@@ -10120,9 +10120,9 @@ var require_api_stream = __commonJS({
         this.factory = null;
         let res;
         if (this.throwOnError && statusCode >= 400) {
-          const parsedHeaders = responseHeaders === "raw" ? util.parseHeaders(rawHeaders) : headers;
+          const parsedHeaders = responseHeaders === "raw" ? util3.parseHeaders(rawHeaders) : headers;
           const contentType = parsedHeaders["content-type"];
-          res = new PassThrough();
+          res = new PassThrough3();
           this.callback = null;
           this.runInAsyncScope(
             getResolveErrorBodyCallback,
@@ -10146,7 +10146,7 @@ var require_api_stream = __commonJS({
             const { callback: callback2, res: res2, opaque: opaque2, trailers, abort } = this;
             this.res = null;
             if (err || !res2.readable) {
-              util.destroy(res2, err);
+              util3.destroy(res2, err);
             }
             this.callback = null;
             this.runInAsyncScope(callback2, null, err || null, { opaque: opaque2, trailers });
@@ -10170,7 +10170,7 @@ var require_api_stream = __commonJS({
         if (!res) {
           return;
         }
-        this.trailers = util.parseHeaders(trailers);
+        this.trailers = util3.parseHeaders(trailers);
         res.end();
       }
       onError(err) {
@@ -10179,7 +10179,7 @@ var require_api_stream = __commonJS({
         this.factory = null;
         if (res) {
           this.res = null;
-          util.destroy(res, err);
+          util3.destroy(res, err);
         } else if (callback) {
           this.callback = null;
           queueMicrotask(() => {
@@ -10188,15 +10188,15 @@ var require_api_stream = __commonJS({
         }
         if (body) {
           this.body = null;
-          util.destroy(body, err);
+          util3.destroy(body, err);
         }
       }
     };
     function stream2(opts, factory, callback) {
       if (callback === void 0) {
-        return new Promise((resolve13, reject) => {
+        return new Promise((resolve14, reject) => {
           stream2.call(this, opts, factory, (err, data) => {
-            return err ? reject(err) : resolve13(data);
+            return err ? reject(err) : resolve14(data);
           });
         });
       }
@@ -10219,21 +10219,21 @@ var require_api_pipeline = __commonJS({
   "node_modules/undici/lib/api/api-pipeline.js"(exports2, module2) {
     "use strict";
     var {
-      Readable: Readable2,
+      Readable: Readable3,
       Duplex,
-      PassThrough
+      PassThrough: PassThrough3
     } = require("node:stream");
     var {
       InvalidArgumentError,
       InvalidReturnValueError,
       RequestAbortedError
     } = require_errors();
-    var util = require_util();
+    var util3 = require_util();
     var { AsyncResource } = require("node:async_hooks");
     var { addSignal, removeSignal } = require_abort_signal();
     var assert = require("node:assert");
     var kResume = /* @__PURE__ */ Symbol("resume");
-    var PipelineRequest = class extends Readable2 {
+    var PipelineRequest = class extends Readable3 {
       constructor() {
         super({ autoDestroy: true });
         this[kResume] = null;
@@ -10250,7 +10250,7 @@ var require_api_pipeline = __commonJS({
         callback(err);
       }
     };
-    var PipelineResponse = class extends Readable2 {
+    var PipelineResponse = class extends Readable3 {
       constructor(resume) {
         super({ autoDestroy: true });
         this[kResume] = resume;
@@ -10290,7 +10290,7 @@ var require_api_pipeline = __commonJS({
         this.abort = null;
         this.context = null;
         this.onInfo = onInfo || null;
-        this.req = new PipelineRequest().on("error", util.nop);
+        this.req = new PipelineRequest().on("error", util3.nop);
         this.ret = new Duplex({
           readableObjectMode: opts.objectMode,
           autoDestroy: true,
@@ -10316,9 +10316,9 @@ var require_api_pipeline = __commonJS({
             if (abort && err) {
               abort();
             }
-            util.destroy(body, err);
-            util.destroy(req, err);
-            util.destroy(res, err);
+            util3.destroy(body, err);
+            util3.destroy(req, err);
+            util3.destroy(res, err);
             removeSignal(this);
             callback(err);
           }
@@ -10344,7 +10344,7 @@ var require_api_pipeline = __commonJS({
         const { opaque, handler: handler2, context: context5 } = this;
         if (statusCode < 200) {
           if (this.onInfo) {
-            const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
+            const headers = this.responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
             this.onInfo({ statusCode, headers });
           }
           return;
@@ -10353,7 +10353,7 @@ var require_api_pipeline = __commonJS({
         let body;
         try {
           this.handler = null;
-          const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
+          const headers = this.responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
           body = this.runInAsyncScope(handler2, null, {
             statusCode,
             headers,
@@ -10362,7 +10362,7 @@ var require_api_pipeline = __commonJS({
             context: context5
           });
         } catch (err) {
-          this.res.on("error", util.nop);
+          this.res.on("error", util3.nop);
           throw err;
         }
         if (!body || typeof body.on !== "function") {
@@ -10375,14 +10375,14 @@ var require_api_pipeline = __commonJS({
           }
         }).on("error", (err) => {
           const { ret } = this;
-          util.destroy(ret, err);
+          util3.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());
+            util3.destroy(ret, new RequestAbortedError());
           }
         });
         this.body = body;
@@ -10398,7 +10398,7 @@ var require_api_pipeline = __commonJS({
       onError(err) {
         const { ret } = this;
         this.handler = null;
-        util.destroy(ret, err);
+        util3.destroy(ret, err);
       }
     };
     function pipeline(opts, handler2) {
@@ -10407,7 +10407,7 @@ var require_api_pipeline = __commonJS({
         this.dispatch({ ...opts, body: pipelineHandler.req }, pipelineHandler);
         return pipelineHandler.ret;
       } catch (err) {
-        return new PassThrough().destroy(err);
+        return new PassThrough3().destroy(err);
       }
     }
     module2.exports = pipeline;
@@ -10420,7 +10420,7 @@ var require_api_upgrade = __commonJS({
     "use strict";
     var { InvalidArgumentError, SocketError } = require_errors();
     var { AsyncResource } = require("node:async_hooks");
-    var util = require_util();
+    var util3 = require_util();
     var { addSignal, removeSignal } = require_abort_signal();
     var assert = require("node:assert");
     var UpgradeHandler = class extends AsyncResource {
@@ -10460,7 +10460,7 @@ var require_api_upgrade = __commonJS({
         const { callback, opaque, context: context5 } = this;
         removeSignal(this);
         this.callback = null;
-        const headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
+        const headers = this.responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
         this.runInAsyncScope(callback, null, null, {
           headers,
           socket,
@@ -10481,9 +10481,9 @@ var require_api_upgrade = __commonJS({
     };
     function upgrade(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve13, reject) => {
+        return new Promise((resolve14, reject) => {
           upgrade.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve13(data);
+            return err ? reject(err) : resolve14(data);
           });
         });
       }
@@ -10513,7 +10513,7 @@ var require_api_connect = __commonJS({
     var assert = require("node:assert");
     var { AsyncResource } = require("node:async_hooks");
     var { InvalidArgumentError, SocketError } = require_errors();
-    var util = require_util();
+    var util3 = require_util();
     var { addSignal, removeSignal } = require_abort_signal();
     var ConnectHandler = class extends AsyncResource {
       constructor(opts, callback) {
@@ -10552,7 +10552,7 @@ var require_api_connect = __commonJS({
         this.callback = null;
         let headers = rawHeaders;
         if (headers != null) {
-          headers = this.responseHeaders === "raw" ? util.parseRawHeaders(rawHeaders) : util.parseHeaders(rawHeaders);
+          headers = this.responseHeaders === "raw" ? util3.parseRawHeaders(rawHeaders) : util3.parseHeaders(rawHeaders);
         }
         this.runInAsyncScope(callback, null, null, {
           statusCode,
@@ -10575,9 +10575,9 @@ var require_api_connect = __commonJS({
     };
     function connect(opts, callback) {
       if (callback === void 0) {
-        return new Promise((resolve13, reject) => {
+        return new Promise((resolve14, reject) => {
           connect.call(this, opts, (err, data) => {
-            return err ? reject(err) : resolve13(data);
+            return err ? reject(err) : resolve14(data);
           });
         });
       }
@@ -10680,15 +10680,15 @@ var require_mock_utils = __commonJS({
         isPromise
       }
     } = require("node:util");
-    function matchValue(match, value) {
-      if (typeof match === "string") {
-        return match === value;
+    function matchValue(match2, value) {
+      if (typeof match2 === "string") {
+        return match2 === value;
       }
-      if (match instanceof RegExp) {
-        return match.test(value);
+      if (match2 instanceof RegExp) {
+        return match2.test(value);
       }
-      if (typeof match === "function") {
-        return match(value) === true;
+      if (typeof match2 === "function") {
+        return match2(value) === true;
       }
       return false;
     }
@@ -10716,8 +10716,8 @@ var require_mock_utils = __commonJS({
     function buildHeadersFromArray(headers) {
       const clone = headers.slice();
       const entries = [];
-      for (let index = 0; index < clone.length; index += 2) {
-        entries.push([clone[index], clone[index + 1]]);
+      for (let index2 = 0; index2 < clone.length; index2 += 2) {
+        entries.push([clone[index2], clone[index2 + 1]]);
       }
       return Object.fromEntries(entries);
     }
@@ -10742,20 +10742,20 @@ var require_mock_utils = __commonJS({
       }
       return true;
     }
-    function safeUrl(path28) {
-      if (typeof path28 !== "string") {
-        return path28;
+    function safeUrl(path29) {
+      if (typeof path29 !== "string") {
+        return path29;
       }
-      const pathSegments = path28.split("?");
+      const pathSegments = path29.split("?");
       if (pathSegments.length !== 2) {
-        return path28;
+        return path29;
       }
       const qp = new URLSearchParams(pathSegments.pop());
       qp.sort();
       return [...pathSegments, qp.toString()].join("?");
     }
-    function matchKey(mockDispatch2, { path: path28, method, body, headers }) {
-      const pathMatch = matchValue(mockDispatch2.path, path28);
+    function matchKey(mockDispatch2, { path: path29, method, body, headers }) {
+      const pathMatch = matchValue(mockDispatch2.path, path29);
       const methodMatch = matchValue(mockDispatch2.method, method);
       const bodyMatch = typeof mockDispatch2.body !== "undefined" ? matchValue(mockDispatch2.body, body) : true;
       const headersMatch = matchHeaders(mockDispatch2, headers);
@@ -10777,7 +10777,7 @@ var require_mock_utils = __commonJS({
     function getMockDispatch(mockDispatches, key) {
       const basePath = key.query ? buildURL(key.path, key.query) : key.path;
       const resolvedPath = typeof basePath === "string" ? safeUrl(basePath) : basePath;
-      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path28 }) => matchValue(safeUrl(path28), resolvedPath));
+      let matchedMockDispatches = mockDispatches.filter(({ consumed }) => !consumed).filter(({ path: path29 }) => matchValue(safeUrl(path29), resolvedPath));
       if (matchedMockDispatches.length === 0) {
         throw new MockNotMatchedError(`Mock dispatch not matched for path '${resolvedPath}'`);
       }
@@ -10804,20 +10804,20 @@ var require_mock_utils = __commonJS({
       return newMockDispatch;
     }
     function deleteMockDispatch(mockDispatches, key) {
-      const index = mockDispatches.findIndex((dispatch) => {
+      const index2 = mockDispatches.findIndex((dispatch) => {
         if (!dispatch.consumed) {
           return false;
         }
         return matchKey(dispatch, key);
       });
-      if (index !== -1) {
-        mockDispatches.splice(index, 1);
+      if (index2 !== -1) {
+        mockDispatches.splice(index2, 1);
       }
     }
     function buildKey(opts) {
-      const { path: path28, method, body, headers, query } = opts;
+      const { path: path29, method, body, headers, query } = opts;
       return {
-        path: path28,
+        path: path29,
         method,
         body,
         headers,
@@ -11260,13 +11260,13 @@ var require_pluralizer = __commonJS({
 var require_pending_interceptors_formatter = __commonJS({
   "node_modules/undici/lib/mock/pending-interceptors-formatter.js"(exports2, module2) {
     "use strict";
-    var { Transform } = require("node:stream");
+    var { Transform: Transform5 } = require("node:stream");
     var { Console } = require("node:console");
     var PERSISTENT = process.versions.icu ? "\u2705" : "Y ";
     var NOT_PERSISTENT = process.versions.icu ? "\u274C" : "N ";
     module2.exports = class PendingInterceptorsFormatter {
       constructor({ disableColors } = {}) {
-        this.transform = new Transform({
+        this.transform = new Transform5({
           transform(chunk, _enc, cb) {
             cb(null, chunk);
           }
@@ -11280,10 +11280,10 @@ var require_pending_interceptors_formatter = __commonJS({
       }
       format(pendingInterceptors) {
         const withPrettyHeaders = pendingInterceptors.map(
-          ({ method, path: path28, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
+          ({ method, path: path29, data: { statusCode }, persist, times, timesInvoked, origin }) => ({
             Method: method,
             Origin: origin,
-            Path: path28,
+            Path: path29,
             "Status code": statusCode,
             Persistent: persist ? PERSISTENT : NOT_PERSISTENT,
             Invocations: timesInvoked,
@@ -11552,7 +11552,7 @@ var require_retry = __commonJS({
 var require_dump = __commonJS({
   "node_modules/undici/lib/interceptor/dump.js"(exports2, module2) {
     "use strict";
-    var util = require_util();
+    var util3 = require_util();
     var { InvalidArgumentError, RequestAbortedError } = require_errors();
     var DecoratorHandler = require_decorator_handler();
     var DumpHandler = class extends DecoratorHandler {
@@ -11581,7 +11581,7 @@ var require_dump = __commonJS({
       }
       // TODO: will require adjustment after new hooks are out
       onHeaders(statusCode, rawHeaders, resume, statusMessage) {
-        const headers = util.parseHeaders(rawHeaders);
+        const headers = util3.parseHeaders(rawHeaders);
         const contentLength = headers["content-length"];
         if (contentLength != null && contentLength > this.#maxSize) {
           throw new RequestAbortedError(
@@ -11948,7 +11948,7 @@ var require_headers = __commonJS({
     } = require_util2();
     var { webidl } = require_webidl();
     var assert = require("node:assert");
-    var util = require("node:util");
+    var util3 = require("node:util");
     var kHeadersMap = /* @__PURE__ */ Symbol("headers map");
     var kHeadersSortedMap = /* @__PURE__ */ Symbol("headers map sorted");
     function isHTTPWhiteSpaceCharCode(code) {
@@ -12307,9 +12307,9 @@ var require_headers = __commonJS({
         }
         return this.#headersList[kHeadersSortedMap] = headers;
       }
-      [util.inspect.custom](depth, options) {
+      [util3.inspect.custom](depth, options) {
         options.depth ??= depth;
-        return `Headers ${util.formatWithOptions(options, this.#headersList.entries)}`;
+        return `Headers ${util3.formatWithOptions(options, this.#headersList.entries)}`;
       }
       static getHeadersGuard(o) {
         return o.#guard;
@@ -12341,14 +12341,14 @@ var require_headers = __commonJS({
         value: "Headers",
         configurable: true
       },
-      [util.inspect.custom]: {
+      [util3.inspect.custom]: {
         enumerable: false
       }
     });
     webidl.converters.HeadersInit = function(V, prefix, argument) {
       if (webidl.util.Type(V) === "Object") {
         const iterator2 = Reflect.get(V, Symbol.iterator);
-        if (!util.types.isProxy(V) && iterator2 === Headers.prototype.entries) {
+        if (!util3.types.isProxy(V) && iterator2 === Headers.prototype.entries) {
           try {
             return getHeadersList(V).entriesList;
           } catch {
@@ -12385,9 +12385,9 @@ var require_response = __commonJS({
     "use strict";
     var { Headers, HeadersList, fill, getHeadersGuard, setHeadersGuard, setHeadersList } = require_headers();
     var { extractBody, cloneBody, mixinBody, hasFinalizationRegistry, streamRegistry, bodyUnusable } = require_body();
-    var util = require_util();
+    var util3 = require_util();
     var nodeUtil = require("node:util");
-    var { kEnumerableProperty } = util;
+    var { kEnumerableProperty } = util3;
     var {
       isValidReasonPhrase,
       isCancelled,
@@ -12408,7 +12408,7 @@ var require_response = __commonJS({
     var { URLSerializer } = require_data_url();
     var { kConstruct } = require_symbols();
     var assert = require("node:assert");
-    var { types: types2 } = require("node:util");
+    var { types: types3 } = require("node:util");
     var textEncoder = new TextEncoder("utf-8");
     var Response = class _Response {
       // Creates network error Response.
@@ -12517,7 +12517,7 @@ var require_response = __commonJS({
       }
       get bodyUsed() {
         webidl.brandCheck(this, _Response);
-        return !!this[kState].body && util.isDisturbed(this[kState].body.stream);
+        return !!this[kState].body && util3.isDisturbed(this[kState].body.stream);
       }
       // Returns a clone of response.
       clone() {
@@ -12729,10 +12729,10 @@ var require_response = __commonJS({
       if (isBlobLike(V)) {
         return webidl.converters.Blob(V, prefix, name, { strict: false });
       }
-      if (ArrayBuffer.isView(V) || types2.isArrayBuffer(V)) {
+      if (ArrayBuffer.isView(V) || types3.isArrayBuffer(V)) {
         return webidl.converters.BufferSource(V, prefix, name);
       }
-      if (util.isFormDataLike(V)) {
+      if (util3.isFormDataLike(V)) {
         return webidl.converters.FormData(V, prefix, name, { strict: false });
       }
       if (V instanceof URLSearchParams) {
@@ -12827,7 +12827,7 @@ var require_request2 = __commonJS({
     var { extractBody, mixinBody, cloneBody, bodyUnusable } = require_body();
     var { Headers, fill: fillHeaders, HeadersList, setHeadersGuard, getHeadersGuard, setHeadersList, getHeadersList } = require_headers();
     var { FinalizationRegistry: FinalizationRegistry2 } = require_dispatcher_weakref()();
-    var util = require_util();
+    var util3 = require_util();
     var nodeUtil = require("node:util");
     var {
       isValidHTTPToken,
@@ -12844,7 +12844,7 @@ var require_request2 = __commonJS({
       requestCache,
       requestDuplex
     } = require_constants3();
-    var { kEnumerableProperty, normalizedMethodRecordsBase, normalizedMethodRecords } = util;
+    var { kEnumerableProperty, normalizedMethodRecordsBase, normalizedMethodRecords } = util3;
     var { kHeaders, kSignal, kState, kDispatcher } = require_symbols2();
     var { webidl } = require_webidl();
     var { URLSerializer } = require_data_url();
@@ -13089,7 +13089,7 @@ var require_request2 = __commonJS({
               }
             } catch {
             }
-            util.addAbortListener(signal, abort);
+            util3.addAbortListener(signal, abort);
             requestFinalizer.register(ac, { signal, abort }, abort);
           }
         }
@@ -13272,7 +13272,7 @@ var require_request2 = __commonJS({
       }
       get bodyUsed() {
         webidl.brandCheck(this, _Request);
-        return !!this[kState].body && util.isDisturbed(this[kState].body.stream);
+        return !!this[kState].body && util3.isDisturbed(this[kState].body.stream);
       }
       get duplex() {
         webidl.brandCheck(this, _Request);
@@ -13296,7 +13296,7 @@ var require_request2 = __commonJS({
           }
           const acRef = new WeakRef(ac);
           list.add(acRef);
-          util.addAbortListener(
+          util3.addAbortListener(
             ac.signal,
             buildAbort(acRef)
           );
@@ -13575,7 +13575,7 @@ var require_fetch = __commonJS({
       subresourceSet
     } = require_constants3();
     var EE = require("node:events");
-    var { Readable: Readable2, pipeline, finished } = require("node:stream");
+    var { Readable: Readable3, pipeline, finished } = require("node:stream");
     var { addAbortListener, isErrored, isReadable, bufferToLowerCasedHeaderName } = require_util();
     var { dataURLProcessor, serializeAMimeType, minimizeSupportedMimeType } = require_data_url();
     var { getGlobalDispatcher } = require_global2();
@@ -14439,7 +14439,7 @@ var require_fetch = __commonJS({
       function dispatch({ body }) {
         const url2 = requestCurrentURL(request3);
         const agent = fetchParams.controller.dispatcher;
-        return new Promise((resolve13, reject) => agent.dispatch(
+        return new Promise((resolve14, reject) => agent.dispatch(
           {
             path: url2.pathname + url2.search,
             origin: url2.origin,
@@ -14476,7 +14476,7 @@ var require_fetch = __commonJS({
                 headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true);
               }
               location = headersList.get("location", true);
-              this.body = new Readable2({ read: resume });
+              this.body = new Readable3({ read: resume });
               const decoders = [];
               const willFollow = location && request3.redirect === "follow" && redirectStatusSet.has(status);
               if (request3.method !== "HEAD" && request3.method !== "CONNECT" && !nullBodyStatus.includes(status) && !willFollow) {
@@ -14515,7 +14515,7 @@ var require_fetch = __commonJS({
                 }
               }
               const onError = this.onError.bind(this);
-              resolve13({
+              resolve14({
                 status,
                 statusText,
                 headersList,
@@ -14561,7 +14561,7 @@ var require_fetch = __commonJS({
               for (let i = 0; i < rawHeaders.length; i += 2) {
                 headersList.append(bufferToLowerCasedHeaderName(rawHeaders[i]), rawHeaders[i + 1].toString("latin1"), true);
               }
-              resolve13({
+              resolve14({
                 status,
                 statusText: STATUS_CODES[status],
                 headersList,
@@ -14965,7 +14965,7 @@ var require_util4 = __commonJS({
     var { ProgressEvent } = require_progressevent();
     var { getEncoding } = require_encoding();
     var { serializeAMimeType, parseMIMEType } = require_data_url();
-    var { types: types2 } = require("node:util");
+    var { types: types3 } = require("node:util");
     var { StringDecoder } = require("string_decoder");
     var { btoa: btoa2 } = require("node:buffer");
     var staticPropertyDescriptors = {
@@ -14995,7 +14995,7 @@ var require_util4 = __commonJS({
               });
             }
             isFirstChunk = false;
-            if (!done && types2.isUint8Array(value)) {
+            if (!done && types3.isUint8Array(value)) {
               bytes.push(value);
               if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) {
                 fr[kLastProgressEventFired] = Date.now();
@@ -15566,18 +15566,18 @@ var require_cache = __commonJS({
         const p = Promise.all(responsePromises);
         const responses = await p;
         const operations = [];
-        let index = 0;
+        let index2 = 0;
         for (const response of responses) {
           const operation = {
             type: "put",
             // 7.3.2
-            request: requestList[index],
+            request: requestList[index2],
             // 7.3.3
             response
             // 7.3.4
           };
           operations.push(operation);
-          index++;
+          index2++;
         }
         const cacheJobPromise = createDeferredPromise();
         let errorData = null;
@@ -16164,9 +16164,9 @@ var require_util6 = __commonJS({
         }
       }
     }
-    function validateCookiePath(path28) {
-      for (let i = 0; i < path28.length; ++i) {
-        const code = path28.charCodeAt(i);
+    function validateCookiePath(path29) {
+      for (let i = 0; i < path29.length; ++i) {
+        const code = path29.charCodeAt(i);
         if (code < 32 || // exclude CTLs (0-31)
         code === 127 || // DEL
         code === 59) {
@@ -17771,9 +17771,9 @@ var require_sender = __commonJS({
       }
       async #run() {
         this.#running = true;
-        const queue = this.#queue;
-        while (!queue.isEmpty()) {
-          const node = queue.shift();
+        const queue2 = this.#queue;
+        while (!queue2.isEmpty()) {
+          const node = queue2.shift();
           if (node.promise !== null) {
             await node.promise;
           }
@@ -17829,7 +17829,7 @@ var require_websocket = __commonJS({
     var { ByteParser } = require_receiver();
     var { kEnumerableProperty, isBlobLike } = require_util();
     var { getGlobalDispatcher } = require_global2();
-    var { types: types2 } = require("node:util");
+    var { types: types3 } = require("node:util");
     var { ErrorEvent, CloseEvent } = require_events();
     var { SendQueue } = require_sender();
     var WebSocket = class _WebSocket extends EventTarget {
@@ -17952,7 +17952,7 @@ var require_websocket = __commonJS({
           this.#sendQueue.add(data, () => {
             this.#bufferedAmount -= length;
           }, sendHints.string);
-        } else if (types2.isArrayBuffer(data)) {
+        } else if (types3.isArrayBuffer(data)) {
           this.#bufferedAmount += data.byteLength;
           this.#sendQueue.add(data, () => {
             this.#bufferedAmount -= data.byteLength;
@@ -18158,7 +18158,7 @@ var require_websocket = __commonJS({
         if (isBlobLike(V)) {
           return webidl.converters.Blob(V, { strict: false });
         }
-        if (ArrayBuffer.isView(V) || types2.isArrayBuffer(V)) {
+        if (ArrayBuffer.isView(V) || types3.isArrayBuffer(V)) {
           return webidl.converters.BufferSource(V);
         }
       }
@@ -18200,8 +18200,8 @@ var require_util8 = __commonJS({
       return true;
     }
     function delay2(ms) {
-      return new Promise((resolve13) => {
-        setTimeout(resolve13, ms).unref();
+      return new Promise((resolve14) => {
+        setTimeout(resolve14, ms).unref();
       });
     }
     module2.exports = {
@@ -18216,14 +18216,14 @@ var require_util8 = __commonJS({
 var require_eventsource_stream = __commonJS({
   "node_modules/undici/lib/web/eventsource/eventsource-stream.js"(exports2, module2) {
     "use strict";
-    var { Transform } = require("node:stream");
+    var { Transform: Transform5 } = require("node:stream");
     var { isASCIINumber, isValidLastEventId } = require_util8();
     var BOM = [239, 187, 191];
     var LF = 10;
     var CR = 13;
     var COLON = 58;
     var SPACE = 32;
-    var EventSourceStream = class extends Transform {
+    var EventSourceStream = class extends Transform5 {
       /**
        * @type {eventSourceSettings}
        */
@@ -18752,7 +18752,7 @@ var require_undici = __commonJS({
     var EnvHttpProxyAgent = require_env_http_proxy_agent();
     var RetryAgent = require_retry_agent();
     var errors = require_errors();
-    var util = require_util();
+    var util3 = require_util();
     var { InvalidArgumentError } = errors;
     var api = require_api();
     var buildConnector = require_connect();
@@ -18787,8 +18787,8 @@ var require_undici = __commonJS({
     module2.exports.buildConnector = buildConnector;
     module2.exports.errors = errors;
     module2.exports.util = {
-      parseHeaders: util.parseHeaders,
-      headerNameToString: util.headerNameToString
+      parseHeaders: util3.parseHeaders,
+      headerNameToString: util3.headerNameToString
     };
     function makeDispatcher(fn) {
       return (url2, opts, handler2) => {
@@ -18806,16 +18806,16 @@ var require_undici = __commonJS({
           if (typeof opts.path !== "string") {
             throw new InvalidArgumentError("invalid opts.path");
           }
-          let path28 = opts.path;
+          let path29 = opts.path;
           if (!opts.path.startsWith("/")) {
-            path28 = `/${path28}`;
+            path29 = `/${path29}`;
           }
-          url2 = new URL(util.parseOrigin(url2).origin + path28);
+          url2 = new URL(util3.parseOrigin(url2).origin + path29);
         } else {
           if (!opts) {
             opts = typeof url2 === "object" ? url2 : {};
           }
-          url2 = util.parseURL(url2);
+          url2 = util3.parseURL(url2);
         }
         const { agent, dispatcher = getGlobalDispatcher() } = opts;
         if (agent) {
@@ -18924,11 +18924,11 @@ var require_lib = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -18944,7 +18944,7 @@ var require_lib = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -19031,26 +19031,26 @@ var require_lib = __commonJS({
       }
       readBody() {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13) => __awaiter2(this, void 0, void 0, function* () {
+          return new Promise((resolve14) => __awaiter2(this, void 0, void 0, function* () {
             let output = Buffer.alloc(0);
             this.message.on("data", (chunk) => {
               output = Buffer.concat([output, chunk]);
             });
             this.message.on("end", () => {
-              resolve13(output.toString());
+              resolve14(output.toString());
             });
           }));
         });
       }
       readBodyBuffer() {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13) => __awaiter2(this, void 0, void 0, function* () {
+          return new Promise((resolve14) => __awaiter2(this, void 0, void 0, function* () {
             const chunks = [];
             this.message.on("data", (chunk) => {
               chunks.push(chunk);
             });
             this.message.on("end", () => {
-              resolve13(Buffer.concat(chunks));
+              resolve14(Buffer.concat(chunks));
             });
           }));
         });
@@ -19258,14 +19258,14 @@ var require_lib = __commonJS({
        */
       requestRaw(info8, data) {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13, reject) => {
+          return new Promise((resolve14, reject) => {
             function callbackForResult(err, res) {
               if (err) {
                 reject(err);
               } else if (!res) {
                 reject(new Error("Unknown error"));
               } else {
-                resolve13(res);
+                resolve14(res);
               }
             }
             this.requestRawWithCallback(info8, data, callbackForResult);
@@ -19509,12 +19509,12 @@ var require_lib = __commonJS({
         return __awaiter2(this, void 0, void 0, function* () {
           retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
           const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
-          return new Promise((resolve13) => setTimeout(() => resolve13(), ms));
+          return new Promise((resolve14) => setTimeout(() => resolve14(), ms));
         });
       }
       _processResponse(res, options) {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13, reject) => __awaiter2(this, void 0, void 0, function* () {
+          return new Promise((resolve14, reject) => __awaiter2(this, void 0, void 0, function* () {
             const statusCode = res.message.statusCode || 0;
             const response = {
               statusCode,
@@ -19522,7 +19522,7 @@ var require_lib = __commonJS({
               headers: {}
             };
             if (statusCode === HttpCodes.NotFound) {
-              resolve13(response);
+              resolve14(response);
             }
             function dateTimeDeserializer(key, value) {
               if (typeof value === "string") {
@@ -19561,7 +19561,7 @@ var require_lib = __commonJS({
               err.result = response.result;
               reject(err);
             } else {
-              resolve13(response);
+              resolve14(response);
             }
           }));
         });
@@ -19578,11 +19578,11 @@ var require_auth = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -19598,7 +19598,7 @@ var require_auth = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -19682,11 +19682,11 @@ var require_oidc_utils = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -19702,7 +19702,7 @@ var require_oidc_utils = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -19736,7 +19736,7 @@ var require_oidc_utils = __commonJS({
       }
       static getCall(id_token_url) {
         return __awaiter2(this, void 0, void 0, function* () {
-          var _a;
+          var _a2;
           const httpclient = _OidcClient.createHttpClient();
           const res = yield httpclient.getJson(id_token_url).catch((error3) => {
             throw new Error(`Failed to get ID Token. 
@@ -19745,7 +19745,7 @@ var require_oidc_utils = __commonJS({
  
         Error Message: ${error3.message}`);
           });
-          const id_token = (_a = res.result) === null || _a === void 0 ? void 0 : _a.value;
+          const id_token = (_a2 = res.result) === null || _a2 === void 0 ? void 0 : _a2.value;
           if (!id_token) {
             throw new Error("Response json body do not have ID Token field");
           }
@@ -19780,11 +19780,11 @@ var require_summary = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -19800,7 +19800,7 @@ var require_summary = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -19833,7 +19833,7 @@ var require_summary = __commonJS({
           }
           try {
             yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK);
-          } catch (_a) {
+          } catch (_a2) {
             throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`);
           }
           this._filePath = pathFromEnv;
@@ -20113,7 +20113,7 @@ var require_path_utils = __commonJS({
     exports2.toPosixPath = toPosixPath;
     exports2.toWin32Path = toWin32Path;
     exports2.toPlatformPath = toPlatformPath;
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     function toPosixPath(pth) {
       return pth.replace(/[\\]/g, "/");
     }
@@ -20121,7 +20121,7 @@ var require_path_utils = __commonJS({
       return pth.replace(/[/]/g, "\\");
     }
     function toPlatformPath(pth) {
-      return pth.replace(/[/\\]/g, path28.sep);
+      return pth.replace(/[/\\]/g, path29.sep);
     }
   }
 });
@@ -20169,11 +20169,11 @@ var require_io_util = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -20189,12 +20189,12 @@ var require_io_util = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
     };
-    var _a;
+    var _a2;
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.READONLY = exports2.UV_FS_O_EXLOCK = exports2.IS_WINDOWS = exports2.unlink = exports2.symlink = exports2.stat = exports2.rmdir = exports2.rm = exports2.rename = exports2.readdir = exports2.open = exports2.mkdir = exports2.lstat = exports2.copyFile = exports2.chmod = void 0;
     exports2.readlink = readlink;
@@ -20203,13 +20203,13 @@ var require_io_util = __commonJS({
     exports2.isRooted = isRooted;
     exports2.tryGetExecutablePath = tryGetExecutablePath;
     exports2.getCmdPath = getCmdPath;
-    var fs30 = __importStar2(require("fs"));
-    var path28 = __importStar2(require("path"));
-    _a = fs30.promises, exports2.chmod = _a.chmod, exports2.copyFile = _a.copyFile, exports2.lstat = _a.lstat, exports2.mkdir = _a.mkdir, exports2.open = _a.open, exports2.readdir = _a.readdir, exports2.rename = _a.rename, exports2.rm = _a.rm, exports2.rmdir = _a.rmdir, exports2.stat = _a.stat, exports2.symlink = _a.symlink, exports2.unlink = _a.unlink;
+    var fs31 = __importStar2(require("fs"));
+    var path29 = __importStar2(require("path"));
+    _a2 = fs31.promises, exports2.chmod = _a2.chmod, exports2.copyFile = _a2.copyFile, exports2.lstat = _a2.lstat, exports2.mkdir = _a2.mkdir, exports2.open = _a2.open, exports2.readdir = _a2.readdir, exports2.rename = _a2.rename, exports2.rm = _a2.rm, exports2.rmdir = _a2.rmdir, exports2.stat = _a2.stat, exports2.symlink = _a2.symlink, exports2.unlink = _a2.unlink;
     exports2.IS_WINDOWS = process.platform === "win32";
     function readlink(fsPath) {
       return __awaiter2(this, void 0, void 0, function* () {
-        const result = yield fs30.promises.readlink(fsPath);
+        const result = yield fs31.promises.readlink(fsPath);
         if (exports2.IS_WINDOWS && !result.endsWith("\\")) {
           return `${result}\\`;
         }
@@ -20217,7 +20217,7 @@ var require_io_util = __commonJS({
       });
     }
     exports2.UV_FS_O_EXLOCK = 268435456;
-    exports2.READONLY = fs30.constants.O_RDONLY;
+    exports2.READONLY = fs31.constants.O_RDONLY;
     function exists(fsPath) {
       return __awaiter2(this, void 0, void 0, function* () {
         try {
@@ -20259,7 +20259,7 @@ var require_io_util = __commonJS({
         }
         if (stats && stats.isFile()) {
           if (exports2.IS_WINDOWS) {
-            const upperExt = path28.extname(filePath).toUpperCase();
+            const upperExt = path29.extname(filePath).toUpperCase();
             if (extensions.some((validExt) => validExt.toUpperCase() === upperExt)) {
               return filePath;
             }
@@ -20283,11 +20283,11 @@ var require_io_util = __commonJS({
           if (stats && stats.isFile()) {
             if (exports2.IS_WINDOWS) {
               try {
-                const directory = path28.dirname(filePath);
-                const upperName = path28.basename(filePath).toUpperCase();
+                const directory = path29.dirname(filePath);
+                const upperName = path29.basename(filePath).toUpperCase();
                 for (const actualName of yield (0, exports2.readdir)(directory)) {
                   if (upperName === actualName.toUpperCase()) {
-                    filePath = path28.join(directory, actualName);
+                    filePath = path29.join(directory, actualName);
                     break;
                   }
                 }
@@ -20317,8 +20317,8 @@ var require_io_util = __commonJS({
       return (stats.mode & 1) > 0 || (stats.mode & 8) > 0 && process.getgid !== void 0 && stats.gid === process.getgid() || (stats.mode & 64) > 0 && process.getuid !== void 0 && stats.uid === process.getuid();
     }
     function getCmdPath() {
-      var _a2;
-      return (_a2 = process.env["COMSPEC"]) !== null && _a2 !== void 0 ? _a2 : `cmd.exe`;
+      var _a3;
+      return (_a3 = process.env["COMSPEC"]) !== null && _a3 !== void 0 ? _a3 : `cmd.exe`;
     }
   }
 });
@@ -20366,11 +20366,11 @@ var require_io = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -20386,7 +20386,7 @@ var require_io = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -20399,7 +20399,7 @@ var require_io = __commonJS({
     exports2.which = which9;
     exports2.findInPath = findInPath;
     var assert_1 = require("assert");
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var ioUtil = __importStar2(require_io_util());
     function cp(source_1, dest_1) {
       return __awaiter2(this, arguments, void 0, function* (source, dest, options = {}) {
@@ -20408,7 +20408,7 @@ var require_io = __commonJS({
         if (destStat && destStat.isFile() && !force) {
           return;
         }
-        const newDest = destStat && destStat.isDirectory() && copySourceDirectory ? path28.join(dest, path28.basename(source)) : dest;
+        const newDest = destStat && destStat.isDirectory() && copySourceDirectory ? path29.join(dest, path29.basename(source)) : dest;
         if (!(yield ioUtil.exists(source))) {
           throw new Error(`no such file or directory: ${source}`);
         }
@@ -20420,7 +20420,7 @@ var require_io = __commonJS({
             yield cpDirRecursive(source, newDest, 0, force);
           }
         } else {
-          if (path28.relative(source, newDest) === "") {
+          if (path29.relative(source, newDest) === "") {
             throw new Error(`'${newDest}' and '${source}' are the same file`);
           }
           yield copyFile2(source, newDest, force);
@@ -20432,7 +20432,7 @@ var require_io = __commonJS({
         if (yield ioUtil.exists(dest)) {
           let destExists = true;
           if (yield ioUtil.isDirectory(dest)) {
-            dest = path28.join(dest, path28.basename(source));
+            dest = path29.join(dest, path29.basename(source));
             destExists = yield ioUtil.exists(dest);
           }
           if (destExists) {
@@ -20443,7 +20443,7 @@ var require_io = __commonJS({
             }
           }
         }
-        yield mkdirP(path28.dirname(dest));
+        yield mkdirP(path29.dirname(dest));
         yield ioUtil.rename(source, dest);
       });
     }
@@ -20502,7 +20502,7 @@ var require_io = __commonJS({
         }
         const extensions = [];
         if (ioUtil.IS_WINDOWS && process.env["PATHEXT"]) {
-          for (const extension of process.env["PATHEXT"].split(path28.delimiter)) {
+          for (const extension of process.env["PATHEXT"].split(path29.delimiter)) {
             if (extension) {
               extensions.push(extension);
             }
@@ -20515,12 +20515,12 @@ var require_io = __commonJS({
           }
           return [];
         }
-        if (tool.includes(path28.sep)) {
+        if (tool.includes(path29.sep)) {
           return [];
         }
         const directories = [];
         if (process.env.PATH) {
-          for (const p of process.env.PATH.split(path28.delimiter)) {
+          for (const p of process.env.PATH.split(path29.delimiter)) {
             if (p) {
               directories.push(p);
             }
@@ -20528,7 +20528,7 @@ var require_io = __commonJS({
         }
         const matches = [];
         for (const directory of directories) {
-          const filePath = yield ioUtil.tryGetExecutablePath(path28.join(directory, tool), extensions);
+          const filePath = yield ioUtil.tryGetExecutablePath(path29.join(directory, tool), extensions);
           if (filePath) {
             matches.push(filePath);
           }
@@ -20627,11 +20627,11 @@ var require_toolrunner = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -20647,7 +20647,7 @@ var require_toolrunner = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -20658,7 +20658,7 @@ var require_toolrunner = __commonJS({
     var os7 = __importStar2(require("os"));
     var events = __importStar2(require("events"));
     var child = __importStar2(require("child_process"));
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var io9 = __importStar2(require_io());
     var ioUtil = __importStar2(require_io_util());
     var timers_1 = require("timers");
@@ -20873,10 +20873,10 @@ var require_toolrunner = __commonJS({
       exec() {
         return __awaiter2(this, void 0, void 0, function* () {
           if (!ioUtil.isRooted(this.toolPath) && (this.toolPath.includes("/") || IS_WINDOWS && this.toolPath.includes("\\"))) {
-            this.toolPath = path28.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
+            this.toolPath = path29.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
           }
           this.toolPath = yield io9.which(this.toolPath, true);
-          return new Promise((resolve13, reject) => __awaiter2(this, void 0, void 0, function* () {
+          return new Promise((resolve14, reject) => __awaiter2(this, void 0, void 0, function* () {
             this._debug(`exec tool: ${this.toolPath}`);
             this._debug("arguments:");
             for (const arg of this.args) {
@@ -20959,7 +20959,7 @@ var require_toolrunner = __commonJS({
               if (error3) {
                 reject(error3);
               } else {
-                resolve13(exitCode);
+                resolve14(exitCode);
               }
             });
             if (this.options.input) {
@@ -21125,11 +21125,11 @@ var require_exec = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -21145,7 +21145,7 @@ var require_exec = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -21169,12 +21169,12 @@ var require_exec = __commonJS({
     }
     function getExecOutput(commandLine, args, options) {
       return __awaiter2(this, void 0, void 0, function* () {
-        var _a, _b;
+        var _a2, _b;
         let stdout = "";
         let stderr = "";
         const stdoutDecoder = new string_decoder_1.StringDecoder("utf8");
         const stderrDecoder = new string_decoder_1.StringDecoder("utf8");
-        const originalStdoutListener = (_a = options === null || options === void 0 ? void 0 : options.listeners) === null || _a === void 0 ? void 0 : _a.stdout;
+        const originalStdoutListener = (_a2 = options === null || options === void 0 ? void 0 : options.listeners) === null || _a2 === void 0 ? void 0 : _a2.stdout;
         const originalStdErrListener = (_b = options === null || options === void 0 ? void 0 : options.listeners) === null || _b === void 0 ? void 0 : _b.stderr;
         const stdErrListener = (data) => {
           stderr += stderrDecoder.write(data);
@@ -21245,11 +21245,11 @@ var require_platform = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -21265,7 +21265,7 @@ var require_platform = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -21291,11 +21291,11 @@ var require_platform = __commonJS({
       };
     });
     var getMacOsInfo = () => __awaiter2(void 0, void 0, void 0, function* () {
-      var _a, _b, _c, _d;
+      var _a2, _b, _c, _d;
       const { stdout } = yield exec3.getExecOutput("sw_vers", void 0, {
         silent: true
       });
-      const version = (_b = (_a = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : "";
+      const version = (_b = (_a2 = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a2 === void 0 ? void 0 : _a2[1]) !== null && _b !== void 0 ? _b : "";
       const name = (_d = (_c = stdout.match(/ProductName:\s*(.+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : "";
       return {
         name,
@@ -21374,11 +21374,11 @@ var require_core = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -21394,7 +21394,7 @@ var require_core = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -21426,7 +21426,7 @@ var require_core = __commonJS({
     var file_command_1 = require_file_command();
     var utils_1 = require_utils();
     var os7 = __importStar2(require("os"));
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var oidc_utils_1 = require_oidc_utils();
     var ExitCode;
     (function(ExitCode2) {
@@ -21452,7 +21452,7 @@ var require_core = __commonJS({
       } else {
         (0, command_1.issueCommand)("add-path", {}, inputPath);
       }
-      process.env["PATH"] = `${inputPath}${path28.delimiter}${process.env["PATH"]}`;
+      process.env["PATH"] = `${inputPath}${path29.delimiter}${process.env["PATH"]}`;
     }
     function getInput2(name, options) {
       const val = process.env[`INPUT_${name.replace(/ /g, "_").toUpperCase()}`] || "";
@@ -21583,14 +21583,14 @@ var require_context = __commonJS({
        * Hydrate the context from the environment
        */
       constructor() {
-        var _a, _b, _c;
+        var _a2, _b, _c;
         this.payload = {};
         if (process.env.GITHUB_EVENT_PATH) {
           if ((0, fs_1.existsSync)(process.env.GITHUB_EVENT_PATH)) {
             this.payload = JSON.parse((0, fs_1.readFileSync)(process.env.GITHUB_EVENT_PATH, { encoding: "utf8" }));
           } else {
-            const path28 = process.env.GITHUB_EVENT_PATH;
-            process.stdout.write(`GITHUB_EVENT_PATH ${path28} does not exist${os_1.EOL}`);
+            const path29 = process.env.GITHUB_EVENT_PATH;
+            process.stdout.write(`GITHUB_EVENT_PATH ${path29} does not exist${os_1.EOL}`);
           }
         }
         this.eventName = process.env.GITHUB_EVENT_NAME;
@@ -21603,7 +21603,7 @@ var require_context = __commonJS({
         this.runAttempt = parseInt(process.env.GITHUB_RUN_ATTEMPT, 10);
         this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER, 10);
         this.runId = parseInt(process.env.GITHUB_RUN_ID, 10);
-        this.apiUrl = (_a = process.env.GITHUB_API_URL) !== null && _a !== void 0 ? _a : `https://api.github.com`;
+        this.apiUrl = (_a2 = process.env.GITHUB_API_URL) !== null && _a2 !== void 0 ? _a2 : `https://api.github.com`;
         this.serverUrl = (_b = process.env.GITHUB_SERVER_URL) !== null && _b !== void 0 ? _b : `https://github.com`;
         this.graphqlUrl = (_c = process.env.GITHUB_GRAPHQL_URL) !== null && _c !== void 0 ? _c : `https://api.github.com/graphql`;
       }
@@ -21672,11 +21672,11 @@ var require_utils3 = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -21692,7 +21692,7 @@ var require_utils3 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -21820,13 +21820,13 @@ function removeHook(state, name, method) {
   if (!state.registry[name]) {
     return;
   }
-  const index = state.registry[name].map((registered) => {
+  const index2 = state.registry[name].map((registered) => {
     return registered.orig;
   }).indexOf(method);
-  if (index === -1) {
+  if (index2 === -1) {
     return;
   }
-  state.registry[name].splice(index, 1);
+  state.registry[name].splice(index2, 1);
 }
 var init_remove = __esm({
   "node_modules/before-after-hook/lib/remove.js"() {
@@ -21908,12 +21908,12 @@ function isPlainObject(value) {
   const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
   return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
 }
-function mergeDeep(defaults, options) {
-  const result = Object.assign({}, defaults);
+function mergeDeep(defaults2, options) {
+  const result = Object.assign({}, defaults2);
   Object.keys(options).forEach((key) => {
     if (isPlainObject(options[key])) {
-      if (!(key in defaults)) Object.assign(result, { [key]: options[key] });
-      else result[key] = mergeDeep(defaults[key], options[key]);
+      if (!(key in defaults2)) Object.assign(result, { [key]: options[key] });
+      else result[key] = mergeDeep(defaults2[key], options[key]);
     } else {
       Object.assign(result, { [key]: options[key] });
     }
@@ -21928,7 +21928,7 @@ function removeUndefinedProperties(obj) {
   }
   return obj;
 }
-function merge(defaults, route, options) {
+function merge(defaults2, route, options) {
   if (typeof route === "string") {
     let [method, url2] = route.split(" ");
     options = Object.assign(url2 ? { method, url: url2 } : { url: method }, options);
@@ -21938,10 +21938,10 @@ function merge(defaults, route, options) {
   options.headers = lowercaseKeys(options.headers);
   removeUndefinedProperties(options);
   removeUndefinedProperties(options.headers);
-  const mergedOptions = mergeDeep(defaults || {}, options);
+  const mergedOptions = mergeDeep(defaults2 || {}, options);
   if (options.url === "/graphql") {
-    if (defaults && defaults.mediaType.previews?.length) {
-      mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(
+    if (defaults2 && defaults2.mediaType.previews?.length) {
+      mergedOptions.mediaType.previews = defaults2.mediaType.previews.filter(
         (preview) => !mergedOptions.mediaType.previews.includes(preview)
       ).concat(mergedOptions.mediaType.previews);
     }
@@ -22174,8 +22174,8 @@ function parse(options) {
     options.request ? { request: options.request } : null
   );
 }
-function endpointWithDefaults(defaults, route, options) {
-  return parse(merge(defaults, route, options));
+function endpointWithDefaults(defaults2, route, options) {
+  return parse(merge(defaults2, route, options));
 }
 function withDefaults(oldDefaults, newDefaults) {
   const DEFAULTS2 = merge(oldDefaults, newDefaults);
@@ -22241,8 +22241,8 @@ var require_fast_content_type_parse = __commonJS({
       if (typeof header !== "string") {
         throw new TypeError("argument header is required and must be a string");
       }
-      let index = header.indexOf(";");
-      const type = index !== -1 ? header.slice(0, index).trim() : header.trim();
+      let index2 = header.indexOf(";");
+      const type = index2 !== -1 ? header.slice(0, index2).trim() : header.trim();
       if (mediaTypeRE.test(type) === false) {
         throw new TypeError("invalid media type");
       }
@@ -22250,27 +22250,27 @@ var require_fast_content_type_parse = __commonJS({
         type: type.toLowerCase(),
         parameters: new NullObject()
       };
-      if (index === -1) {
+      if (index2 === -1) {
         return result;
       }
       let key;
-      let match;
+      let match2;
       let value;
-      paramRE.lastIndex = index;
-      while (match = paramRE.exec(header)) {
-        if (match.index !== index) {
+      paramRE.lastIndex = index2;
+      while (match2 = paramRE.exec(header)) {
+        if (match2.index !== index2) {
           throw new TypeError("invalid parameter format");
         }
-        index += match[0].length;
-        key = match[1].toLowerCase();
-        value = match[2];
+        index2 += match2[0].length;
+        key = match2[1].toLowerCase();
+        value = match2[2];
         if (value[0] === '"') {
           value = value.slice(1, value.length - 1);
           quotedPairRE.test(value) && (value = value.replace(quotedPairRE, "$1"));
         }
         result.parameters[key] = value;
       }
-      if (index !== header.length) {
+      if (index2 !== header.length) {
         throw new TypeError("invalid parameter format");
       }
       return result;
@@ -22279,8 +22279,8 @@ var require_fast_content_type_parse = __commonJS({
       if (typeof header !== "string") {
         return defaultContentType;
       }
-      let index = header.indexOf(";");
-      const type = index !== -1 ? header.slice(0, index).trim() : header.trim();
+      let index2 = header.indexOf(";");
+      const type = index2 !== -1 ? header.slice(0, index2).trim() : header.trim();
       if (mediaTypeRE.test(type) === false) {
         return defaultContentType;
       }
@@ -22288,27 +22288,27 @@ var require_fast_content_type_parse = __commonJS({
         type: type.toLowerCase(),
         parameters: new NullObject()
       };
-      if (index === -1) {
+      if (index2 === -1) {
         return result;
       }
       let key;
-      let match;
+      let match2;
       let value;
-      paramRE.lastIndex = index;
-      while (match = paramRE.exec(header)) {
-        if (match.index !== index) {
+      paramRE.lastIndex = index2;
+      while (match2 = paramRE.exec(header)) {
+        if (match2.index !== index2) {
           return defaultContentType;
         }
-        index += match[0].length;
-        key = match[1].toLowerCase();
-        value = match[2];
+        index2 += match2[0].length;
+        key = match2[1].toLowerCase();
+        value = match2[2];
         if (value[0] === '"') {
           value = value.slice(1, value.length - 1);
           quotedPairRE.test(value) && (value = value.replace(quotedPairRE, "$1"));
         }
         result.parameters[key] = value;
       }
-      if (index !== header.length) {
+      if (index2 !== header.length) {
         return defaultContentType;
       }
       return result;
@@ -22774,21 +22774,21 @@ var init_dist_src2 = __esm({
     userAgentTrail = `octokit-core.js/${VERSION4} ${getUserAgent()}`;
     Octokit = class {
       static VERSION = VERSION4;
-      static defaults(defaults) {
+      static defaults(defaults2) {
         const OctokitWithDefaults = class extends this {
           constructor(...args) {
             const options = args[0] || {};
-            if (typeof defaults === "function") {
-              super(defaults(options));
+            if (typeof defaults2 === "function") {
+              super(defaults2(options));
               return;
             }
             super(
               Object.assign(
                 {},
-                defaults,
+                defaults2,
                 options,
-                options.userAgent && defaults.userAgent ? {
-                  userAgent: `${options.userAgent} ${defaults.userAgent}`
+                options.userAgent && defaults2.userAgent ? {
+                  userAgent: `${options.userAgent} ${defaults2.userAgent}`
                 } : null
               )
             );
@@ -25200,8 +25200,8 @@ function endpointsToMethods(octokit) {
   }
   return newMethods;
 }
-function decorate(octokit, scope, methodName, defaults, decorations) {
-  const requestWithDefaults = octokit.request.defaults(defaults);
+function decorate(octokit, scope, methodName, defaults2, decorations) {
+  const requestWithDefaults = octokit.request.defaults(defaults2);
   function withDecorations(...args) {
     let options = requestWithDefaults.endpoint.merge(...args);
     if (decorations.mapToData) {
@@ -25248,14 +25248,14 @@ var init_endpoints_to_methods = __esm({
     endpointMethodsMap = /* @__PURE__ */ new Map();
     for (const [scope, endpoints] of Object.entries(endpoints_default)) {
       for (const [methodName, endpoint2] of Object.entries(endpoints)) {
-        const [route, defaults, decorations] = endpoint2;
+        const [route, defaults2, decorations] = endpoint2;
         const [method, url2] = route.split(/ /);
         const endpointDefaults = Object.assign(
           {
             method,
             url: url2
           },
-          defaults
+          defaults2
         );
         if (!endpointMethodsMap.has(scope)) {
           endpointMethodsMap.set(scope, /* @__PURE__ */ new Map());
@@ -25954,13 +25954,13 @@ var require_re = __commonJS({
     };
     var createToken = (name, value, isGlobal) => {
       const safe = makeSafeRegex(value);
-      const index = R++;
-      debug6(name, index, value);
-      t[name] = index;
-      src[index] = value;
-      safeSrc[index] = safe;
-      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
-      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+      const index2 = R++;
+      debug6(name, index2, value);
+      t[name] = index2;
+      src[index2] = value;
+      safeSrc[index2] = safe;
+      re[index2] = new RegExp(value, isGlobal ? "g" : void 0);
+      safeRe[index2] = new RegExp(safe, isGlobal ? "g" : void 0);
     };
     createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
     createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
@@ -26034,13 +26034,13 @@ var require_parse_options = __commonJS({
 var require_identifiers = __commonJS({
   "node_modules/semver/internal/identifiers.js"(exports2, module2) {
     "use strict";
-    var numeric = /^[0-9]+$/;
+    var numeric2 = /^[0-9]+$/;
     var compareIdentifiers = (a, b) => {
       if (typeof a === "number" && typeof b === "number") {
         return a === b ? 0 : a < b ? -1 : 1;
       }
-      const anum = numeric.test(a);
-      const bnum = numeric.test(b);
+      const anum = numeric2.test(a);
+      const bnum = numeric2.test(b);
       if (anum && bnum) {
         a = +a;
         b = +b;
@@ -26236,8 +26236,8 @@ var require_semver = __commonJS({
             throw new Error("invalid increment argument: identifier is empty");
           }
           if (identifier) {
-            const match = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
-            if (!match || match[1] !== identifier) {
+            const match2 = `-${identifier}`.match(this.options.loose ? re[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+            if (!match2 || match2[1] !== identifier) {
               throw new Error(`invalid identifier: ${identifier}`);
             }
           }
@@ -26615,8 +26615,8 @@ var require_gte = __commonJS({
   "node_modules/semver/functions/gte.js"(exports2, module2) {
     "use strict";
     var compare3 = require_compare();
-    var gte6 = (a, b, loose) => compare3(a, b, loose) >= 0;
-    module2.exports = gte6;
+    var gte7 = (a, b, loose) => compare3(a, b, loose) >= 0;
+    module2.exports = gte7;
   }
 });
 
@@ -26625,8 +26625,8 @@ var require_lte = __commonJS({
   "node_modules/semver/functions/lte.js"(exports2, module2) {
     "use strict";
     var compare3 = require_compare();
-    var lte = (a, b, loose) => compare3(a, b, loose) <= 0;
-    module2.exports = lte;
+    var lte2 = (a, b, loose) => compare3(a, b, loose) <= 0;
+    module2.exports = lte2;
   }
 });
 
@@ -26637,9 +26637,9 @@ var require_cmp = __commonJS({
     var eq = require_eq();
     var neq = require_neq();
     var gt = require_gt();
-    var gte6 = require_gte();
+    var gte7 = require_gte();
     var lt2 = require_lt();
-    var lte = require_lte();
+    var lte2 = require_lte();
     var cmp = (a, op, b, loose) => {
       switch (op) {
         case "===":
@@ -26667,11 +26667,11 @@ var require_cmp = __commonJS({
         case ">":
           return gt(a, b, loose);
         case ">=":
-          return gte6(a, b, loose);
+          return gte7(a, b, loose);
         case "<":
           return lt2(a, b, loose);
         case "<=":
-          return lte(a, b, loose);
+          return lte2(a, b, loose);
         default:
           throw new TypeError(`Invalid operator: ${op}`);
       }
@@ -26698,28 +26698,28 @@ var require_coerce = __commonJS({
         return null;
       }
       options = options || {};
-      let match = null;
+      let match2 = null;
       if (!options.rtl) {
-        match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+        match2 = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
       } else {
         const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
         let next;
-        while ((next = coerceRtlRegex.exec(version)) && (!match || match.index + match[0].length !== version.length)) {
-          if (!match || next.index + next[0].length !== match.index + match[0].length) {
-            match = next;
+        while ((next = coerceRtlRegex.exec(version)) && (!match2 || match2.index + match2[0].length !== version.length)) {
+          if (!match2 || next.index + next[0].length !== match2.index + match2[0].length) {
+            match2 = next;
           }
           coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
         }
         coerceRtlRegex.lastIndex = -1;
       }
-      if (match === null) {
+      if (match2 === null) {
         return null;
       }
-      const major = match[2];
-      const minor = match[3] || "0";
-      const patch = match[4] || "0";
-      const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : "";
-      const build = options.includePrerelease && match[6] ? `+${match[6]}` : "";
+      const major = match2[2];
+      const minor = match2[3] || "0";
+      const patch = match2[4] || "0";
+      const prerelease = options.includePrerelease && match2[5] ? `-${match2[5]}` : "";
+      const build = options.includePrerelease && match2[6] ? `+${match2[6]}` : "";
       return parse2(`${major}.${minor}.${patch}${prerelease}${build}`, options);
     };
     module2.exports = coerce3;
@@ -26811,25 +26811,25 @@ var require_range = __commonJS({
     "use strict";
     var SPACE_CHARACTERS = /\s+/g;
     var Range2 = class _Range {
-      constructor(range, options) {
+      constructor(range2, options) {
         options = parseOptions(options);
-        if (range instanceof _Range) {
-          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
-            return range;
+        if (range2 instanceof _Range) {
+          if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) {
+            return range2;
           } else {
-            return new _Range(range.raw, options);
+            return new _Range(range2.raw, options);
           }
         }
-        if (range instanceof Comparator) {
-          this.raw = range.value;
-          this.set = [[range]];
+        if (range2 instanceof Comparator) {
+          this.raw = range2.value;
+          this.set = [[range2]];
           this.formatted = void 0;
           return this;
         }
         this.options = options;
         this.loose = !!options.loose;
         this.includePrerelease = !!options.includePrerelease;
-        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.raw = range2.trim().replace(SPACE_CHARACTERS, " ");
         this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
         if (!this.set.length) {
           throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
@@ -26874,25 +26874,25 @@ var require_range = __commonJS({
       toString() {
         return this.range;
       }
-      parseRange(range) {
-        range = range.replace(BUILDSTRIPRE, "");
+      parseRange(range2) {
+        range2 = range2.replace(BUILDSTRIPRE, "");
         const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
-        const memoKey = memoOpts + ":" + range;
+        const memoKey = memoOpts + ":" + range2;
         const cached = cache.get(memoKey);
         if (cached) {
           return cached;
         }
         const loose = this.options.loose;
         const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
-        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
-        debug6("hyphen replace", range);
-        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
-        debug6("comparator trim", range);
-        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
-        debug6("tilde trim", range);
-        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
-        debug6("caret trim", range);
-        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        range2 = range2.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug6("hyphen replace", range2);
+        range2 = range2.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+        debug6("comparator trim", range2);
+        range2 = range2.replace(re[t.TILDETRIM], tildeTrimReplace);
+        debug6("tilde trim", range2);
+        range2 = range2.replace(re[t.CARETTRIM], caretTrimReplace);
+        debug6("caret trim", range2);
+        let rangeList = range2.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
         if (loose) {
           rangeList = rangeList.filter((comp) => {
             debug6("loose invalid filter", comp, this.options);
@@ -26915,12 +26915,12 @@ var require_range = __commonJS({
         cache.set(memoKey, result);
         return result;
       }
-      intersects(range, options) {
-        if (!(range instanceof _Range)) {
+      intersects(range2, options) {
+        if (!(range2 instanceof _Range)) {
           throw new TypeError("a Range is required");
         }
         return this.set.some((thisComparators) => {
-          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+          return isSatisfiable(thisComparators, options) && range2.set.some((rangeComparators) => {
             return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
               return rangeComparators.every((rangeComparator) => {
                 return thisComparator.intersects(rangeComparator, options);
@@ -27307,13 +27307,13 @@ var require_satisfies = __commonJS({
   "node_modules/semver/functions/satisfies.js"(exports2, module2) {
     "use strict";
     var Range2 = require_range();
-    var satisfies2 = (version, range, options) => {
+    var satisfies2 = (version, range2, options) => {
       try {
-        range = new Range2(range, options);
+        range2 = new Range2(range2, options);
       } catch (er) {
         return false;
       }
-      return range.test(version);
+      return range2.test(version);
     };
     module2.exports = satisfies2;
   }
@@ -27324,7 +27324,7 @@ var require_to_comparators = __commonJS({
   "node_modules/semver/ranges/to-comparators.js"(exports2, module2) {
     "use strict";
     var Range2 = require_range();
-    var toComparators = (range, options) => new Range2(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+    var toComparators = (range2, options) => new Range2(range2, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
     module2.exports = toComparators;
   }
 });
@@ -27335,12 +27335,12 @@ var require_max_satisfying = __commonJS({
     "use strict";
     var SemVer = require_semver();
     var Range2 = require_range();
-    var maxSatisfying = (versions, range, options) => {
+    var maxSatisfying = (versions, range2, options) => {
       let max = null;
       let maxSV = null;
       let rangeObj = null;
       try {
-        rangeObj = new Range2(range, options);
+        rangeObj = new Range2(range2, options);
       } catch (er) {
         return null;
       }
@@ -27364,12 +27364,12 @@ var require_min_satisfying = __commonJS({
     "use strict";
     var SemVer = require_semver();
     var Range2 = require_range();
-    var minSatisfying = (versions, range, options) => {
+    var minSatisfying = (versions, range2, options) => {
       let min = null;
       let minSV = null;
       let rangeObj = null;
       try {
-        rangeObj = new Range2(range, options);
+        rangeObj = new Range2(range2, options);
       } catch (er) {
         return null;
       }
@@ -27394,19 +27394,19 @@ var require_min_version = __commonJS({
     var SemVer = require_semver();
     var Range2 = require_range();
     var gt = require_gt();
-    var minVersion = (range, loose) => {
-      range = new Range2(range, loose);
+    var minVersion = (range2, loose) => {
+      range2 = new Range2(range2, loose);
       let minver = new SemVer("0.0.0");
-      if (range.test(minver)) {
+      if (range2.test(minver)) {
         return minver;
       }
       minver = new SemVer("0.0.0-0");
-      if (range.test(minver)) {
+      if (range2.test(minver)) {
         return minver;
       }
       minver = null;
-      for (let i = 0; i < range.set.length; ++i) {
-        const comparators = range.set[i];
+      for (let i = 0; i < range2.set.length; ++i) {
+        const comparators = range2.set[i];
         let setMin = null;
         comparators.forEach((comparator) => {
           const compver = new SemVer(comparator.semver.version);
@@ -27437,7 +27437,7 @@ var require_min_version = __commonJS({
           minver = setMin;
         }
       }
-      if (minver && range.test(minver)) {
+      if (minver && range2.test(minver)) {
         return minver;
       }
       return null;
@@ -27451,9 +27451,9 @@ var require_valid2 = __commonJS({
   "node_modules/semver/ranges/valid.js"(exports2, module2) {
     "use strict";
     var Range2 = require_range();
-    var validRange = (range, options) => {
+    var validRange = (range2, options) => {
       try {
-        return new Range2(range, options).range || "*";
+        return new Range2(range2, options).range || "*";
       } catch (er) {
         return null;
       }
@@ -27473,23 +27473,23 @@ var require_outside = __commonJS({
     var satisfies2 = require_satisfies();
     var gt = require_gt();
     var lt2 = require_lt();
-    var lte = require_lte();
-    var gte6 = require_gte();
-    var outside = (version, range, hilo, options) => {
+    var lte2 = require_lte();
+    var gte7 = require_gte();
+    var outside = (version, range2, hilo, options) => {
       version = new SemVer(version, options);
-      range = new Range2(range, options);
+      range2 = new Range2(range2, options);
       let gtfn, ltefn, ltfn, comp, ecomp;
       switch (hilo) {
         case ">":
           gtfn = gt;
-          ltefn = lte;
+          ltefn = lte2;
           ltfn = lt2;
           comp = ">";
           ecomp = ">=";
           break;
         case "<":
           gtfn = lt2;
-          ltefn = gte6;
+          ltefn = gte7;
           ltfn = gt;
           comp = "<";
           ecomp = "<=";
@@ -27497,11 +27497,11 @@ var require_outside = __commonJS({
         default:
           throw new TypeError('Must provide a hilo val of "<" or ">"');
       }
-      if (satisfies2(version, range, options)) {
+      if (satisfies2(version, range2, options)) {
         return false;
       }
-      for (let i = 0; i < range.set.length; ++i) {
-        const comparators = range.set[i];
+      for (let i = 0; i < range2.set.length; ++i) {
+        const comparators = range2.set[i];
         let high = null;
         let low = null;
         comparators.forEach((comparator) => {
@@ -27536,7 +27536,7 @@ var require_gtr = __commonJS({
   "node_modules/semver/ranges/gtr.js"(exports2, module2) {
     "use strict";
     var outside = require_outside();
-    var gtr = (version, range, options) => outside(version, range, ">", options);
+    var gtr = (version, range2, options) => outside(version, range2, ">", options);
     module2.exports = gtr;
   }
 });
@@ -27546,7 +27546,7 @@ var require_ltr = __commonJS({
   "node_modules/semver/ranges/ltr.js"(exports2, module2) {
     "use strict";
     var outside = require_outside();
-    var ltr = (version, range, options) => outside(version, range, "<", options);
+    var ltr = (version, range2, options) => outside(version, range2, "<", options);
     module2.exports = ltr;
   }
 });
@@ -27571,13 +27571,13 @@ var require_simplify = __commonJS({
     "use strict";
     var satisfies2 = require_satisfies();
     var compare3 = require_compare();
-    module2.exports = (versions, range, options) => {
+    module2.exports = (versions, range2, options) => {
       const set = [];
       let first = null;
       let prev = null;
       const v = versions.sort((a, b) => compare3(a, b, options));
       for (const version of v) {
-        const included = satisfies2(version, range, options);
+        const included = satisfies2(version, range2, options);
         if (included) {
           prev = version;
           if (!first) {
@@ -27609,8 +27609,8 @@ var require_simplify = __commonJS({
         }
       }
       const simplified = ranges.join(" || ");
-      const original = typeof range.raw === "string" ? range.raw : String(range);
-      return simplified.length < original.length ? simplified : range;
+      const original = typeof range2.raw === "string" ? range2.raw : String(range2);
+      return simplified.length < original.length ? simplified : range2;
     };
   }
 });
@@ -27804,8 +27804,8 @@ var require_semver2 = __commonJS({
     var lt2 = require_lt();
     var eq = require_eq();
     var neq = require_neq();
-    var gte6 = require_gte();
-    var lte = require_lte();
+    var gte7 = require_gte();
+    var lte2 = require_lte();
     var cmp = require_cmp();
     var coerce3 = require_coerce();
     var truncate = require_truncate();
@@ -27843,8 +27843,8 @@ var require_semver2 = __commonJS({
       lt: lt2,
       eq,
       neq,
-      gte: gte6,
-      lte,
+      gte: gte7,
+      lte: lte2,
       cmp,
       coerce: coerce3,
       truncate,
@@ -27885,19 +27885,19 @@ var require_light = __commonJS({
       function getCjsExportFromNamespace(n) {
         return n && n["default"] || n;
       }
-      var load2 = function(received, defaults, onto = {}) {
+      var load2 = function(received, defaults2, onto = {}) {
         var k, ref, v;
-        for (k in defaults) {
-          v = defaults[k];
+        for (k in defaults2) {
+          v = defaults2[k];
           onto[k] = (ref = received[k]) != null ? ref : v;
         }
         return onto;
       };
-      var overwrite = function(received, defaults, onto = {}) {
+      var overwrite = function(received, defaults2, onto = {}) {
         var k, v;
         for (k in received) {
           v = received[k];
-          if (defaults[k] !== void 0) {
+          if (defaults2[k] !== void 0) {
             onto[k] = v;
           }
         }
@@ -28327,8 +28327,8 @@ var require_light = __commonJS({
           return this.Promise.resolve();
         }
         yieldLoop(t = 0) {
-          return new this.Promise(function(resolve13, reject) {
-            return setTimeout(resolve13, t);
+          return new this.Promise(function(resolve14, reject) {
+            return setTimeout(resolve14, t);
           });
         }
         computePenalty() {
@@ -28399,7 +28399,7 @@ var require_light = __commonJS({
           now = Date.now();
           return this.check(weight, now);
         }
-        async __register__(index, weight, expiration) {
+        async __register__(index2, weight, expiration) {
           var now, wait;
           await this.yieldLoop();
           now = Date.now();
@@ -28444,7 +28444,7 @@ var require_light = __commonJS({
             strategy: this.storeOptions.strategy
           };
         }
-        async __free__(index, weight) {
+        async __free__(index2, weight) {
           await this.yieldLoop();
           this._running -= weight;
           this._done += weight;
@@ -28539,15 +28539,15 @@ var require_light = __commonJS({
           return this._queue.length === 0;
         }
         async _tryToRun() {
-          var args, cb, error3, reject, resolve13, returned, task;
+          var args, cb, error3, reject, resolve14, returned, task;
           if (this._running < 1 && this._queue.length > 0) {
             this._running++;
-            ({ task, args, resolve: resolve13, reject } = this._queue.shift());
+            ({ task, args, resolve: resolve14, reject } = this._queue.shift());
             cb = await (async function() {
               try {
                 returned = await task(...args);
                 return function() {
-                  return resolve13(returned);
+                  return resolve14(returned);
                 };
               } catch (error1) {
                 error3 = error1;
@@ -28562,13 +28562,13 @@ var require_light = __commonJS({
           }
         }
         schedule(task, ...args) {
-          var promise, reject, resolve13;
-          resolve13 = reject = null;
+          var promise, reject, resolve14;
+          resolve14 = reject = null;
           promise = new this.Promise(function(_resolve, _reject) {
-            resolve13 = _resolve;
+            resolve14 = _resolve;
             return reject = _reject;
           });
-          this._queue.push({ task, args, resolve: resolve13, reject });
+          this._queue.push({ task, args, resolve: resolve14, reject });
           this._tryToRun();
           return promise;
         }
@@ -28870,19 +28870,19 @@ var require_light = __commonJS({
           check(weight = 1) {
             return this._store.__check__(weight);
           }
-          _clearGlobalState(index) {
-            if (this._scheduled[index] != null) {
-              clearTimeout(this._scheduled[index].expiration);
-              delete this._scheduled[index];
+          _clearGlobalState(index2) {
+            if (this._scheduled[index2] != null) {
+              clearTimeout(this._scheduled[index2].expiration);
+              delete this._scheduled[index2];
               return true;
             } else {
               return false;
             }
           }
-          async _free(index, job, options, eventInfo) {
+          async _free(index2, job, options, eventInfo) {
             var e, running;
             try {
-              ({ running } = await this._store.__free__(index, options.weight));
+              ({ running } = await this._store.__free__(index2, options.weight));
               this.Events.trigger("debug", `Freed ${options.id}`, eventInfo);
               if (running === 0 && this.empty()) {
                 return this.Events.trigger("idle");
@@ -28892,13 +28892,13 @@ var require_light = __commonJS({
               return this.Events.trigger("error", e);
             }
           }
-          _run(index, job, wait) {
+          _run(index2, job, wait) {
             var clearGlobalState, free, run9;
             job.doRun();
-            clearGlobalState = this._clearGlobalState.bind(this, index);
-            run9 = this._run.bind(this, index, job);
-            free = this._free.bind(this, index, job);
-            return this._scheduled[index] = {
+            clearGlobalState = this._clearGlobalState.bind(this, index2);
+            run9 = this._run.bind(this, index2, job);
+            free = this._free.bind(this, index2, job);
+            return this._scheduled[index2] = {
               timeout: setTimeout(() => {
                 return job.doExecute(this._limiter, clearGlobalState, run9, free);
               }, wait),
@@ -28910,22 +28910,22 @@ var require_light = __commonJS({
           }
           _drainOne(capacity) {
             return this._registerLock.schedule(() => {
-              var args, index, next, options, queue;
+              var args, index2, next, options, queue2;
               if (this.queued() === 0) {
                 return this.Promise.resolve(null);
               }
-              queue = this._queues.getFirst();
-              ({ options, args } = next = queue.first());
+              queue2 = this._queues.getFirst();
+              ({ options, args } = next = queue2.first());
               if (capacity != null && options.weight > capacity) {
                 return this.Promise.resolve(null);
               }
               this.Events.trigger("debug", `Draining ${options.id}`, { args, options });
-              index = this._randomIndex();
-              return this._store.__register__(index, options.weight, options.expiration).then(({ success, wait, reservoir }) => {
+              index2 = this._randomIndex();
+              return this._store.__register__(index2, options.weight, options.expiration).then(({ success, wait, reservoir }) => {
                 var empty;
                 this.Events.trigger("debug", `Drained ${options.id}`, { success, args, options });
                 if (success) {
-                  queue.shift();
+                  queue2.shift();
                   empty = this.empty();
                   if (empty) {
                     this.Events.trigger("empty");
@@ -28933,7 +28933,7 @@ var require_light = __commonJS({
                   if (reservoir === 0) {
                     this.Events.trigger("depleted", empty);
                   }
-                  this._run(index, next, wait);
+                  this._run(index2, next, wait);
                   return this.Promise.resolve(options.weight);
                 } else {
                   return this.Promise.resolve(null);
@@ -28969,20 +28969,20 @@ var require_light = __commonJS({
                 counts = this._states.counts;
                 return counts[0] + counts[1] + counts[2] + counts[3] === at;
               };
-              return new this.Promise((resolve13, reject) => {
+              return new this.Promise((resolve14, reject) => {
                 if (finished()) {
-                  return resolve13();
+                  return resolve14();
                 } else {
                   return this.on("done", () => {
                     if (finished()) {
                       this.removeAllListeners("done");
-                      return resolve13();
+                      return resolve14();
                     }
                   });
                 }
               });
             };
-            done = options.dropWaitingJobs ? (this._run = function(index, next) {
+            done = options.dropWaitingJobs ? (this._run = function(index2, next) {
               return next.doDrop({
                 message: options.dropErrorMessage
               });
@@ -29069,9 +29069,9 @@ var require_light = __commonJS({
               options = parser$5.load(options, this.jobDefaults);
             }
             task = (...args2) => {
-              return new this.Promise(function(resolve13, reject) {
+              return new this.Promise(function(resolve14, reject) {
                 return fn(...args2, function(...args3) {
-                  return (args3[0] != null ? reject : resolve13)(args3);
+                  return (args3[0] != null ? reject : resolve14)(args3);
                 });
               });
             };
@@ -29197,14 +29197,14 @@ var require_light = __commonJS({
 var require_helpers = __commonJS({
   "node_modules/jsonschema/lib/helpers.js"(exports2, module2) {
     "use strict";
-    var ValidationError = exports2.ValidationError = function ValidationError2(message, instance, schema, path28, name, argument) {
-      if (Array.isArray(path28)) {
-        this.path = path28;
-        this.property = path28.reduce(function(sum, item) {
+    var ValidationError = exports2.ValidationError = function ValidationError2(message, instance, schema, path29, name, argument) {
+      if (Array.isArray(path29)) {
+        this.path = path29;
+        this.property = path29.reduce(function(sum, item) {
           return sum + makeSuffix(item);
         }, "instance");
-      } else if (path28 !== void 0) {
-        this.property = path28;
+      } else if (path29 !== void 0) {
+        this.property = path29;
       }
       if (message) {
         this.message = message;
@@ -29297,28 +29297,28 @@ var require_helpers = __commonJS({
         name: { value: "SchemaError", enumerable: false }
       }
     );
-    var SchemaContext = exports2.SchemaContext = function SchemaContext2(schema, options, path28, base, schemas) {
+    var SchemaContext = exports2.SchemaContext = function SchemaContext2(schema, options, path29, base, schemas) {
       this.schema = schema;
       this.options = options;
-      if (Array.isArray(path28)) {
-        this.path = path28;
-        this.propertyPath = path28.reduce(function(sum, item) {
+      if (Array.isArray(path29)) {
+        this.path = path29;
+        this.propertyPath = path29.reduce(function(sum, item) {
           return sum + makeSuffix(item);
         }, "instance");
       } else {
-        this.propertyPath = path28;
+        this.propertyPath = path29;
       }
       this.base = base;
       this.schemas = schemas;
     };
-    SchemaContext.prototype.resolve = function resolve13(target) {
+    SchemaContext.prototype.resolve = function resolve14(target) {
       return (() => resolveUrl(this.base, target))();
     };
     SchemaContext.prototype.makeChild = function makeChild(schema, propertyName) {
-      var path28 = propertyName === void 0 ? this.path : this.path.concat([propertyName]);
+      var path29 = propertyName === void 0 ? this.path : this.path.concat([propertyName]);
       var id = schema.$id || schema.id;
       let base = (() => resolveUrl(this.base, id || ""))();
-      var ctx = new SchemaContext(schema, this.options, path28, base, Object.create(this.schemas));
+      var ctx = new SchemaContext(schema, this.options, path29, base, Object.create(this.schemas));
       if (id && !ctx.schemas[base]) {
         ctx.schemas[base] = schema;
       }
@@ -29551,9 +29551,9 @@ var require_attribute = __commonJS({
         return null;
       }
       var result = new ValidatorResult(instance, schema, options, ctx);
-      var types2 = Array.isArray(schema.type) ? schema.type : [schema.type];
-      if (!types2.some(this.testType.bind(this, instance, schema, options, ctx))) {
-        var list = types2.map(function(v) {
+      var types3 = Array.isArray(schema.type) ? schema.type : [schema.type];
+      if (!types3.some(this.testType.bind(this, instance, schema, options, ctx))) {
+        var list = types3.map(function(v) {
           if (!v) return;
           var id = v.$id || v.id;
           return id ? "<" + id + ">" : v + "";
@@ -30274,7 +30274,7 @@ var require_validator = __commonJS({
       this.customFormats = Object.create(Validator4.prototype.customFormats);
       this.schemas = {};
       this.unresolvedRefs = [];
-      this.types = Object.create(types2);
+      this.types = Object.create(types3);
       this.attributes = Object.create(attribute.validators);
     };
     Validator3.prototype.customFormats = {};
@@ -30416,7 +30416,7 @@ var require_validator = __commonJS({
       }
       return schema;
     };
-    Validator3.prototype.resolve = function resolve13(schema, switchSchema, ctx) {
+    Validator3.prototype.resolve = function resolve14(schema, switchSchema, ctx) {
       switchSchema = ctx.resolve(switchSchema);
       if (ctx.schemas[switchSchema]) {
         return { subschema: ctx.schemas[switchSchema], switchSchema };
@@ -30448,32 +30448,32 @@ var require_validator = __commonJS({
       }
       return true;
     };
-    var types2 = Validator3.prototype.types = {};
-    types2.string = function testString(instance) {
+    var types3 = Validator3.prototype.types = {};
+    types3.string = function testString(instance) {
       return typeof instance == "string";
     };
-    types2.number = function testNumber(instance) {
+    types3.number = function testNumber(instance) {
       return typeof instance == "number" && isFinite(instance);
     };
-    types2.integer = function testInteger(instance) {
+    types3.integer = function testInteger(instance) {
       return typeof instance == "number" && instance % 1 === 0;
     };
-    types2.boolean = function testBoolean(instance) {
+    types3.boolean = function testBoolean(instance) {
       return typeof instance == "boolean";
     };
-    types2.array = function testArray(instance) {
+    types3.array = function testArray(instance) {
       return Array.isArray(instance);
     };
-    types2["null"] = function testNull(instance) {
+    types3["null"] = function testNull(instance) {
       return instance === null;
     };
-    types2.date = function testDate(instance) {
+    types3.date = function testDate(instance) {
       return instance instanceof Date;
     };
-    types2.any = function testAny(instance) {
+    types3.any = function testAny(instance) {
       return true;
     };
-    types2.object = function testObject(instance) {
+    types3.object = function testObject(instance) {
       return instance && typeof instance === "object" && !Array.isArray(instance) && !(instance instanceof Date);
     };
     module2.exports = Validator3;
@@ -30773,21 +30773,21 @@ var require_internal_path_helper = __commonJS({
       return mod && mod.__esModule ? mod : { "default": mod };
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.dirname = dirname5;
+    exports2.dirname = dirname6;
     exports2.ensureAbsoluteRoot = ensureAbsoluteRoot;
     exports2.hasAbsoluteRoot = hasAbsoluteRoot;
     exports2.hasRoot = hasRoot;
     exports2.normalizeSeparators = normalizeSeparators;
     exports2.safeTrimTrailingSeparator = safeTrimTrailingSeparator;
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var assert_1 = __importDefault2(require("assert"));
     var IS_WINDOWS = process.platform === "win32";
-    function dirname5(p) {
+    function dirname6(p) {
       p = safeTrimTrailingSeparator(p);
       if (IS_WINDOWS && /^\\\\[^\\]+(\\[^\\]+)?$/.test(p)) {
         return p;
       }
-      let result = path28.dirname(p);
+      let result = path29.dirname(p);
       if (IS_WINDOWS && /^\\\\[^\\]+\\[^\\]+\\$/.test(result)) {
         result = safeTrimTrailingSeparator(result);
       }
@@ -30824,7 +30824,7 @@ var require_internal_path_helper = __commonJS({
       (0, assert_1.default)(hasAbsoluteRoot(root), `ensureAbsoluteRoot parameter 'root' must have an absolute root`);
       if (root.endsWith("/") || IS_WINDOWS && root.endsWith("\\")) {
       } else {
-        root += path28.sep;
+        root += path29.sep;
       }
       return root + itemPath;
     }
@@ -30858,10 +30858,10 @@ var require_internal_path_helper = __commonJS({
         return "";
       }
       p = normalizeSeparators(p);
-      if (!p.endsWith(path28.sep)) {
+      if (!p.endsWith(path29.sep)) {
         return p;
       }
-      if (p === path28.sep) {
+      if (p === path29.sep) {
         return p;
       }
       if (IS_WINDOWS && /^[A-Z]:\\$/i.test(p)) {
@@ -30931,7 +30931,7 @@ var require_internal_pattern_helper = __commonJS({
     })();
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getSearchPaths = getSearchPaths;
-    exports2.match = match;
+    exports2.match = match2;
     exports2.partialMatch = partialMatch;
     var pathHelper = __importStar2(require_internal_path_helper());
     var internal_match_kind_1 = require_internal_match_kind();
@@ -30967,7 +30967,7 @@ var require_internal_pattern_helper = __commonJS({
       }
       return result;
     }
-    function match(patterns, itemPath) {
+    function match2(patterns, itemPath) {
       let result = internal_match_kind_1.MatchKind.None;
       for (const pattern of patterns) {
         if (pattern.negate) {
@@ -31006,11 +31006,11 @@ var require_concat_map = __commonJS({
 var require_balanced_match = __commonJS({
   "node_modules/balanced-match/index.js"(exports2, module2) {
     "use strict";
-    module2.exports = balanced;
-    function balanced(a, b, str) {
-      if (a instanceof RegExp) a = maybeMatch(a, str);
-      if (b instanceof RegExp) b = maybeMatch(b, str);
-      var r = range(a, b, str);
+    module2.exports = balanced2;
+    function balanced2(a, b, str) {
+      if (a instanceof RegExp) a = maybeMatch2(a, str);
+      if (b instanceof RegExp) b = maybeMatch2(b, str);
+      var r = range2(a, b, str);
       return r && {
         start: r[0],
         end: r[1],
@@ -31019,12 +31019,12 @@ var require_balanced_match = __commonJS({
         post: str.slice(r[1] + b.length)
       };
     }
-    function maybeMatch(reg, str) {
+    function maybeMatch2(reg, str) {
       var m = str.match(reg);
       return m ? m[0] : null;
     }
-    balanced.range = range;
-    function range(a, b, str) {
+    balanced2.range = range2;
+    function range2(a, b, str) {
       var begs, beg, left, right, result;
       var ai = str.indexOf(a);
       var bi = str.indexOf(b, ai + 1);
@@ -31061,27 +31061,27 @@ var require_balanced_match = __commonJS({
 var require_brace_expansion = __commonJS({
   "node_modules/brace-expansion/index.js"(exports2, module2) {
     var concatMap = require_concat_map();
-    var balanced = require_balanced_match();
+    var balanced2 = require_balanced_match();
     module2.exports = expandTop;
-    var escSlash = "\0SLASH" + Math.random() + "\0";
-    var escOpen = "\0OPEN" + Math.random() + "\0";
-    var escClose = "\0CLOSE" + Math.random() + "\0";
-    var escComma = "\0COMMA" + Math.random() + "\0";
-    var escPeriod = "\0PERIOD" + Math.random() + "\0";
-    function numeric(str) {
+    var escSlash2 = "\0SLASH" + Math.random() + "\0";
+    var escOpen2 = "\0OPEN" + Math.random() + "\0";
+    var escClose2 = "\0CLOSE" + Math.random() + "\0";
+    var escComma2 = "\0COMMA" + Math.random() + "\0";
+    var escPeriod2 = "\0PERIOD" + Math.random() + "\0";
+    function numeric2(str) {
       return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
     }
-    function escapeBraces(str) {
-      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+    function escapeBraces2(str) {
+      return str.split("\\\\").join(escSlash2).split("\\{").join(escOpen2).split("\\}").join(escClose2).split("\\,").join(escComma2).split("\\.").join(escPeriod2);
     }
-    function unescapeBraces(str) {
-      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+    function unescapeBraces2(str) {
+      return str.split(escSlash2).join("\\").split(escOpen2).join("{").split(escClose2).join("}").split(escComma2).join(",").split(escPeriod2).join(".");
     }
-    function parseCommaParts(str) {
+    function parseCommaParts2(str) {
       if (!str)
         return [""];
       var parts = [];
-      var m = balanced("{", "}", str);
+      var m = balanced2("{", "}", str);
       if (!m)
         return str.split(",");
       var pre = m.pre;
@@ -31089,7 +31089,7 @@ var require_brace_expansion = __commonJS({
       var post = m.post;
       var p = pre.split(",");
       p[p.length - 1] += "{" + body + "}";
-      var postParts = parseCommaParts(post);
+      var postParts = parseCommaParts2(post);
       if (post.length) {
         p[p.length - 1] += postParts.shift();
         p.push.apply(p, postParts);
@@ -31105,23 +31105,23 @@ var require_brace_expansion = __commonJS({
       if (str.substr(0, 2) === "{}") {
         str = "\\{\\}" + str.substr(2);
       }
-      return expand2(escapeBraces(str), max, true).map(unescapeBraces);
+      return expand3(escapeBraces2(str), max, true).map(unescapeBraces2);
     }
-    function embrace(str) {
+    function embrace2(str) {
       return "{" + str + "}";
     }
-    function isPadded(el) {
+    function isPadded2(el) {
       return /^-?0\d/.test(el);
     }
-    function lte(i, y) {
+    function lte2(i, y) {
       return i <= y;
     }
-    function gte6(i, y) {
+    function gte7(i, y) {
       return i >= y;
     }
-    function expand2(str, max, isTop) {
+    function expand3(str, max, isTop) {
       var expansions = [];
-      var m = balanced("{", "}", str);
+      var m = balanced2("{", "}", str);
       if (!m || /\$$/.test(m.pre)) return [str];
       var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
       var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
@@ -31129,8 +31129,8 @@ var require_brace_expansion = __commonJS({
       var isOptions = m.body.indexOf(",") >= 0;
       if (!isSequence && !isOptions) {
         if (m.post.match(/,(?!,).*\}/)) {
-          str = m.pre + "{" + m.body + escClose + m.post;
-          return expand2(str, max, true);
+          str = m.pre + "{" + m.body + escClose2 + m.post;
+          return expand3(str, max, true);
         }
         return [str];
       }
@@ -31138,11 +31138,11 @@ var require_brace_expansion = __commonJS({
       if (isSequence) {
         n = m.body.split(/\.\./);
       } else {
-        n = parseCommaParts(m.body);
+        n = parseCommaParts2(m.body);
         if (n.length === 1) {
-          n = expand2(n[0], max, false).map(embrace);
+          n = expand3(n[0], max, false).map(embrace2);
           if (n.length === 1) {
-            var post = m.post.length ? expand2(m.post, max, false) : [""];
+            var post = m.post.length ? expand3(m.post, max, false) : [""];
             return post.map(function(p) {
               return m.pre + n[0] + p;
             });
@@ -31150,20 +31150,20 @@ var require_brace_expansion = __commonJS({
         }
       }
       var pre = m.pre;
-      var post = m.post.length ? expand2(m.post, max, false) : [""];
+      var post = m.post.length ? expand3(m.post, max, false) : [""];
       var N;
       if (isSequence) {
-        var x = numeric(n[0]);
-        var y = numeric(n[1]);
+        var x = numeric2(n[0]);
+        var y = numeric2(n[1]);
         var width = Math.max(n[0].length, n[1].length);
-        var incr = n.length == 3 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
-        var test = lte;
+        var incr = n.length == 3 ? Math.max(Math.abs(numeric2(n[2])), 1) : 1;
+        var test = lte2;
         var reverse = y < x;
         if (reverse) {
           incr *= -1;
-          test = gte6;
+          test = gte7;
         }
-        var pad = n.some(isPadded);
+        var pad = n.some(isPadded2);
         N = [];
         for (var i = x; test(i, y); i += incr) {
           var c;
@@ -31188,7 +31188,7 @@ var require_brace_expansion = __commonJS({
         }
       } else {
         N = concatMap(n, function(el) {
-          return expand2(el, max, false);
+          return expand3(el, max, false);
         });
       }
       for (var j = 0; j < N.length; j++) {
@@ -31206,9 +31206,9 @@ var require_brace_expansion = __commonJS({
 // node_modules/minimatch/minimatch.js
 var require_minimatch = __commonJS({
   "node_modules/minimatch/minimatch.js"(exports2, module2) {
-    module2.exports = minimatch;
-    minimatch.Minimatch = Minimatch;
-    var path28 = (function() {
+    module2.exports = minimatch2;
+    minimatch2.Minimatch = Minimatch2;
+    var path29 = (function() {
       try {
         return require("path");
       } catch (e) {
@@ -31216,9 +31216,9 @@ var require_minimatch = __commonJS({
     })() || {
       sep: "/"
     };
-    minimatch.sep = path28.sep;
-    var GLOBSTAR = minimatch.GLOBSTAR = Minimatch.GLOBSTAR = {};
-    var expand2 = require_brace_expansion();
+    minimatch2.sep = path29.sep;
+    var GLOBSTAR2 = minimatch2.GLOBSTAR = Minimatch2.GLOBSTAR = {};
+    var expand3 = require_brace_expansion();
     var plTypes = {
       "!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
       "?": { open: "(?:", close: ")?" },
@@ -31226,11 +31226,11 @@ var require_minimatch = __commonJS({
       "*": { open: "(?:", close: ")*" },
       "@": { open: "(?:", close: ")" }
     };
-    var qmark = "[^/]";
-    var star = qmark + "*?";
-    var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
-    var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
-    var reSpecials = charSet("().*{}+?[]^$\\!");
+    var qmark3 = "[^/]";
+    var star3 = qmark3 + "*?";
+    var twoStarDot2 = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+    var twoStarNoDot2 = "(?:(?!(?:\\/|^)\\.).)*?";
+    var reSpecials2 = charSet("().*{}+?[]^$\\!");
     function charSet(s) {
       return s.split("").reduce(function(set, c) {
         set[c] = true;
@@ -31238,14 +31238,14 @@ var require_minimatch = __commonJS({
       }, {});
     }
     var slashSplit = /\/+/;
-    minimatch.filter = filter;
-    function filter(pattern, options) {
+    minimatch2.filter = filter2;
+    function filter2(pattern, options) {
       options = options || {};
       return function(p, i, list) {
-        return minimatch(p, pattern, options);
+        return minimatch2(p, pattern, options);
       };
     }
-    function ext(a, b) {
+    function ext2(a, b) {
       b = b || {};
       var t = {};
       Object.keys(a).forEach(function(k) {
@@ -31256,57 +31256,57 @@ var require_minimatch = __commonJS({
       });
       return t;
     }
-    minimatch.defaults = function(def) {
+    minimatch2.defaults = function(def) {
       if (!def || typeof def !== "object" || !Object.keys(def).length) {
-        return minimatch;
+        return minimatch2;
       }
-      var orig = minimatch;
-      var m = function minimatch2(p, pattern, options) {
-        return orig(p, pattern, ext(def, options));
+      var orig = minimatch2;
+      var m = function minimatch3(p, pattern, options) {
+        return orig(p, pattern, ext2(def, options));
       };
-      m.Minimatch = function Minimatch2(pattern, options) {
-        return new orig.Minimatch(pattern, ext(def, options));
+      m.Minimatch = function Minimatch3(pattern, options) {
+        return new orig.Minimatch(pattern, ext2(def, options));
       };
-      m.Minimatch.defaults = function defaults(options) {
-        return orig.defaults(ext(def, options)).Minimatch;
+      m.Minimatch.defaults = function defaults2(options) {
+        return orig.defaults(ext2(def, options)).Minimatch;
       };
-      m.filter = function filter2(pattern, options) {
-        return orig.filter(pattern, ext(def, options));
+      m.filter = function filter3(pattern, options) {
+        return orig.filter(pattern, ext2(def, options));
       };
-      m.defaults = function defaults(options) {
-        return orig.defaults(ext(def, options));
+      m.defaults = function defaults2(options) {
+        return orig.defaults(ext2(def, options));
       };
-      m.makeRe = function makeRe2(pattern, options) {
-        return orig.makeRe(pattern, ext(def, options));
+      m.makeRe = function makeRe3(pattern, options) {
+        return orig.makeRe(pattern, ext2(def, options));
       };
-      m.braceExpand = function braceExpand2(pattern, options) {
-        return orig.braceExpand(pattern, ext(def, options));
+      m.braceExpand = function braceExpand3(pattern, options) {
+        return orig.braceExpand(pattern, ext2(def, options));
       };
       m.match = function(list, pattern, options) {
-        return orig.match(list, pattern, ext(def, options));
+        return orig.match(list, pattern, ext2(def, options));
       };
       return m;
     };
-    Minimatch.defaults = function(def) {
-      return minimatch.defaults(def).Minimatch;
+    Minimatch2.defaults = function(def) {
+      return minimatch2.defaults(def).Minimatch;
     };
-    function minimatch(p, pattern, options) {
-      assertValidPattern(pattern);
+    function minimatch2(p, pattern, options) {
+      assertValidPattern2(pattern);
       if (!options) options = {};
       if (!options.nocomment && pattern.charAt(0) === "#") {
         return false;
       }
-      return new Minimatch(pattern, options).match(p);
+      return new Minimatch2(pattern, options).match(p);
     }
-    function Minimatch(pattern, options) {
-      if (!(this instanceof Minimatch)) {
-        return new Minimatch(pattern, options);
+    function Minimatch2(pattern, options) {
+      if (!(this instanceof Minimatch2)) {
+        return new Minimatch2(pattern, options);
       }
-      assertValidPattern(pattern);
+      assertValidPattern2(pattern);
       if (!options) options = {};
       pattern = pattern.trim();
-      if (!options.allowWindowsEscape && path28.sep !== "/") {
-        pattern = pattern.split(path28.sep).join("/");
+      if (!options.allowWindowsEscape && path29.sep !== "/") {
+        pattern = pattern.split(path29.sep).join("/");
       }
       this.options = options;
       this.maxGlobstarRecursion = options.maxGlobstarRecursion !== void 0 ? options.maxGlobstarRecursion : 200;
@@ -31319,9 +31319,9 @@ var require_minimatch = __commonJS({
       this.partial = !!options.partial;
       this.make();
     }
-    Minimatch.prototype.debug = function() {
+    Minimatch2.prototype.debug = function() {
     };
-    Minimatch.prototype.make = make;
+    Minimatch2.prototype.make = make;
     function make() {
       var pattern = this.pattern;
       var options = this.options;
@@ -31353,7 +31353,7 @@ var require_minimatch = __commonJS({
       this.debug(this.pattern, set);
       this.set = set;
     }
-    Minimatch.prototype.parseNegate = parseNegate;
+    Minimatch2.prototype.parseNegate = parseNegate;
     function parseNegate() {
       var pattern = this.pattern;
       var negate2 = false;
@@ -31367,42 +31367,42 @@ var require_minimatch = __commonJS({
       if (negateOffset) this.pattern = pattern.substr(negateOffset);
       this.negate = negate2;
     }
-    minimatch.braceExpand = function(pattern, options) {
-      return braceExpand(pattern, options);
+    minimatch2.braceExpand = function(pattern, options) {
+      return braceExpand2(pattern, options);
     };
-    Minimatch.prototype.braceExpand = braceExpand;
-    function braceExpand(pattern, options) {
+    Minimatch2.prototype.braceExpand = braceExpand2;
+    function braceExpand2(pattern, options) {
       if (!options) {
-        if (this instanceof Minimatch) {
+        if (this instanceof Minimatch2) {
           options = this.options;
         } else {
           options = {};
         }
       }
       pattern = typeof pattern === "undefined" ? this.pattern : pattern;
-      assertValidPattern(pattern);
+      assertValidPattern2(pattern);
       if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
         return [pattern];
       }
-      return expand2(pattern);
+      return expand3(pattern);
     }
-    var MAX_PATTERN_LENGTH = 1024 * 64;
-    var assertValidPattern = function(pattern) {
+    var MAX_PATTERN_LENGTH2 = 1024 * 64;
+    var assertValidPattern2 = function(pattern) {
       if (typeof pattern !== "string") {
         throw new TypeError("invalid pattern");
       }
-      if (pattern.length > MAX_PATTERN_LENGTH) {
+      if (pattern.length > MAX_PATTERN_LENGTH2) {
         throw new TypeError("pattern is too long");
       }
     };
-    Minimatch.prototype.parse = parse2;
+    Minimatch2.prototype.parse = parse2;
     var SUBPARSE = {};
     function parse2(pattern, isSub) {
-      assertValidPattern(pattern);
+      assertValidPattern2(pattern);
       var options = this.options;
       if (pattern === "**") {
         if (!options.noglobstar)
-          return GLOBSTAR;
+          return GLOBSTAR2;
         else
           pattern = "*";
       }
@@ -31422,11 +31422,11 @@ var require_minimatch = __commonJS({
         if (stateChar) {
           switch (stateChar) {
             case "*":
-              re += star;
+              re += star3;
               hasMagic = true;
               break;
             case "?":
-              re += qmark;
+              re += qmark3;
               hasMagic = true;
               break;
             default:
@@ -31439,7 +31439,7 @@ var require_minimatch = __commonJS({
       }
       for (var i = 0, len = pattern.length, c; i < len && (c = pattern.charAt(i)); i++) {
         this.debug("%s	%s %s %j", pattern, i, re, c);
-        if (escaping && reSpecials[c]) {
+        if (escaping && reSpecials2[c]) {
           re += "\\" + c;
           escaping = false;
           continue;
@@ -31552,7 +31552,7 @@ var require_minimatch = __commonJS({
             clearStateChar();
             if (escaping) {
               escaping = false;
-            } else if (reSpecials[c] && !(c === "^" && inClass)) {
+            } else if (reSpecials2[c] && !(c === "^" && inClass)) {
               re += "\\";
             }
             re += c;
@@ -31574,7 +31574,7 @@ var require_minimatch = __commonJS({
           return $1 + $1 + $2 + "|";
         });
         this.debug("tail=%j\n   %s", tail, tail, pl, re);
-        var t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
+        var t = pl.type === "*" ? star3 : pl.type === "?" ? qmark3 : "\\" + pl.type;
         hasMagic = true;
         re = re.slice(0, pl.reStart) + t + "\\(" + tail;
       }
@@ -31582,12 +31582,12 @@ var require_minimatch = __commonJS({
       if (escaping) {
         re += "\\\\";
       }
-      var addPatternStart = false;
+      var addPatternStart2 = false;
       switch (re.charAt(0)) {
         case "[":
         case ".":
         case "(":
-          addPatternStart = true;
+          addPatternStart2 = true;
       }
       for (var n = negativeLists.length - 1; n > -1; n--) {
         var nl = negativeLists[n];
@@ -31612,7 +31612,7 @@ var require_minimatch = __commonJS({
       if (re !== "" && hasMagic) {
         re = "(?=.)" + re;
       }
-      if (addPatternStart) {
+      if (addPatternStart2) {
         re = patternStart + re;
       }
       if (isSub === SUBPARSE) {
@@ -31631,11 +31631,11 @@ var require_minimatch = __commonJS({
       regExp._src = re;
       return regExp;
     }
-    minimatch.makeRe = function(pattern, options) {
-      return new Minimatch(pattern, options || {}).makeRe();
+    minimatch2.makeRe = function(pattern, options) {
+      return new Minimatch2(pattern, options || {}).makeRe();
     };
-    Minimatch.prototype.makeRe = makeRe;
-    function makeRe() {
+    Minimatch2.prototype.makeRe = makeRe2;
+    function makeRe2() {
       if (this.regexp || this.regexp === false) return this.regexp;
       var set = this.set;
       if (!set.length) {
@@ -31643,11 +31643,11 @@ var require_minimatch = __commonJS({
         return this.regexp;
       }
       var options = this.options;
-      var twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+      var twoStar = options.noglobstar ? star3 : options.dot ? twoStarDot2 : twoStarNoDot2;
       var flags = options.nocase ? "i" : "";
       var re = set.map(function(pattern) {
         return pattern.map(function(p) {
-          return p === GLOBSTAR ? twoStar : typeof p === "string" ? regExpEscape(p) : p._src;
+          return p === GLOBSTAR2 ? twoStar : typeof p === "string" ? regExpEscape3(p) : p._src;
         }).join("\\/");
       }).join("|");
       re = "^(?:" + re + ")$";
@@ -31659,9 +31659,9 @@ var require_minimatch = __commonJS({
       }
       return this.regexp;
     }
-    minimatch.match = function(list, pattern, options) {
+    minimatch2.match = function(list, pattern, options) {
       options = options || {};
-      var mm = new Minimatch(pattern, options);
+      var mm = new Minimatch2(pattern, options);
       list = list.filter(function(f) {
         return mm.match(f);
       });
@@ -31670,15 +31670,15 @@ var require_minimatch = __commonJS({
       }
       return list;
     };
-    Minimatch.prototype.match = function match(f, partial) {
+    Minimatch2.prototype.match = function match2(f, partial) {
       if (typeof partial === "undefined") partial = this.partial;
       this.debug("match", f, this.pattern);
       if (this.comment) return false;
       if (this.empty) return f === "";
       if (f === "/" && partial) return true;
       var options = this.options;
-      if (path28.sep !== "/") {
-        f = f.split(path28.sep).join("/");
+      if (path29.sep !== "/") {
+        f = f.split(path29.sep).join("/");
       }
       f = f.split(slashSplit);
       this.debug(this.pattern, "split", f);
@@ -31705,24 +31705,24 @@ var require_minimatch = __commonJS({
       if (options.flipNegate) return false;
       return this.negate;
     };
-    Minimatch.prototype.matchOne = function(file, pattern, partial) {
-      if (pattern.indexOf(GLOBSTAR) !== -1) {
+    Minimatch2.prototype.matchOne = function(file, pattern, partial) {
+      if (pattern.indexOf(GLOBSTAR2) !== -1) {
         return this._matchGlobstar(file, pattern, partial, 0, 0);
       }
       return this._matchOne(file, pattern, partial, 0, 0);
     };
-    Minimatch.prototype._matchGlobstar = function(file, pattern, partial, fileIndex, patternIndex) {
+    Minimatch2.prototype._matchGlobstar = function(file, pattern, partial, fileIndex, patternIndex) {
       var i;
       var firstgs = -1;
       for (i = patternIndex; i < pattern.length; i++) {
-        if (pattern[i] === GLOBSTAR) {
+        if (pattern[i] === GLOBSTAR2) {
           firstgs = i;
           break;
         }
       }
       var lastgs = -1;
       for (i = pattern.length - 1; i >= 0; i--) {
-        if (pattern[i] === GLOBSTAR) {
+        if (pattern[i] === GLOBSTAR2) {
           lastgs = i;
           break;
         }
@@ -31771,7 +31771,7 @@ var require_minimatch = __commonJS({
       var nonGsPartsSums = [0];
       for (var bi = 0; bi < body.length; bi++) {
         var b = body[bi];
-        if (b === GLOBSTAR) {
+        if (b === GLOBSTAR2) {
           nonGsPartsSums.push(nonGsParts);
           currentBody = [[], 0];
           bodySegments.push(currentBody);
@@ -31795,7 +31795,7 @@ var require_minimatch = __commonJS({
         !!fileTailMatch
       );
     };
-    Minimatch.prototype._matchGlobStarBodySections = function(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+    Minimatch2.prototype._matchGlobStarBodySections = function(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
       var bs = bodySegments[bodyIndex];
       if (!bs) {
         for (var i = fileIndex; i < file.length; i++) {
@@ -31839,14 +31839,14 @@ var require_minimatch = __commonJS({
       }
       return partial || null;
     };
-    Minimatch.prototype._matchOne = function(file, pattern, partial, fileIndex, patternIndex) {
+    Minimatch2.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];
         this.debug(pattern, p, f);
-        if (p === false || p === GLOBSTAR) return false;
+        if (p === false || p === GLOBSTAR2) return false;
         var hit;
         if (typeof p === "string") {
           hit = f === p;
@@ -31869,7 +31869,7 @@ var require_minimatch = __commonJS({
     function globUnescape(s) {
       return s.replace(/\\(.)/g, "$1");
     }
-    function regExpEscape(s) {
+    function regExpEscape3(s) {
       return s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
     }
   }
@@ -31921,7 +31921,7 @@ var require_internal_path = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.Path = void 0;
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var pathHelper = __importStar2(require_internal_path_helper());
     var assert_1 = __importDefault2(require("assert"));
     var IS_WINDOWS = process.platform === "win32";
@@ -31936,12 +31936,12 @@ var require_internal_path = __commonJS({
           (0, assert_1.default)(itemPath, `Parameter 'itemPath' must not be empty`);
           itemPath = pathHelper.safeTrimTrailingSeparator(itemPath);
           if (!pathHelper.hasRoot(itemPath)) {
-            this.segments = itemPath.split(path28.sep);
+            this.segments = itemPath.split(path29.sep);
           } else {
             let remaining = itemPath;
             let dir = pathHelper.dirname(remaining);
             while (dir !== remaining) {
-              const basename2 = path28.basename(remaining);
+              const basename2 = path29.basename(remaining);
               this.segments.unshift(basename2);
               remaining = dir;
               dir = pathHelper.dirname(remaining);
@@ -31959,7 +31959,7 @@ var require_internal_path = __commonJS({
               (0, assert_1.default)(segment === pathHelper.dirname(segment), `Parameter 'itemPath' root segment contains information for multiple segments`);
               this.segments.push(segment);
             } else {
-              (0, assert_1.default)(!segment.includes(path28.sep), `Parameter 'itemPath' contains unexpected path separators`);
+              (0, assert_1.default)(!segment.includes(path29.sep), `Parameter 'itemPath' contains unexpected path separators`);
               this.segments.push(segment);
             }
           }
@@ -31970,12 +31970,12 @@ var require_internal_path = __commonJS({
        */
       toString() {
         let result = this.segments[0];
-        let skipSlash = result.endsWith(path28.sep) || IS_WINDOWS && /^[A-Z]:$/i.test(result);
+        let skipSlash = result.endsWith(path29.sep) || IS_WINDOWS && /^[A-Z]:$/i.test(result);
         for (let i = 1; i < this.segments.length; i++) {
           if (skipSlash) {
             skipSlash = false;
           } else {
-            result += path28.sep;
+            result += path29.sep;
           }
           result += this.segments[i];
         }
@@ -32033,7 +32033,7 @@ var require_internal_pattern = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.Pattern = void 0;
     var os7 = __importStar2(require("os"));
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var pathHelper = __importStar2(require_internal_path_helper());
     var assert_1 = __importDefault2(require("assert"));
     var minimatch_1 = require_minimatch();
@@ -32062,7 +32062,7 @@ var require_internal_pattern = __commonJS({
         }
         pattern = _Pattern.fixupPattern(pattern, homedir2);
         this.segments = new internal_path_1.Path(pattern).segments;
-        this.trailingSeparator = pathHelper.normalizeSeparators(pattern).endsWith(path28.sep);
+        this.trailingSeparator = pathHelper.normalizeSeparators(pattern).endsWith(path29.sep);
         pattern = pathHelper.safeTrimTrailingSeparator(pattern);
         let foundGlob = false;
         const searchSegments = this.segments.map((x) => _Pattern.getLiteral(x)).filter((x) => !foundGlob && !(foundGlob = x === ""));
@@ -32086,8 +32086,8 @@ var require_internal_pattern = __commonJS({
       match(itemPath) {
         if (this.segments[this.segments.length - 1] === "**") {
           itemPath = pathHelper.normalizeSeparators(itemPath);
-          if (!itemPath.endsWith(path28.sep) && this.isImplicitPattern === false) {
-            itemPath = `${itemPath}${path28.sep}`;
+          if (!itemPath.endsWith(path29.sep) && this.isImplicitPattern === false) {
+            itemPath = `${itemPath}${path29.sep}`;
           }
         } else {
           itemPath = pathHelper.safeTrimTrailingSeparator(itemPath);
@@ -32122,9 +32122,9 @@ var require_internal_pattern = __commonJS({
         (0, assert_1.default)(literalSegments.every((x, i) => (x !== "." || i === 0) && x !== ".."), `Invalid pattern '${pattern}'. Relative pathing '.' and '..' is not allowed.`);
         (0, assert_1.default)(!pathHelper.hasRoot(pattern) || literalSegments[0], `Invalid pattern '${pattern}'. Root segment must not contain globs.`);
         pattern = pathHelper.normalizeSeparators(pattern);
-        if (pattern === "." || pattern.startsWith(`.${path28.sep}`)) {
+        if (pattern === "." || pattern.startsWith(`.${path29.sep}`)) {
           pattern = _Pattern.globEscape(process.cwd()) + pattern.substr(1);
-        } else if (pattern === "~" || pattern.startsWith(`~${path28.sep}`)) {
+        } else if (pattern === "~" || pattern.startsWith(`~${path29.sep}`)) {
           homedir2 = homedir2 || os7.homedir();
           (0, assert_1.default)(homedir2, "Unable to determine HOME directory");
           (0, assert_1.default)(pathHelper.hasAbsoluteRoot(homedir2), `Expected HOME directory to be a rooted path. Actual '${homedir2}'`);
@@ -32208,8 +32208,8 @@ var require_internal_search_state = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.SearchState = void 0;
     var SearchState = class {
-      constructor(path28, level) {
-        this.path = path28;
+      constructor(path29, level) {
+        this.path = path29;
         this.level = level;
       }
     };
@@ -32260,11 +32260,11 @@ var require_internal_globber = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -32280,7 +32280,7 @@ var require_internal_globber = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -32293,14 +32293,14 @@ var require_internal_globber = __commonJS({
       }, i);
       function verb(n) {
         i[n] = o[n] && function(v) {
-          return new Promise(function(resolve13, reject) {
-            v = o[n](v), settle(resolve13, reject, v.done, v.value);
+          return new Promise(function(resolve14, reject) {
+            v = o[n](v), settle(resolve14, reject, v.done, v.value);
           });
         };
       }
-      function settle(resolve13, reject, d, v) {
+      function settle(resolve14, reject, d, v) {
         Promise.resolve(v).then(function(v2) {
-          resolve13({ value: v2, done: d });
+          resolve14({ value: v2, done: d });
         }, reject);
       }
     };
@@ -32351,9 +32351,9 @@ var require_internal_globber = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DefaultGlobber = void 0;
     var core30 = __importStar2(require_core());
-    var fs30 = __importStar2(require("fs"));
+    var fs31 = __importStar2(require("fs"));
     var globOptionsHelper = __importStar2(require_internal_glob_options_helper());
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var patternHelper = __importStar2(require_internal_pattern_helper());
     var internal_match_kind_1 = require_internal_match_kind();
     var internal_pattern_1 = require_internal_pattern();
@@ -32370,10 +32370,10 @@ var require_internal_globber = __commonJS({
       }
       glob() {
         return __awaiter2(this, void 0, void 0, function* () {
-          var _a, e_1, _b, _c;
+          var _a2, e_1, _b, _c;
           const result = [];
           try {
-            for (var _d = true, _e = __asyncValues2(this.globGenerator()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+            for (var _d = true, _e = __asyncValues2(this.globGenerator()), _f; _f = yield _e.next(), _a2 = _f.done, !_a2; _d = true) {
               _c = _f.value;
               _d = false;
               const itemPath = _c;
@@ -32383,7 +32383,7 @@ var require_internal_globber = __commonJS({
             e_1 = { error: e_1_1 };
           } finally {
             try {
-              if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+              if (!_d && !_a2 && (_b = _e.return)) yield _b.call(_e);
             } finally {
               if (e_1) throw e_1.error;
             }
@@ -32405,7 +32405,7 @@ var require_internal_globber = __commonJS({
           for (const searchPath of patternHelper.getSearchPaths(patterns)) {
             core30.debug(`Search path '${searchPath}'`);
             try {
-              yield __await2(fs30.promises.lstat(searchPath));
+              yield __await2(fs31.promises.lstat(searchPath));
             } catch (err) {
               if (err.code === "ENOENT") {
                 continue;
@@ -32417,9 +32417,9 @@ var require_internal_globber = __commonJS({
           const traversalChain = [];
           while (stack.length) {
             const item = stack.pop();
-            const match = patternHelper.match(patterns, item.path);
-            const partialMatch = !!match || patternHelper.partialMatch(patterns, item.path);
-            if (!match && !partialMatch) {
+            const match2 = patternHelper.match(patterns, item.path);
+            const partialMatch = !!match2 || patternHelper.partialMatch(patterns, item.path);
+            if (!match2 && !partialMatch) {
               continue;
             }
             const stats = yield __await2(
@@ -32429,19 +32429,19 @@ var require_internal_globber = __commonJS({
             if (!stats) {
               continue;
             }
-            if (options.excludeHiddenFiles && path28.basename(item.path).match(/^\./)) {
+            if (options.excludeHiddenFiles && path29.basename(item.path).match(/^\./)) {
               continue;
             }
             if (stats.isDirectory()) {
-              if (match & internal_match_kind_1.MatchKind.Directory && options.matchDirectories) {
+              if (match2 & internal_match_kind_1.MatchKind.Directory && options.matchDirectories) {
                 yield yield __await2(item.path);
               } else if (!partialMatch) {
                 continue;
               }
               const childLevel = item.level + 1;
-              const childItems = (yield __await2(fs30.promises.readdir(item.path))).map((x) => new internal_search_state_1.SearchState(path28.join(item.path, x), childLevel));
+              const childItems = (yield __await2(fs31.promises.readdir(item.path))).map((x) => new internal_search_state_1.SearchState(path29.join(item.path, x), childLevel));
               stack.push(...childItems.reverse());
-            } else if (match & internal_match_kind_1.MatchKind.File) {
+            } else if (match2 & internal_match_kind_1.MatchKind.File) {
               yield yield __await2(item.path);
             }
           }
@@ -32474,7 +32474,7 @@ var require_internal_globber = __commonJS({
           let stats;
           if (options.followSymbolicLinks) {
             try {
-              stats = yield fs30.promises.stat(item.path);
+              stats = yield fs31.promises.stat(item.path);
             } catch (err) {
               if (err.code === "ENOENT") {
                 if (options.omitBrokenSymbolicLinks) {
@@ -32486,10 +32486,10 @@ var require_internal_globber = __commonJS({
               throw err;
             }
           } else {
-            stats = yield fs30.promises.lstat(item.path);
+            stats = yield fs31.promises.lstat(item.path);
           }
           if (stats.isDirectory() && options.followSymbolicLinks) {
-            const realPath = yield fs30.promises.realpath(item.path);
+            const realPath = yield fs31.promises.realpath(item.path);
             while (traversalChain.length >= item.level) {
               traversalChain.pop();
             }
@@ -32550,11 +32550,11 @@ var require_internal_hash_files = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -32570,7 +32570,7 @@ var require_internal_hash_files = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -32583,14 +32583,14 @@ var require_internal_hash_files = __commonJS({
       }, i);
       function verb(n) {
         i[n] = o[n] && function(v) {
-          return new Promise(function(resolve13, reject) {
-            v = o[n](v), settle(resolve13, reject, v.done, v.value);
+          return new Promise(function(resolve14, reject) {
+            v = o[n](v), settle(resolve14, reject, v.done, v.value);
           });
         };
       }
-      function settle(resolve13, reject, d, v) {
+      function settle(resolve14, reject, d, v) {
         Promise.resolve(v).then(function(v2) {
-          resolve13({ value: v2, done: d });
+          resolve14({ value: v2, done: d });
         }, reject);
       }
     };
@@ -32598,13 +32598,13 @@ var require_internal_hash_files = __commonJS({
     exports2.hashFiles = hashFiles2;
     var crypto3 = __importStar2(require("crypto"));
     var core30 = __importStar2(require_core());
-    var fs30 = __importStar2(require("fs"));
+    var fs31 = __importStar2(require("fs"));
     var stream2 = __importStar2(require("stream"));
-    var util = __importStar2(require("util"));
-    var path28 = __importStar2(require("path"));
+    var util3 = __importStar2(require("util"));
+    var path29 = __importStar2(require("path"));
     function hashFiles2(globber_1, currentWorkspace_1) {
       return __awaiter2(this, arguments, void 0, function* (globber, currentWorkspace, verbose = false) {
-        var _a, e_1, _b, _c;
+        var _a2, e_1, _b, _c;
         var _d;
         const writeDelegate = verbose ? core30.info : core30.debug;
         let hasMatch = false;
@@ -32612,22 +32612,22 @@ var require_internal_hash_files = __commonJS({
         const result = crypto3.createHash("sha256");
         let count = 0;
         try {
-          for (var _e = true, _f = __asyncValues2(globber.globGenerator()), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
+          for (var _e = true, _f = __asyncValues2(globber.globGenerator()), _g; _g = yield _f.next(), _a2 = _g.done, !_a2; _e = true) {
             _c = _g.value;
             _e = false;
             const file = _c;
             writeDelegate(file);
-            if (!file.startsWith(`${githubWorkspace}${path28.sep}`)) {
+            if (!file.startsWith(`${githubWorkspace}${path29.sep}`)) {
               writeDelegate(`Ignore '${file}' since it is not under GITHUB_WORKSPACE.`);
               continue;
             }
-            if (fs30.statSync(file).isDirectory()) {
+            if (fs31.statSync(file).isDirectory()) {
               writeDelegate(`Skip directory '${file}'.`);
               continue;
             }
             const hash2 = crypto3.createHash("sha256");
-            const pipeline = util.promisify(stream2.pipeline);
-            yield pipeline(fs30.createReadStream(file), hash2);
+            const pipeline = util3.promisify(stream2.pipeline);
+            yield pipeline(fs31.createReadStream(file), hash2);
             result.write(hash2.digest());
             count++;
             if (!hasMatch) {
@@ -32638,7 +32638,7 @@ var require_internal_hash_files = __commonJS({
           e_1 = { error: e_1_1 };
         } finally {
           try {
-            if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+            if (!_e && !_a2 && (_b = _f.return)) yield _b.call(_f);
           } finally {
             if (e_1) throw e_1.error;
           }
@@ -32662,11 +32662,11 @@ var require_glob = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -32682,7 +32682,7 @@ var require_glob = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -33135,10 +33135,10 @@ var require_semver3 = __commonJS({
       }
     }
     exports2.compareIdentifiers = compareIdentifiers;
-    var numeric = /^[0-9]+$/;
+    var numeric2 = /^[0-9]+$/;
     function compareIdentifiers(a, b) {
-      var anum = numeric.test(a);
-      var bnum = numeric.test(b);
+      var anum = numeric2.test(a);
+      var bnum = numeric2.test(b);
       if (anum && bnum) {
         a = +a;
         b = +b;
@@ -33207,12 +33207,12 @@ var require_semver3 = __commonJS({
     function neq(a, b, loose) {
       return compare3(a, b, loose) !== 0;
     }
-    exports2.gte = gte6;
-    function gte6(a, b, loose) {
+    exports2.gte = gte7;
+    function gte7(a, b, loose) {
       return compare3(a, b, loose) >= 0;
     }
-    exports2.lte = lte;
-    function lte(a, b, loose) {
+    exports2.lte = lte2;
+    function lte2(a, b, loose) {
       return compare3(a, b, loose) <= 0;
     }
     exports2.cmp = cmp;
@@ -33239,11 +33239,11 @@ var require_semver3 = __commonJS({
         case ">":
           return gt(a, b, loose);
         case ">=":
-          return gte6(a, b, loose);
+          return gte7(a, b, loose);
         case "<":
           return lt2(a, b, loose);
         case "<=":
-          return lte(a, b, loose);
+          return lte2(a, b, loose);
         default:
           throw new TypeError("Invalid operator: " + op);
       }
@@ -33345,32 +33345,32 @@ var require_semver3 = __commonJS({
       return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
     };
     exports2.Range = Range2;
-    function Range2(range, options) {
+    function Range2(range2, options) {
       if (!options || typeof options !== "object") {
         options = {
           loose: !!options,
           includePrerelease: false
         };
       }
-      if (range instanceof Range2) {
-        if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
-          return range;
+      if (range2 instanceof Range2) {
+        if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) {
+          return range2;
         } else {
-          return new Range2(range.raw, options);
+          return new Range2(range2.raw, options);
         }
       }
-      if (range instanceof Comparator) {
-        return new Range2(range.value, options);
+      if (range2 instanceof Comparator) {
+        return new Range2(range2.value, options);
       }
       if (!(this instanceof Range2)) {
-        return new Range2(range, options);
+        return new Range2(range2, options);
       }
       this.options = options;
       this.loose = !!options.loose;
       this.includePrerelease = !!options.includePrerelease;
-      this.raw = range.trim().split(/\s+/).join(" ");
-      this.set = this.raw.split("||").map(function(range2) {
-        return this.parseRange(range2.trim());
+      this.raw = range2.trim().split(/\s+/).join(" ");
+      this.set = this.raw.split("||").map(function(range3) {
+        return this.parseRange(range3.trim());
       }, this).filter(function(c) {
         return c.length;
       });
@@ -33388,18 +33388,18 @@ var require_semver3 = __commonJS({
     Range2.prototype.toString = function() {
       return this.range;
     };
-    Range2.prototype.parseRange = function(range) {
+    Range2.prototype.parseRange = function(range2) {
       var loose = this.options.loose;
       var hr = loose ? safeRe[t.HYPHENRANGELOOSE] : safeRe[t.HYPHENRANGE];
-      range = range.replace(hr, hyphenReplace);
-      debug6("hyphen replace", range);
-      range = range.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace);
-      debug6("comparator trim", range, safeRe[t.COMPARATORTRIM]);
-      range = range.replace(safeRe[t.TILDETRIM], tildeTrimReplace);
-      range = range.replace(safeRe[t.CARETTRIM], caretTrimReplace);
-      range = range.split(/\s+/).join(" ");
+      range2 = range2.replace(hr, hyphenReplace);
+      debug6("hyphen replace", range2);
+      range2 = range2.replace(safeRe[t.COMPARATORTRIM], comparatorTrimReplace);
+      debug6("comparator trim", range2, safeRe[t.COMPARATORTRIM]);
+      range2 = range2.replace(safeRe[t.TILDETRIM], tildeTrimReplace);
+      range2 = range2.replace(safeRe[t.CARETTRIM], caretTrimReplace);
+      range2 = range2.split(/\s+/).join(" ");
       var compRe = loose ? safeRe[t.COMPARATORLOOSE] : safeRe[t.COMPARATOR];
-      var set = range.split(" ").map(function(comp) {
+      var set = range2.split(" ").map(function(comp) {
         return parseComparator(comp, this.options);
       }, this).join(" ").split(/\s+/);
       if (this.options.loose) {
@@ -33412,12 +33412,12 @@ var require_semver3 = __commonJS({
       }, this);
       return set;
     };
-    Range2.prototype.intersects = function(range, options) {
-      if (!(range instanceof Range2)) {
+    Range2.prototype.intersects = function(range2, options) {
+      if (!(range2 instanceof Range2)) {
         throw new TypeError("a Range is required");
       }
       return this.set.some(function(thisComparators) {
-        return isSatisfiable(thisComparators, options) && range.set.some(function(rangeComparators) {
+        return isSatisfiable(thisComparators, options) && range2.set.some(function(rangeComparators) {
           return isSatisfiable(rangeComparators, options) && thisComparators.every(function(thisComparator) {
             return rangeComparators.every(function(rangeComparator) {
               return thisComparator.intersects(rangeComparator, options);
@@ -33439,8 +33439,8 @@ var require_semver3 = __commonJS({
       return result;
     }
     exports2.toComparators = toComparators;
-    function toComparators(range, options) {
-      return new Range2(range, options).set.map(function(comp) {
+    function toComparators(range2, options) {
+      return new Range2(range2, options).set.map(function(comp) {
         return comp.map(function(c) {
           return c.value;
         }).join(" ").trim().split(" ");
@@ -33662,20 +33662,20 @@ var require_semver3 = __commonJS({
       return true;
     }
     exports2.satisfies = satisfies2;
-    function satisfies2(version, range, options) {
+    function satisfies2(version, range2, options) {
       try {
-        range = new Range2(range, options);
+        range2 = new Range2(range2, options);
       } catch (er) {
         return false;
       }
-      return range.test(version);
+      return range2.test(version);
     }
     exports2.maxSatisfying = maxSatisfying;
-    function maxSatisfying(versions, range, options) {
+    function maxSatisfying(versions, range2, options) {
       var max = null;
       var maxSV = null;
       try {
-        var rangeObj = new Range2(range, options);
+        var rangeObj = new Range2(range2, options);
       } catch (er) {
         return null;
       }
@@ -33690,11 +33690,11 @@ var require_semver3 = __commonJS({
       return max;
     }
     exports2.minSatisfying = minSatisfying;
-    function minSatisfying(versions, range, options) {
+    function minSatisfying(versions, range2, options) {
       var min = null;
       var minSV = null;
       try {
-        var rangeObj = new Range2(range, options);
+        var rangeObj = new Range2(range2, options);
       } catch (er) {
         return null;
       }
@@ -33709,19 +33709,19 @@ var require_semver3 = __commonJS({
       return min;
     }
     exports2.minVersion = minVersion;
-    function minVersion(range, loose) {
-      range = new Range2(range, loose);
+    function minVersion(range2, loose) {
+      range2 = new Range2(range2, loose);
       var minver = new SemVer("0.0.0");
-      if (range.test(minver)) {
+      if (range2.test(minver)) {
         return minver;
       }
       minver = new SemVer("0.0.0-0");
-      if (range.test(minver)) {
+      if (range2.test(minver)) {
         return minver;
       }
       minver = null;
-      for (var i2 = 0; i2 < range.set.length; ++i2) {
-        var comparators = range.set[i2];
+      for (var i2 = 0; i2 < range2.set.length; ++i2) {
+        var comparators = range2.set[i2];
         comparators.forEach(function(comparator) {
           var compver = new SemVer(comparator.semver.version);
           switch (comparator.operator) {
@@ -33748,43 +33748,43 @@ var require_semver3 = __commonJS({
           }
         });
       }
-      if (minver && range.test(minver)) {
+      if (minver && range2.test(minver)) {
         return minver;
       }
       return null;
     }
     exports2.validRange = validRange;
-    function validRange(range, options) {
+    function validRange(range2, options) {
       try {
-        return new Range2(range, options).range || "*";
+        return new Range2(range2, options).range || "*";
       } catch (er) {
         return null;
       }
     }
     exports2.ltr = ltr;
-    function ltr(version, range, options) {
-      return outside(version, range, "<", options);
+    function ltr(version, range2, options) {
+      return outside(version, range2, "<", options);
     }
     exports2.gtr = gtr;
-    function gtr(version, range, options) {
-      return outside(version, range, ">", options);
+    function gtr(version, range2, options) {
+      return outside(version, range2, ">", options);
     }
     exports2.outside = outside;
-    function outside(version, range, hilo, options) {
+    function outside(version, range2, hilo, options) {
       version = new SemVer(version, options);
-      range = new Range2(range, options);
+      range2 = new Range2(range2, options);
       var gtfn, ltefn, ltfn, comp, ecomp;
       switch (hilo) {
         case ">":
           gtfn = gt;
-          ltefn = lte;
+          ltefn = lte2;
           ltfn = lt2;
           comp = ">";
           ecomp = ">=";
           break;
         case "<":
           gtfn = lt2;
-          ltefn = gte6;
+          ltefn = gte7;
           ltfn = gt;
           comp = "<";
           ecomp = "<=";
@@ -33792,11 +33792,11 @@ var require_semver3 = __commonJS({
         default:
           throw new TypeError('Must provide a hilo val of "<" or ">"');
       }
-      if (satisfies2(version, range, options)) {
+      if (satisfies2(version, range2, options)) {
         return false;
       }
-      for (var i2 = 0; i2 < range.set.length; ++i2) {
-        var comparators = range.set[i2];
+      for (var i2 = 0; i2 < range2.set.length; ++i2) {
+        var comparators = range2.set[i2];
         var high = null;
         var low = null;
         comparators.forEach(function(comparator) {
@@ -33845,23 +33845,23 @@ var require_semver3 = __commonJS({
         return null;
       }
       options = options || {};
-      var match = null;
+      var match2 = null;
       if (!options.rtl) {
-        match = version.match(safeRe[t.COERCE]);
+        match2 = version.match(safeRe[t.COERCE]);
       } else {
         var next;
-        while ((next = safeRe[t.COERCERTL].exec(version)) && (!match || match.index + match[0].length !== version.length)) {
-          if (!match || next.index + next[0].length !== match.index + match[0].length) {
-            match = next;
+        while ((next = safeRe[t.COERCERTL].exec(version)) && (!match2 || match2.index + match2[0].length !== version.length)) {
+          if (!match2 || next.index + next[0].length !== match2.index + match2[0].length) {
+            match2 = next;
           }
           safeRe[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
         }
         safeRe[t.COERCERTL].lastIndex = -1;
       }
-      if (match === null) {
+      if (match2 === null) {
         return null;
       }
-      return parse2(match[2] + "." + (match[3] || "0") + "." + (match[4] || "0"), options);
+      return parse2(match2[2] + "." + (match2[3] || "0") + "." + (match2[4] || "0"), options);
     }
   }
 });
@@ -33942,11 +33942,11 @@ var require_cacheUtils = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -33962,7 +33962,7 @@ var require_cacheUtils = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -33975,14 +33975,14 @@ var require_cacheUtils = __commonJS({
       }, i);
       function verb(n) {
         i[n] = o[n] && function(v) {
-          return new Promise(function(resolve13, reject) {
-            v = o[n](v), settle(resolve13, reject, v.done, v.value);
+          return new Promise(function(resolve14, reject) {
+            v = o[n](v), settle(resolve14, reject, v.done, v.value);
           });
         };
       }
-      function settle(resolve13, reject, d, v) {
+      function settle(resolve14, reject, d, v) {
         Promise.resolve(v).then(function(v2) {
-          resolve13({ value: v2, done: d });
+          resolve14({ value: v2, done: d });
         }, reject);
       }
     };
@@ -34002,10 +34002,10 @@ var require_cacheUtils = __commonJS({
     var glob2 = __importStar2(require_glob());
     var io9 = __importStar2(require_io());
     var crypto3 = __importStar2(require("crypto"));
-    var fs30 = __importStar2(require("fs"));
-    var path28 = __importStar2(require("path"));
+    var fs31 = __importStar2(require("fs"));
+    var path29 = __importStar2(require("path"));
     var semver11 = __importStar2(require_semver3());
-    var util = __importStar2(require("util"));
+    var util3 = __importStar2(require("util"));
     var constants_1 = require_constants7();
     var versionSalt = "1.0";
     function createTempDirectory() {
@@ -34023,19 +34023,19 @@ var require_cacheUtils = __commonJS({
               baseLocation = "/home";
             }
           }
-          tempDirectory = path28.join(baseLocation, "actions", "temp");
+          tempDirectory = path29.join(baseLocation, "actions", "temp");
         }
-        const dest = path28.join(tempDirectory, crypto3.randomUUID());
+        const dest = path29.join(tempDirectory, crypto3.randomUUID());
         yield io9.mkdirP(dest);
         return dest;
       });
     }
     function getArchiveFileSizeInBytes(filePath) {
-      return fs30.statSync(filePath).size;
+      return fs31.statSync(filePath).size;
     }
     function resolvePaths(patterns) {
       return __awaiter2(this, void 0, void 0, function* () {
-        var _a, e_1, _b, _c;
+        var _a2, e_1, _b, _c;
         var _d;
         const paths = [];
         const workspace = (_d = process.env["GITHUB_WORKSPACE"]) !== null && _d !== void 0 ? _d : process.cwd();
@@ -34043,11 +34043,11 @@ var require_cacheUtils = __commonJS({
           implicitDescendants: false
         });
         try {
-          for (var _e = true, _f = __asyncValues2(globber.globGenerator()), _g; _g = yield _f.next(), _a = _g.done, !_a; _e = true) {
+          for (var _e = true, _f = __asyncValues2(globber.globGenerator()), _g; _g = yield _f.next(), _a2 = _g.done, !_a2; _e = true) {
             _c = _g.value;
             _e = false;
             const file = _c;
-            const relativeFile = path28.relative(workspace, file).replace(new RegExp(`\\${path28.sep}`, "g"), "/");
+            const relativeFile = path29.relative(workspace, file).replace(new RegExp(`\\${path29.sep}`, "g"), "/");
             core30.debug(`Matched: ${relativeFile}`);
             if (relativeFile === "") {
               paths.push(".");
@@ -34059,7 +34059,7 @@ var require_cacheUtils = __commonJS({
           e_1 = { error: e_1_1 };
         } finally {
           try {
-            if (!_e && !_a && (_b = _f.return)) yield _b.call(_f);
+            if (!_e && !_a2 && (_b = _f.return)) yield _b.call(_f);
           } finally {
             if (e_1) throw e_1.error;
           }
@@ -34069,7 +34069,7 @@ var require_cacheUtils = __commonJS({
     }
     function unlinkFile(filePath) {
       return __awaiter2(this, void 0, void 0, function* () {
-        return util.promisify(fs30.unlink)(filePath);
+        return util3.promisify(fs31.unlink)(filePath);
       });
     }
     function getVersion(app_1) {
@@ -34111,7 +34111,7 @@ var require_cacheUtils = __commonJS({
     }
     function getGnuTarPathOnWindows() {
       return __awaiter2(this, void 0, void 0, function* () {
-        if (fs30.existsSync(constants_1.GnuTarPathOnWindows)) {
+        if (fs31.existsSync(constants_1.GnuTarPathOnWindows)) {
           return constants_1.GnuTarPathOnWindows;
         }
         const versionOutput = yield getVersion("tar");
@@ -34264,11 +34264,11 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P, generator) {
   function adopt(value) {
-    return value instanceof P ? value : new P(function(resolve13) {
-      resolve13(value);
+    return value instanceof P ? value : new P(function(resolve14) {
+      resolve14(value);
     });
   }
-  return new (P || (P = Promise))(function(resolve13, reject) {
+  return new (P || (P = Promise))(function(resolve14, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -34284,7 +34284,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -34475,14 +34475,14 @@ function __asyncValues(o) {
   }, i);
   function verb(n) {
     i[n] = o[n] && function(v) {
-      return new Promise(function(resolve13, reject) {
-        v = o[n](v), settle(resolve13, reject, v.done, v.value);
+      return new Promise(function(resolve14, reject) {
+        v = o[n](v), settle(resolve14, reject, v.done, v.value);
       });
     };
   }
-  function settle(resolve13, reject, d, v) {
+  function settle(resolve14, reject, d, v) {
     Promise.resolve(v).then(function(v2) {
-      resolve13({ value: v2, done: d });
+      resolve14({ value: v2, done: d });
     }, reject);
   }
 }
@@ -34574,13 +34574,13 @@ function __disposeResources(env) {
   }
   return next();
 }
-function __rewriteRelativeImportExtension(path28, preserveJsx) {
-  if (typeof path28 === "string" && /^\.\.?\//.test(path28)) {
-    return path28.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
-      return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+function __rewriteRelativeImportExtension(path29, preserveJsx) {
+  if (typeof path29 === "string" && /^\.\.?\//.test(path29)) {
+    return path29.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext2, cm) {
+      return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext2 || !cm) ? m : d + ext2 + "." + cm.toLowerCase() + "js";
     });
   }
-  return path28;
+  return path29;
 }
 var extendStatics, __assign, __createBinding, __setModuleDefault, ownKeys, _SuppressedError, tslib_es6_default;
 var init_tslib_es6 = __esm({
@@ -34851,9 +34851,9 @@ var require_debug2 = __commonJS({
       return newDebugger;
     }
     function destroy() {
-      const index = debuggers.indexOf(this);
-      if (index >= 0) {
-        debuggers.splice(index, 1);
+      const index2 = debuggers.indexOf(this);
+      if (index2 >= 0) {
+        debuggers.splice(index2, 1);
         return true;
       }
       return false;
@@ -35654,9 +35654,9 @@ var require_nodeHttpClient = __commonJS({
       if (stream2.readable === false) {
         return Promise.resolve();
       }
-      return new Promise((resolve13) => {
+      return new Promise((resolve14) => {
         const handler2 = () => {
-          resolve13();
+          resolve14();
           stream2.removeListener("close", handler2);
           stream2.removeListener("end", handler2);
           stream2.removeListener("error", handler2);
@@ -35811,8 +35811,8 @@ var require_nodeHttpClient = __commonJS({
           headers: request3.headers.toJSON({ preserveCase: true }),
           ...request3.requestOverrides
         };
-        return new Promise((resolve13, reject) => {
-          const req = isInsecure ? node_http_1.default.request(options, resolve13) : node_https_1.default.request(options, resolve13);
+        return new Promise((resolve14, reject) => {
+          const req = isInsecure ? node_http_1.default.request(options, resolve14) : node_https_1.default.request(options, resolve14);
           req.once("error", (err) => {
             reject(new restError_js_1.RestError(err.message, { code: err.code ?? restError_js_1.RestError.REQUEST_SEND_ERROR, request: request3 }));
           });
@@ -35896,7 +35896,7 @@ var require_nodeHttpClient = __commonJS({
       return stream2;
     }
     function streamToText(stream2) {
-      return new Promise((resolve13, reject) => {
+      return new Promise((resolve14, reject) => {
         const buffer = [];
         stream2.on("data", (chunk) => {
           if (Buffer.isBuffer(chunk)) {
@@ -35906,7 +35906,7 @@ var require_nodeHttpClient = __commonJS({
           }
         });
         stream2.on("end", () => {
-          resolve13(Buffer.concat(buffer).toString("utf8"));
+          resolve14(Buffer.concat(buffer).toString("utf8"));
         });
         stream2.on("error", (e) => {
           if (e && e?.name === "AbortError") {
@@ -36184,7 +36184,7 @@ var require_helpers2 = __commonJS({
     var AbortError_js_1 = require_AbortError();
     var StandardAbortMessage = "The operation was aborted.";
     function delay2(delayInMs, value, options) {
-      return new Promise((resolve13, reject) => {
+      return new Promise((resolve14, reject) => {
         let timer = void 0;
         let onAborted = void 0;
         const rejectOnAbort = () => {
@@ -36207,7 +36207,7 @@ var require_helpers2 = __commonJS({
         }
         timer = setTimeout(() => {
           removeListeners();
-          resolve13(value);
+          resolve14(value);
         }, delayInMs);
         if (options?.abortSignal) {
           options.abortSignal.addEventListener("abort", onAborted);
@@ -36573,14 +36573,14 @@ var require_ms = __commonJS({
       if (str.length > 100) {
         return;
       }
-      var match = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
+      var match2 = /^(-?(?:\d+)?\.?\d+) *(milliseconds?|msecs?|ms|seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)?$/i.exec(
         str
       );
-      if (!match) {
+      if (!match2) {
         return;
       }
-      var n = parseFloat(match[1]);
-      var type = (match[2] || "ms").toLowerCase();
+      var n = parseFloat(match2[1]);
+      var type = (match2[2] || "ms").toLowerCase();
       switch (type) {
         case "years":
         case "year":
@@ -36710,20 +36710,20 @@ var require_common2 = __commonJS({
           if (typeof args[0] !== "string") {
             args.unshift("%O");
           }
-          let index = 0;
-          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match, format) => {
-            if (match === "%%") {
+          let index2 = 0;
+          args[0] = args[0].replace(/%([a-zA-Z%])/g, (match2, format) => {
+            if (match2 === "%%") {
               return "%";
             }
-            index++;
+            index2++;
             const formatter = createDebug.formatters[format];
             if (typeof formatter === "function") {
-              const val = args[index];
-              match = formatter.call(self2, val);
-              args.splice(index, 1);
-              index--;
+              const val = args[index2];
+              match2 = formatter.call(self2, val);
+              args.splice(index2, 1);
+              index2--;
             }
-            return match;
+            return match2;
           });
           createDebug.formatArgs.call(self2, args);
           const logFn = self2.log || createDebug.log;
@@ -36956,15 +36956,15 @@ var require_browser = __commonJS({
       }
       const c = "color: " + this.color;
       args.splice(1, 0, c, "color: inherit");
-      let index = 0;
+      let index2 = 0;
       let lastC = 0;
-      args[0].replace(/%[a-zA-Z%]/g, (match) => {
-        if (match === "%%") {
+      args[0].replace(/%[a-zA-Z%]/g, (match2) => {
+        if (match2 === "%%") {
           return;
         }
-        index++;
-        if (match === "%c") {
-          lastC = index;
+        index2++;
+        if (match2 === "%c") {
+          lastC = index2;
         }
       });
       args.splice(lastC, 0, c);
@@ -37129,14 +37129,14 @@ var require_supports_color = __commonJS({
 var require_node = __commonJS({
   "node_modules/debug/src/node.js"(exports2, module2) {
     var tty = require("tty");
-    var util = require("util");
+    var util3 = require("util");
     exports2.init = init;
     exports2.log = log;
     exports2.formatArgs = formatArgs;
     exports2.save = save;
     exports2.load = load2;
     exports2.useColors = useColors;
-    exports2.destroy = util.deprecate(
+    exports2.destroy = util3.deprecate(
       () => {
       },
       "Instance method `debug.destroy()` is deprecated and no longer does anything. It will be removed in the next major version of `debug`."
@@ -37267,7 +37267,7 @@ var require_node = __commonJS({
       return (/* @__PURE__ */ new Date()).toISOString() + " ";
     }
     function log(...args) {
-      return process.stderr.write(util.formatWithOptions(exports2.inspectOpts, ...args) + "\n");
+      return process.stderr.write(util3.formatWithOptions(exports2.inspectOpts, ...args) + "\n");
     }
     function save(namespaces) {
       if (namespaces) {
@@ -37290,11 +37290,11 @@ var require_node = __commonJS({
     var { formatters } = module2.exports;
     formatters.o = function(v) {
       this.inspectOpts.colors = this.useColors;
-      return util.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
+      return util3.inspect(v, this.inspectOpts).split("\n").map((str) => str.trim()).join(" ");
     };
     formatters.O = function(v) {
       this.inspectOpts.colors = this.useColors;
-      return util.inspect(v, this.inspectOpts);
+      return util3.inspect(v, this.inspectOpts);
     };
   }
 });
@@ -37370,8 +37370,8 @@ var require_helpers3 = __commonJS({
     function req(url2, opts = {}) {
       const href = typeof url2 === "string" ? url2 : url2.href;
       const req2 = (href.startsWith("https:") ? https3 : http).request(url2, opts);
-      const promise = new Promise((resolve13, reject) => {
-        req2.once("response", resolve13).once("error", reject).end();
+      const promise = new Promise((resolve14, reject) => {
+        req2.once("response", resolve14).once("error", reject).end();
       });
       req2.then = promise.then.bind(promise);
       return req2;
@@ -37466,9 +37466,9 @@ var require_dist = __commonJS({
           return;
         }
         const sockets = this.sockets[name];
-        const index = sockets.indexOf(socket);
-        if (index !== -1) {
-          sockets.splice(index, 1);
+        const index2 = sockets.indexOf(socket);
+        if (index2 !== -1) {
+          sockets.splice(index2, 1);
           this.totalSocketCount--;
           if (sockets.length === 0) {
             delete this.sockets[name];
@@ -37548,7 +37548,7 @@ var require_parse_proxy_response = __commonJS({
     var debug_1 = __importDefault2(require_src());
     var debug6 = (0, debug_1.default)("https-proxy-agent:parse-proxy-response");
     function parseProxyResponse(socket) {
-      return new Promise((resolve13, reject) => {
+      return new Promise((resolve14, reject) => {
         let buffersLength = 0;
         const buffers = [];
         function read() {
@@ -37614,7 +37614,7 @@ var require_parse_proxy_response = __commonJS({
           }
           debug6("got proxy server response: %o %o", firstLine, headers);
           cleanup();
-          resolve13({
+          resolve14({
             connect: {
               statusCode,
               statusText,
@@ -38994,8 +38994,8 @@ var require_getClient = __commonJS({
       }
       const { allowInsecureConnection, httpClient } = clientOptions;
       const endpointUrl = clientOptions.endpoint ?? endpoint2;
-      const client = (path28, ...args) => {
-        const getUrl = (requestOptions) => (0, urlHelpers_js_1.buildRequestUrl)(endpointUrl, path28, args, { allowInsecureConnection, ...requestOptions });
+      const client = (path29, ...args) => {
+        const getUrl = (requestOptions) => (0, urlHelpers_js_1.buildRequestUrl)(endpointUrl, path29, args, { allowInsecureConnection, ...requestOptions });
         return {
           get: (requestOptions = {}) => {
             return buildOperation("GET", getUrl(requestOptions), pipeline, requestOptions, allowInsecureConnection, httpClient);
@@ -39700,7 +39700,7 @@ var require_createAbortablePromise = __commonJS({
     var abort_controller_1 = require_commonjs3();
     function createAbortablePromise(buildPromise, options) {
       const { cleanupBeforeAbort, abortSignal, abortErrorMsg } = options ?? {};
-      return new Promise((resolve13, reject) => {
+      return new Promise((resolve14, reject) => {
         function rejectOnAbort() {
           reject(new abort_controller_1.AbortError(abortErrorMsg ?? "The operation was aborted."));
         }
@@ -39718,7 +39718,7 @@ var require_createAbortablePromise = __commonJS({
         try {
           buildPromise((x) => {
             removeListeners();
-            resolve13(x);
+            resolve14(x);
           }, (x) => {
             removeListeners();
             reject(x);
@@ -39745,8 +39745,8 @@ var require_delay2 = __commonJS({
     function delay2(timeInMs, options) {
       let token;
       const { abortSignal, abortErrorMsg } = options ?? {};
-      return (0, createAbortablePromise_js_1.createAbortablePromise)((resolve13) => {
-        token = setTimeout(resolve13, timeInMs);
+      return (0, createAbortablePromise_js_1.createAbortablePromise)((resolve14) => {
+        token = setTimeout(resolve14, timeInMs);
       }, {
         cleanupBeforeAbort: () => clearTimeout(token),
         abortSignal,
@@ -40951,10 +40951,10 @@ var require_bearerTokenAuthenticationPolicy = __commonJS({
       const challengeRegex = /(\w+)\s+((?:\w+=(?:"[^"]*"|[^,]*),?\s*)+)/g;
       const paramRegex = /(\w+)="([^"]*)"/g;
       const parsedChallenges = [];
-      let match;
-      while ((match = challengeRegex.exec(challenges)) !== null) {
-        const scheme = match[1];
-        const paramsString = match[2];
+      let match2;
+      while ((match2 = challengeRegex.exec(challenges)) !== null) {
+        const scheme = match2[1];
+        const paramsString = match2[2];
         const params = {};
         let paramMatch;
         while ((paramMatch = paramRegex.exec(paramsString)) !== null) {
@@ -42747,13 +42747,13 @@ var require_serializationPolicy = __commonJS({
           if (request3.body !== void 0 && request3.body !== null || nullable && request3.body === null || required) {
             const requestBodyParameterPathString = (0, interfaceHelpers_js_1.getPathStringFromParameter)(operationSpec.requestBody);
             request3.body = operationSpec.serializer.serialize(bodyMapper, request3.body, requestBodyParameterPathString, updatedOptions);
-            const isStream = typeName === serializer_js_1.MapperTypeNames.Stream;
+            const isStream2 = typeName === serializer_js_1.MapperTypeNames.Stream;
             if (operationSpec.isXML) {
               const xmlnsKey = xmlNamespacePrefix ? `xmlns:${xmlNamespacePrefix}` : "xmlns";
               const value = getXmlValueWithNamespace(xmlNamespace, xmlnsKey, typeName, request3.body, updatedOptions);
               if (typeName === serializer_js_1.MapperTypeNames.Sequence) {
                 request3.body = stringifyXML(prepareXMLRootList(value, xmlElementName || xmlName || serializedName, xmlnsKey, xmlNamespace), { rootName: xmlName || serializedName, xmlCharKey });
-              } else if (!isStream) {
+              } else if (!isStream2) {
                 request3.body = stringifyXML(value, {
                   rootName: xmlName || serializedName,
                   xmlCharKey
@@ -42761,7 +42761,7 @@ var require_serializationPolicy = __commonJS({
               }
             } else if (typeName === serializer_js_1.MapperTypeNames.String && (operationSpec.contentType?.match("text/plain") || operationSpec.mediaType === "text")) {
               return;
-            } else if (!isStream) {
+            } else if (!isStream2) {
               request3.body = JSON.stringify(request3.body);
             }
           }
@@ -42866,15 +42866,15 @@ var require_urlHelpers2 = __commonJS({
       let isAbsolutePath = false;
       let requestUrl = replaceAll(baseUri, urlReplacements);
       if (operationSpec.path) {
-        let path28 = replaceAll(operationSpec.path, urlReplacements);
-        if (operationSpec.path === "/{nextLink}" && path28.startsWith("/")) {
-          path28 = path28.substring(1);
+        let path29 = replaceAll(operationSpec.path, urlReplacements);
+        if (operationSpec.path === "/{nextLink}" && path29.startsWith("/")) {
+          path29 = path29.substring(1);
         }
-        if (isAbsoluteUrl(path28)) {
-          requestUrl = path28;
+        if (isAbsoluteUrl(path29)) {
+          requestUrl = path29;
           isAbsolutePath = true;
         } else {
-          requestUrl = appendPath(requestUrl, path28);
+          requestUrl = appendPath(requestUrl, path29);
         }
       }
       const { queryParams, sequenceParams } = calculateQueryParameters(operationSpec, operationArguments, fallbackObject);
@@ -42920,9 +42920,9 @@ var require_urlHelpers2 = __commonJS({
       }
       const searchStart = pathToAppend.indexOf("?");
       if (searchStart !== -1) {
-        const path28 = pathToAppend.substring(0, searchStart);
+        const path29 = pathToAppend.substring(0, searchStart);
         const search = pathToAppend.substring(searchStart + 1);
-        newPath = newPath + path28;
+        newPath = newPath + path29;
         if (search) {
           parsedUrl.search = parsedUrl.search ? `${parsedUrl.search}&${search}` : search;
         }
@@ -45418,17 +45418,17 @@ var require_xml = __commonJS({
     var fast_xml_parser_1 = require_fxp();
     var xml_common_js_1 = require_xml_common();
     function getCommonOptions(options) {
-      var _a;
+      var _a2;
       return {
         attributesGroupName: xml_common_js_1.XML_ATTRKEY,
-        textNodeName: (_a = options.xmlCharKey) !== null && _a !== void 0 ? _a : xml_common_js_1.XML_CHARKEY,
+        textNodeName: (_a2 = options.xmlCharKey) !== null && _a2 !== void 0 ? _a2 : xml_common_js_1.XML_CHARKEY,
         ignoreAttributes: false,
         suppressBooleanAttributes: false
       };
     }
     function getSerializerOptions(options = {}) {
-      var _a, _b;
-      return Object.assign(Object.assign({}, getCommonOptions(options)), { attributeNamePrefix: "@_", format: true, suppressEmptyNode: true, indentBy: "", rootNodeName: (_a = options.rootName) !== null && _a !== void 0 ? _a : "root", cdataPropName: (_b = options.cdataPropName) !== null && _b !== void 0 ? _b : "__cdata" });
+      var _a2, _b;
+      return Object.assign(Object.assign({}, getCommonOptions(options)), { attributeNamePrefix: "@_", format: true, suppressEmptyNode: true, indentBy: "", rootNodeName: (_a2 = options.rootName) !== null && _a2 !== void 0 ? _a2 : "root", cdataPropName: (_b = options.cdataPropName) !== null && _b !== void 0 ? _b : "__cdata" });
     }
     function getParserOptions(options = {}) {
       return Object.assign(Object.assign({}, getCommonOptions(options)), { parseAttributeValue: false, parseTagValue: false, attributeNamePrefix: "", stopNodes: options.stopNodes, processEntities: true, trimValues: false });
@@ -45838,10 +45838,10 @@ var require_utils_common = __commonJS({
     var constants_js_1 = require_constants10();
     function escapeURLPath(url2) {
       const urlParsed = new URL(url2);
-      let path28 = urlParsed.pathname;
-      path28 = path28 || "/";
-      path28 = escape2(path28);
-      urlParsed.pathname = path28;
+      let path29 = urlParsed.pathname;
+      path29 = path29 || "/";
+      path29 = escape3(path29);
+      urlParsed.pathname = path29;
       return urlParsed.toString();
     }
     function getProxyUriFromDevConnString(connectionString) {
@@ -45921,14 +45921,14 @@ var require_utils_common = __commonJS({
         return { kind: "SASConnString", url: blobEndpoint, accountName, accountSas };
       }
     }
-    function escape2(text) {
+    function escape3(text) {
       return encodeURIComponent(text).replace(/%2F/g, "/").replace(/'/g, "%27").replace(/\+/g, "%20").replace(/%25/g, "%");
     }
     function appendToURLPath(url2, name) {
       const urlParsed = new URL(url2);
-      let path28 = urlParsed.pathname;
-      path28 = path28 ? path28.endsWith("/") ? `${path28}${name}` : `${path28}/${name}` : name;
-      urlParsed.pathname = path28;
+      let path29 = urlParsed.pathname;
+      path29 = path29 ? path29.endsWith("/") ? `${path29}${name}` : `${path29}/${name}` : name;
+      urlParsed.pathname = path29;
       return urlParsed.toString();
     }
     function setURLParameter(url2, name, value) {
@@ -46043,7 +46043,7 @@ var require_utils_common = __commonJS({
       return base64encode(res);
     }
     async function delay2(timeInMs, aborter, abortError) {
-      return new Promise((resolve13, reject) => {
+      return new Promise((resolve14, reject) => {
         let timeout;
         const abortHandler = () => {
           if (timeout !== void 0) {
@@ -46055,7 +46055,7 @@ var require_utils_common = __commonJS({
           if (aborter !== void 0) {
             aborter.removeEventListener("abort", abortHandler);
           }
-          resolve13();
+          resolve14();
         };
         timeout = setTimeout(resolveHandler, timeInMs);
         if (aborter !== void 0) {
@@ -47136,8 +47136,8 @@ var require_StorageSharedKeyCredentialPolicy = __commonJS({
         headersArray.sort((a, b) => {
           return (0, SharedKeyComparator_js_1.compareHeader)(a.name.toLowerCase(), b.name.toLowerCase());
         });
-        headersArray = headersArray.filter((value, index, array) => {
-          if (index > 0 && value.name.toLowerCase() === array[index - 1].name.toLowerCase()) {
+        headersArray = headersArray.filter((value, index2, array) => {
+          if (index2 > 0 && value.name.toLowerCase() === array[index2 - 1].name.toLowerCase()) {
             return false;
           }
           return true;
@@ -47155,9 +47155,9 @@ var require_StorageSharedKeyCredentialPolicy = __commonJS({
        * @param request -
        */
       getCanonicalizedResourceString(request3) {
-        const path28 = (0, utils_common_js_1.getURLPath)(request3.url) || "/";
+        const path29 = (0, utils_common_js_1.getURLPath)(request3.url) || "/";
         let canonicalizedResourceString = "";
-        canonicalizedResourceString += `/${this.factory.accountName}${path28}`;
+        canonicalizedResourceString += `/${this.factory.accountName}${path29}`;
         const queries = (0, utils_common_js_1.getURLQueries)(request3.url);
         const lowercaseQueries = {};
         if (queries) {
@@ -47596,7 +47596,7 @@ var require_BufferScheduler = __commonJS({
        *
        */
       async do() {
-        return new Promise((resolve13, reject) => {
+        return new Promise((resolve14, reject) => {
           this.readable.on("data", (data) => {
             data = typeof data === "string" ? Buffer.from(data, this.encoding) : data;
             this.appendUnresolvedData(data);
@@ -47624,11 +47624,11 @@ var require_BufferScheduler = __commonJS({
             if (this.isStreamEnd && this.executingOutgoingHandlers === 0) {
               if (this.unresolvedLength > 0 && this.unresolvedLength < this.bufferSize) {
                 const buffer = this.shiftBufferFromUnresolvedDataArray();
-                this.outgoingHandler(() => buffer.getReadableStream(), buffer.size, this.offset).then(resolve13).catch(reject);
+                this.outgoingHandler(() => buffer.getReadableStream(), buffer.size, this.offset).then(resolve14).catch(reject);
               } else if (this.unresolvedLength >= this.bufferSize) {
                 return;
               } else {
-                resolve13();
+                resolve14();
               }
             }
           });
@@ -47896,10 +47896,10 @@ var require_utils_common2 = __commonJS({
     var constants_js_1 = require_constants11();
     function escapeURLPath(url2) {
       const urlParsed = new URL(url2);
-      let path28 = urlParsed.pathname;
-      path28 = path28 || "/";
-      path28 = escape2(path28);
-      urlParsed.pathname = path28;
+      let path29 = urlParsed.pathname;
+      path29 = path29 || "/";
+      path29 = escape3(path29);
+      urlParsed.pathname = path29;
       return urlParsed.toString();
     }
     function getProxyUriFromDevConnString(connectionString) {
@@ -47979,14 +47979,14 @@ var require_utils_common2 = __commonJS({
         return { kind: "SASConnString", url: blobEndpoint, accountName, accountSas };
       }
     }
-    function escape2(text) {
+    function escape3(text) {
       return encodeURIComponent(text).replace(/%2F/g, "/").replace(/'/g, "%27").replace(/\+/g, "%20").replace(/%25/g, "%");
     }
     function appendToURLPath(url2, name) {
       const urlParsed = new URL(url2);
-      let path28 = urlParsed.pathname;
-      path28 = path28 ? path28.endsWith("/") ? `${path28}${name}` : `${path28}/${name}` : name;
-      urlParsed.pathname = path28;
+      let path29 = urlParsed.pathname;
+      path29 = path29 ? path29.endsWith("/") ? `${path29}${name}` : `${path29}/${name}` : name;
+      urlParsed.pathname = path29;
       return urlParsed.toString();
     }
     function setURLParameter(url2, name, value) {
@@ -48101,7 +48101,7 @@ var require_utils_common2 = __commonJS({
       return base64encode(res);
     }
     async function delay2(timeInMs, aborter, abortError) {
-      return new Promise((resolve13, reject) => {
+      return new Promise((resolve14, reject) => {
         let timeout;
         const abortHandler = () => {
           if (timeout !== void 0) {
@@ -48113,7 +48113,7 @@ var require_utils_common2 = __commonJS({
           if (aborter !== void 0) {
             aborter.removeEventListener("abort", abortHandler);
           }
-          resolve13();
+          resolve14();
         };
         timeout = setTimeout(resolveHandler, timeInMs);
         if (aborter !== void 0) {
@@ -48888,8 +48888,8 @@ var require_StorageSharedKeyCredentialPolicy2 = __commonJS({
         headersArray.sort((a, b) => {
           return (0, SharedKeyComparator_js_1.compareHeader)(a.name.toLowerCase(), b.name.toLowerCase());
         });
-        headersArray = headersArray.filter((value, index, array) => {
-          if (index > 0 && value.name.toLowerCase() === array[index - 1].name.toLowerCase()) {
+        headersArray = headersArray.filter((value, index2, array) => {
+          if (index2 > 0 && value.name.toLowerCase() === array[index2 - 1].name.toLowerCase()) {
             return false;
           }
           return true;
@@ -48907,9 +48907,9 @@ var require_StorageSharedKeyCredentialPolicy2 = __commonJS({
        * @param request -
        */
       getCanonicalizedResourceString(request3) {
-        const path28 = (0, utils_common_js_1.getURLPath)(request3.url) || "/";
+        const path29 = (0, utils_common_js_1.getURLPath)(request3.url) || "/";
         let canonicalizedResourceString = "";
-        canonicalizedResourceString += `/${this.factory.accountName}${path28}`;
+        canonicalizedResourceString += `/${this.factory.accountName}${path29}`;
         const queries = (0, utils_common_js_1.getURLQueries)(request3.url);
         const lowercaseQueries = {};
         if (queries) {
@@ -49525,8 +49525,8 @@ var require_StorageSharedKeyCredentialPolicyV2 = __commonJS({
         headersArray.sort((a, b) => {
           return (0, SharedKeyComparator_js_1.compareHeader)(a.name.toLowerCase(), b.name.toLowerCase());
         });
-        headersArray = headersArray.filter((value, index, array) => {
-          if (index > 0 && value.name.toLowerCase() === array[index - 1].name.toLowerCase()) {
+        headersArray = headersArray.filter((value, index2, array) => {
+          if (index2 > 0 && value.name.toLowerCase() === array[index2 - 1].name.toLowerCase()) {
             return false;
           }
           return true;
@@ -49539,9 +49539,9 @@ var require_StorageSharedKeyCredentialPolicyV2 = __commonJS({
         return canonicalizedHeadersStringToSign;
       }
       function getCanonicalizedResourceString(request3) {
-        const path28 = (0, utils_common_js_1.getURLPath)(request3.url) || "/";
+        const path29 = (0, utils_common_js_1.getURLPath)(request3.url) || "/";
         let canonicalizedResourceString = "";
-        canonicalizedResourceString += `/${options.accountName}${path28}`;
+        canonicalizedResourceString += `/${options.accountName}${path29}`;
         const queries = (0, utils_common_js_1.getURLQueries)(request3.url);
         const lowercaseQueries = {};
         if (queries) {
@@ -49872,8 +49872,8 @@ var require_StorageSharedKeyCredentialPolicyV22 = __commonJS({
         headersArray.sort((a, b) => {
           return (0, SharedKeyComparator_js_1.compareHeader)(a.name.toLowerCase(), b.name.toLowerCase());
         });
-        headersArray = headersArray.filter((value, index, array) => {
-          if (index > 0 && value.name.toLowerCase() === array[index - 1].name.toLowerCase()) {
+        headersArray = headersArray.filter((value, index2, array) => {
+          if (index2 > 0 && value.name.toLowerCase() === array[index2 - 1].name.toLowerCase()) {
             return false;
           }
           return true;
@@ -49886,9 +49886,9 @@ var require_StorageSharedKeyCredentialPolicyV22 = __commonJS({
         return canonicalizedHeadersStringToSign;
       }
       function getCanonicalizedResourceString(request3) {
-        const path28 = (0, utils_common_js_1.getURLPath)(request3.url) || "/";
+        const path29 = (0, utils_common_js_1.getURLPath)(request3.url) || "/";
         let canonicalizedResourceString = "";
-        canonicalizedResourceString += `/${options.accountName}${path28}`;
+        canonicalizedResourceString += `/${options.accountName}${path29}`;
         const queries = (0, utils_common_js_1.getURLQueries)(request3.url);
         const lowercaseQueries = {};
         if (queries) {
@@ -62499,8 +62499,8 @@ var require_pageBlob = __commonJS({
        *              aligned and range-end is required.
        * @param options The options parameters.
        */
-      uploadPagesFromURL(sourceUrl, sourceRange, contentLength, range, options) {
-        return this.client.sendOperationRequest({ sourceUrl, sourceRange, contentLength, range, options }, uploadPagesFromURLOperationSpec);
+      uploadPagesFromURL(sourceUrl, sourceRange, contentLength, range2, options) {
+        return this.client.sendOperationRequest({ sourceUrl, sourceRange, contentLength, range: range2, options }, uploadPagesFromURLOperationSpec);
       }
       /**
        * The Get Page Ranges operation returns the list of valid page ranges for a page blob or snapshot of a
@@ -63546,13 +63546,13 @@ var require_storageClient = __commonJS({
         if (!options) {
           options = {};
         }
-        const defaults = {
+        const defaults2 = {
           requestContentType: "application/json; charset=utf-8"
         };
         const packageDetails = `azsdk-js-azure-storage-blob/12.29.1`;
         const userAgentPrefix = options.userAgentOptions && options.userAgentOptions.userAgentPrefix ? `${options.userAgentOptions.userAgentPrefix} ${packageDetails}` : `${packageDetails}`;
         const optionsWithDefaults = {
-          ...defaults,
+          ...defaults2,
           ...options,
           userAgentOptions: {
             userAgentPrefix
@@ -66074,9 +66074,9 @@ var require_AvroParser = __commonJS({
     };
     var AvroUnionType = class extends AvroType {
       _types;
-      constructor(types2) {
+      constructor(types3) {
         super();
-        this._types = types2;
+        this._types = types3;
       }
       async read(stream2, options = {}) {
         const typeIndex = await AvroParser.readInt(stream2, options);
@@ -66311,7 +66311,7 @@ var require_AvroReadableFromStream = __commonJS({
           this._position += chunk.length;
           return this.toUint8Array(chunk);
         } else {
-          return new Promise((resolve13, reject) => {
+          return new Promise((resolve14, reject) => {
             const cleanUp = () => {
               this._readable.removeListener("readable", readableCallback);
               this._readable.removeListener("error", rejectCallback);
@@ -66326,7 +66326,7 @@ var require_AvroReadableFromStream = __commonJS({
               if (callbackChunk) {
                 this._position += callbackChunk.length;
                 cleanUp();
-                resolve13(this.toUint8Array(callbackChunk));
+                resolve14(this.toUint8Array(callbackChunk));
               }
             };
             const rejectCallback = () => {
@@ -67159,7 +67159,7 @@ var require_operation2 = __commonJS({
       return rawResponse.headers["azure-asyncoperation"];
     }
     function findResourceLocation(inputs) {
-      var _a;
+      var _a2;
       const { location, requestMethod, requestPath, resourceLocationConfig } = inputs;
       switch (requestMethod) {
         case "PUT": {
@@ -67169,7 +67169,7 @@ var require_operation2 = __commonJS({
           return void 0;
         }
         case "PATCH": {
-          return (_a = getDefault()) !== null && _a !== void 0 ? _a : requestPath;
+          return (_a2 = getDefault()) !== null && _a2 !== void 0 ? _a2 : requestPath;
         }
         default: {
           return getDefault();
@@ -67251,13 +67251,13 @@ var require_operation2 = __commonJS({
       }
     }
     function getStatus(rawResponse) {
-      var _a;
-      const { status } = (_a = rawResponse.body) !== null && _a !== void 0 ? _a : {};
+      var _a2;
+      const { status } = (_a2 = rawResponse.body) !== null && _a2 !== void 0 ? _a2 : {};
       return transformStatus({ status, statusCode: rawResponse.statusCode });
     }
     function getProvisioningState(rawResponse) {
-      var _a, _b;
-      const { properties, provisioningState } = (_a = rawResponse.body) !== null && _a !== void 0 ? _a : {};
+      var _a2, _b;
+      const { properties, provisioningState } = (_a2 = rawResponse.body) !== null && _a2 !== void 0 ? _a2 : {};
       const status = (_b = properties === null || properties === void 0 ? void 0 : properties.provisioningState) !== null && _b !== void 0 ? _b : provisioningState;
       return transformStatus({ status, statusCode: rawResponse.statusCode });
     }
@@ -67303,8 +67303,8 @@ var require_operation2 = __commonJS({
     function getStatusFromInitialResponse(inputs) {
       const { response, state, operationLocation } = inputs;
       function helper() {
-        var _a;
-        const mode = (_a = state.config.metadata) === null || _a === void 0 ? void 0 : _a["mode"];
+        var _a2;
+        const mode = (_a2 = state.config.metadata) === null || _a2 === void 0 ? void 0 : _a2["mode"];
         switch (mode) {
           case void 0:
             return toOperationStatus(response.rawResponse.statusCode);
@@ -67339,8 +67339,8 @@ var require_operation2 = __commonJS({
     }
     exports2.initHttpOperation = initHttpOperation;
     function getOperationLocation({ rawResponse }, state) {
-      var _a;
-      const mode = (_a = state.config.metadata) === null || _a === void 0 ? void 0 : _a["mode"];
+      var _a2;
+      const mode = (_a2 = state.config.metadata) === null || _a2 === void 0 ? void 0 : _a2["mode"];
       switch (mode) {
         case "OperationLocation": {
           return getOperationLocationPollingUrl({
@@ -67359,8 +67359,8 @@ var require_operation2 = __commonJS({
     }
     exports2.getOperationLocation = getOperationLocation;
     function getOperationStatus({ rawResponse }, state) {
-      var _a;
-      const mode = (_a = state.config.metadata) === null || _a === void 0 ? void 0 : _a["mode"];
+      var _a2;
+      const mode = (_a2 = state.config.metadata) === null || _a2 === void 0 ? void 0 : _a2["mode"];
       switch (mode) {
         case "OperationLocation": {
           return getStatus(rawResponse);
@@ -67377,8 +67377,8 @@ var require_operation2 = __commonJS({
     }
     exports2.getOperationStatus = getOperationStatus;
     function accessBodyProperty({ flatResponse, rawResponse }, prop) {
-      var _a, _b;
-      return (_a = flatResponse === null || flatResponse === void 0 ? void 0 : flatResponse[prop]) !== null && _a !== void 0 ? _a : (_b = rawResponse.body) === null || _b === void 0 ? void 0 : _b[prop];
+      var _a2, _b;
+      return (_a2 = flatResponse === null || flatResponse === void 0 ? void 0 : flatResponse[prop]) !== null && _a2 !== void 0 ? _a2 : (_b = rawResponse.body) === null || _b === void 0 ? void 0 : _b[prop];
     }
     function getResourceLocation(res, state) {
       const loc = accessBodyProperty(res, "resourceLocation");
@@ -67665,7 +67665,7 @@ var require_operation3 = __commonJS({
         this.pollerConfig = pollerConfig;
       }
       async update(options) {
-        var _a;
+        var _a2;
         const stateProxy = createStateProxy();
         if (!this.state.isStarted) {
           this.state = Object.assign(Object.assign({}, this.state), await (0, operation_js_1.initHttpOperation)({
@@ -67693,7 +67693,7 @@ var require_operation3 = __commonJS({
             setErrorAsResult: this.setErrorAsResult
           });
         }
-        (_a = options === null || options === void 0 ? void 0 : options.fireProgress) === null || _a === void 0 ? void 0 : _a.call(options, this.state);
+        (_a2 = options === null || options === void 0 ? void 0 : options.fireProgress) === null || _a2 === void 0 ? void 0 : _a2.call(options, this.state);
         return this;
       }
       async cancel() {
@@ -67806,8 +67806,8 @@ var require_poller3 = __commonJS({
         this.stopped = true;
         this.pollProgressCallbacks = [];
         this.operation = operation;
-        this.promise = new Promise((resolve13, reject) => {
-          this.resolve = resolve13;
+        this.promise = new Promise((resolve14, reject) => {
+          this.resolve = resolve14;
           this.reject = reject;
         });
         this.promise.catch(() => {
@@ -68060,7 +68060,7 @@ var require_lroEngine = __commonJS({
        * The method used by the poller to wait before attempting to update its operation.
        */
       delay() {
-        return new Promise((resolve13) => setTimeout(() => resolve13(), this.config.intervalInMs));
+        return new Promise((resolve14) => setTimeout(() => resolve14(), this.config.intervalInMs));
       }
     };
     exports2.LroEngine = LroEngine;
@@ -68306,8 +68306,8 @@ var require_Batch = __commonJS({
           return Promise.resolve();
         }
         this.parallelExecute();
-        return new Promise((resolve13, reject) => {
-          this.emitter.on("finish", resolve13);
+        return new Promise((resolve14, reject) => {
+          this.emitter.on("finish", resolve14);
           this.emitter.on("error", (error3) => {
             this.state = BatchStates.Error;
             reject(error3);
@@ -68368,12 +68368,12 @@ var require_utils6 = __commonJS({
     async function streamToBuffer(stream2, buffer, offset, end, encoding) {
       let pos = 0;
       const count = end - offset;
-      return new Promise((resolve13, reject) => {
+      return new Promise((resolve14, reject) => {
         const timeout = setTimeout(() => reject(new Error(`The operation cannot be completed in timeout.`)), constants_js_1.REQUEST_TIMEOUT);
         stream2.on("readable", () => {
           if (pos >= count) {
             clearTimeout(timeout);
-            resolve13();
+            resolve14();
             return;
           }
           let chunk = stream2.read();
@@ -68392,7 +68392,7 @@ var require_utils6 = __commonJS({
           if (pos < count) {
             reject(new Error(`Stream drains before getting enough data needed. Data read: ${pos}, data need: ${count}`));
           }
-          resolve13();
+          resolve14();
         });
         stream2.on("error", (msg) => {
           clearTimeout(timeout);
@@ -68403,7 +68403,7 @@ var require_utils6 = __commonJS({
     async function streamToBuffer2(stream2, buffer, encoding) {
       let pos = 0;
       const bufferSize = buffer.length;
-      return new Promise((resolve13, reject) => {
+      return new Promise((resolve14, reject) => {
         stream2.on("readable", () => {
           let chunk = stream2.read();
           if (!chunk) {
@@ -68420,25 +68420,25 @@ var require_utils6 = __commonJS({
           pos += chunk.length;
         });
         stream2.on("end", () => {
-          resolve13(pos);
+          resolve14(pos);
         });
         stream2.on("error", reject);
       });
     }
     async function streamToBuffer3(readableStream, encoding) {
-      return new Promise((resolve13, reject) => {
+      return new Promise((resolve14, reject) => {
         const chunks = [];
         readableStream.on("data", (data) => {
           chunks.push(typeof data === "string" ? Buffer.from(data, encoding) : data);
         });
         readableStream.on("end", () => {
-          resolve13(Buffer.concat(chunks));
+          resolve14(Buffer.concat(chunks));
         });
         readableStream.on("error", reject);
       });
     }
     async function readStreamToLocalFile(rs, file) {
-      return new Promise((resolve13, reject) => {
+      return new Promise((resolve14, reject) => {
         const ws = node_fs_1.default.createWriteStream(file);
         rs.on("error", (err) => {
           reject(err);
@@ -68446,7 +68446,7 @@ var require_utils6 = __commonJS({
         ws.on("error", (err) => {
           reject(err);
         });
-        ws.on("close", resolve13);
+        ws.on("close", resolve14);
         rs.pipe(ws);
       });
     }
@@ -69385,7 +69385,7 @@ var require_Clients = __commonJS({
        * @returns The SAS URI consisting of the URI to the resource represented by this client, followed by the generated SAS token.
        */
       generateSasUrl(options) {
-        return new Promise((resolve13) => {
+        return new Promise((resolve14) => {
           if (!(this.credential instanceof StorageSharedKeyCredential_js_1.StorageSharedKeyCredential)) {
             throw new RangeError("Can only generate the SAS when the client is initialized with a shared key credential");
           }
@@ -69396,7 +69396,7 @@ var require_Clients = __commonJS({
             versionId: this._versionId,
             ...options
           }, this.credential).toString();
-          resolve13((0, utils_common_js_1.appendToURLQuery)(this.url, sas));
+          resolve14((0, utils_common_js_1.appendToURLQuery)(this.url, sas));
         });
       }
       /**
@@ -69435,7 +69435,7 @@ var require_Clients = __commonJS({
        * @returns The SAS URI consisting of the URI to the resource represented by this client, followed by the generated SAS token.
        */
       generateUserDelegationSasUrl(options, userDelegationKey) {
-        return new Promise((resolve13) => {
+        return new Promise((resolve14) => {
           const sas = (0, BlobSASSignatureValues_js_1.generateBlobSASQueryParameters)({
             containerName: this._containerName,
             blobName: this._name,
@@ -69443,7 +69443,7 @@ var require_Clients = __commonJS({
             versionId: this._versionId,
             ...options
           }, userDelegationKey, this.accountName).toString();
-          resolve13((0, utils_common_js_1.appendToURLQuery)(this.url, sas));
+          resolve14((0, utils_common_js_1.appendToURLQuery)(this.url, sas));
         });
       }
       /**
@@ -71211,8 +71211,8 @@ var require_BatchResponseParser = __commonJS({
         const deserializedSubResponses = new Array(subResponseCount);
         let subResponsesSucceededCount = 0;
         let subResponsesFailedCount = 0;
-        for (let index = 0; index < subResponseCount; index++) {
-          const subResponse = subResponses[index];
+        for (let index2 = 0; index2 < subResponseCount; index2++) {
+          const subResponse = subResponses[index2];
           const deserializedSubResponse = {};
           deserializedSubResponse.headers = (0, core_http_compat_1.toHttpHeadersLike)((0, core_rest_pipeline_1.createHttpHeaders)());
           const responseLines = subResponse.split(`${constants_js_1.HTTP_LINE_ENDING}`);
@@ -71260,7 +71260,7 @@ var require_BatchResponseParser = __commonJS({
             deserializedSubResponse._request = this.subRequests.get(contentId);
             deserializedSubResponses[contentId] = deserializedSubResponse;
           } else {
-            log_js_1.logger.error(`subResponses[${index}] is dropped as the Content-ID is not found or invalid, Content-ID: ${contentId}`);
+            log_js_1.logger.error(`subResponses[${index2}] is dropped as the Content-ID is not found or invalid, Content-ID: ${contentId}`);
           }
           if (subRespFailed) {
             subResponsesFailedCount++;
@@ -71298,14 +71298,14 @@ var require_Mutex = __commonJS({
        * @param key - lock key
        */
       static async lock(key) {
-        return new Promise((resolve13) => {
+        return new Promise((resolve14) => {
           if (this.keys[key] === void 0 || this.keys[key] === MutexLockStatus.UNLOCKED) {
             this.keys[key] = MutexLockStatus.LOCKED;
-            resolve13();
+            resolve14();
           } else {
             this.onUnlockEvent(key, () => {
               this.keys[key] = MutexLockStatus.LOCKED;
-              resolve13();
+              resolve14();
             });
           }
         });
@@ -71316,12 +71316,12 @@ var require_Mutex = __commonJS({
        * @param key -
        */
       static async unlock(key) {
-        return new Promise((resolve13) => {
+        return new Promise((resolve14) => {
           if (this.keys[key] === MutexLockStatus.LOCKED) {
             this.emitUnlockEvent(key);
           }
           delete this.keys[key];
-          resolve13();
+          resolve14();
         });
       }
       static keys = {};
@@ -71543,8 +71543,8 @@ var require_BlobBatch = __commonJS({
         if (this.operationCount >= constants_js_1.BATCH_MAX_REQUEST) {
           throw new RangeError(`Cannot exceed ${constants_js_1.BATCH_MAX_REQUEST} sub requests in a single batch`);
         }
-        const path28 = (0, utils_common_js_1.getURLPath)(subRequest.url);
-        if (!path28 || path28 === "") {
+        const path29 = (0, utils_common_js_1.getURLPath)(subRequest.url);
+        if (!path29 || path29 === "") {
           throw new RangeError(`Invalid url for sub request: '${subRequest.url}'`);
         }
       }
@@ -71622,8 +71622,8 @@ var require_BlobBatchClient = __commonJS({
           pipeline = (0, Pipeline_js_1.newPipeline)(credentialOrPipeline, options);
         }
         const storageClientContext = new StorageContextClient_js_1.StorageContextClient(url2, (0, Pipeline_js_1.getCoreClientOptions)(pipeline));
-        const path28 = (0, utils_common_js_1.getURLPath)(url2);
-        if (path28 && path28 !== "/") {
+        const path29 = (0, utils_common_js_1.getURLPath)(url2);
+        if (path29 && path29 !== "/") {
           this.serviceOrContainerContext = storageClientContext.container;
         } else {
           this.serviceOrContainerContext = storageClientContext.service;
@@ -72924,7 +72924,7 @@ var require_ContainerClient = __commonJS({
        * @returns The SAS URI consisting of the URI to the resource represented by this client, followed by the generated SAS token.
        */
       generateSasUrl(options) {
-        return new Promise((resolve13) => {
+        return new Promise((resolve14) => {
           if (!(this.credential instanceof StorageSharedKeyCredential_js_1.StorageSharedKeyCredential)) {
             throw new RangeError("Can only generate the SAS when the client is initialized with a shared key credential");
           }
@@ -72932,7 +72932,7 @@ var require_ContainerClient = __commonJS({
             containerName: this._containerName,
             ...options
           }, this.credential).toString();
-          resolve13((0, utils_common_js_1.appendToURLQuery)(this.url, sas));
+          resolve14((0, utils_common_js_1.appendToURLQuery)(this.url, sas));
         });
       }
       /**
@@ -72967,12 +72967,12 @@ var require_ContainerClient = __commonJS({
        * @returns The SAS URI consisting of the URI to the resource represented by this client, followed by the generated SAS token.
        */
       generateUserDelegationSasUrl(options, userDelegationKey) {
-        return new Promise((resolve13) => {
+        return new Promise((resolve14) => {
           const sas = (0, BlobSASSignatureValues_js_1.generateBlobSASQueryParameters)({
             containerName: this._containerName,
             ...options
           }, userDelegationKey, this.accountName).toString();
-          resolve13((0, utils_common_js_1.appendToURLQuery)(this.url, sas));
+          resolve14((0, utils_common_js_1.appendToURLQuery)(this.url, sas));
         });
       }
       /**
@@ -74368,11 +74368,11 @@ var require_uploadUtils = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -74388,7 +74388,7 @@ var require_uploadUtils = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -74481,10 +74481,10 @@ var require_uploadUtils = __commonJS({
     exports2.UploadProgress = UploadProgress;
     function uploadCacheArchiveSDK(signedUploadURL, archivePath, options) {
       return __awaiter2(this, void 0, void 0, function* () {
-        var _a;
+        var _a2;
         const blobClient = new storage_blob_1.BlobClient(signedUploadURL);
         const blockBlobClient = blobClient.getBlockBlobClient();
-        const uploadProgress = new UploadProgress((_a = options === null || options === void 0 ? void 0 : options.archiveSizeBytes) !== null && _a !== void 0 ? _a : 0);
+        const uploadProgress = new UploadProgress((_a2 = options === null || options === void 0 ? void 0 : options.archiveSizeBytes) !== null && _a2 !== void 0 ? _a2 : 0);
         const uploadOptions = {
           blockSize: options === null || options === void 0 ? void 0 : options.uploadChunkSize,
           concurrency: options === null || options === void 0 ? void 0 : options.uploadConcurrency,
@@ -74555,11 +74555,11 @@ var require_requestUtils = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -74575,7 +74575,7 @@ var require_requestUtils = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -74615,7 +74615,7 @@ var require_requestUtils = __commonJS({
     }
     function sleep(milliseconds) {
       return __awaiter2(this, void 0, void 0, function* () {
-        return new Promise((resolve13) => setTimeout(resolve13, milliseconds));
+        return new Promise((resolve14) => setTimeout(resolve14, milliseconds));
       });
     }
     function retry2(name_1, method_1, getStatusCode_1) {
@@ -74745,9 +74745,9 @@ var require_dist4 = __commonJS({
           throw new TypeError("Expected `this` to be an instance of AbortSignal.");
         }
         const listeners = listenersMap.get(this);
-        const index = listeners.indexOf(listener);
-        if (index > -1) {
-          listeners.splice(index, 1);
+        const index2 = listeners.indexOf(listener);
+        if (index2 > -1) {
+          listeners.splice(index2, 1);
         }
       }
       /**
@@ -74876,11 +74876,11 @@ var require_downloadUtils = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -74896,7 +74896,7 @@ var require_downloadUtils = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -74910,16 +74910,16 @@ var require_downloadUtils = __commonJS({
     var http_client_1 = require_lib();
     var storage_blob_1 = require_commonjs15();
     var buffer = __importStar2(require("buffer"));
-    var fs30 = __importStar2(require("fs"));
+    var fs31 = __importStar2(require("fs"));
     var stream2 = __importStar2(require("stream"));
-    var util = __importStar2(require("util"));
+    var util3 = __importStar2(require("util"));
     var utils = __importStar2(require_cacheUtils());
     var constants_1 = require_constants7();
     var requestUtils_1 = require_requestUtils();
     var abort_controller_1 = require_dist4();
     function pipeResponseToStream(response, output) {
       return __awaiter2(this, void 0, void 0, function* () {
-        const pipeline = util.promisify(stream2.pipeline);
+        const pipeline = util3.promisify(stream2.pipeline);
         yield pipeline(response.message, output);
       });
     }
@@ -75021,7 +75021,7 @@ var require_downloadUtils = __commonJS({
     exports2.DownloadProgress = DownloadProgress;
     function downloadCacheHttpClient(archiveLocation, archivePath) {
       return __awaiter2(this, void 0, void 0, function* () {
-        const writeStream = fs30.createWriteStream(archivePath);
+        const writeStream = fs31.createWriteStream(archivePath);
         const httpClient = new http_client_1.HttpClient("actions/cache");
         const downloadResponse = yield (0, requestUtils_1.retryHttpClientResponse)("downloadCache", () => __awaiter2(this, void 0, void 0, function* () {
           return httpClient.get(archiveLocation);
@@ -75045,8 +75045,8 @@ var require_downloadUtils = __commonJS({
     }
     function downloadCacheHttpClientConcurrent(archiveLocation, archivePath, options) {
       return __awaiter2(this, void 0, void 0, function* () {
-        var _a;
-        const archiveDescriptor = yield fs30.promises.open(archivePath, "w");
+        var _a2;
+        const archiveDescriptor = yield fs31.promises.open(archivePath, "w");
         const httpClient = new http_client_1.HttpClient("actions/cache", void 0, {
           socketTimeout: options.timeoutInMs,
           keepAlive: true
@@ -75093,7 +75093,7 @@ var require_downloadUtils = __commonJS({
           while (nextDownload = downloads.pop()) {
             activeDownloads[nextDownload.offset] = nextDownload.promiseGetter();
             actives++;
-            if (actives >= ((_a = options.downloadConcurrency) !== null && _a !== void 0 ? _a : 10)) {
+            if (actives >= ((_a2 = options.downloadConcurrency) !== null && _a2 !== void 0 ? _a2 : 10)) {
               yield waitAndWrite();
             }
           }
@@ -75146,7 +75146,7 @@ var require_downloadUtils = __commonJS({
     }
     function downloadCacheStorageSDK(archiveLocation, archivePath, options) {
       return __awaiter2(this, void 0, void 0, function* () {
-        var _a;
+        var _a2;
         const client = new storage_blob_1.BlockBlobClient(archiveLocation, void 0, {
           retryOptions: {
             // Override the timeout used when downloading each 4 MB chunk
@@ -75155,14 +75155,14 @@ var require_downloadUtils = __commonJS({
           }
         });
         const properties = yield client.getProperties();
-        const contentLength = (_a = properties.contentLength) !== null && _a !== void 0 ? _a : -1;
+        const contentLength = (_a2 = properties.contentLength) !== null && _a2 !== void 0 ? _a2 : -1;
         if (contentLength < 0) {
           core30.debug("Unable to determine content length, downloading file with http-client...");
           yield downloadCacheHttpClient(archiveLocation, archivePath);
         } else {
           const maxSegmentSize = Math.min(134217728, buffer.constants.MAX_LENGTH);
           const downloadProgress = new DownloadProgress(contentLength);
-          const fd = fs30.openSync(archivePath, "w");
+          const fd = fs31.openSync(archivePath, "w");
           try {
             downloadProgress.startDisplayTimer();
             const controller = new abort_controller_1.AbortController();
@@ -75180,20 +75180,20 @@ var require_downloadUtils = __commonJS({
                 controller.abort();
                 throw new Error("Aborting cache download as the download time exceeded the timeout.");
               } else if (Buffer.isBuffer(result)) {
-                fs30.writeFileSync(fd, result);
+                fs31.writeFileSync(fd, result);
               }
             }
           } finally {
             downloadProgress.stopDisplayTimer();
-            fs30.closeSync(fd);
+            fs31.closeSync(fd);
           }
         }
       });
     }
     var promiseWithTimeout = (timeoutMs, promise) => __awaiter2(void 0, void 0, void 0, function* () {
       let timeoutHandle;
-      const timeoutPromise = new Promise((resolve13) => {
-        timeoutHandle = setTimeout(() => resolve13("timeout"), timeoutMs);
+      const timeoutPromise = new Promise((resolve14) => {
+        timeoutHandle = setTimeout(() => resolve14("timeout"), timeoutMs);
       });
       return Promise.race([promise, timeoutPromise]).then((result) => {
         clearTimeout(timeoutHandle);
@@ -75474,11 +75474,11 @@ var require_cacheHttpClient = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -75494,7 +75494,7 @@ var require_cacheHttpClient = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -75507,7 +75507,7 @@ var require_cacheHttpClient = __commonJS({
     var core30 = __importStar2(require_core());
     var http_client_1 = require_lib();
     var auth_1 = require_auth();
-    var fs30 = __importStar2(require("fs"));
+    var fs31 = __importStar2(require("fs"));
     var url_1 = require("url");
     var utils = __importStar2(require_cacheUtils());
     var uploadUtils_1 = require_uploadUtils();
@@ -75642,7 +75642,7 @@ Other caches with similar key:`);
       return __awaiter2(this, void 0, void 0, function* () {
         const fileSize = utils.getArchiveFileSizeInBytes(archivePath);
         const resourceUrl = getCacheApiUrl(`caches/${cacheId.toString()}`);
-        const fd = fs30.openSync(archivePath, "r");
+        const fd = fs31.openSync(archivePath, "r");
         const uploadOptions = (0, options_1.getUploadOptions)(options);
         const concurrency = utils.assertDefined("uploadConcurrency", uploadOptions.uploadConcurrency);
         const maxChunkSize = utils.assertDefined("uploadChunkSize", uploadOptions.uploadChunkSize);
@@ -75656,7 +75656,7 @@ Other caches with similar key:`);
               const start = offset;
               const end = offset + chunkSize - 1;
               offset += maxChunkSize;
-              yield uploadChunk(httpClient, resourceUrl, () => fs30.createReadStream(archivePath, {
+              yield uploadChunk(httpClient, resourceUrl, () => fs31.createReadStream(archivePath, {
                 fd,
                 start,
                 end,
@@ -75667,7 +75667,7 @@ Other caches with similar key:`);
             }
           })));
         } finally {
-          fs30.closeSync(fd);
+          fs31.closeSync(fd);
         }
         return;
       });
@@ -76784,9 +76784,9 @@ var require_json_format_contract = __commonJS({
     }
     exports2.jsonWriteOptions = jsonWriteOptions;
     function mergeJsonOptions(a, b) {
-      var _a, _b;
+      var _a2, _b;
       let c = Object.assign(Object.assign({}, a), b);
-      c.typeRegistry = [...(_a = a === null || a === void 0 ? void 0 : a.typeRegistry) !== null && _a !== void 0 ? _a : [], ...(_b = b === null || b === void 0 ? void 0 : b.typeRegistry) !== null && _b !== void 0 ? _b : []];
+      c.typeRegistry = [...(_a2 = a === null || a === void 0 ? void 0 : a.typeRegistry) !== null && _a2 !== void 0 ? _a2 : [], ...(_b = b === null || b === void 0 ? void 0 : b.typeRegistry) !== null && _b !== void 0 ? _b : []];
       return c;
     }
     exports2.mergeJsonOptions = mergeJsonOptions;
@@ -76872,8 +76872,8 @@ var require_reflection_info = __commonJS({
       RepeatType2[RepeatType2["UNPACKED"] = 2] = "UNPACKED";
     })(RepeatType = exports2.RepeatType || (exports2.RepeatType = {}));
     function normalizeFieldInfo(field) {
-      var _a, _b, _c, _d;
-      field.localName = (_a = field.localName) !== null && _a !== void 0 ? _a : lower_camel_case_1.lowerCamelCase(field.name);
+      var _a2, _b, _c, _d;
+      field.localName = (_a2 = field.localName) !== null && _a2 !== void 0 ? _a2 : lower_camel_case_1.lowerCamelCase(field.name);
       field.jsonName = (_b = field.jsonName) !== null && _b !== void 0 ? _b : lower_camel_case_1.lowerCamelCase(field.name);
       field.repeat = (_c = field.repeat) !== null && _c !== void 0 ? _c : RepeatType.NO;
       field.opt = (_d = field.opt) !== null && _d !== void 0 ? _d : field.repeat ? false : field.oneof ? false : field.kind == "message";
@@ -76881,14 +76881,14 @@ var require_reflection_info = __commonJS({
     }
     exports2.normalizeFieldInfo = normalizeFieldInfo;
     function readFieldOptions(messageType, fieldName, extensionName, extensionType) {
-      var _a;
-      const options = (_a = messageType.fields.find((m, i) => m.localName == fieldName || i == fieldName)) === null || _a === void 0 ? void 0 : _a.options;
+      var _a2;
+      const options = (_a2 = messageType.fields.find((m, i) => m.localName == fieldName || i == fieldName)) === null || _a2 === void 0 ? void 0 : _a2.options;
       return options && options[extensionName] ? extensionType.fromJson(options[extensionName]) : void 0;
     }
     exports2.readFieldOptions = readFieldOptions;
     function readFieldOption(messageType, fieldName, extensionName, extensionType) {
-      var _a;
-      const options = (_a = messageType.fields.find((m, i) => m.localName == fieldName || i == fieldName)) === null || _a === void 0 ? void 0 : _a.options;
+      var _a2;
+      const options = (_a2 = messageType.fields.find((m, i) => m.localName == fieldName || i == fieldName)) === null || _a2 === void 0 ? void 0 : _a2.options;
       if (!options) {
         return void 0;
       }
@@ -76984,8 +76984,8 @@ var require_reflection_type_check = __commonJS({
     var oneof_1 = require_oneof();
     var ReflectionTypeCheck = class {
       constructor(info8) {
-        var _a;
-        this.fields = (_a = info8.fields) !== null && _a !== void 0 ? _a : [];
+        var _a2;
+        this.fields = (_a2 = info8.fields) !== null && _a2 !== void 0 ? _a2 : [];
       }
       prepare() {
         if (this.data)
@@ -77235,10 +77235,10 @@ var require_reflection_json_reader = __commonJS({
         this.info = info8;
       }
       prepare() {
-        var _a;
+        var _a2;
         if (this.fMap === void 0) {
           this.fMap = {};
-          const fieldsInput = (_a = this.info.fields) !== null && _a !== void 0 ? _a : [];
+          const fieldsInput = (_a2 = this.info.fields) !== null && _a2 !== void 0 ? _a2 : [];
           for (const field of fieldsInput) {
             this.fMap[field.name] = field;
             this.fMap[field.jsonName] = field;
@@ -77529,8 +77529,8 @@ var require_reflection_json_writer = __commonJS({
     var assert_1 = require_assert();
     var ReflectionJsonWriter = class {
       constructor(info8) {
-        var _a;
-        this.fields = (_a = info8.fields) !== null && _a !== void 0 ? _a : [];
+        var _a2;
+        this.fields = (_a2 = info8.fields) !== null && _a2 !== void 0 ? _a2 : [];
       }
       /**
        * Converts the message to a JSON object, based on the field descriptors.
@@ -77787,9 +77787,9 @@ var require_reflection_binary_reader = __commonJS({
         this.info = info8;
       }
       prepare() {
-        var _a;
+        var _a2;
         if (!this.fieldNoToField) {
-          const fieldsInput = (_a = this.info.fields) !== null && _a !== void 0 ? _a : [];
+          const fieldsInput = (_a2 = this.info.fields) !== null && _a2 !== void 0 ? _a2 : [];
           this.fieldNoToField = new Map(fieldsInput.map((field) => [field.no, field]));
         }
       }
@@ -78457,9 +78457,9 @@ var require_message_type = __commonJS({
        * This is equivalent to `JSON.stringify(T.toJson(t))`
        */
       toJsonString(message, options) {
-        var _a;
+        var _a2;
         let value = this.toJson(message, options);
-        return JSON.stringify(value, null, (_a = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a !== void 0 ? _a : 0);
+        return JSON.stringify(value, null, (_a2 = options === null || options === void 0 ? void 0 : options.prettySpaces) !== null && _a2 !== void 0 ? _a2 : 0);
       }
       /**
        * Write the message to binary format.
@@ -78585,7 +78585,7 @@ var require_enum_object = __commonJS({
     }
     exports2.listEnumNames = listEnumNames;
     function listEnumNumbers(enumObject) {
-      return listEnumValues(enumObject).map((val) => val.number).filter((num, index, arr) => arr.indexOf(num) == index);
+      return listEnumValues(enumObject).map((val) => val.number).filter((num, index2, arr) => arr.indexOf(num) == index2);
     }
     exports2.listEnumNumbers = listEnumNumbers;
   }
@@ -78785,10 +78785,10 @@ var require_reflection_info2 = __commonJS({
     exports2.readServiceOption = exports2.readMethodOption = exports2.readMethodOptions = exports2.normalizeMethodInfo = void 0;
     var runtime_1 = require_commonjs16();
     function normalizeMethodInfo(method, service) {
-      var _a, _b, _c;
+      var _a2, _b, _c;
       let m = method;
       m.service = service;
-      m.localName = (_a = m.localName) !== null && _a !== void 0 ? _a : runtime_1.lowerCamelCase(m.name);
+      m.localName = (_a2 = m.localName) !== null && _a2 !== void 0 ? _a2 : runtime_1.lowerCamelCase(m.name);
       m.serverStreaming = !!m.serverStreaming;
       m.clientStreaming = !!m.clientStreaming;
       m.options = (_b = m.options) !== null && _b !== void 0 ? _b : {};
@@ -78797,14 +78797,14 @@ var require_reflection_info2 = __commonJS({
     }
     exports2.normalizeMethodInfo = normalizeMethodInfo;
     function readMethodOptions(service, methodName, extensionName, extensionType) {
-      var _a;
-      const options = (_a = service.methods.find((m, i) => m.localName === methodName || i === methodName)) === null || _a === void 0 ? void 0 : _a.options;
+      var _a2;
+      const options = (_a2 = service.methods.find((m, i) => m.localName === methodName || i === methodName)) === null || _a2 === void 0 ? void 0 : _a2.options;
       return options && options[extensionName] ? extensionType.fromJson(options[extensionName]) : void 0;
     }
     exports2.readMethodOptions = readMethodOptions;
     function readMethodOption(service, methodName, extensionName, extensionType) {
-      var _a;
-      const options = (_a = service.methods.find((m, i) => m.localName === methodName || i === methodName)) === null || _a === void 0 ? void 0 : _a.options;
+      var _a2;
+      const options = (_a2 = service.methods.find((m, i) => m.localName === methodName || i === methodName)) === null || _a2 === void 0 ? void 0 : _a2.options;
       if (!options) {
         return void 0;
       }
@@ -78893,28 +78893,28 @@ var require_rpc_options = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.mergeRpcOptions = void 0;
     var runtime_1 = require_commonjs16();
-    function mergeRpcOptions(defaults, options) {
+    function mergeRpcOptions(defaults2, options) {
       if (!options)
-        return defaults;
+        return defaults2;
       let o = {};
-      copy(defaults, o);
+      copy(defaults2, o);
       copy(options, o);
       for (let key of Object.keys(options)) {
         let val = options[key];
         switch (key) {
           case "jsonOptions":
-            o.jsonOptions = runtime_1.mergeJsonOptions(defaults.jsonOptions, o.jsonOptions);
+            o.jsonOptions = runtime_1.mergeJsonOptions(defaults2.jsonOptions, o.jsonOptions);
             break;
           case "binaryOptions":
-            o.binaryOptions = runtime_1.mergeBinaryOptions(defaults.binaryOptions, o.binaryOptions);
+            o.binaryOptions = runtime_1.mergeBinaryOptions(defaults2.binaryOptions, o.binaryOptions);
             break;
           case "meta":
             o.meta = {};
-            copy(defaults.meta, o.meta);
+            copy(defaults2.meta, o.meta);
             copy(options.meta, o.meta);
             break;
           case "interceptors":
-            o.interceptors = defaults.interceptors ? defaults.interceptors.concat(val) : val.concat();
+            o.interceptors = defaults2.interceptors ? defaults2.interceptors.concat(val) : val.concat();
             break;
         }
       }
@@ -78964,8 +78964,8 @@ var require_deferred = __commonJS({
        */
       constructor(preventUnhandledRejectionWarning = true) {
         this._state = DeferredState.PENDING;
-        this._promise = new Promise((resolve13, reject) => {
-          this._resolve = resolve13;
+        this._promise = new Promise((resolve14, reject) => {
+          this._resolve = resolve14;
           this._reject = reject;
         });
         if (preventUnhandledRejectionWarning) {
@@ -79180,11 +79180,11 @@ var require_unary_call = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -79200,7 +79200,7 @@ var require_unary_call = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -79249,11 +79249,11 @@ var require_server_streaming_call = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -79269,7 +79269,7 @@ var require_server_streaming_call = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -79319,11 +79319,11 @@ var require_client_streaming_call = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -79339,7 +79339,7 @@ var require_client_streaming_call = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -79388,11 +79388,11 @@ var require_duplex_streaming_call = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -79408,7 +79408,7 @@ var require_duplex_streaming_call = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -79456,11 +79456,11 @@ var require_test_transport = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -79476,7 +79476,7 @@ var require_test_transport = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -79527,8 +79527,8 @@ var require_test_transport = __commonJS({
       }
       // Creates a promise for response headers from the mock data.
       promiseHeaders() {
-        var _a;
-        const headers = (_a = this.data.headers) !== null && _a !== void 0 ? _a : _TestTransport.defaultHeaders;
+        var _a2;
+        const headers = (_a2 = this.data.headers) !== null && _a2 !== void 0 ? _a2 : _TestTransport.defaultHeaders;
         return headers instanceof rpc_error_1.RpcError ? Promise.reject(headers) : Promise.resolve(headers);
       }
       // Creates a promise for a single, valid, message from the mock data.
@@ -79603,14 +79603,14 @@ var require_test_transport = __commonJS({
       }
       // Creates a promise for response status from the mock data.
       promiseStatus() {
-        var _a;
-        const status = (_a = this.data.status) !== null && _a !== void 0 ? _a : _TestTransport.defaultStatus;
+        var _a2;
+        const status = (_a2 = this.data.status) !== null && _a2 !== void 0 ? _a2 : _TestTransport.defaultStatus;
         return status instanceof rpc_error_1.RpcError ? Promise.reject(status) : Promise.resolve(status);
       }
       // Creates a promise for response trailers from the mock data.
       promiseTrailers() {
-        var _a;
-        const trailers = (_a = this.data.trailers) !== null && _a !== void 0 ? _a : _TestTransport.defaultTrailers;
+        var _a2;
+        const trailers = (_a2 = this.data.trailers) !== null && _a2 !== void 0 ? _a2 : _TestTransport.defaultTrailers;
         return trailers instanceof rpc_error_1.RpcError ? Promise.reject(trailers) : Promise.resolve(trailers);
       }
       maybeSuppressUncaught(...promise) {
@@ -79625,8 +79625,8 @@ var require_test_transport = __commonJS({
         return rpc_options_1.mergeRpcOptions({}, options);
       }
       unary(method, input, options) {
-        var _a;
-        const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders().then(delay2(this.headerDelay, options.abort)), responsePromise = headersPromise.catch((_2) => {
+        var _a2;
+        const requestHeaders = (_a2 = options.meta) !== null && _a2 !== void 0 ? _a2 : {}, headersPromise = this.promiseHeaders().then(delay2(this.headerDelay, options.abort)), responsePromise = headersPromise.catch((_2) => {
         }).then(delay2(this.responseDelay, options.abort)).then((_2) => this.promiseSingleResponse(method)), statusPromise = responsePromise.catch((_2) => {
         }).then(delay2(this.afterResponseDelay, options.abort)).then((_2) => this.promiseStatus()), trailersPromise = responsePromise.catch((_2) => {
         }).then(delay2(this.afterResponseDelay, options.abort)).then((_2) => this.promiseTrailers());
@@ -79635,16 +79635,16 @@ var require_test_transport = __commonJS({
         return new unary_call_1.UnaryCall(method, requestHeaders, input, headersPromise, responsePromise, statusPromise, trailersPromise);
       }
       serverStreaming(method, input, options) {
-        var _a;
-        const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders().then(delay2(this.headerDelay, options.abort)), outputStream = new rpc_output_stream_1.RpcOutputStreamController(), responseStreamClosedPromise = headersPromise.then(delay2(this.responseDelay, options.abort)).catch(() => {
+        var _a2;
+        const requestHeaders = (_a2 = options.meta) !== null && _a2 !== void 0 ? _a2 : {}, headersPromise = this.promiseHeaders().then(delay2(this.headerDelay, options.abort)), outputStream = new rpc_output_stream_1.RpcOutputStreamController(), responseStreamClosedPromise = headersPromise.then(delay2(this.responseDelay, options.abort)).catch(() => {
         }).then(() => this.streamResponses(method, outputStream, options.abort)).then(delay2(this.afterResponseDelay, options.abort)), statusPromise = responseStreamClosedPromise.then(() => this.promiseStatus()), trailersPromise = responseStreamClosedPromise.then(() => this.promiseTrailers());
         this.maybeSuppressUncaught(statusPromise, trailersPromise);
         this.lastInput = { single: input };
         return new server_streaming_call_1.ServerStreamingCall(method, requestHeaders, input, headersPromise, outputStream, statusPromise, trailersPromise);
       }
       clientStreaming(method, options) {
-        var _a;
-        const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders().then(delay2(this.headerDelay, options.abort)), responsePromise = headersPromise.catch((_2) => {
+        var _a2;
+        const requestHeaders = (_a2 = options.meta) !== null && _a2 !== void 0 ? _a2 : {}, headersPromise = this.promiseHeaders().then(delay2(this.headerDelay, options.abort)), responsePromise = headersPromise.catch((_2) => {
         }).then(delay2(this.responseDelay, options.abort)).then((_2) => this.promiseSingleResponse(method)), statusPromise = responsePromise.catch((_2) => {
         }).then(delay2(this.afterResponseDelay, options.abort)).then((_2) => this.promiseStatus()), trailersPromise = responsePromise.catch((_2) => {
         }).then(delay2(this.afterResponseDelay, options.abort)).then((_2) => this.promiseTrailers());
@@ -79653,8 +79653,8 @@ var require_test_transport = __commonJS({
         return new client_streaming_call_1.ClientStreamingCall(method, requestHeaders, this.lastInput, headersPromise, responsePromise, statusPromise, trailersPromise);
       }
       duplex(method, options) {
-        var _a;
-        const requestHeaders = (_a = options.meta) !== null && _a !== void 0 ? _a : {}, headersPromise = this.promiseHeaders().then(delay2(this.headerDelay, options.abort)), outputStream = new rpc_output_stream_1.RpcOutputStreamController(), responseStreamClosedPromise = headersPromise.then(delay2(this.responseDelay, options.abort)).catch(() => {
+        var _a2;
+        const requestHeaders = (_a2 = options.meta) !== null && _a2 !== void 0 ? _a2 : {}, headersPromise = this.promiseHeaders().then(delay2(this.headerDelay, options.abort)), outputStream = new rpc_output_stream_1.RpcOutputStreamController(), responseStreamClosedPromise = headersPromise.then(delay2(this.responseDelay, options.abort)).catch(() => {
         }).then(() => this.streamResponses(method, outputStream, options.abort)).then(delay2(this.afterResponseDelay, options.abort)), statusPromise = responseStreamClosedPromise.then(() => this.promiseStatus()), trailersPromise = responseStreamClosedPromise.then(() => this.promiseTrailers());
         this.maybeSuppressUncaught(statusPromise, trailersPromise);
         this.lastInput = new TestInputStream(this.data, options.abort);
@@ -79673,11 +79673,11 @@ var require_test_transport = __commonJS({
       responseTrailer: "test"
     };
     function delay2(ms, abort) {
-      return (v) => new Promise((resolve13, reject) => {
+      return (v) => new Promise((resolve14, reject) => {
         if (abort === null || abort === void 0 ? void 0 : abort.aborted) {
           reject(new rpc_error_1.RpcError("user cancel", "CANCELLED"));
         } else {
-          const id = setTimeout(() => resolve13(v), ms);
+          const id = setTimeout(() => resolve14(v), ms);
           if (abort) {
             abort.addEventListener("abort", (ev) => {
               clearTimeout(id);
@@ -79730,10 +79730,10 @@ var require_rpc_interceptor = __commonJS({
     exports2.stackDuplexStreamingInterceptors = exports2.stackClientStreamingInterceptors = exports2.stackServerStreamingInterceptors = exports2.stackUnaryInterceptors = exports2.stackIntercept = void 0;
     var runtime_1 = require_commonjs16();
     function stackIntercept(kind, transport, method, options, input) {
-      var _a, _b, _c, _d;
+      var _a2, _b, _c, _d;
       if (kind == "unary") {
         let tail = (mtd, inp, opt) => transport.unary(mtd, inp, opt);
-        for (const curr of ((_a = options.interceptors) !== null && _a !== void 0 ? _a : []).filter((i) => i.interceptUnary).reverse()) {
+        for (const curr of ((_a2 = options.interceptors) !== null && _a2 !== void 0 ? _a2 : []).filter((i) => i.interceptUnary).reverse()) {
           const next = tail;
           tail = (mtd, inp, opt) => curr.interceptUnary(next, mtd, inp, opt);
         }
@@ -80675,11 +80675,11 @@ var require_cacheTwirpClient = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -80695,7 +80695,7 @@ var require_cacheTwirpClient = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -80835,7 +80835,7 @@ var require_cacheTwirpClient = __commonJS({
       }
       sleep(milliseconds) {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13) => setTimeout(resolve13, milliseconds));
+          return new Promise((resolve14) => setTimeout(resolve14, milliseconds));
         });
       }
       getExponentialRetryTimeMilliseconds(attempt) {
@@ -80900,11 +80900,11 @@ var require_tar = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -80920,7 +80920,7 @@ var require_tar = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -80932,7 +80932,7 @@ var require_tar = __commonJS({
     var exec_1 = require_exec();
     var io9 = __importStar2(require_io());
     var fs_1 = require("fs");
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var utils = __importStar2(require_cacheUtils());
     var constants_1 = require_constants7();
     var IS_WINDOWS = process.platform === "win32";
@@ -80978,13 +80978,13 @@ var require_tar = __commonJS({
         const BSD_TAR_ZSTD = tarPath.type === constants_1.ArchiveToolType.BSD && compressionMethod !== constants_1.CompressionMethod.Gzip && IS_WINDOWS;
         switch (type) {
           case "create":
-            args.push("--posix", "-cf", BSD_TAR_ZSTD ? tarFile : cacheFileName.replace(new RegExp(`\\${path28.sep}`, "g"), "/"), "--exclude", BSD_TAR_ZSTD ? tarFile : cacheFileName.replace(new RegExp(`\\${path28.sep}`, "g"), "/"), "-P", "-C", workingDirectory.replace(new RegExp(`\\${path28.sep}`, "g"), "/"), "--files-from", constants_1.ManifestFilename);
+            args.push("--posix", "-cf", BSD_TAR_ZSTD ? tarFile : cacheFileName.replace(new RegExp(`\\${path29.sep}`, "g"), "/"), "--exclude", BSD_TAR_ZSTD ? tarFile : cacheFileName.replace(new RegExp(`\\${path29.sep}`, "g"), "/"), "-P", "-C", workingDirectory.replace(new RegExp(`\\${path29.sep}`, "g"), "/"), "--files-from", constants_1.ManifestFilename);
             break;
           case "extract":
-            args.push("-xf", BSD_TAR_ZSTD ? tarFile : archivePath.replace(new RegExp(`\\${path28.sep}`, "g"), "/"), "-P", "-C", workingDirectory.replace(new RegExp(`\\${path28.sep}`, "g"), "/"));
+            args.push("-xf", BSD_TAR_ZSTD ? tarFile : archivePath.replace(new RegExp(`\\${path29.sep}`, "g"), "/"), "-P", "-C", workingDirectory.replace(new RegExp(`\\${path29.sep}`, "g"), "/"));
             break;
           case "list":
-            args.push("-tf", BSD_TAR_ZSTD ? tarFile : archivePath.replace(new RegExp(`\\${path28.sep}`, "g"), "/"), "-P");
+            args.push("-tf", BSD_TAR_ZSTD ? tarFile : archivePath.replace(new RegExp(`\\${path29.sep}`, "g"), "/"), "-P");
             break;
         }
         if (tarPath.type === constants_1.ArchiveToolType.GNU) {
@@ -81019,8 +81019,8 @@ var require_tar = __commonJS({
       });
     }
     function getWorkingDirectory() {
-      var _a;
-      return (_a = process.env["GITHUB_WORKSPACE"]) !== null && _a !== void 0 ? _a : process.cwd();
+      var _a2;
+      return (_a2 = process.env["GITHUB_WORKSPACE"]) !== null && _a2 !== void 0 ? _a2 : process.cwd();
     }
     function getDecompressionProgram(tarPath, compressionMethod, archivePath) {
       return __awaiter2(this, void 0, void 0, function* () {
@@ -81030,7 +81030,7 @@ var require_tar = __commonJS({
             return BSD_TAR_ZSTD ? [
               "zstd -d --long=30 --force -o",
               constants_1.TarFilename,
-              archivePath.replace(new RegExp(`\\${path28.sep}`, "g"), "/")
+              archivePath.replace(new RegExp(`\\${path29.sep}`, "g"), "/")
             ] : [
               "--use-compress-program",
               IS_WINDOWS ? '"zstd -d --long=30"' : "unzstd --long=30"
@@ -81039,7 +81039,7 @@ var require_tar = __commonJS({
             return BSD_TAR_ZSTD ? [
               "zstd -d --force -o",
               constants_1.TarFilename,
-              archivePath.replace(new RegExp(`\\${path28.sep}`, "g"), "/")
+              archivePath.replace(new RegExp(`\\${path29.sep}`, "g"), "/")
             ] : ["--use-compress-program", IS_WINDOWS ? '"zstd -d"' : "unzstd"];
           default:
             return ["-z"];
@@ -81054,7 +81054,7 @@ var require_tar = __commonJS({
           case constants_1.CompressionMethod.Zstd:
             return BSD_TAR_ZSTD ? [
               "zstd -T0 --long=30 --force -o",
-              cacheFileName.replace(new RegExp(`\\${path28.sep}`, "g"), "/"),
+              cacheFileName.replace(new RegExp(`\\${path29.sep}`, "g"), "/"),
               constants_1.TarFilename
             ] : [
               "--use-compress-program",
@@ -81063,7 +81063,7 @@ var require_tar = __commonJS({
           case constants_1.CompressionMethod.ZstdWithoutLong:
             return BSD_TAR_ZSTD ? [
               "zstd -T0 --force -o",
-              cacheFileName.replace(new RegExp(`\\${path28.sep}`, "g"), "/"),
+              cacheFileName.replace(new RegExp(`\\${path29.sep}`, "g"), "/"),
               constants_1.TarFilename
             ] : ["--use-compress-program", IS_WINDOWS ? '"zstd -T0"' : "zstdmt"];
           default:
@@ -81101,7 +81101,7 @@ var require_tar = __commonJS({
     }
     function createTar(archiveFolder, sourceDirectories, compressionMethod) {
       return __awaiter2(this, void 0, void 0, function* () {
-        (0, fs_1.writeFileSync)(path28.join(archiveFolder, constants_1.ManifestFilename), sourceDirectories.join("\n"));
+        (0, fs_1.writeFileSync)(path29.join(archiveFolder, constants_1.ManifestFilename), sourceDirectories.join("\n"));
         const commands = yield getCommands(compressionMethod, "create");
         yield execCommands(commands, archiveFolder);
       });
@@ -81152,11 +81152,11 @@ var require_cache4 = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -81172,7 +81172,7 @@ var require_cache4 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -81183,7 +81183,7 @@ var require_cache4 = __commonJS({
     exports2.restoreCache = restoreCache5;
     exports2.saveCache = saveCache5;
     var core30 = __importStar2(require_core());
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var utils = __importStar2(require_cacheUtils());
     var cacheHttpClient = __importStar2(require_cacheHttpClient());
     var cacheTwirpClient = __importStar2(require_cacheTwirpClient());
@@ -81278,7 +81278,7 @@ var require_cache4 = __commonJS({
             core30.info("Lookup only - skipping download");
             return cacheEntry.cacheKey;
           }
-          archivePath = path28.join(yield utils.createTempDirectory(), utils.getCacheFileName(compressionMethod));
+          archivePath = path29.join(yield utils.createTempDirectory(), utils.getCacheFileName(compressionMethod));
           core30.debug(`Archive Path: ${archivePath}`);
           yield cacheHttpClient.downloadCache(cacheEntry.archiveLocation, archivePath, options);
           if (core30.isDebug()) {
@@ -81347,7 +81347,7 @@ var require_cache4 = __commonJS({
             core30.info("Lookup only - skipping download");
             return response.matchedKey;
           }
-          archivePath = path28.join(yield utils.createTempDirectory(), utils.getCacheFileName(compressionMethod));
+          archivePath = path29.join(yield utils.createTempDirectory(), utils.getCacheFileName(compressionMethod));
           core30.debug(`Archive path: ${archivePath}`);
           core30.debug(`Starting download of archive to: ${archivePath}`);
           yield cacheHttpClient.downloadCache(response.signedDownloadUrl, archivePath, options);
@@ -81399,7 +81399,7 @@ var require_cache4 = __commonJS({
     }
     function saveCacheV1(paths_1, key_1, options_1) {
       return __awaiter2(this, arguments, void 0, function* (paths, key, options, enableCrossOsArchive = false) {
-        var _a, _b, _c, _d, _e;
+        var _a2, _b, _c, _d, _e;
         const compressionMethod = yield utils.getCompressionMethod();
         let cacheId = -1;
         const cachePaths = yield utils.resolvePaths(paths);
@@ -81409,7 +81409,7 @@ var require_cache4 = __commonJS({
           throw new Error(`Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`);
         }
         const archiveFolder = yield utils.createTempDirectory();
-        const archivePath = path28.join(archiveFolder, utils.getCacheFileName(compressionMethod));
+        const archivePath = path29.join(archiveFolder, utils.getCacheFileName(compressionMethod));
         core30.debug(`Archive Path: ${archivePath}`);
         try {
           yield (0, tar_1.createTar)(archiveFolder, cachePaths, compressionMethod);
@@ -81428,7 +81428,7 @@ var require_cache4 = __commonJS({
             enableCrossOsArchive,
             cacheSize: archiveFileSize
           });
-          if ((_a = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.result) === null || _a === void 0 ? void 0 : _a.cacheId) {
+          if ((_a2 = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.result) === null || _a2 === void 0 ? void 0 : _a2.cacheId) {
             cacheId = (_b = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.result) === null || _b === void 0 ? void 0 : _b.cacheId;
           } else if ((reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.statusCode) === 400) {
             throw new Error((_d = (_c = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.error) === null || _c === void 0 ? void 0 : _c.message) !== null && _d !== void 0 ? _d : `Cache size of ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B) is over the data cap limit, not saving cache.`);
@@ -81473,7 +81473,7 @@ var require_cache4 = __commonJS({
           throw new Error(`Path Validation Error: Path(s) specified in the action for caching do(es) not exist, hence no cache is being saved.`);
         }
         const archiveFolder = yield utils.createTempDirectory();
-        const archivePath = path28.join(archiveFolder, utils.getCacheFileName(compressionMethod));
+        const archivePath = path29.join(archiveFolder, utils.getCacheFileName(compressionMethod));
         core30.debug(`Archive Path: ${archivePath}`);
         try {
           yield (0, tar_1.createTar)(archiveFolder, cachePaths, compressionMethod);
@@ -81590,11 +81590,11 @@ var require_manifest = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -81610,7 +81610,7 @@ var require_manifest = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -81623,12 +81623,12 @@ var require_manifest = __commonJS({
     var core_1 = require_core();
     var os7 = require("os");
     var cp = require("child_process");
-    var fs30 = require("fs");
+    var fs31 = require("fs");
     function _findMatch(versionSpec, stable, candidates, archFilter) {
       return __awaiter2(this, void 0, void 0, function* () {
         const platFilter = os7.platform();
         let result;
-        let match;
+        let match2;
         let file;
         for (const candidate of candidates) {
           const version = candidate.version;
@@ -81649,13 +81649,13 @@ var require_manifest = __commonJS({
             });
             if (file) {
               (0, core_1.debug)(`matched ${candidate.version}`);
-              match = candidate;
+              match2 = candidate;
               break;
             }
           }
         }
-        if (match && file) {
-          result = Object.assign({}, match);
+        if (match2 && file) {
+          result = Object.assign({}, match2);
           result.files = [file];
         }
         return result;
@@ -81685,10 +81685,10 @@ var require_manifest = __commonJS({
       const lsbReleaseFile = "/etc/lsb-release";
       const osReleaseFile = "/etc/os-release";
       let contents = "";
-      if (fs30.existsSync(lsbReleaseFile)) {
-        contents = fs30.readFileSync(lsbReleaseFile).toString();
-      } else if (fs30.existsSync(osReleaseFile)) {
-        contents = fs30.readFileSync(osReleaseFile).toString();
+      if (fs31.existsSync(lsbReleaseFile)) {
+        contents = fs31.readFileSync(lsbReleaseFile).toString();
+      } else if (fs31.existsSync(osReleaseFile)) {
+        contents = fs31.readFileSync(osReleaseFile).toString();
       }
       return contents;
     }
@@ -81738,11 +81738,11 @@ var require_retry_helper = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -81758,7 +81758,7 @@ var require_retry_helper = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -81803,7 +81803,7 @@ var require_retry_helper = __commonJS({
       }
       sleep(seconds) {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13) => setTimeout(resolve13, seconds * 1e3));
+          return new Promise((resolve14) => setTimeout(resolve14, seconds * 1e3));
         });
       }
     };
@@ -81854,11 +81854,11 @@ var require_tool_cache = __commonJS({
     })();
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -81874,7 +81874,7 @@ var require_tool_cache = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -81897,14 +81897,14 @@ var require_tool_cache = __commonJS({
     var core30 = __importStar2(require_core());
     var io9 = __importStar2(require_io());
     var crypto3 = __importStar2(require("crypto"));
-    var fs30 = __importStar2(require("fs"));
+    var fs31 = __importStar2(require("fs"));
     var mm = __importStar2(require_manifest());
     var os7 = __importStar2(require("os"));
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var httpm = __importStar2(require_lib());
     var semver11 = __importStar2(require_semver2());
     var stream2 = __importStar2(require("stream"));
-    var util = __importStar2(require("util"));
+    var util3 = __importStar2(require("util"));
     var assert_1 = require("assert");
     var exec_1 = require_exec();
     var retry_helper_1 = require_retry_helper();
@@ -81921,8 +81921,8 @@ var require_tool_cache = __commonJS({
     var userAgent2 = "actions/tool-cache";
     function downloadTool3(url2, dest, auth2, headers) {
       return __awaiter2(this, void 0, void 0, function* () {
-        dest = dest || path28.join(_getTempDirectory(), crypto3.randomUUID());
-        yield io9.mkdirP(path28.dirname(dest));
+        dest = dest || path29.join(_getTempDirectory(), crypto3.randomUUID());
+        yield io9.mkdirP(path29.dirname(dest));
         core30.debug(`Downloading ${url2}`);
         core30.debug(`Destination ${dest}`);
         const maxAttempts = 3;
@@ -81943,7 +81943,7 @@ var require_tool_cache = __commonJS({
     }
     function downloadToolAttempt(url2, dest, auth2, headers) {
       return __awaiter2(this, void 0, void 0, function* () {
-        if (fs30.existsSync(dest)) {
+        if (fs31.existsSync(dest)) {
           throw new Error(`Destination file path ${dest} already exists`);
         }
         const http = new httpm.HttpClient(userAgent2, [], {
@@ -81962,12 +81962,12 @@ var require_tool_cache = __commonJS({
           core30.debug(`Failed to download from "${url2}". Code(${response.message.statusCode}) Message(${response.message.statusMessage})`);
           throw err;
         }
-        const pipeline = util.promisify(stream2.pipeline);
+        const pipeline = util3.promisify(stream2.pipeline);
         const responseMessageFactory = _getGlobal("TEST_DOWNLOAD_TOOL_RESPONSE_MESSAGE_FACTORY", () => response.message);
         const readStream = responseMessageFactory();
         let succeeded = false;
         try {
-          yield pipeline(readStream, fs30.createWriteStream(dest));
+          yield pipeline(readStream, fs31.createWriteStream(dest));
           core30.debug("download complete");
           succeeded = true;
           return dest;
@@ -82012,7 +82012,7 @@ var require_tool_cache = __commonJS({
             process.chdir(originalCwd);
           }
         } else {
-          const escapedScript = path28.join(__dirname, "..", "scripts", "Invoke-7zdec.ps1").replace(/'/g, "''").replace(/"|\n|\r/g, "");
+          const escapedScript = path29.join(__dirname, "..", "scripts", "Invoke-7zdec.ps1").replace(/'/g, "''").replace(/"|\n|\r/g, "");
           const escapedFile = file.replace(/'/g, "''").replace(/"|\n|\r/g, "");
           const escapedTarget = dest.replace(/'/g, "''").replace(/"|\n|\r/g, "");
           const command = `& '${escapedScript}' -Source '${escapedFile}' -Target '${escapedTarget}'`;
@@ -82179,12 +82179,12 @@ var require_tool_cache = __commonJS({
         arch2 = arch2 || os7.arch();
         core30.debug(`Caching tool ${tool} ${version} ${arch2}`);
         core30.debug(`source dir: ${sourceDir}`);
-        if (!fs30.statSync(sourceDir).isDirectory()) {
+        if (!fs31.statSync(sourceDir).isDirectory()) {
           throw new Error("sourceDir is not a directory");
         }
         const destPath = yield _createToolPath(tool, version, arch2);
-        for (const itemName of fs30.readdirSync(sourceDir)) {
-          const s = path28.join(sourceDir, itemName);
+        for (const itemName of fs31.readdirSync(sourceDir)) {
+          const s = path29.join(sourceDir, itemName);
           yield io9.cp(s, destPath, { recursive: true });
         }
         _completeToolPath(tool, version, arch2);
@@ -82197,11 +82197,11 @@ var require_tool_cache = __commonJS({
         arch2 = arch2 || os7.arch();
         core30.debug(`Caching tool ${tool} ${version} ${arch2}`);
         core30.debug(`source file: ${sourceFile}`);
-        if (!fs30.statSync(sourceFile).isFile()) {
+        if (!fs31.statSync(sourceFile).isFile()) {
           throw new Error("sourceFile is not a file");
         }
         const destFolder = yield _createToolPath(tool, version, arch2);
-        const destPath = path28.join(destFolder, targetFile);
+        const destPath = path29.join(destFolder, targetFile);
         core30.debug(`destination file ${destPath}`);
         yield io9.cp(sourceFile, destPath);
         _completeToolPath(tool, version, arch2);
@@ -82218,15 +82218,15 @@ var require_tool_cache = __commonJS({
       arch2 = arch2 || os7.arch();
       if (!isExplicitVersion(versionSpec)) {
         const localVersions = findAllVersions2(toolName, arch2);
-        const match = evaluateVersions(localVersions, versionSpec);
-        versionSpec = match;
+        const match2 = evaluateVersions(localVersions, versionSpec);
+        versionSpec = match2;
       }
       let toolPath = "";
       if (versionSpec) {
         versionSpec = semver11.clean(versionSpec) || "";
-        const cachePath = path28.join(_getCacheDirectory(), toolName, versionSpec, arch2);
+        const cachePath = path29.join(_getCacheDirectory(), toolName, versionSpec, arch2);
         core30.debug(`checking cache: ${cachePath}`);
-        if (fs30.existsSync(cachePath) && fs30.existsSync(`${cachePath}.complete`)) {
+        if (fs31.existsSync(cachePath) && fs31.existsSync(`${cachePath}.complete`)) {
           core30.debug(`Found tool in cache ${toolName} ${versionSpec} ${arch2}`);
           toolPath = cachePath;
         } else {
@@ -82238,13 +82238,13 @@ var require_tool_cache = __commonJS({
     function findAllVersions2(toolName, arch2) {
       const versions = [];
       arch2 = arch2 || os7.arch();
-      const toolPath = path28.join(_getCacheDirectory(), toolName);
-      if (fs30.existsSync(toolPath)) {
-        const children = fs30.readdirSync(toolPath);
+      const toolPath = path29.join(_getCacheDirectory(), toolName);
+      if (fs31.existsSync(toolPath)) {
+        const children = fs31.readdirSync(toolPath);
         for (const child of children) {
           if (isExplicitVersion(child)) {
-            const fullPath = path28.join(toolPath, child, arch2 || "");
-            if (fs30.existsSync(fullPath) && fs30.existsSync(`${fullPath}.complete`)) {
+            const fullPath = path29.join(toolPath, child, arch2 || "");
+            if (fs31.existsSync(fullPath) && fs31.existsSync(`${fullPath}.complete`)) {
               versions.push(child);
             }
           }
@@ -82279,7 +82279,7 @@ var require_tool_cache = __commonJS({
           versionsRaw = versionsRaw.replace(/^\uFEFF/, "");
           try {
             releases = JSON.parse(versionsRaw);
-          } catch (_a) {
+          } catch (_a2) {
             core30.debug("Invalid json");
           }
         }
@@ -82288,14 +82288,14 @@ var require_tool_cache = __commonJS({
     }
     function findFromManifest(versionSpec_1, stable_1, manifest_1) {
       return __awaiter2(this, arguments, void 0, function* (versionSpec, stable, manifest, archFilter = os7.arch()) {
-        const match = yield mm._findMatch(versionSpec, stable, manifest, archFilter);
-        return match;
+        const match2 = yield mm._findMatch(versionSpec, stable, manifest, archFilter);
+        return match2;
       });
     }
     function _createExtractFolder(dest) {
       return __awaiter2(this, void 0, void 0, function* () {
         if (!dest) {
-          dest = path28.join(_getTempDirectory(), crypto3.randomUUID());
+          dest = path29.join(_getTempDirectory(), crypto3.randomUUID());
         }
         yield io9.mkdirP(dest);
         return dest;
@@ -82303,7 +82303,7 @@ var require_tool_cache = __commonJS({
     }
     function _createToolPath(tool, version, arch2) {
       return __awaiter2(this, void 0, void 0, function* () {
-        const folderPath = path28.join(_getCacheDirectory(), tool, semver11.clean(version) || version, arch2 || "");
+        const folderPath = path29.join(_getCacheDirectory(), tool, semver11.clean(version) || version, arch2 || "");
         core30.debug(`destination ${folderPath}`);
         const markerPath = `${folderPath}.complete`;
         yield io9.rmRF(folderPath);
@@ -82313,9 +82313,9 @@ var require_tool_cache = __commonJS({
       });
     }
     function _completeToolPath(tool, version, arch2) {
-      const folderPath = path28.join(_getCacheDirectory(), tool, semver11.clean(version) || version, arch2 || "");
+      const folderPath = path29.join(_getCacheDirectory(), tool, semver11.clean(version) || version, arch2 || "");
       const markerPath = `${folderPath}.complete`;
-      fs30.writeFileSync(markerPath, "");
+      fs31.writeFileSync(markerPath, "");
       core30.debug("finished caching tool");
     }
     function isExplicitVersion(versionSpec) {
@@ -88006,13 +88006,13 @@ These characters are not allowed in the artifact name due to limitations with ce
       (0, core_1.info)(`Artifact name is valid!`);
     }
     exports2.validateArtifactName = validateArtifactName;
-    function validateFilePath(path28) {
-      if (!path28) {
+    function validateFilePath(path29) {
+      if (!path29) {
         throw new Error(`Provided file path input during validation is empty`);
       }
       for (const [invalidCharacterKey, errorMessageForCharacter] of invalidArtifactFilePathCharacters) {
-        if (path28.includes(invalidCharacterKey)) {
-          throw new Error(`The path for one of the files in artifact is not valid: ${path28}. Contains the following character: ${errorMessageForCharacter}
+        if (path29.includes(invalidCharacterKey)) {
+          throw new Error(`The path for one of the files in artifact is not valid: ${path29}. Contains the following character: ${errorMessageForCharacter}
           
 Invalid characters include: ${Array.from(invalidArtifactFilePathCharacters.values()).toString()}
           
@@ -88354,11 +88354,11 @@ var require_artifact_twirp_client2 = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -88374,7 +88374,7 @@ var require_artifact_twirp_client2 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -88501,7 +88501,7 @@ var require_artifact_twirp_client2 = __commonJS({
       }
       sleep(milliseconds) {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13) => setTimeout(resolve13, milliseconds));
+          return new Promise((resolve14) => setTimeout(resolve14, milliseconds));
         });
       }
       getExponentialRetryTimeMilliseconds(attempt) {
@@ -88557,15 +88557,15 @@ var require_upload_zip_specification = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getUploadZipSpecification = exports2.validateRootDirectory = void 0;
-    var fs30 = __importStar2(require("fs"));
+    var fs31 = __importStar2(require("fs"));
     var core_1 = require_core();
     var path_1 = require("path");
     var path_and_artifact_name_validation_1 = require_path_and_artifact_name_validation();
     function validateRootDirectory(rootDirectory) {
-      if (!fs30.existsSync(rootDirectory)) {
+      if (!fs31.existsSync(rootDirectory)) {
         throw new Error(`The provided rootDirectory ${rootDirectory} does not exist`);
       }
-      if (!fs30.statSync(rootDirectory).isDirectory()) {
+      if (!fs31.statSync(rootDirectory).isDirectory()) {
         throw new Error(`The provided rootDirectory ${rootDirectory} is not a valid directory`);
       }
       (0, core_1.info)(`Root directory input is valid!`);
@@ -88576,7 +88576,7 @@ var require_upload_zip_specification = __commonJS({
       rootDirectory = (0, path_1.normalize)(rootDirectory);
       rootDirectory = (0, path_1.resolve)(rootDirectory);
       for (let file of filesToZip) {
-        const stats = fs30.lstatSync(file, { throwIfNoEntry: false });
+        const stats = fs31.lstatSync(file, { throwIfNoEntry: false });
         if (!stats) {
           throw new Error(`File ${file} does not exist`);
         }
@@ -88642,11 +88642,11 @@ var require_blob_upload = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -88662,7 +88662,7 @@ var require_blob_upload = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -88681,7 +88681,7 @@ var require_blob_upload = __commonJS({
         let lastProgressTime = Date.now();
         const abortController = new AbortController();
         const chunkTimer = (interval) => __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13, reject) => {
+          return new Promise((resolve14, reject) => {
             const timer = setInterval(() => {
               if (Date.now() - lastProgressTime > interval) {
                 reject(new Error("Upload progress stalled."));
@@ -88689,7 +88689,7 @@ var require_blob_upload = __commonJS({
             }, interval);
             abortController.signal.addEventListener("abort", () => {
               clearInterval(timer);
-              resolve13();
+              resolve14();
             });
           });
         });
@@ -88744,38 +88744,38 @@ var require_blob_upload = __commonJS({
   }
 });
 
-// node_modules/readdir-glob/node_modules/minimatch/lib/path.js
+// node_modules/@actions/artifact/node_modules/minimatch/lib/path.js
 var require_path = __commonJS({
-  "node_modules/readdir-glob/node_modules/minimatch/lib/path.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/minimatch/lib/path.js"(exports2, module2) {
     var isWindows = typeof process === "object" && process && process.platform === "win32";
     module2.exports = isWindows ? { sep: "\\" } : { sep: "/" };
   }
 });
 
-// node_modules/readdir-glob/node_modules/brace-expansion/index.js
+// node_modules/@actions/artifact/node_modules/brace-expansion/index.js
 var require_brace_expansion2 = __commonJS({
-  "node_modules/readdir-glob/node_modules/brace-expansion/index.js"(exports2, module2) {
-    var balanced = require_balanced_match();
+  "node_modules/@actions/artifact/node_modules/brace-expansion/index.js"(exports2, module2) {
+    var balanced2 = require_balanced_match();
     module2.exports = expandTop;
-    var escSlash = "\0SLASH" + Math.random() + "\0";
-    var escOpen = "\0OPEN" + Math.random() + "\0";
-    var escClose = "\0CLOSE" + Math.random() + "\0";
-    var escComma = "\0COMMA" + Math.random() + "\0";
-    var escPeriod = "\0PERIOD" + Math.random() + "\0";
-    function numeric(str) {
+    var escSlash2 = "\0SLASH" + Math.random() + "\0";
+    var escOpen2 = "\0OPEN" + Math.random() + "\0";
+    var escClose2 = "\0CLOSE" + Math.random() + "\0";
+    var escComma2 = "\0COMMA" + Math.random() + "\0";
+    var escPeriod2 = "\0PERIOD" + Math.random() + "\0";
+    function numeric2(str) {
       return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
     }
-    function escapeBraces(str) {
-      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+    function escapeBraces2(str) {
+      return str.split("\\\\").join(escSlash2).split("\\{").join(escOpen2).split("\\}").join(escClose2).split("\\,").join(escComma2).split("\\.").join(escPeriod2);
     }
-    function unescapeBraces(str) {
-      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+    function unescapeBraces2(str) {
+      return str.split(escSlash2).join("\\").split(escOpen2).join("{").split(escClose2).join("}").split(escComma2).join(",").split(escPeriod2).join(".");
     }
-    function parseCommaParts(str) {
+    function parseCommaParts2(str) {
       if (!str)
         return [""];
       var parts = [];
-      var m = balanced("{", "}", str);
+      var m = balanced2("{", "}", str);
       if (!m)
         return str.split(",");
       var pre = m.pre;
@@ -88783,7 +88783,7 @@ var require_brace_expansion2 = __commonJS({
       var post = m.post;
       var p = pre.split(",");
       p[p.length - 1] += "{" + body + "}";
-      var postParts = parseCommaParts(post);
+      var postParts = parseCommaParts2(post);
       if (post.length) {
         p[p.length - 1] += postParts.shift();
         p.push.apply(p, postParts);
@@ -88799,26 +88799,26 @@ var require_brace_expansion2 = __commonJS({
       if (str.substr(0, 2) === "{}") {
         str = "\\{\\}" + str.substr(2);
       }
-      return expand2(escapeBraces(str), max, true).map(unescapeBraces);
+      return expand3(escapeBraces2(str), max, true).map(unescapeBraces2);
     }
-    function embrace(str) {
+    function embrace2(str) {
       return "{" + str + "}";
     }
-    function isPadded(el) {
+    function isPadded2(el) {
       return /^-?0\d/.test(el);
     }
-    function lte(i, y) {
+    function lte2(i, y) {
       return i <= y;
     }
-    function gte6(i, y) {
+    function gte7(i, y) {
       return i >= y;
     }
-    function expand2(str, max, isTop) {
+    function expand3(str, max, isTop) {
       var expansions = [];
-      var m = balanced("{", "}", str);
+      var m = balanced2("{", "}", str);
       if (!m) return [str];
       var pre = m.pre;
-      var post = m.post.length ? expand2(m.post, max, false) : [""];
+      var post = m.post.length ? expand3(m.post, max, false) : [""];
       if (/\$$/.test(m.pre)) {
         for (var k = 0; k < post.length && k < max; k++) {
           var expansion = pre + "{" + m.body + "}" + post[k];
@@ -88831,8 +88831,8 @@ var require_brace_expansion2 = __commonJS({
         var isOptions = m.body.indexOf(",") >= 0;
         if (!isSequence && !isOptions) {
           if (m.post.match(/,(?!,).*\}/)) {
-            str = m.pre + "{" + m.body + escClose + m.post;
-            return expand2(str, max, true);
+            str = m.pre + "{" + m.body + escClose2 + m.post;
+            return expand3(str, max, true);
           }
           return [str];
         }
@@ -88840,9 +88840,9 @@ var require_brace_expansion2 = __commonJS({
         if (isSequence) {
           n = m.body.split(/\.\./);
         } else {
-          n = parseCommaParts(m.body);
+          n = parseCommaParts2(m.body);
           if (n.length === 1) {
-            n = expand2(n[0], max, false).map(embrace);
+            n = expand3(n[0], max, false).map(embrace2);
             if (n.length === 1) {
               return post.map(function(p) {
                 return m.pre + n[0] + p;
@@ -88852,19 +88852,19 @@ var require_brace_expansion2 = __commonJS({
         }
         var N;
         if (isSequence) {
-          var x = numeric(n[0]);
-          var y = numeric(n[1]);
+          var x = numeric2(n[0]);
+          var y = numeric2(n[1]);
           var width = Math.max(n[0].length, n[1].length);
-          var incr = n.length == 3 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
-          var test = lte;
+          var incr = n.length == 3 ? Math.max(Math.abs(numeric2(n[2])), 1) : 1;
+          var test = lte2;
           var reverse = y < x;
           if (reverse) {
             incr *= -1;
-            test = gte6;
+            test = gte7;
           }
-          var pad = n.some(isPadded);
+          var pad = n.some(isPadded2);
           N = [];
-          for (var i = x; test(i, y); i += incr) {
+          for (var i = x; test(i, y) && N.length < max; i += incr) {
             var c;
             if (isAlphaSequence) {
               c = String.fromCharCode(i);
@@ -88888,7 +88888,7 @@ var require_brace_expansion2 = __commonJS({
         } else {
           N = [];
           for (var j = 0; j < n.length; j++) {
-            N.push.apply(N, expand2(n[j], max, false));
+            N.push.apply(N, expand3(n[j], max, false));
           }
         }
         for (var j = 0; j < N.length; j++) {
@@ -88904,22 +88904,22 @@ var require_brace_expansion2 = __commonJS({
   }
 });
 
-// node_modules/readdir-glob/node_modules/minimatch/minimatch.js
+// node_modules/@actions/artifact/node_modules/minimatch/minimatch.js
 var require_minimatch2 = __commonJS({
-  "node_modules/readdir-glob/node_modules/minimatch/minimatch.js"(exports2, module2) {
-    var minimatch = module2.exports = (p, pattern, options = {}) => {
-      assertValidPattern(pattern);
+  "node_modules/@actions/artifact/node_modules/minimatch/minimatch.js"(exports2, module2) {
+    var minimatch2 = module2.exports = (p, pattern, options = {}) => {
+      assertValidPattern2(pattern);
       if (!options.nocomment && pattern.charAt(0) === "#") {
         return false;
       }
-      return new Minimatch(pattern, options).match(p);
+      return new Minimatch2(pattern, options).match(p);
     };
-    module2.exports = minimatch;
-    var path28 = require_path();
-    minimatch.sep = path28.sep;
-    var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
-    minimatch.GLOBSTAR = GLOBSTAR;
-    var expand2 = require_brace_expansion2();
+    module2.exports = minimatch2;
+    var path29 = require_path();
+    minimatch2.sep = path29.sep;
+    var GLOBSTAR2 = /* @__PURE__ */ Symbol("globstar **");
+    minimatch2.GLOBSTAR = GLOBSTAR2;
+    var expand3 = require_brace_expansion2();
     var plTypes = {
       "!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
       "?": { open: "(?:", close: ")?" },
@@ -88927,64 +88927,64 @@ var require_minimatch2 = __commonJS({
       "*": { open: "(?:", close: ")*" },
       "@": { open: "(?:", close: ")" }
     };
-    var qmark = "[^/]";
-    var star = qmark + "*?";
-    var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
-    var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+    var qmark3 = "[^/]";
+    var star3 = qmark3 + "*?";
+    var twoStarDot2 = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+    var twoStarNoDot2 = "(?:(?!(?:\\/|^)\\.).)*?";
     var charSet = (s) => s.split("").reduce((set, c) => {
       set[c] = true;
       return set;
     }, {});
-    var reSpecials = charSet("().*{}+?[]^$\\!");
+    var reSpecials2 = charSet("().*{}+?[]^$\\!");
     var addPatternStartSet = charSet("[.(");
     var slashSplit = /\/+/;
-    minimatch.filter = (pattern, options = {}) => (p, i, list) => minimatch(p, pattern, options);
-    var ext = (a, b = {}) => {
+    minimatch2.filter = (pattern, options = {}) => (p, i, list) => minimatch2(p, pattern, options);
+    var ext2 = (a, b = {}) => {
       const t = {};
       Object.keys(a).forEach((k) => t[k] = a[k]);
       Object.keys(b).forEach((k) => t[k] = b[k]);
       return t;
     };
-    minimatch.defaults = (def) => {
+    minimatch2.defaults = (def) => {
       if (!def || typeof def !== "object" || !Object.keys(def).length) {
-        return minimatch;
+        return minimatch2;
       }
-      const orig = minimatch;
-      const m = (p, pattern, options) => orig(p, pattern, ext(def, options));
+      const orig = minimatch2;
+      const m = (p, pattern, options) => orig(p, pattern, ext2(def, options));
       m.Minimatch = class Minimatch extends orig.Minimatch {
         constructor(pattern, options) {
-          super(pattern, ext(def, options));
+          super(pattern, ext2(def, options));
         }
       };
-      m.Minimatch.defaults = (options) => orig.defaults(ext(def, options)).Minimatch;
-      m.filter = (pattern, options) => orig.filter(pattern, ext(def, options));
-      m.defaults = (options) => orig.defaults(ext(def, options));
-      m.makeRe = (pattern, options) => orig.makeRe(pattern, ext(def, options));
-      m.braceExpand = (pattern, options) => orig.braceExpand(pattern, ext(def, options));
-      m.match = (list, pattern, options) => orig.match(list, pattern, ext(def, options));
+      m.Minimatch.defaults = (options) => orig.defaults(ext2(def, options)).Minimatch;
+      m.filter = (pattern, options) => orig.filter(pattern, ext2(def, options));
+      m.defaults = (options) => orig.defaults(ext2(def, options));
+      m.makeRe = (pattern, options) => orig.makeRe(pattern, ext2(def, options));
+      m.braceExpand = (pattern, options) => orig.braceExpand(pattern, ext2(def, options));
+      m.match = (list, pattern, options) => orig.match(list, pattern, ext2(def, options));
       return m;
     };
-    minimatch.braceExpand = (pattern, options) => braceExpand(pattern, options);
-    var braceExpand = (pattern, options = {}) => {
-      assertValidPattern(pattern);
+    minimatch2.braceExpand = (pattern, options) => braceExpand2(pattern, options);
+    var braceExpand2 = (pattern, options = {}) => {
+      assertValidPattern2(pattern);
       if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
         return [pattern];
       }
-      return expand2(pattern);
+      return expand3(pattern);
     };
-    var MAX_PATTERN_LENGTH = 1024 * 64;
-    var assertValidPattern = (pattern) => {
+    var MAX_PATTERN_LENGTH2 = 1024 * 64;
+    var assertValidPattern2 = (pattern) => {
       if (typeof pattern !== "string") {
         throw new TypeError("invalid pattern");
       }
-      if (pattern.length > MAX_PATTERN_LENGTH) {
+      if (pattern.length > MAX_PATTERN_LENGTH2) {
         throw new TypeError("pattern is too long");
       }
     };
     var SUBPARSE = /* @__PURE__ */ Symbol("subparse");
-    minimatch.makeRe = (pattern, options) => new Minimatch(pattern, options || {}).makeRe();
-    minimatch.match = (list, pattern, options = {}) => {
-      const mm = new Minimatch(pattern, options);
+    minimatch2.makeRe = (pattern, options) => new Minimatch2(pattern, options || {}).makeRe();
+    minimatch2.match = (list, pattern, options = {}) => {
+      const mm = new Minimatch2(pattern, options);
       list = list.filter((f) => mm.match(f));
       if (mm.options.nonull && !list.length) {
         list.push(pattern);
@@ -88993,11 +88993,11 @@ var require_minimatch2 = __commonJS({
     };
     var globUnescape = (s) => s.replace(/\\(.)/g, "$1");
     var charUnescape = (s) => s.replace(/\\([^-\]])/g, "$1");
-    var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    var regExpEscape3 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
     var braExpEscape = (s) => s.replace(/[[\]\\]/g, "\\$&");
-    var Minimatch = class {
+    var Minimatch2 = class {
       constructor(pattern, options) {
-        assertValidPattern(pattern);
+        assertValidPattern2(pattern);
         if (!options) options = {};
         this.options = options;
         this.maxGlobstarRecursion = options.maxGlobstarRecursion !== void 0 ? options.maxGlobstarRecursion : 200;
@@ -89057,7 +89057,7 @@ var require_minimatch2 = __commonJS({
       // out of pattern, then that's fine, as long as all
       // the parts match.
       matchOne(file, pattern, partial) {
-        if (pattern.indexOf(GLOBSTAR) !== -1) {
+        if (pattern.indexOf(GLOBSTAR2) !== -1) {
           return this._matchGlobstar(file, pattern, partial, 0, 0);
         }
         return this._matchOne(file, pattern, partial, 0, 0);
@@ -89065,14 +89065,14 @@ var require_minimatch2 = __commonJS({
       _matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
         let firstgs = -1;
         for (let i = patternIndex; i < pattern.length; i++) {
-          if (pattern[i] === GLOBSTAR) {
+          if (pattern[i] === GLOBSTAR2) {
             firstgs = i;
             break;
           }
         }
         let lastgs = -1;
         for (let i = pattern.length - 1; i >= 0; i--) {
-          if (pattern[i] === GLOBSTAR) {
+          if (pattern[i] === GLOBSTAR2) {
             lastgs = i;
             break;
           }
@@ -89119,7 +89119,7 @@ var require_minimatch2 = __commonJS({
         let nonGsParts = 0;
         const nonGsPartsSums = [0];
         for (const b of body) {
-          if (b === GLOBSTAR) {
+          if (b === GLOBSTAR2) {
             nonGsPartsSums.push(nonGsParts);
             currentBody = [[], 0];
             bodySegments.push(currentBody);
@@ -89195,7 +89195,7 @@ var require_minimatch2 = __commonJS({
           const p = pattern[pi];
           const f = file[fi];
           this.debug(pattern, p, f);
-          if (p === false || p === GLOBSTAR) return false;
+          if (p === false || p === GLOBSTAR2) return false;
           let hit;
           if (typeof p === "string") {
             hit = f === p;
@@ -89216,14 +89216,14 @@ var require_minimatch2 = __commonJS({
         throw new Error("wtf?");
       }
       braceExpand() {
-        return braceExpand(this.pattern, this.options);
+        return braceExpand2(this.pattern, this.options);
       }
       parse(pattern, isSub) {
-        assertValidPattern(pattern);
+        assertValidPattern2(pattern);
         const options = this.options;
         if (pattern === "**") {
           if (!options.noglobstar)
-            return GLOBSTAR;
+            return GLOBSTAR2;
           else
             pattern = "*";
         }
@@ -89248,11 +89248,11 @@ var require_minimatch2 = __commonJS({
           if (stateChar) {
             switch (stateChar) {
               case "*":
-                re += star;
+                re += star3;
                 hasMagic = true;
                 break;
               case "?":
-                re += qmark;
+                re += qmark3;
                 hasMagic = true;
                 break;
               default:
@@ -89269,7 +89269,7 @@ var require_minimatch2 = __commonJS({
             if (c === "/") {
               return false;
             }
-            if (reSpecials[c]) {
+            if (reSpecials2[c]) {
               re += "\\";
             }
             re += c;
@@ -89395,7 +89395,7 @@ var require_minimatch2 = __commonJS({
               continue;
             default:
               clearStateChar();
-              if (reSpecials[c] && !(c === "^" && inClass)) {
+              if (reSpecials2[c] && !(c === "^" && inClass)) {
                 re += "\\";
               }
               re += c;
@@ -89419,7 +89419,7 @@ var require_minimatch2 = __commonJS({
             return $1 + $1 + $2 + "|";
           });
           this.debug("tail=%j\n   %s", tail, tail, pl, re);
-          const t = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
+          const t = pl.type === "*" ? star3 : pl.type === "?" ? qmark3 : "\\" + pl.type;
           hasMagic = true;
           re = re.slice(0, pl.reStart) + t + "\\(" + tail;
         }
@@ -89427,7 +89427,7 @@ var require_minimatch2 = __commonJS({
         if (escaping) {
           re += "\\\\";
         }
-        const addPatternStart = addPatternStartSet[re.charAt(0)];
+        const addPatternStart2 = addPatternStartSet[re.charAt(0)];
         for (let n = negativeLists.length - 1; n > -1; n--) {
           const nl = negativeLists[n];
           const nlBefore = re.slice(0, nl.reStart);
@@ -89447,7 +89447,7 @@ var require_minimatch2 = __commonJS({
         if (re !== "" && hasMagic) {
           re = "(?=.)" + re;
         }
-        if (addPatternStart) {
+        if (addPatternStart2) {
           re = patternStart() + re;
         }
         if (isSub === SUBPARSE) {
@@ -89477,19 +89477,19 @@ var require_minimatch2 = __commonJS({
           return this.regexp;
         }
         const options = this.options;
-        const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+        const twoStar = options.noglobstar ? star3 : options.dot ? twoStarDot2 : twoStarNoDot2;
         const flags = options.nocase ? "i" : "";
         let re = set.map((pattern) => {
           pattern = pattern.map(
-            (p) => typeof p === "string" ? regExpEscape(p) : p === GLOBSTAR ? GLOBSTAR : p._src
+            (p) => typeof p === "string" ? regExpEscape3(p) : p === GLOBSTAR2 ? GLOBSTAR2 : p._src
           ).reduce((set2, p) => {
-            if (!(set2[set2.length - 1] === GLOBSTAR && p === GLOBSTAR)) {
+            if (!(set2[set2.length - 1] === GLOBSTAR2 && p === GLOBSTAR2)) {
               set2.push(p);
             }
             return set2;
           }, []);
           pattern.forEach((p, i) => {
-            if (p !== GLOBSTAR || pattern[i - 1] === GLOBSTAR) {
+            if (p !== GLOBSTAR2 || pattern[i - 1] === GLOBSTAR2) {
               return;
             }
             if (i === 0) {
@@ -89502,10 +89502,10 @@ var require_minimatch2 = __commonJS({
               pattern[i - 1] += "(?:\\/|" + twoStar + ")?";
             } else {
               pattern[i - 1] += "(?:\\/|\\/" + twoStar + "\\/)" + pattern[i + 1];
-              pattern[i + 1] = GLOBSTAR;
+              pattern[i + 1] = GLOBSTAR2;
             }
           });
-          return pattern.filter((p) => p !== GLOBSTAR).join("/");
+          return pattern.filter((p) => p !== GLOBSTAR2).join("/");
         }).join("|");
         re = "^(?:" + re + ")$";
         if (this.negate) re = "^(?!" + re + ").*$";
@@ -89522,8 +89522,8 @@ var require_minimatch2 = __commonJS({
         if (this.empty) return f === "";
         if (f === "/" && partial) return true;
         const options = this.options;
-        if (path28.sep !== "/") {
-          f = f.split(path28.sep).join("/");
+        if (path29.sep !== "/") {
+          f = f.split(path29.sep).join("/");
         }
         f = f.split(slashSplit);
         this.debug(this.pattern, "split", f);
@@ -89550,31 +89550,31 @@ var require_minimatch2 = __commonJS({
         return this.negate;
       }
       static defaults(def) {
-        return minimatch.defaults(def).Minimatch;
+        return minimatch2.defaults(def).Minimatch;
       }
     };
-    minimatch.Minimatch = Minimatch;
+    minimatch2.Minimatch = Minimatch2;
   }
 });
 
-// node_modules/readdir-glob/index.js
+// node_modules/@actions/artifact/node_modules/readdir-glob/index.js
 var require_readdir_glob = __commonJS({
-  "node_modules/readdir-glob/index.js"(exports2, module2) {
-    module2.exports = readdirGlob;
-    var fs30 = require("fs");
-    var { EventEmitter } = require("events");
-    var { Minimatch } = require_minimatch2();
-    var { resolve: resolve13 } = require("path");
-    function readdir(dir, strict) {
-      return new Promise((resolve14, reject) => {
-        fs30.readdir(dir, { withFileTypes: true }, (err, files) => {
+  "node_modules/@actions/artifact/node_modules/readdir-glob/index.js"(exports2, module2) {
+    module2.exports = readdirGlob2;
+    var fs31 = require("fs");
+    var { EventEmitter: EventEmitter2 } = require("events");
+    var { Minimatch: Minimatch2 } = require_minimatch2();
+    var { resolve: resolve14 } = require("path");
+    function readdir3(dir, strict) {
+      return new Promise((resolve15, reject) => {
+        fs31.readdir(dir, { withFileTypes: true }, (err, files) => {
           if (err) {
             switch (err.code) {
               case "ENOTDIR":
                 if (strict) {
                   reject(err);
                 } else {
-                  resolve14([]);
+                  resolve15([]);
                 }
                 break;
               case "ENOTSUP":
@@ -89584,7 +89584,7 @@ var require_readdir_glob = __commonJS({
               case "ENAMETOOLONG":
               // Filename too long
               case "UNKNOWN":
-                resolve14([]);
+                resolve15([]);
                 break;
               case "ELOOP":
               // Too many levels of symbolic links
@@ -89593,36 +89593,36 @@ var require_readdir_glob = __commonJS({
                 break;
             }
           } else {
-            resolve14(files);
+            resolve15(files);
           }
         });
       });
     }
-    function stat(file, followSymlinks) {
-      return new Promise((resolve14, reject) => {
-        const statFunc = followSymlinks ? fs30.stat : fs30.lstat;
+    function stat2(file, followSymlinks) {
+      return new Promise((resolve15, reject) => {
+        const statFunc = followSymlinks ? fs31.stat : fs31.lstat;
         statFunc(file, (err, stats) => {
           if (err) {
             switch (err.code) {
               case "ENOENT":
                 if (followSymlinks) {
-                  resolve14(stat(file, false));
+                  resolve15(stat2(file, false));
                 } else {
-                  resolve14(null);
+                  resolve15(null);
                 }
                 break;
               default:
-                resolve14(null);
+                resolve15(null);
                 break;
             }
           } else {
-            resolve14(stats);
+            resolve15(stats);
           }
         });
       });
     }
-    async function* exploreWalkAsync(dir, path28, followSymlinks, useStat, shouldSkip, strict) {
-      let files = await readdir(path28 + dir, strict);
+    async function* exploreWalkAsync2(dir, path29, followSymlinks, useStat, shouldSkip, strict) {
+      let files = await readdir3(path29 + dir, strict);
       for (const file of files) {
         let name = file.name;
         if (name === void 0) {
@@ -89631,10 +89631,10 @@ var require_readdir_glob = __commonJS({
         }
         const filename = dir + "/" + name;
         const relative3 = filename.slice(1);
-        const absolute = path28 + "/" + relative3;
+        const absolute = path29 + "/" + relative3;
         let stats = null;
         if (useStat || followSymlinks) {
-          stats = await stat(absolute, followSymlinks);
+          stats = await stat2(absolute, followSymlinks);
         }
         if (!stats && file.name !== void 0) {
           stats = file;
@@ -89645,17 +89645,17 @@ var require_readdir_glob = __commonJS({
         if (stats.isDirectory()) {
           if (!shouldSkip(relative3)) {
             yield { relative: relative3, absolute, stats };
-            yield* exploreWalkAsync(filename, path28, followSymlinks, useStat, shouldSkip, false);
+            yield* exploreWalkAsync2(filename, path29, followSymlinks, useStat, shouldSkip, false);
           }
         } else {
           yield { relative: relative3, absolute, stats };
         }
       }
     }
-    async function* explore(path28, followSymlinks, useStat, shouldSkip) {
-      yield* exploreWalkAsync("", path28, followSymlinks, useStat, shouldSkip, true);
+    async function* explore2(path29, followSymlinks, useStat, shouldSkip) {
+      yield* exploreWalkAsync2("", path29, followSymlinks, useStat, shouldSkip, true);
     }
-    function readOptions(options) {
+    function readOptions2(options) {
       return {
         pattern: options.pattern,
         dot: !!options.dot,
@@ -89672,19 +89672,19 @@ var require_readdir_glob = __commonJS({
         absolute: !!options.absolute
       };
     }
-    var ReaddirGlob = class extends EventEmitter {
+    var ReaddirGlob3 = class extends EventEmitter2 {
       constructor(cwd, options, cb) {
         super();
         if (typeof options === "function") {
           cb = options;
           options = null;
         }
-        this.options = readOptions(options || {});
+        this.options = readOptions2(options || {});
         this.matchers = [];
         if (this.options.pattern) {
           const matchers = Array.isArray(this.options.pattern) ? this.options.pattern : [this.options.pattern];
           this.matchers = matchers.map(
-            (m) => new Minimatch(m, {
+            (m) => new Minimatch2(m, {
               dot: this.options.dot,
               noglobstar: this.options.noglobstar,
               matchBase: this.options.matchBase,
@@ -89696,23 +89696,23 @@ var require_readdir_glob = __commonJS({
         if (this.options.ignore) {
           const ignorePatterns = Array.isArray(this.options.ignore) ? this.options.ignore : [this.options.ignore];
           this.ignoreMatchers = ignorePatterns.map(
-            (ignore) => new Minimatch(ignore, { dot: true })
+            (ignore) => new Minimatch2(ignore, { dot: true })
           );
         }
         this.skipMatchers = [];
         if (this.options.skip) {
           const skipPatterns = Array.isArray(this.options.skip) ? this.options.skip : [this.options.skip];
           this.skipMatchers = skipPatterns.map(
-            (skip) => new Minimatch(skip, { dot: true })
+            (skip) => new Minimatch2(skip, { dot: true })
           );
         }
-        this.iterator = explore(resolve13(cwd || "."), this.options.follow, this.options.stat, this._shouldSkipDirectory.bind(this));
+        this.iterator = explore2(resolve14(cwd || "."), this.options.follow, this.options.stat, this._shouldSkipDirectory.bind(this));
         this.paused = false;
         this.inactive = false;
         this.aborted = false;
         if (cb) {
           this._matches = [];
-          this.on("match", (match) => this._matches.push(this.options.absolute ? match.absolute : match.relative));
+          this.on("match", (match2) => this._matches.push(this.options.absolute ? match2.absolute : match2.relative));
           this.on("error", (err) => cb(err));
           this.on("end", () => cb(null, this._matches));
         }
@@ -89772,10 +89772,10 @@ var require_readdir_glob = __commonJS({
         }
       }
     };
-    function readdirGlob(pattern, options, cb) {
-      return new ReaddirGlob(pattern, options, cb);
+    function readdirGlob2(pattern, options, cb) {
+      return new ReaddirGlob3(pattern, options, cb);
     }
-    readdirGlob.ReaddirGlob = ReaddirGlob;
+    readdirGlob2.ReaddirGlob = ReaddirGlob3;
   }
 });
 
@@ -89873,10 +89873,10 @@ var require_async = __commonJS({
           if (typeof args[arity - 1] === "function") {
             return asyncFn.apply(this, args);
           }
-          return new Promise((resolve13, reject2) => {
+          return new Promise((resolve14, reject2) => {
             args[arity - 1] = (err, ...cbArgs) => {
               if (err) return reject2(err);
-              resolve13(cbArgs.length > 1 ? cbArgs : cbArgs[0]);
+              resolve14(cbArgs.length > 1 ? cbArgs : cbArgs[0]);
             };
             asyncFn.apply(this, args);
           });
@@ -89900,9 +89900,9 @@ var require_async = __commonJS({
         var counter = 0;
         var _iteratee = wrapAsync(iteratee);
         return eachfn(arr, (value, _2, iterCb) => {
-          var index2 = counter++;
+          var index3 = counter++;
           _iteratee(value, (err, v) => {
-            results[index2] = v;
+            results[index3] = v;
             iterCb(err);
           });
         }, (err) => {
@@ -90079,7 +90079,7 @@ var require_async = __commonJS({
       var eachOfLimit$1 = awaitify(eachOfLimit, 4);
       function eachOfArrayLike(coll, iteratee, callback) {
         callback = once(callback);
-        var index2 = 0, completed = 0, { length } = coll, canceled = false;
+        var index3 = 0, completed = 0, { length } = coll, canceled = false;
         if (length === 0) {
           callback(null);
         }
@@ -90094,8 +90094,8 @@ var require_async = __commonJS({
             callback(null);
           }
         }
-        for (; index2 < length; index2++) {
-          iteratee(coll[index2], index2, onlyOnce(iteratorCallback));
+        for (; index3 < length; index3++) {
+          iteratee(coll[index3], index3, onlyOnce(iteratorCallback));
         }
       }
       function eachOfGeneric(coll, iteratee, callback) {
@@ -90122,13 +90122,13 @@ var require_async = __commonJS({
       var applyEachSeries = applyEach$1(mapSeries$1);
       const PROMISE_SYMBOL = /* @__PURE__ */ Symbol("promiseCallback");
       function promiseCallback() {
-        let resolve13, reject2;
+        let resolve14, reject2;
         function callback(err, ...args) {
           if (err) return reject2(err);
-          resolve13(args.length > 1 ? args : args[0]);
+          resolve14(args.length > 1 ? args : args[0]);
         }
         callback[PROMISE_SYMBOL] = new Promise((res, rej) => {
-          resolve13 = res, reject2 = rej;
+          resolve14 = res, reject2 = rej;
         });
         return callback;
       }
@@ -90277,36 +90277,36 @@ var require_async = __commonJS({
       var FN_ARG = /(=.+)?(\s*)$/;
       function stripComments(string2) {
         let stripped = "";
-        let index2 = 0;
+        let index3 = 0;
         let endBlockComment = string2.indexOf("*/");
-        while (index2 < string2.length) {
-          if (string2[index2] === "/" && string2[index2 + 1] === "/") {
-            let endIndex = string2.indexOf("\n", index2);
-            index2 = endIndex === -1 ? string2.length : endIndex;
-          } else if (endBlockComment !== -1 && string2[index2] === "/" && string2[index2 + 1] === "*") {
-            let endIndex = string2.indexOf("*/", index2);
+        while (index3 < string2.length) {
+          if (string2[index3] === "/" && string2[index3 + 1] === "/") {
+            let endIndex = string2.indexOf("\n", index3);
+            index3 = endIndex === -1 ? string2.length : endIndex;
+          } else if (endBlockComment !== -1 && string2[index3] === "/" && string2[index3 + 1] === "*") {
+            let endIndex = string2.indexOf("*/", index3);
             if (endIndex !== -1) {
-              index2 = endIndex + 2;
-              endBlockComment = string2.indexOf("*/", index2);
+              index3 = endIndex + 2;
+              endBlockComment = string2.indexOf("*/", index3);
             } else {
-              stripped += string2[index2];
-              index2++;
+              stripped += string2[index3];
+              index3++;
             }
           } else {
-            stripped += string2[index2];
-            index2++;
+            stripped += string2[index3];
+            index3++;
           }
         }
         return stripped;
       }
       function parseParams(func) {
         const src = stripComments(func.toString());
-        let match = src.match(FN_ARGS);
-        if (!match) {
-          match = src.match(ARROW_FN_ARGS);
+        let match2 = src.match(FN_ARGS);
+        if (!match2) {
+          match2 = src.match(ARROW_FN_ARGS);
         }
-        if (!match) throw new Error("could not parse args in autoInject\nSource:\n" + src);
-        let [, args] = match;
+        if (!match2) throw new Error("could not parse args in autoInject\nSource:\n" + src);
+        let [, args] = match2;
         return args.replace(/\s/g, "").split(FN_ARG_SPLIT).map((arg) => arg.replace(FN_ARG, "").trim());
       }
       function autoInject(tasks, callback) {
@@ -90475,8 +90475,8 @@ var require_async = __commonJS({
             });
           }
           if (rejectOnError || !callback) {
-            return new Promise((resolve13, reject2) => {
-              res = resolve13;
+            return new Promise((resolve14, reject2) => {
+              res = resolve14;
               rej = reject2;
             });
           }
@@ -90486,11 +90486,11 @@ var require_async = __commonJS({
             numRunning -= 1;
             for (var i = 0, l = tasks.length; i < l; i++) {
               var task = tasks[i];
-              var index2 = workersList.indexOf(task);
-              if (index2 === 0) {
+              var index3 = workersList.indexOf(task);
+              if (index3 === 0) {
                 workersList.shift();
-              } else if (index2 > 0) {
-                workersList.splice(index2, 1);
+              } else if (index3 > 0) {
+                workersList.splice(index3, 1);
               }
               task.callback(err, ...args);
               if (err != null) {
@@ -90515,10 +90515,10 @@ var require_async = __commonJS({
         }
         const eventMethod = (name) => (handler2) => {
           if (!handler2) {
-            return new Promise((resolve13, reject2) => {
+            return new Promise((resolve14, reject2) => {
               once2(name, (err, data) => {
                 if (err) return reject2(err);
-                resolve13(data);
+                resolve14(data);
               });
             });
           }
@@ -90805,7 +90805,7 @@ var require_async = __commonJS({
         }, callback);
       }
       function _withoutIndex(iteratee) {
-        return (value, index2, callback) => iteratee(value, callback);
+        return (value, index3, callback) => iteratee(value, callback);
       }
       function eachLimit$2(coll, iteratee, callback) {
         return eachOf$1(coll, _withoutIndex(wrapAsync(iteratee)), callback);
@@ -90849,9 +90849,9 @@ var require_async = __commonJS({
       var everySeries$1 = awaitify(everySeries, 3);
       function filterArray(eachfn, arr, iteratee, callback) {
         var truthValues = new Array(arr.length);
-        eachfn(arr, (x, index2, iterCb) => {
+        eachfn(arr, (x, index3, iterCb) => {
           iteratee(x, (err, v) => {
-            truthValues[index2] = !!v;
+            truthValues[index3] = !!v;
             iterCb(err);
           });
         }, (err) => {
@@ -90865,11 +90865,11 @@ var require_async = __commonJS({
       }
       function filterGeneric(eachfn, coll, iteratee, callback) {
         var results = [];
-        eachfn(coll, (x, index2, iterCb) => {
+        eachfn(coll, (x, index3, iterCb) => {
           iteratee(x, (err, v) => {
             if (err) return iterCb(err);
             if (v) {
-              results.push({ index: index2, value: x });
+              results.push({ index: index3, value: x });
             }
             iterCb(err);
           });
@@ -90879,13 +90879,13 @@ var require_async = __commonJS({
         });
       }
       function _filter(eachfn, coll, iteratee, callback) {
-        var filter2 = isArrayLike(coll) ? filterArray : filterGeneric;
-        return filter2(eachfn, coll, wrapAsync(iteratee), callback);
+        var filter3 = isArrayLike(coll) ? filterArray : filterGeneric;
+        return filter3(eachfn, coll, wrapAsync(iteratee), callback);
       }
-      function filter(coll, iteratee, callback) {
+      function filter2(coll, iteratee, callback) {
         return _filter(eachOf$1, coll, iteratee, callback);
       }
-      var filter$1 = awaitify(filter, 3);
+      var filter$1 = awaitify(filter2, 3);
       function filterLimit(coll, limit, iteratee, callback) {
         return _filter(eachOfLimit$2(limit), coll, iteratee, callback);
       }
@@ -91011,7 +91011,7 @@ var require_async = __commonJS({
       function parallelLimit(tasks, limit, callback) {
         return _parallel(eachOfLimit$2(limit), tasks, callback);
       }
-      function queue(worker, concurrency) {
+      function queue2(worker, concurrency) {
         var _worker = wrapAsync(worker);
         return queue$1((items, cb) => {
           _worker(items[0], cb);
@@ -91029,28 +91029,28 @@ var require_async = __commonJS({
           this.heap = [];
           return this;
         }
-        percUp(index2) {
+        percUp(index3) {
           let p;
-          while (index2 > 0 && smaller(this.heap[index2], this.heap[p = parent(index2)])) {
-            let t = this.heap[index2];
-            this.heap[index2] = this.heap[p];
+          while (index3 > 0 && smaller(this.heap[index3], this.heap[p = parent(index3)])) {
+            let t = this.heap[index3];
+            this.heap[index3] = this.heap[p];
             this.heap[p] = t;
-            index2 = p;
+            index3 = p;
           }
         }
-        percDown(index2) {
+        percDown(index3) {
           let l;
-          while ((l = leftChi(index2)) < this.heap.length) {
+          while ((l = leftChi(index3)) < this.heap.length) {
             if (l + 1 < this.heap.length && smaller(this.heap[l + 1], this.heap[l])) {
               l = l + 1;
             }
-            if (smaller(this.heap[index2], this.heap[l])) {
+            if (smaller(this.heap[index3], this.heap[l])) {
               break;
             }
-            let t = this.heap[index2];
-            this.heap[index2] = this.heap[l];
+            let t = this.heap[index3];
+            this.heap[index3] = this.heap[l];
             this.heap[l] = t;
-            index2 = l;
+            index3 = l;
           }
         }
         push(node) {
@@ -91105,7 +91105,7 @@ var require_async = __commonJS({
         }
       }
       function priorityQueue(worker, concurrency) {
-        var q = queue(worker, concurrency);
+        var q = queue2(worker, concurrency);
         var {
           push,
           pushAsync
@@ -91329,7 +91329,7 @@ var require_async = __commonJS({
           fn(...args);
         });
       }
-      function range(size) {
+      function range2(size) {
         var result = Array(size);
         while (size--) {
           result[size] = size;
@@ -91338,7 +91338,7 @@ var require_async = __commonJS({
       }
       function timesLimit(count, limit, iteratee, callback) {
         var _iteratee = wrapAsync(iteratee);
-        return mapLimit$1(range(count), limit, _iteratee, callback);
+        return mapLimit$1(range2(count), limit, _iteratee, callback);
       }
       function times(n, iteratee, callback) {
         return timesLimit(n, Infinity, iteratee, callback);
@@ -91424,7 +91424,7 @@ var require_async = __commonJS({
         nextTask([]);
       }
       var waterfall$1 = awaitify(waterfall);
-      var index = {
+      var index2 = {
         apply,
         applyEach,
         applyEachSeries,
@@ -91473,7 +91473,7 @@ var require_async = __commonJS({
         parallel,
         parallelLimit,
         priorityQueue,
-        queue,
+        queue: queue2,
         race: race$1,
         reduce: reduce$1,
         reduceRight,
@@ -91549,7 +91549,7 @@ var require_async = __commonJS({
       exports3.concatLimit = concatLimit$1;
       exports3.concatSeries = concatSeries$1;
       exports3.constant = constant$1;
-      exports3.default = index;
+      exports3.default = index2;
       exports3.detect = detect$1;
       exports3.detectLimit = detectLimit$1;
       exports3.detectSeries = detectSeries$1;
@@ -91602,7 +91602,7 @@ var require_async = __commonJS({
       exports3.parallel = parallel;
       exports3.parallelLimit = parallelLimit;
       exports3.priorityQueue = priorityQueue;
-      exports3.queue = queue;
+      exports3.queue = queue2;
       exports3.race = race$1;
       exports3.reduce = reduce$1;
       exports3.reduceRight = reduceRight;
@@ -91665,54 +91665,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module2.exports = patch;
-    function patch(fs30) {
+    function patch(fs31) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs30);
-      }
-      if (!fs30.lutimes) {
-        patchLutimes(fs30);
-      }
-      fs30.chown = chownFix(fs30.chown);
-      fs30.fchown = chownFix(fs30.fchown);
-      fs30.lchown = chownFix(fs30.lchown);
-      fs30.chmod = chmodFix(fs30.chmod);
-      fs30.fchmod = chmodFix(fs30.fchmod);
-      fs30.lchmod = chmodFix(fs30.lchmod);
-      fs30.chownSync = chownFixSync(fs30.chownSync);
-      fs30.fchownSync = chownFixSync(fs30.fchownSync);
-      fs30.lchownSync = chownFixSync(fs30.lchownSync);
-      fs30.chmodSync = chmodFixSync(fs30.chmodSync);
-      fs30.fchmodSync = chmodFixSync(fs30.fchmodSync);
-      fs30.lchmodSync = chmodFixSync(fs30.lchmodSync);
-      fs30.stat = statFix(fs30.stat);
-      fs30.fstat = statFix(fs30.fstat);
-      fs30.lstat = statFix(fs30.lstat);
-      fs30.statSync = statFixSync(fs30.statSync);
-      fs30.fstatSync = statFixSync(fs30.fstatSync);
-      fs30.lstatSync = statFixSync(fs30.lstatSync);
-      if (fs30.chmod && !fs30.lchmod) {
-        fs30.lchmod = function(path28, mode, cb) {
+        patchLchmod(fs31);
+      }
+      if (!fs31.lutimes) {
+        patchLutimes(fs31);
+      }
+      fs31.chown = chownFix(fs31.chown);
+      fs31.fchown = chownFix(fs31.fchown);
+      fs31.lchown = chownFix(fs31.lchown);
+      fs31.chmod = chmodFix(fs31.chmod);
+      fs31.fchmod = chmodFix(fs31.fchmod);
+      fs31.lchmod = chmodFix(fs31.lchmod);
+      fs31.chownSync = chownFixSync(fs31.chownSync);
+      fs31.fchownSync = chownFixSync(fs31.fchownSync);
+      fs31.lchownSync = chownFixSync(fs31.lchownSync);
+      fs31.chmodSync = chmodFixSync(fs31.chmodSync);
+      fs31.fchmodSync = chmodFixSync(fs31.fchmodSync);
+      fs31.lchmodSync = chmodFixSync(fs31.lchmodSync);
+      fs31.stat = statFix(fs31.stat);
+      fs31.fstat = statFix(fs31.fstat);
+      fs31.lstat = statFix(fs31.lstat);
+      fs31.statSync = statFixSync(fs31.statSync);
+      fs31.fstatSync = statFixSync(fs31.fstatSync);
+      fs31.lstatSync = statFixSync(fs31.lstatSync);
+      if (fs31.chmod && !fs31.lchmod) {
+        fs31.lchmod = function(path29, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs30.lchmodSync = function() {
+        fs31.lchmodSync = function() {
         };
       }
-      if (fs30.chown && !fs30.lchown) {
-        fs30.lchown = function(path28, uid, gid, cb) {
+      if (fs31.chown && !fs31.lchown) {
+        fs31.lchown = function(path29, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs30.lchownSync = function() {
+        fs31.lchownSync = function() {
         };
       }
       if (platform2 === "win32") {
-        fs30.rename = typeof fs30.rename !== "function" ? fs30.rename : (function(fs$rename) {
+        fs31.rename = typeof fs31.rename !== "function" ? fs31.rename : (function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs30.stat(to, function(stater, st) {
+                  fs31.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -91728,9 +91728,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        })(fs30.rename);
+        })(fs31.rename);
       }
-      fs30.read = typeof fs30.read !== "function" ? fs30.read : (function(fs$read) {
+      fs31.read = typeof fs31.read !== "function" ? fs31.read : (function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -91738,22 +91738,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _2, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs30, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs31, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs30, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs31, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      })(fs30.read);
-      fs30.readSync = typeof fs30.readSync !== "function" ? fs30.readSync : /* @__PURE__ */ (function(fs$readSync) {
+      })(fs31.read);
+      fs31.readSync = typeof fs31.readSync !== "function" ? fs31.readSync : /* @__PURE__ */ (function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs30, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs31, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -91763,11 +91763,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      })(fs30.readSync);
-      function patchLchmod(fs31) {
-        fs31.lchmod = function(path28, mode, callback) {
-          fs31.open(
-            path28,
+      })(fs31.readSync);
+      function patchLchmod(fs32) {
+        fs32.lchmod = function(path29, mode, callback) {
+          fs32.open(
+            path29,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -91775,80 +91775,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs31.fchmod(fd, mode, function(err2) {
-                fs31.close(fd, function(err22) {
+              fs32.fchmod(fd, mode, function(err2) {
+                fs32.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs31.lchmodSync = function(path28, mode) {
-          var fd = fs31.openSync(path28, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs32.lchmodSync = function(path29, mode) {
+          var fd = fs32.openSync(path29, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs31.fchmodSync(fd, mode);
+            ret = fs32.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs31.closeSync(fd);
+                fs32.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs31.closeSync(fd);
+              fs32.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs31) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs31.futimes) {
-          fs31.lutimes = function(path28, at, mt, cb) {
-            fs31.open(path28, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs32) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs32.futimes) {
+          fs32.lutimes = function(path29, at, mt, cb) {
+            fs32.open(path29, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs31.futimes(fd, at, mt, function(er2) {
-                fs31.close(fd, function(er22) {
+              fs32.futimes(fd, at, mt, function(er2) {
+                fs32.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs31.lutimesSync = function(path28, at, mt) {
-            var fd = fs31.openSync(path28, constants.O_SYMLINK);
+          fs32.lutimesSync = function(path29, at, mt) {
+            var fd = fs32.openSync(path29, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs31.futimesSync(fd, at, mt);
+              ret = fs32.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs31.closeSync(fd);
+                  fs32.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs31.closeSync(fd);
+                fs32.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs31.futimes) {
-          fs31.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs32.futimes) {
+          fs32.lutimes = function(_a2, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs31.lutimesSync = function() {
+          fs32.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs30, target, mode, function(er) {
+          return orig.call(fs31, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -91858,7 +91858,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs30, target, mode);
+            return orig.call(fs31, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -91867,7 +91867,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs30, target, uid, gid, function(er) {
+          return orig.call(fs31, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -91877,7 +91877,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs30, target, uid, gid);
+            return orig.call(fs31, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -91897,13 +91897,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs30, target, options, callback) : orig.call(fs30, target, callback);
+          return options ? orig.call(fs31, target, options, callback) : orig.call(fs31, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs30, target, options) : orig.call(fs30, target);
+          var stats = options ? orig.call(fs31, target, options) : orig.call(fs31, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -91932,16 +91932,16 @@ var require_legacy_streams = __commonJS({
   "node_modules/graceful-fs/legacy-streams.js"(exports2, module2) {
     var Stream = require("stream").Stream;
     module2.exports = legacy;
-    function legacy(fs30) {
+    function legacy(fs31) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path28, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path28, options);
+      function ReadStream(path29, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path29, options);
         Stream.call(this);
         var self2 = this;
-        this.path = path28;
+        this.path = path29;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -91950,8 +91950,8 @@ var require_legacy_streams = __commonJS({
         this.bufferSize = 64 * 1024;
         options = options || {};
         var keys = Object.keys(options);
-        for (var index = 0, length = keys.length; index < length; index++) {
-          var key = keys[index];
+        for (var index2 = 0, length = keys.length; index2 < length; index2++) {
+          var key = keys[index2];
           this[key] = options[key];
         }
         if (this.encoding) this.setEncoding(this.encoding);
@@ -91975,7 +91975,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs30.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs31.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self2.emit("error", err);
             self2.readable = false;
@@ -91986,10 +91986,10 @@ var require_legacy_streams = __commonJS({
           self2._read();
         });
       }
-      function WriteStream(path28, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path28, options);
+      function WriteStream(path29, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path29, options);
         Stream.call(this);
-        this.path = path28;
+        this.path = path29;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -91998,8 +91998,8 @@ var require_legacy_streams = __commonJS({
         this.bytesWritten = 0;
         options = options || {};
         var keys = Object.keys(options);
-        for (var index = 0, length = keys.length; index < length; index++) {
-          var key = keys[index];
+        for (var index2 = 0, length = keys.length; index2 < length; index2++) {
+          var key = keys[index2];
           this[key] = options[key];
         }
         if (this.start !== void 0) {
@@ -92014,7 +92014,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs30.open;
+          this._open = fs31.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -92049,11 +92049,11 @@ var require_clone = __commonJS({
 // node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS({
   "node_modules/graceful-fs/graceful-fs.js"(exports2, module2) {
-    var fs30 = require("fs");
+    var fs31 = require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
-    var util = require("util");
+    var util3 = require("util");
     var gracefulQueue;
     var previousSymbol;
     if (typeof Symbol === "function" && typeof Symbol.for === "function") {
@@ -92065,28 +92065,28 @@ var require_graceful_fs = __commonJS({
     }
     function noop3() {
     }
-    function publishQueue(context5, queue2) {
+    function publishQueue(context5, queue3) {
       Object.defineProperty(context5, gracefulQueue, {
         get: function() {
-          return queue2;
+          return queue3;
         }
       });
     }
     var debug6 = noop3;
-    if (util.debuglog)
-      debug6 = util.debuglog("gfs4");
+    if (util3.debuglog)
+      debug6 = util3.debuglog("gfs4");
     else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
       debug6 = function() {
-        var m = util.format.apply(util, arguments);
+        var m = util3.format.apply(util3, arguments);
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs30[gracefulQueue]) {
-      queue = global[gracefulQueue] || [];
-      publishQueue(fs30, queue);
-      fs30.close = (function(fs$close) {
+    if (!fs31[gracefulQueue]) {
+      queue2 = global[gracefulQueue] || [];
+      publishQueue(fs31, queue2);
+      fs31.close = (function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs30, fd, function(err) {
+          return fs$close.call(fs31, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -92098,48 +92098,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      })(fs30.close);
-      fs30.closeSync = (function(fs$closeSync) {
+      })(fs31.close);
+      fs31.closeSync = (function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs30, arguments);
+          fs$closeSync.apply(fs31, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      })(fs30.closeSync);
+      })(fs31.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug6(fs30[gracefulQueue]);
-          require("assert").equal(fs30[gracefulQueue].length, 0);
+          debug6(fs31[gracefulQueue]);
+          require("assert").equal(fs31[gracefulQueue].length, 0);
         });
       }
     }
-    var queue;
+    var queue2;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs30[gracefulQueue]);
-    }
-    module2.exports = patch(clone(fs30));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs30.__patched) {
-      module2.exports = patch(fs30);
-      fs30.__patched = true;
-    }
-    function patch(fs31) {
-      polyfills(fs31);
-      fs31.gracefulify = patch;
-      fs31.createReadStream = createReadStream3;
-      fs31.createWriteStream = createWriteStream3;
-      var fs$readFile = fs31.readFile;
-      fs31.readFile = readFile;
-      function readFile(path28, options, cb) {
+      publishQueue(global, fs31[gracefulQueue]);
+    }
+    module2.exports = patch(clone(fs31));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs31.__patched) {
+      module2.exports = patch(fs31);
+      fs31.__patched = true;
+    }
+    function patch(fs32) {
+      polyfills(fs32);
+      fs32.gracefulify = patch;
+      fs32.createReadStream = createReadStream4;
+      fs32.createWriteStream = createWriteStream3;
+      var fs$readFile = fs32.readFile;
+      fs32.readFile = readFile;
+      function readFile(path29, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path28, options, cb);
-        function go$readFile(path29, options2, cb2, startTime) {
-          return fs$readFile(path29, options2, function(err) {
+        return go$readFile(path29, options, cb);
+        function go$readFile(path30, options2, cb2, startTime) {
+          return fs$readFile(path30, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path29, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path30, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -92147,16 +92147,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs31.writeFile;
-      fs31.writeFile = writeFile;
-      function writeFile(path28, data, options, cb) {
+      var fs$writeFile = fs32.writeFile;
+      fs32.writeFile = writeFile;
+      function writeFile(path29, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path28, data, options, cb);
-        function go$writeFile(path29, data2, options2, cb2, startTime) {
-          return fs$writeFile(path29, data2, options2, function(err) {
+        return go$writeFile(path29, data, options, cb);
+        function go$writeFile(path30, data2, options2, cb2, startTime) {
+          return fs$writeFile(path30, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path29, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path30, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -92164,17 +92164,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs31.appendFile;
+      var fs$appendFile = fs32.appendFile;
       if (fs$appendFile)
-        fs31.appendFile = appendFile;
-      function appendFile(path28, data, options, cb) {
+        fs32.appendFile = appendFile;
+      function appendFile(path29, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path28, data, options, cb);
-        function go$appendFile(path29, data2, options2, cb2, startTime) {
-          return fs$appendFile(path29, data2, options2, function(err) {
+        return go$appendFile(path29, data, options, cb);
+        function go$appendFile(path30, data2, options2, cb2, startTime) {
+          return fs$appendFile(path30, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path29, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path30, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -92182,9 +92182,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs31.copyFile;
+      var fs$copyFile = fs32.copyFile;
       if (fs$copyFile)
-        fs31.copyFile = copyFile2;
+        fs32.copyFile = copyFile2;
       function copyFile2(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -92202,34 +92202,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs31.readdir;
-      fs31.readdir = readdir;
+      var fs$readdir = fs32.readdir;
+      fs32.readdir = readdir3;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path28, options, cb) {
+      function readdir3(path29, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path29, options2, cb2, startTime) {
-          return fs$readdir(path29, fs$readdirCallback(
-            path29,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path30, options2, cb2, startTime) {
+          return fs$readdir(path30, fs$readdirCallback(
+            path30,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path29, options2, cb2, startTime) {
-          return fs$readdir(path29, options2, fs$readdirCallback(
-            path29,
+        } : function go$readdir2(path30, options2, cb2, startTime) {
+          return fs$readdir(path30, options2, fs$readdirCallback(
+            path30,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path28, options, cb);
-        function fs$readdirCallback(path29, options2, cb2, startTime) {
+        return go$readdir(path29, options, cb);
+        function fs$readdirCallback(path30, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path29, options2, cb2],
+                [path30, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -92244,21 +92244,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs31);
+        var legStreams = legacy(fs32);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs31.ReadStream;
+      var fs$ReadStream = fs32.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs31.WriteStream;
+      var fs$WriteStream = fs32.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs31, "ReadStream", {
+      Object.defineProperty(fs32, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -92268,7 +92268,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs31, "WriteStream", {
+      Object.defineProperty(fs32, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -92279,7 +92279,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs31, "FileReadStream", {
+      Object.defineProperty(fs32, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -92290,7 +92290,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs31, "FileWriteStream", {
+      Object.defineProperty(fs32, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -92300,7 +92300,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path28, options) {
+      function ReadStream(path29, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -92320,7 +92320,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path28, options) {
+      function WriteStream(path29, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -92338,22 +92338,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream3(path28, options) {
-        return new fs31.ReadStream(path28, options);
+      function createReadStream4(path29, options) {
+        return new fs32.ReadStream(path29, options);
       }
-      function createWriteStream3(path28, options) {
-        return new fs31.WriteStream(path28, options);
+      function createWriteStream3(path29, options) {
+        return new fs32.WriteStream(path29, options);
       }
-      var fs$open = fs31.open;
-      fs31.open = open;
-      function open(path28, flags, mode, cb) {
+      var fs$open = fs32.open;
+      fs32.open = open;
+      function open(path29, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path28, flags, mode, cb);
-        function go$open(path29, flags2, mode2, cb2, startTime) {
-          return fs$open(path29, flags2, mode2, function(err, fd) {
+        return go$open(path29, flags, mode, cb);
+        function go$open(path30, flags2, mode2, cb2, startTime) {
+          return fs$open(path30, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path29, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path30, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -92361,20 +92361,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs31;
+      return fs32;
     }
     function enqueue(elem) {
       debug6("ENQUEUE", elem[0].name, elem[1]);
-      fs30[gracefulQueue].push(elem);
+      fs31[gracefulQueue].push(elem);
       retry2();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs30[gracefulQueue].length; ++i) {
-        if (fs30[gracefulQueue][i].length > 2) {
-          fs30[gracefulQueue][i][3] = now;
-          fs30[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs31[gracefulQueue].length; ++i) {
+        if (fs31[gracefulQueue][i].length > 2) {
+          fs31[gracefulQueue][i][3] = now;
+          fs31[gracefulQueue][i][4] = now;
         }
       }
       retry2();
@@ -92382,9 +92382,9 @@ var require_graceful_fs = __commonJS({
     function retry2() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs30[gracefulQueue].length === 0)
+      if (fs31[gracefulQueue].length === 0)
         return;
-      var elem = fs30[gracefulQueue].shift();
+      var elem = fs31[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -92406,7 +92406,7 @@ var require_graceful_fs = __commonJS({
           debug6("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs30[gracefulQueue].push(elem);
+          fs31[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -92420,12 +92420,12 @@ var require_graceful_fs = __commonJS({
 var require_is_stream = __commonJS({
   "node_modules/archiver-utils/node_modules/is-stream/index.js"(exports2, module2) {
     "use strict";
-    var isStream = (stream2) => stream2 !== null && typeof stream2 === "object" && typeof stream2.pipe === "function";
-    isStream.writable = (stream2) => isStream(stream2) && stream2.writable !== false && typeof stream2._write === "function" && typeof stream2._writableState === "object";
-    isStream.readable = (stream2) => isStream(stream2) && stream2.readable !== false && typeof stream2._read === "function" && typeof stream2._readableState === "object";
-    isStream.duplex = (stream2) => isStream.writable(stream2) && isStream.readable(stream2);
-    isStream.transform = (stream2) => isStream.duplex(stream2) && typeof stream2._transform === "function";
-    module2.exports = isStream;
+    var isStream2 = (stream2) => stream2 !== null && typeof stream2 === "object" && typeof stream2.pipe === "function";
+    isStream2.writable = (stream2) => isStream2(stream2) && stream2.writable !== false && typeof stream2._write === "function" && typeof stream2._writableState === "object";
+    isStream2.readable = (stream2) => isStream2(stream2) && stream2.readable !== false && typeof stream2._read === "function" && typeof stream2._readableState === "object";
+    isStream2.duplex = (stream2) => isStream2.writable(stream2) && isStream2.readable(stream2);
+    isStream2.transform = (stream2) => isStream2.duplex(stream2) && typeof stream2._transform === "function";
+    module2.exports = isStream2;
   }
 });
 
@@ -92623,24 +92623,28 @@ var require_inherits_browser = __commonJS({
   "node_modules/inherits/inherits_browser.js"(exports2, module2) {
     if (typeof Object.create === "function") {
       module2.exports = function inherits(ctor, superCtor) {
-        ctor.super_ = superCtor;
-        ctor.prototype = Object.create(superCtor.prototype, {
-          constructor: {
-            value: ctor,
-            enumerable: false,
-            writable: true,
-            configurable: true
-          }
-        });
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          ctor.prototype = Object.create(superCtor.prototype, {
+            constructor: {
+              value: ctor,
+              enumerable: false,
+              writable: true,
+              configurable: true
+            }
+          });
+        }
       };
     } else {
       module2.exports = function inherits(ctor, superCtor) {
-        ctor.super_ = superCtor;
-        var TempCtor = function() {
-        };
-        TempCtor.prototype = superCtor.prototype;
-        ctor.prototype = new TempCtor();
-        ctor.prototype.constructor = ctor;
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          var TempCtor = function() {
+          };
+          TempCtor.prototype = superCtor.prototype;
+          ctor.prototype = new TempCtor();
+          ctor.prototype.constructor = ctor;
+        }
       };
     }
   }
@@ -92650,13 +92654,13 @@ var require_inherits_browser = __commonJS({
 var require_inherits = __commonJS({
   "node_modules/inherits/inherits.js"(exports2, module2) {
     try {
-      util = require("util");
-      if (typeof util.inherits !== "function") throw "";
-      module2.exports = util.inherits;
+      util3 = require("util");
+      if (typeof util3.inherits !== "function") throw "";
+      module2.exports = util3.inherits;
     } catch (e) {
       module2.exports = require_inherits_browser();
     }
-    var util;
+    var util3;
   }
 });
 
@@ -92670,7 +92674,7 @@ var require_BufferList = __commonJS({
       }
     }
     var Buffer2 = require_safe_buffer().Buffer;
-    var util = require("util");
+    var util3 = require("util");
     function copyBuffer(src, target, offset) {
       src.copy(target, offset);
     }
@@ -92729,9 +92733,9 @@ var require_BufferList = __commonJS({
       };
       return BufferList;
     })();
-    if (util && util.inspect && util.inspect.custom) {
-      module2.exports.prototype[util.inspect.custom] = function() {
-        var obj = util.inspect({ length: this.length });
+    if (util3 && util3.inspect && util3.inspect.custom) {
+      module2.exports.prototype[util3.inspect.custom] = function() {
+        var obj = util3.inspect({ length: this.length });
         return this.constructor.name + " " + obj;
       };
     }
@@ -92831,8 +92835,8 @@ var require_stream_writable = __commonJS({
     var asyncWrite = !process.browser && ["v0.10", "v0.9."].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;
     var Duplex;
     Writable.WritableState = WritableState;
-    var util = Object.create(require_util12());
-    util.inherits = require_inherits();
+    var util3 = Object.create(require_util12());
+    util3.inherits = require_inherits();
     var internalUtil = {
       deprecate: require_node2()
     };
@@ -92847,7 +92851,7 @@ var require_stream_writable = __commonJS({
       return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
     }
     var destroyImpl = require_destroy();
-    util.inherits(Writable, Stream);
+    util3.inherits(Writable, Stream);
     function nop() {
     }
     function WritableState(options, stream2) {
@@ -93267,11 +93271,11 @@ var require_stream_duplex = __commonJS({
       return keys2;
     };
     module2.exports = Duplex;
-    var util = Object.create(require_util12());
-    util.inherits = require_inherits();
-    var Readable2 = require_stream_readable();
+    var util3 = Object.create(require_util12());
+    util3.inherits = require_inherits();
+    var Readable3 = require_stream_readable();
     var Writable = require_stream_writable();
-    util.inherits(Duplex, Readable2);
+    util3.inherits(Duplex, Readable3);
     {
       keys = objectKeys(Writable.prototype);
       for (v = 0; v < keys.length; v++) {
@@ -93284,7 +93288,7 @@ var require_stream_duplex = __commonJS({
     var v;
     function Duplex(options) {
       if (!(this instanceof Duplex)) return new Duplex(options);
-      Readable2.call(this, options);
+      Readable3.call(this, options);
       Writable.call(this, options);
       if (options && options.readable === false) this.readable = false;
       if (options && options.writable === false) this.writable = false;
@@ -93574,10 +93578,10 @@ var require_stream_readable = __commonJS({
   "node_modules/lazystream/node_modules/readable-stream/lib/_stream_readable.js"(exports2, module2) {
     "use strict";
     var pna = require_process_nextick_args();
-    module2.exports = Readable2;
+    module2.exports = Readable3;
     var isArray2 = require_isarray();
     var Duplex;
-    Readable2.ReadableState = ReadableState;
+    Readable3.ReadableState = ReadableState;
     var EE = require("events").EventEmitter;
     var EElistenerCount = function(emitter, type) {
       return emitter.listeners(type).length;
@@ -93592,8 +93596,8 @@ var require_stream_readable = __commonJS({
     function _isUint8Array(obj) {
       return Buffer2.isBuffer(obj) || obj instanceof OurUint8Array;
     }
-    var util = Object.create(require_util12());
-    util.inherits = require_inherits();
+    var util3 = Object.create(require_util12());
+    util3.inherits = require_inherits();
     var debugUtil = require("util");
     var debug6 = void 0;
     if (debugUtil && debugUtil.debuglog) {
@@ -93605,7 +93609,7 @@ var require_stream_readable = __commonJS({
     var BufferList = require_BufferList();
     var destroyImpl = require_destroy();
     var StringDecoder;
-    util.inherits(Readable2, Stream);
+    util3.inherits(Readable3, Stream);
     var kProxyEvents = ["error", "close", "destroy", "pause", "resume"];
     function prependListener(emitter, event, fn) {
       if (typeof emitter.prependListener === "function") return emitter.prependListener(event, fn);
@@ -93651,9 +93655,9 @@ var require_stream_readable = __commonJS({
         this.encoding = options.encoding;
       }
     }
-    function Readable2(options) {
+    function Readable3(options) {
       Duplex = Duplex || require_stream_duplex();
-      if (!(this instanceof Readable2)) return new Readable2(options);
+      if (!(this instanceof Readable3)) return new Readable3(options);
       this._readableState = new ReadableState(options, this);
       this.readable = true;
       if (options) {
@@ -93662,7 +93666,7 @@ var require_stream_readable = __commonJS({
       }
       Stream.call(this);
     }
-    Object.defineProperty(Readable2.prototype, "destroyed", {
+    Object.defineProperty(Readable3.prototype, "destroyed", {
       get: function() {
         if (this._readableState === void 0) {
           return false;
@@ -93676,13 +93680,13 @@ var require_stream_readable = __commonJS({
         this._readableState.destroyed = value;
       }
     });
-    Readable2.prototype.destroy = destroyImpl.destroy;
-    Readable2.prototype._undestroy = destroyImpl.undestroy;
-    Readable2.prototype._destroy = function(err, cb) {
+    Readable3.prototype.destroy = destroyImpl.destroy;
+    Readable3.prototype._undestroy = destroyImpl.undestroy;
+    Readable3.prototype._destroy = function(err, cb) {
       this.push(null);
       cb(err);
     };
-    Readable2.prototype.push = function(chunk, encoding) {
+    Readable3.prototype.push = function(chunk, encoding) {
       var state = this._readableState;
       var skipChunkCheck;
       if (!state.objectMode) {
@@ -93699,7 +93703,7 @@ var require_stream_readable = __commonJS({
       }
       return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
     };
-    Readable2.prototype.unshift = function(chunk) {
+    Readable3.prototype.unshift = function(chunk) {
       return readableAddChunk(this, chunk, null, true, false);
     };
     function readableAddChunk(stream2, chunk, encoding, addToFront, skipChunkCheck) {
@@ -93759,10 +93763,10 @@ var require_stream_readable = __commonJS({
     function needMoreData(state) {
       return !state.ended && (state.needReadable || state.length < state.highWaterMark || state.length === 0);
     }
-    Readable2.prototype.isPaused = function() {
+    Readable3.prototype.isPaused = function() {
       return this._readableState.flowing === false;
     };
-    Readable2.prototype.setEncoding = function(enc) {
+    Readable3.prototype.setEncoding = function(enc) {
       if (!StringDecoder) StringDecoder = require_string_decoder().StringDecoder;
       this._readableState.decoder = new StringDecoder(enc);
       this._readableState.encoding = enc;
@@ -93798,7 +93802,7 @@ var require_stream_readable = __commonJS({
       }
       return state.length;
     }
-    Readable2.prototype.read = function(n) {
+    Readable3.prototype.read = function(n) {
       debug6("read", n);
       n = parseInt(n, 10);
       var state = this._readableState;
@@ -93893,10 +93897,10 @@ var require_stream_readable = __commonJS({
       }
       state.readingMore = false;
     }
-    Readable2.prototype._read = function(n) {
+    Readable3.prototype._read = function(n) {
       this.emit("error", new Error("_read() is not implemented"));
     };
-    Readable2.prototype.pipe = function(dest, pipeOpts) {
+    Readable3.prototype.pipe = function(dest, pipeOpts) {
       var src = this;
       var state = this._readableState;
       switch (state.pipesCount) {
@@ -94001,7 +94005,7 @@ var require_stream_readable = __commonJS({
         }
       };
     }
-    Readable2.prototype.unpipe = function(dest) {
+    Readable3.prototype.unpipe = function(dest) {
       var state = this._readableState;
       var unpipeInfo = { hasUnpiped: false };
       if (state.pipesCount === 0) return this;
@@ -94025,15 +94029,15 @@ var require_stream_readable = __commonJS({
         }
         return this;
       }
-      var index = indexOf(state.pipes, dest);
-      if (index === -1) return this;
-      state.pipes.splice(index, 1);
+      var index2 = indexOf(state.pipes, dest);
+      if (index2 === -1) return this;
+      state.pipes.splice(index2, 1);
       state.pipesCount -= 1;
       if (state.pipesCount === 1) state.pipes = state.pipes[0];
       dest.emit("unpipe", this, unpipeInfo);
       return this;
     };
-    Readable2.prototype.on = function(ev, fn) {
+    Readable3.prototype.on = function(ev, fn) {
       var res = Stream.prototype.on.call(this, ev, fn);
       if (ev === "data") {
         if (this._readableState.flowing !== false) this.resume();
@@ -94051,12 +94055,12 @@ var require_stream_readable = __commonJS({
       }
       return res;
     };
-    Readable2.prototype.addListener = Readable2.prototype.on;
+    Readable3.prototype.addListener = Readable3.prototype.on;
     function nReadingNextTick(self2) {
       debug6("readable nexttick read 0");
       self2.read(0);
     }
-    Readable2.prototype.resume = function() {
+    Readable3.prototype.resume = function() {
       var state = this._readableState;
       if (!state.flowing) {
         debug6("resume");
@@ -94082,7 +94086,7 @@ var require_stream_readable = __commonJS({
       flow(stream2);
       if (state.flowing && !state.reading) stream2.read(0);
     }
-    Readable2.prototype.pause = function() {
+    Readable3.prototype.pause = function() {
       debug6("call pause flowing=%j", this._readableState.flowing);
       if (false !== this._readableState.flowing) {
         debug6("pause");
@@ -94097,7 +94101,7 @@ var require_stream_readable = __commonJS({
       while (state.flowing && stream2.read() !== null) {
       }
     }
-    Readable2.prototype.wrap = function(stream2) {
+    Readable3.prototype.wrap = function(stream2) {
       var _this = this;
       var state = this._readableState;
       var paused = false;
@@ -94141,7 +94145,7 @@ var require_stream_readable = __commonJS({
       };
       return this;
     };
-    Object.defineProperty(Readable2.prototype, "readableHighWaterMark", {
+    Object.defineProperty(Readable3.prototype, "readableHighWaterMark", {
       // making it explicit this property is not enumerable
       // because otherwise some prototype manipulation in
       // userland will fail
@@ -94150,7 +94154,7 @@ var require_stream_readable = __commonJS({
         return this._readableState.highWaterMark;
       }
     });
-    Readable2._fromList = fromList;
+    Readable3._fromList = fromList;
     function fromList(n, state) {
       if (state.length === 0) return null;
       var ret;
@@ -94259,11 +94263,11 @@ var require_stream_readable = __commonJS({
 var require_stream_transform = __commonJS({
   "node_modules/lazystream/node_modules/readable-stream/lib/_stream_transform.js"(exports2, module2) {
     "use strict";
-    module2.exports = Transform;
+    module2.exports = Transform5;
     var Duplex = require_stream_duplex();
-    var util = Object.create(require_util12());
-    util.inherits = require_inherits();
-    util.inherits(Transform, Duplex);
+    var util3 = Object.create(require_util12());
+    util3.inherits = require_inherits();
+    util3.inherits(Transform5, Duplex);
     function afterTransform(er, data) {
       var ts = this._transformState;
       ts.transforming = false;
@@ -94282,8 +94286,8 @@ var require_stream_transform = __commonJS({
         this._read(rs.highWaterMark);
       }
     }
-    function Transform(options) {
-      if (!(this instanceof Transform)) return new Transform(options);
+    function Transform5(options) {
+      if (!(this instanceof Transform5)) return new Transform5(options);
       Duplex.call(this, options);
       this._transformState = {
         afterTransform: afterTransform.bind(this),
@@ -94311,14 +94315,14 @@ var require_stream_transform = __commonJS({
         done(this, null, null);
       }
     }
-    Transform.prototype.push = function(chunk, encoding) {
+    Transform5.prototype.push = function(chunk, encoding) {
       this._transformState.needTransform = false;
       return Duplex.prototype.push.call(this, chunk, encoding);
     };
-    Transform.prototype._transform = function(chunk, encoding, cb) {
+    Transform5.prototype._transform = function(chunk, encoding, cb) {
       throw new Error("_transform() is not implemented");
     };
-    Transform.prototype._write = function(chunk, encoding, cb) {
+    Transform5.prototype._write = function(chunk, encoding, cb) {
       var ts = this._transformState;
       ts.writecb = cb;
       ts.writechunk = chunk;
@@ -94328,7 +94332,7 @@ var require_stream_transform = __commonJS({
         if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
       }
     };
-    Transform.prototype._read = function(n) {
+    Transform5.prototype._read = function(n) {
       var ts = this._transformState;
       if (ts.writechunk !== null && ts.writecb && !ts.transforming) {
         ts.transforming = true;
@@ -94337,7 +94341,7 @@ var require_stream_transform = __commonJS({
         ts.needTransform = true;
       }
     };
-    Transform.prototype._destroy = function(err, cb) {
+    Transform5.prototype._destroy = function(err, cb) {
       var _this2 = this;
       Duplex.prototype._destroy.call(this, err, function(err2) {
         cb(err2);
@@ -94359,16 +94363,16 @@ var require_stream_transform = __commonJS({
 var require_stream_passthrough = __commonJS({
   "node_modules/lazystream/node_modules/readable-stream/lib/_stream_passthrough.js"(exports2, module2) {
     "use strict";
-    module2.exports = PassThrough;
-    var Transform = require_stream_transform();
-    var util = Object.create(require_util12());
-    util.inherits = require_inherits();
-    util.inherits(PassThrough, Transform);
-    function PassThrough(options) {
-      if (!(this instanceof PassThrough)) return new PassThrough(options);
-      Transform.call(this, options);
+    module2.exports = PassThrough3;
+    var Transform5 = require_stream_transform();
+    var util3 = Object.create(require_util12());
+    util3.inherits = require_inherits();
+    util3.inherits(PassThrough3, Transform5);
+    function PassThrough3(options) {
+      if (!(this instanceof PassThrough3)) return new PassThrough3(options);
+      Transform5.call(this, options);
     }
-    PassThrough.prototype._transform = function(chunk, encoding, cb) {
+    PassThrough3.prototype._transform = function(chunk, encoding, cb) {
       cb(null, chunk);
     };
   }
@@ -94409,14 +94413,14 @@ var require_passthrough = __commonJS({
 // node_modules/lazystream/lib/lazystream.js
 var require_lazystream = __commonJS({
   "node_modules/lazystream/lib/lazystream.js"(exports2, module2) {
-    var util = require("util");
-    var PassThrough = require_passthrough();
+    var util3 = require("util");
+    var PassThrough3 = require_passthrough();
     module2.exports = {
-      Readable: Readable2,
+      Readable: Readable3,
       Writable
     };
-    util.inherits(Readable2, PassThrough);
-    util.inherits(Writable, PassThrough);
+    util3.inherits(Readable3, PassThrough3);
+    util3.inherits(Writable, PassThrough3);
     function beforeFirstCall(instance, method, callback) {
       instance[method] = function() {
         delete instance[method];
@@ -94424,10 +94428,10 @@ var require_lazystream = __commonJS({
         return this[method].apply(this, arguments);
       };
     }
-    function Readable2(fn, options) {
-      if (!(this instanceof Readable2))
-        return new Readable2(fn, options);
-      PassThrough.call(this, options);
+    function Readable3(fn, options) {
+      if (!(this instanceof Readable3))
+        return new Readable3(fn, options);
+      PassThrough3.call(this, options);
       beforeFirstCall(this, "_read", function() {
         var source = fn.call(this, options);
         var emit = this.emit.bind(this, "error");
@@ -94439,7 +94443,7 @@ var require_lazystream = __commonJS({
     function Writable(fn, options) {
       if (!(this instanceof Writable))
         return new Writable(fn, options);
-      PassThrough.call(this, options);
+      PassThrough3.call(this, options);
       beforeFirstCall(this, "_write", function() {
         var destination = fn.call(this, options);
         var emit = this.emit.bind(this, "error");
@@ -94454,22 +94458,22 @@ var require_lazystream = __commonJS({
 // node_modules/normalize-path/index.js
 var require_normalize_path = __commonJS({
   "node_modules/normalize-path/index.js"(exports2, module2) {
-    module2.exports = function(path28, stripTrailing) {
-      if (typeof path28 !== "string") {
+    module2.exports = function(path29, stripTrailing) {
+      if (typeof path29 !== "string") {
         throw new TypeError("expected path to be a string");
       }
-      if (path28 === "\\" || path28 === "/") return "/";
-      var len = path28.length;
-      if (len <= 1) return path28;
+      if (path29 === "\\" || path29 === "/") return "/";
+      var len = path29.length;
+      if (len <= 1) return path29;
       var prefix = "";
-      if (len > 4 && path28[3] === "\\") {
-        var ch = path28[2];
-        if ((ch === "?" || ch === ".") && path28.slice(0, 2) === "\\\\") {
-          path28 = path28.slice(2);
+      if (len > 4 && path29[3] === "\\") {
+        var ch = path29[2];
+        if ((ch === "?" || ch === ".") && path29.slice(0, 2) === "\\\\") {
+          path29 = path29.slice(2);
           prefix = "//";
         }
       }
-      var segs = path28.split(/[/\\]+/);
+      var segs = path29.split(/[/\\]+/);
       if (stripTrailing !== false && segs[segs.length - 1] === "") {
         segs.pop();
       }
@@ -94516,14 +94520,14 @@ var require_overRest = __commonJS({
     function overRest(func, start, transform) {
       start = nativeMax(start === void 0 ? func.length - 1 : start, 0);
       return function() {
-        var args = arguments, index = -1, length = nativeMax(args.length - start, 0), array = Array(length);
-        while (++index < length) {
-          array[index] = args[start + index];
+        var args = arguments, index2 = -1, length = nativeMax(args.length - start, 0), array = Array(length);
+        while (++index2 < length) {
+          array[index2] = args[start + index2];
         }
-        index = -1;
+        index2 = -1;
         var otherArgs = Array(start + 1);
-        while (++index < start) {
-          otherArgs[index] = args[index];
+        while (++index2 < start) {
+          otherArgs[index2] = args[index2];
         }
         otherArgs[start] = transform(array);
         return apply(func, this, otherArgs);
@@ -94895,13 +94899,13 @@ var require_isIterateeCall = __commonJS({
     var isArrayLike = require_isArrayLike();
     var isIndex = require_isIndex();
     var isObject2 = require_isObject();
-    function isIterateeCall(value, index, object) {
+    function isIterateeCall(value, index2, object) {
       if (!isObject2(object)) {
         return false;
       }
-      var type = typeof index;
-      if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
-        return eq(object[index], value);
+      var type = typeof index2;
+      if (type == "number" ? isArrayLike(object) && isIndex(index2, object.length) : type == "string" && index2 in object) {
+        return eq(object[index2], value);
       }
       return false;
     }
@@ -94913,9 +94917,9 @@ var require_isIterateeCall = __commonJS({
 var require_baseTimes = __commonJS({
   "node_modules/lodash/_baseTimes.js"(exports2, module2) {
     function baseTimes(n, iteratee) {
-      var index = -1, result = Array(n);
-      while (++index < n) {
-        result[index] = iteratee(index);
+      var index2 = -1, result = Array(n);
+      while (++index2 < n) {
+        result[index2] = iteratee(index2);
       }
       return result;
     }
@@ -95058,9 +95062,9 @@ var require_nodeUtil = __commonJS({
     var freeProcess = moduleExports && freeGlobal.process;
     var nodeUtil = (function() {
       try {
-        var types2 = freeModule && freeModule.require && freeModule.require("util").types;
-        if (types2) {
-          return types2;
+        var types3 = freeModule && freeModule.require && freeModule.require("util").types;
+        if (types3) {
+          return types3;
         }
         return freeProcess && freeProcess.binding && freeProcess.binding("util");
       } catch (e) {
@@ -95184,16 +95188,16 @@ var require_defaults = __commonJS({
     var keysIn = require_keysIn();
     var objectProto = Object.prototype;
     var hasOwnProperty = objectProto.hasOwnProperty;
-    var defaults = baseRest(function(object, sources) {
+    var defaults2 = baseRest(function(object, sources) {
       object = Object(object);
-      var index = -1;
+      var index2 = -1;
       var length = sources.length;
       var guard = length > 2 ? sources[2] : void 0;
       if (guard && isIterateeCall(sources[0], sources[1], guard)) {
         length = 1;
       }
-      while (++index < length) {
-        var source = sources[index];
+      while (++index2 < length) {
+        var source = sources[index2];
         var props = keysIn(source);
         var propsIndex = -1;
         var propsLength = props.length;
@@ -95207,7 +95211,7 @@ var require_defaults = __commonJS({
       }
       return object;
     });
-    module2.exports = defaults;
+    module2.exports = defaults2;
   }
 });
 
@@ -95215,7 +95219,23 @@ var require_defaults = __commonJS({
 var require_primordials = __commonJS({
   "node_modules/readable-stream/lib/ours/primordials.js"(exports2, module2) {
     "use strict";
+    var AggregateError = class extends Error {
+      constructor(errors) {
+        if (!Array.isArray(errors)) {
+          throw new TypeError(`Expected input to be an Array, got ${typeof errors}`);
+        }
+        let message = "";
+        for (let i = 0; i < errors.length; i++) {
+          message += `    ${errors[i].stack}
+`;
+        }
+        super(message);
+        this.name = "AggregateError";
+        this.errors = errors;
+      }
+    };
     module2.exports = {
+      AggregateError,
       ArrayIsArray(self2) {
         return Array.isArray(self2);
       },
@@ -95225,8 +95245,8 @@ var require_primordials = __commonJS({
       ArrayPrototypeIndexOf(self2, el) {
         return self2.indexOf(el);
       },
-      ArrayPrototypeJoin(self2, sep6) {
-        return self2.join(sep6);
+      ArrayPrototypeJoin(self2, sep7) {
+        return self2.join(sep7);
       },
       ArrayPrototypeMap(self2, fn) {
         return self2.map(fn);
@@ -95316,6 +95336,375 @@ var require_primordials = __commonJS({
   }
 });
 
+// node_modules/readable-stream/lib/ours/util/inspect.js
+var require_inspect2 = __commonJS({
+  "node_modules/readable-stream/lib/ours/util/inspect.js"(exports2, module2) {
+    "use strict";
+    module2.exports = {
+      format(format, ...args) {
+        return format.replace(/%([sdifj])/g, function(...[_unused, type]) {
+          const replacement = args.shift();
+          if (type === "f") {
+            return replacement.toFixed(6);
+          } else if (type === "j") {
+            return JSON.stringify(replacement);
+          } else if (type === "s" && typeof replacement === "object") {
+            const ctor = replacement.constructor !== Object ? replacement.constructor.name : "";
+            return `${ctor} {}`.trim();
+          } else {
+            return replacement.toString();
+          }
+        });
+      },
+      inspect(value) {
+        switch (typeof value) {
+          case "string":
+            if (value.includes("'")) {
+              if (!value.includes('"')) {
+                return `"${value}"`;
+              } else if (!value.includes("`") && !value.includes("${")) {
+                return `\`${value}\``;
+              }
+            }
+            return `'${value}'`;
+          case "number":
+            if (isNaN(value)) {
+              return "NaN";
+            } else if (Object.is(value, -0)) {
+              return String(value);
+            }
+            return value;
+          case "bigint":
+            return `${String(value)}n`;
+          case "boolean":
+          case "undefined":
+            return String(value);
+          case "object":
+            return "{}";
+        }
+      }
+    };
+  }
+});
+
+// node_modules/readable-stream/lib/ours/errors.js
+var require_errors4 = __commonJS({
+  "node_modules/readable-stream/lib/ours/errors.js"(exports2, module2) {
+    "use strict";
+    var { format, inspect } = require_inspect2();
+    var { AggregateError: CustomAggregateError } = require_primordials();
+    var AggregateError = globalThis.AggregateError || CustomAggregateError;
+    var kIsNodeError = /* @__PURE__ */ Symbol("kIsNodeError");
+    var kTypes = [
+      "string",
+      "function",
+      "number",
+      "object",
+      // Accept 'Function' and 'Object' as alternative to the lower cased version.
+      "Function",
+      "Object",
+      "boolean",
+      "bigint",
+      "symbol"
+    ];
+    var classRegExp = /^([A-Z][a-z0-9]*)+$/;
+    var nodeInternalPrefix = "__node_internal_";
+    var codes = {};
+    function assert(value, message) {
+      if (!value) {
+        throw new codes.ERR_INTERNAL_ASSERTION(message);
+      }
+    }
+    function addNumericalSeparator(val) {
+      let res = "";
+      let i = val.length;
+      const start = val[0] === "-" ? 1 : 0;
+      for (; i >= start + 4; i -= 3) {
+        res = `_${val.slice(i - 3, i)}${res}`;
+      }
+      return `${val.slice(0, i)}${res}`;
+    }
+    function getMessage(key, msg, args) {
+      if (typeof msg === "function") {
+        assert(
+          msg.length <= args.length,
+          // Default options do not count.
+          `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${msg.length}).`
+        );
+        return msg(...args);
+      }
+      const expectedLength = (msg.match(/%[dfijoOs]/g) || []).length;
+      assert(
+        expectedLength === args.length,
+        `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`
+      );
+      if (args.length === 0) {
+        return msg;
+      }
+      return format(msg, ...args);
+    }
+    function E(code, message, Base) {
+      if (!Base) {
+        Base = Error;
+      }
+      class NodeError extends Base {
+        constructor(...args) {
+          super(getMessage(code, message, args));
+        }
+        toString() {
+          return `${this.name} [${code}]: ${this.message}`;
+        }
+      }
+      Object.defineProperties(NodeError.prototype, {
+        name: {
+          value: Base.name,
+          writable: true,
+          enumerable: false,
+          configurable: true
+        },
+        toString: {
+          value() {
+            return `${this.name} [${code}]: ${this.message}`;
+          },
+          writable: true,
+          enumerable: false,
+          configurable: true
+        }
+      });
+      NodeError.prototype.code = code;
+      NodeError.prototype[kIsNodeError] = true;
+      codes[code] = NodeError;
+    }
+    function hideStackFrames(fn) {
+      const hidden = nodeInternalPrefix + fn.name;
+      Object.defineProperty(fn, "name", {
+        value: hidden
+      });
+      return fn;
+    }
+    function aggregateTwoErrors(innerError, outerError) {
+      if (innerError && outerError && innerError !== outerError) {
+        if (Array.isArray(outerError.errors)) {
+          outerError.errors.push(innerError);
+          return outerError;
+        }
+        const err = new AggregateError([outerError, innerError], outerError.message);
+        err.code = outerError.code;
+        return err;
+      }
+      return innerError || outerError;
+    }
+    var AbortError = class extends Error {
+      constructor(message = "The operation was aborted", options = void 0) {
+        if (options !== void 0 && typeof options !== "object") {
+          throw new codes.ERR_INVALID_ARG_TYPE("options", "Object", options);
+        }
+        super(message, options);
+        this.code = "ABORT_ERR";
+        this.name = "AbortError";
+      }
+    };
+    E("ERR_ASSERTION", "%s", Error);
+    E(
+      "ERR_INVALID_ARG_TYPE",
+      (name, expected, actual) => {
+        assert(typeof name === "string", "'name' must be a string");
+        if (!Array.isArray(expected)) {
+          expected = [expected];
+        }
+        let msg = "The ";
+        if (name.endsWith(" argument")) {
+          msg += `${name} `;
+        } else {
+          msg += `"${name}" ${name.includes(".") ? "property" : "argument"} `;
+        }
+        msg += "must be ";
+        const types3 = [];
+        const instances = [];
+        const other = [];
+        for (const value of expected) {
+          assert(typeof value === "string", "All expected entries have to be of type string");
+          if (kTypes.includes(value)) {
+            types3.push(value.toLowerCase());
+          } else if (classRegExp.test(value)) {
+            instances.push(value);
+          } else {
+            assert(value !== "object", 'The value "object" should be written as "Object"');
+            other.push(value);
+          }
+        }
+        if (instances.length > 0) {
+          const pos = types3.indexOf("object");
+          if (pos !== -1) {
+            types3.splice(types3, pos, 1);
+            instances.push("Object");
+          }
+        }
+        if (types3.length > 0) {
+          switch (types3.length) {
+            case 1:
+              msg += `of type ${types3[0]}`;
+              break;
+            case 2:
+              msg += `one of type ${types3[0]} or ${types3[1]}`;
+              break;
+            default: {
+              const last = types3.pop();
+              msg += `one of type ${types3.join(", ")}, or ${last}`;
+            }
+          }
+          if (instances.length > 0 || other.length > 0) {
+            msg += " or ";
+          }
+        }
+        if (instances.length > 0) {
+          switch (instances.length) {
+            case 1:
+              msg += `an instance of ${instances[0]}`;
+              break;
+            case 2:
+              msg += `an instance of ${instances[0]} or ${instances[1]}`;
+              break;
+            default: {
+              const last = instances.pop();
+              msg += `an instance of ${instances.join(", ")}, or ${last}`;
+            }
+          }
+          if (other.length > 0) {
+            msg += " or ";
+          }
+        }
+        switch (other.length) {
+          case 0:
+            break;
+          case 1:
+            if (other[0].toLowerCase() !== other[0]) {
+              msg += "an ";
+            }
+            msg += `${other[0]}`;
+            break;
+          case 2:
+            msg += `one of ${other[0]} or ${other[1]}`;
+            break;
+          default: {
+            const last = other.pop();
+            msg += `one of ${other.join(", ")}, or ${last}`;
+          }
+        }
+        if (actual == null) {
+          msg += `. Received ${actual}`;
+        } else if (typeof actual === "function" && actual.name) {
+          msg += `. Received function ${actual.name}`;
+        } else if (typeof actual === "object") {
+          var _actual$constructor;
+          if ((_actual$constructor = actual.constructor) !== null && _actual$constructor !== void 0 && _actual$constructor.name) {
+            msg += `. Received an instance of ${actual.constructor.name}`;
+          } else {
+            const inspected = inspect(actual, {
+              depth: -1
+            });
+            msg += `. Received ${inspected}`;
+          }
+        } else {
+          let inspected = inspect(actual, {
+            colors: false
+          });
+          if (inspected.length > 25) {
+            inspected = `${inspected.slice(0, 25)}...`;
+          }
+          msg += `. Received type ${typeof actual} (${inspected})`;
+        }
+        return msg;
+      },
+      TypeError
+    );
+    E(
+      "ERR_INVALID_ARG_VALUE",
+      (name, value, reason = "is invalid") => {
+        let inspected = inspect(value);
+        if (inspected.length > 128) {
+          inspected = inspected.slice(0, 128) + "...";
+        }
+        const type = name.includes(".") ? "property" : "argument";
+        return `The ${type} '${name}' ${reason}. Received ${inspected}`;
+      },
+      TypeError
+    );
+    E(
+      "ERR_INVALID_RETURN_VALUE",
+      (input, name, value) => {
+        var _value$constructor;
+        const type = value !== null && value !== void 0 && (_value$constructor = value.constructor) !== null && _value$constructor !== void 0 && _value$constructor.name ? `instance of ${value.constructor.name}` : `type ${typeof value}`;
+        return `Expected ${input} to be returned from the "${name}" function but got ${type}.`;
+      },
+      TypeError
+    );
+    E(
+      "ERR_MISSING_ARGS",
+      (...args) => {
+        assert(args.length > 0, "At least one arg needs to be specified");
+        let msg;
+        const len = args.length;
+        args = (Array.isArray(args) ? args : [args]).map((a) => `"${a}"`).join(" or ");
+        switch (len) {
+          case 1:
+            msg += `The ${args[0]} argument`;
+            break;
+          case 2:
+            msg += `The ${args[0]} and ${args[1]} arguments`;
+            break;
+          default:
+            {
+              const last = args.pop();
+              msg += `The ${args.join(", ")}, and ${last} arguments`;
+            }
+            break;
+        }
+        return `${msg} must be specified`;
+      },
+      TypeError
+    );
+    E(
+      "ERR_OUT_OF_RANGE",
+      (str, range2, input) => {
+        assert(range2, 'Missing "range" argument');
+        let received;
+        if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
+          received = addNumericalSeparator(String(input));
+        } else if (typeof input === "bigint") {
+          received = String(input);
+          const limit = BigInt(2) ** BigInt(32);
+          if (input > limit || input < -limit) {
+            received = addNumericalSeparator(received);
+          }
+          received += "n";
+        } else {
+          received = inspect(input);
+        }
+        return `The value of "${str}" is out of range. It must be ${range2}. Received ${received}`;
+      },
+      RangeError
+    );
+    E("ERR_MULTIPLE_CALLBACK", "Callback called multiple times", Error);
+    E("ERR_METHOD_NOT_IMPLEMENTED", "The %s method is not implemented", Error);
+    E("ERR_STREAM_ALREADY_FINISHED", "Cannot call %s after a stream was finished", Error);
+    E("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable", Error);
+    E("ERR_STREAM_DESTROYED", "Cannot call %s after a stream was destroyed", Error);
+    E("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
+    E("ERR_STREAM_PREMATURE_CLOSE", "Premature close", Error);
+    E("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF", Error);
+    E("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event", Error);
+    E("ERR_STREAM_WRITE_AFTER_END", "write after end", Error);
+    E("ERR_UNKNOWN_ENCODING", "Unknown encoding: %s", TypeError);
+    module2.exports = {
+      AbortError,
+      aggregateTwoErrors: hideStackFrames(aggregateTwoErrors),
+      hideStackFrames,
+      codes
+    };
+  }
+});
+
 // node_modules/event-target-shim/dist/event-target-shim.js
 var require_event_target_shim = __commonJS({
   "node_modules/event-target-shim/dist/event-target-shim.js"(exports2, module2) {
@@ -95736,11 +96125,11 @@ var require_event_target_shim = __commonJS({
         return defineCustomEventTarget(arguments[0]);
       }
       if (arguments.length > 0) {
-        const types2 = new Array(arguments.length);
+        const types3 = new Array(arguments.length);
         for (let i = 0; i < arguments.length; ++i) {
-          types2[i] = arguments[i];
+          types3[i] = arguments[i];
         }
-        return defineCustomEventTarget(types2);
+        return defineCustomEventTarget(types3);
       }
       throw new TypeError("Cannot call a class as a function");
     }
@@ -95989,7 +96378,11 @@ var require_util13 = __commonJS({
   "node_modules/readable-stream/lib/ours/util.js"(exports2, module2) {
     "use strict";
     var bufferModule = require("buffer");
-    var { kResistStopPropagation, SymbolDispose } = require_primordials();
+    var { format, inspect } = require_inspect2();
+    var {
+      codes: { ERR_INVALID_ARG_TYPE }
+    } = require_errors4();
+    var { kResistStopPropagation, AggregateError, SymbolDispose } = require_primordials();
     var AbortSignal2 = globalThis.AbortSignal || require_abort_controller().AbortSignal;
     var AbortController2 = globalThis.AbortController || require_abort_controller().AbortController;
     var AsyncFunction = Object.getPrototypeOf(async function() {
@@ -96006,21 +96399,8 @@ var require_util13 = __commonJS({
       }
     };
     var validateFunction = (value, name) => {
-      if (typeof value !== "function") throw new ERR_INVALID_ARG_TYPE(name, "Function", value);
-    };
-    var AggregateError = class extends Error {
-      constructor(errors) {
-        if (!Array.isArray(errors)) {
-          throw new TypeError(`Expected input to be an Array, got ${typeof errors}`);
-        }
-        let message = "";
-        for (let i = 0; i < errors.length; i++) {
-          message += `    ${errors[i].stack}
-`;
-        }
-        super(message);
-        this.name = "AggregateError";
-        this.errors = errors;
+      if (typeof value !== "function") {
+        throw new ERR_INVALID_ARG_TYPE(name, "Function", value);
       }
     };
     module2.exports = {
@@ -96037,25 +96417,25 @@ var require_util13 = __commonJS({
         };
       },
       createDeferredPromise: function() {
-        let resolve13;
+        let resolve14;
         let reject;
         const promise = new Promise((res, rej) => {
-          resolve13 = res;
+          resolve14 = res;
           reject = rej;
         });
         return {
           promise,
-          resolve: resolve13,
+          resolve: resolve14,
           reject
         };
       },
       promisify(fn) {
-        return new Promise((resolve13, reject) => {
+        return new Promise((resolve14, reject) => {
           fn((err, ...args) => {
             if (err) {
               return reject(err);
             }
-            return resolve13(...args);
+            return resolve14(...args);
           });
         });
       },
@@ -96063,48 +96443,8 @@ var require_util13 = __commonJS({
         return function() {
         };
       },
-      format(format, ...args) {
-        return format.replace(/%([sdifj])/g, function(...[_unused, type]) {
-          const replacement = args.shift();
-          if (type === "f") {
-            return replacement.toFixed(6);
-          } else if (type === "j") {
-            return JSON.stringify(replacement);
-          } else if (type === "s" && typeof replacement === "object") {
-            const ctor = replacement.constructor !== Object ? replacement.constructor.name : "";
-            return `${ctor} {}`.trim();
-          } else {
-            return replacement.toString();
-          }
-        });
-      },
-      inspect(value) {
-        switch (typeof value) {
-          case "string":
-            if (value.includes("'")) {
-              if (!value.includes('"')) {
-                return `"${value}"`;
-              } else if (!value.includes("`") && !value.includes("${")) {
-                return `\`${value}\``;
-              }
-            }
-            return `'${value}'`;
-          case "number":
-            if (isNaN(value)) {
-              return "NaN";
-            } else if (Object.is(value, -0)) {
-              return String(value);
-            }
-            return value;
-          case "bigint":
-            return `${String(value)}n`;
-          case "boolean":
-          case "undefined":
-            return String(value);
-          case "object":
-            return "{}";
-        }
-      },
+      format,
+      inspect,
       types: {
         isAsyncFunction(fn) {
           return fn instanceof AsyncFunction;
@@ -96172,322 +96512,6 @@ var require_util13 = __commonJS({
   }
 });
 
-// node_modules/readable-stream/lib/ours/errors.js
-var require_errors4 = __commonJS({
-  "node_modules/readable-stream/lib/ours/errors.js"(exports2, module2) {
-    "use strict";
-    var { format, inspect, AggregateError: CustomAggregateError } = require_util13();
-    var AggregateError = globalThis.AggregateError || CustomAggregateError;
-    var kIsNodeError = /* @__PURE__ */ Symbol("kIsNodeError");
-    var kTypes = [
-      "string",
-      "function",
-      "number",
-      "object",
-      // Accept 'Function' and 'Object' as alternative to the lower cased version.
-      "Function",
-      "Object",
-      "boolean",
-      "bigint",
-      "symbol"
-    ];
-    var classRegExp = /^([A-Z][a-z0-9]*)+$/;
-    var nodeInternalPrefix = "__node_internal_";
-    var codes = {};
-    function assert(value, message) {
-      if (!value) {
-        throw new codes.ERR_INTERNAL_ASSERTION(message);
-      }
-    }
-    function addNumericalSeparator(val) {
-      let res = "";
-      let i = val.length;
-      const start = val[0] === "-" ? 1 : 0;
-      for (; i >= start + 4; i -= 3) {
-        res = `_${val.slice(i - 3, i)}${res}`;
-      }
-      return `${val.slice(0, i)}${res}`;
-    }
-    function getMessage(key, msg, args) {
-      if (typeof msg === "function") {
-        assert(
-          msg.length <= args.length,
-          // Default options do not count.
-          `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${msg.length}).`
-        );
-        return msg(...args);
-      }
-      const expectedLength = (msg.match(/%[dfijoOs]/g) || []).length;
-      assert(
-        expectedLength === args.length,
-        `Code: ${key}; The provided arguments length (${args.length}) does not match the required ones (${expectedLength}).`
-      );
-      if (args.length === 0) {
-        return msg;
-      }
-      return format(msg, ...args);
-    }
-    function E(code, message, Base) {
-      if (!Base) {
-        Base = Error;
-      }
-      class NodeError extends Base {
-        constructor(...args) {
-          super(getMessage(code, message, args));
-        }
-        toString() {
-          return `${this.name} [${code}]: ${this.message}`;
-        }
-      }
-      Object.defineProperties(NodeError.prototype, {
-        name: {
-          value: Base.name,
-          writable: true,
-          enumerable: false,
-          configurable: true
-        },
-        toString: {
-          value() {
-            return `${this.name} [${code}]: ${this.message}`;
-          },
-          writable: true,
-          enumerable: false,
-          configurable: true
-        }
-      });
-      NodeError.prototype.code = code;
-      NodeError.prototype[kIsNodeError] = true;
-      codes[code] = NodeError;
-    }
-    function hideStackFrames(fn) {
-      const hidden = nodeInternalPrefix + fn.name;
-      Object.defineProperty(fn, "name", {
-        value: hidden
-      });
-      return fn;
-    }
-    function aggregateTwoErrors(innerError, outerError) {
-      if (innerError && outerError && innerError !== outerError) {
-        if (Array.isArray(outerError.errors)) {
-          outerError.errors.push(innerError);
-          return outerError;
-        }
-        const err = new AggregateError([outerError, innerError], outerError.message);
-        err.code = outerError.code;
-        return err;
-      }
-      return innerError || outerError;
-    }
-    var AbortError = class extends Error {
-      constructor(message = "The operation was aborted", options = void 0) {
-        if (options !== void 0 && typeof options !== "object") {
-          throw new codes.ERR_INVALID_ARG_TYPE("options", "Object", options);
-        }
-        super(message, options);
-        this.code = "ABORT_ERR";
-        this.name = "AbortError";
-      }
-    };
-    E("ERR_ASSERTION", "%s", Error);
-    E(
-      "ERR_INVALID_ARG_TYPE",
-      (name, expected, actual) => {
-        assert(typeof name === "string", "'name' must be a string");
-        if (!Array.isArray(expected)) {
-          expected = [expected];
-        }
-        let msg = "The ";
-        if (name.endsWith(" argument")) {
-          msg += `${name} `;
-        } else {
-          msg += `"${name}" ${name.includes(".") ? "property" : "argument"} `;
-        }
-        msg += "must be ";
-        const types2 = [];
-        const instances = [];
-        const other = [];
-        for (const value of expected) {
-          assert(typeof value === "string", "All expected entries have to be of type string");
-          if (kTypes.includes(value)) {
-            types2.push(value.toLowerCase());
-          } else if (classRegExp.test(value)) {
-            instances.push(value);
-          } else {
-            assert(value !== "object", 'The value "object" should be written as "Object"');
-            other.push(value);
-          }
-        }
-        if (instances.length > 0) {
-          const pos = types2.indexOf("object");
-          if (pos !== -1) {
-            types2.splice(types2, pos, 1);
-            instances.push("Object");
-          }
-        }
-        if (types2.length > 0) {
-          switch (types2.length) {
-            case 1:
-              msg += `of type ${types2[0]}`;
-              break;
-            case 2:
-              msg += `one of type ${types2[0]} or ${types2[1]}`;
-              break;
-            default: {
-              const last = types2.pop();
-              msg += `one of type ${types2.join(", ")}, or ${last}`;
-            }
-          }
-          if (instances.length > 0 || other.length > 0) {
-            msg += " or ";
-          }
-        }
-        if (instances.length > 0) {
-          switch (instances.length) {
-            case 1:
-              msg += `an instance of ${instances[0]}`;
-              break;
-            case 2:
-              msg += `an instance of ${instances[0]} or ${instances[1]}`;
-              break;
-            default: {
-              const last = instances.pop();
-              msg += `an instance of ${instances.join(", ")}, or ${last}`;
-            }
-          }
-          if (other.length > 0) {
-            msg += " or ";
-          }
-        }
-        switch (other.length) {
-          case 0:
-            break;
-          case 1:
-            if (other[0].toLowerCase() !== other[0]) {
-              msg += "an ";
-            }
-            msg += `${other[0]}`;
-            break;
-          case 2:
-            msg += `one of ${other[0]} or ${other[1]}`;
-            break;
-          default: {
-            const last = other.pop();
-            msg += `one of ${other.join(", ")}, or ${last}`;
-          }
-        }
-        if (actual == null) {
-          msg += `. Received ${actual}`;
-        } else if (typeof actual === "function" && actual.name) {
-          msg += `. Received function ${actual.name}`;
-        } else if (typeof actual === "object") {
-          var _actual$constructor;
-          if ((_actual$constructor = actual.constructor) !== null && _actual$constructor !== void 0 && _actual$constructor.name) {
-            msg += `. Received an instance of ${actual.constructor.name}`;
-          } else {
-            const inspected = inspect(actual, {
-              depth: -1
-            });
-            msg += `. Received ${inspected}`;
-          }
-        } else {
-          let inspected = inspect(actual, {
-            colors: false
-          });
-          if (inspected.length > 25) {
-            inspected = `${inspected.slice(0, 25)}...`;
-          }
-          msg += `. Received type ${typeof actual} (${inspected})`;
-        }
-        return msg;
-      },
-      TypeError
-    );
-    E(
-      "ERR_INVALID_ARG_VALUE",
-      (name, value, reason = "is invalid") => {
-        let inspected = inspect(value);
-        if (inspected.length > 128) {
-          inspected = inspected.slice(0, 128) + "...";
-        }
-        const type = name.includes(".") ? "property" : "argument";
-        return `The ${type} '${name}' ${reason}. Received ${inspected}`;
-      },
-      TypeError
-    );
-    E(
-      "ERR_INVALID_RETURN_VALUE",
-      (input, name, value) => {
-        var _value$constructor;
-        const type = value !== null && value !== void 0 && (_value$constructor = value.constructor) !== null && _value$constructor !== void 0 && _value$constructor.name ? `instance of ${value.constructor.name}` : `type ${typeof value}`;
-        return `Expected ${input} to be returned from the "${name}" function but got ${type}.`;
-      },
-      TypeError
-    );
-    E(
-      "ERR_MISSING_ARGS",
-      (...args) => {
-        assert(args.length > 0, "At least one arg needs to be specified");
-        let msg;
-        const len = args.length;
-        args = (Array.isArray(args) ? args : [args]).map((a) => `"${a}"`).join(" or ");
-        switch (len) {
-          case 1:
-            msg += `The ${args[0]} argument`;
-            break;
-          case 2:
-            msg += `The ${args[0]} and ${args[1]} arguments`;
-            break;
-          default:
-            {
-              const last = args.pop();
-              msg += `The ${args.join(", ")}, and ${last} arguments`;
-            }
-            break;
-        }
-        return `${msg} must be specified`;
-      },
-      TypeError
-    );
-    E(
-      "ERR_OUT_OF_RANGE",
-      (str, range, input) => {
-        assert(range, 'Missing "range" argument');
-        let received;
-        if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
-          received = addNumericalSeparator(String(input));
-        } else if (typeof input === "bigint") {
-          received = String(input);
-          if (input > 2n ** 32n || input < -(2n ** 32n)) {
-            received = addNumericalSeparator(received);
-          }
-          received += "n";
-        } else {
-          received = inspect(input);
-        }
-        return `The value of "${str}" is out of range. It must be ${range}. Received ${received}`;
-      },
-      RangeError
-    );
-    E("ERR_MULTIPLE_CALLBACK", "Callback called multiple times", Error);
-    E("ERR_METHOD_NOT_IMPLEMENTED", "The %s method is not implemented", Error);
-    E("ERR_STREAM_ALREADY_FINISHED", "Cannot call %s after a stream was finished", Error);
-    E("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable", Error);
-    E("ERR_STREAM_DESTROYED", "Cannot call %s after a stream was destroyed", Error);
-    E("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
-    E("ERR_STREAM_PREMATURE_CLOSE", "Premature close", Error);
-    E("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF", Error);
-    E("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event", Error);
-    E("ERR_STREAM_WRITE_AFTER_END", "write after end", Error);
-    E("ERR_UNKNOWN_ENCODING", "Unknown encoding: %s", TypeError);
-    module2.exports = {
-      AbortError,
-      aggregateTwoErrors: hideStackFrames(aggregateTwoErrors),
-      hideStackFrames,
-      codes
-    };
-  }
-});
-
 // node_modules/readable-stream/lib/internal/validators.js
 var require_validators = __commonJS({
   "node_modules/readable-stream/lib/internal/validators.js"(exports2, module2) {
@@ -96510,7 +96534,7 @@ var require_validators = __commonJS({
     } = require_primordials();
     var {
       hideStackFrames,
-      codes: { ERR_SOCKET_BAD_PORT, ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2, ERR_INVALID_ARG_VALUE, ERR_OUT_OF_RANGE, ERR_UNKNOWN_SIGNAL }
+      codes: { ERR_SOCKET_BAD_PORT, ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_OUT_OF_RANGE, ERR_UNKNOWN_SIGNAL }
     } = require_errors4();
     var { normalizeEncoding } = require_util13();
     var { isAsyncFunction, isArrayBufferView } = require_util13().types;
@@ -96537,13 +96561,13 @@ var require_validators = __commonJS({
       return value;
     }
     var validateInteger = hideStackFrames((value, name, min = NumberMIN_SAFE_INTEGER, max = NumberMAX_SAFE_INTEGER) => {
-      if (typeof value !== "number") throw new ERR_INVALID_ARG_TYPE2(name, "number", value);
+      if (typeof value !== "number") throw new ERR_INVALID_ARG_TYPE(name, "number", value);
       if (!NumberIsInteger(value)) throw new ERR_OUT_OF_RANGE(name, "an integer", value);
       if (value < min || value > max) throw new ERR_OUT_OF_RANGE(name, `>= ${min} && <= ${max}`, value);
     });
     var validateInt32 = hideStackFrames((value, name, min = -2147483648, max = 2147483647) => {
       if (typeof value !== "number") {
-        throw new ERR_INVALID_ARG_TYPE2(name, "number", value);
+        throw new ERR_INVALID_ARG_TYPE(name, "number", value);
       }
       if (!NumberIsInteger(value)) {
         throw new ERR_OUT_OF_RANGE(name, "an integer", value);
@@ -96554,7 +96578,7 @@ var require_validators = __commonJS({
     });
     var validateUint32 = hideStackFrames((value, name, positive = false) => {
       if (typeof value !== "number") {
-        throw new ERR_INVALID_ARG_TYPE2(name, "number", value);
+        throw new ERR_INVALID_ARG_TYPE(name, "number", value);
       }
       if (!NumberIsInteger(value)) {
         throw new ERR_OUT_OF_RANGE(name, "an integer", value);
@@ -96566,10 +96590,10 @@ var require_validators = __commonJS({
       }
     });
     function validateString(value, name) {
-      if (typeof value !== "string") throw new ERR_INVALID_ARG_TYPE2(name, "string", value);
+      if (typeof value !== "string") throw new ERR_INVALID_ARG_TYPE(name, "string", value);
     }
     function validateNumber(value, name, min = void 0, max) {
-      if (typeof value !== "number") throw new ERR_INVALID_ARG_TYPE2(name, "number", value);
+      if (typeof value !== "number") throw new ERR_INVALID_ARG_TYPE(name, "number", value);
       if (min != null && value < min || max != null && value > max || (min != null || max != null) && NumberIsNaN(value)) {
         throw new ERR_OUT_OF_RANGE(
           name,
@@ -96589,7 +96613,7 @@ var require_validators = __commonJS({
       }
     });
     function validateBoolean(value, name) {
-      if (typeof value !== "boolean") throw new ERR_INVALID_ARG_TYPE2(name, "boolean", value);
+      if (typeof value !== "boolean") throw new ERR_INVALID_ARG_TYPE(name, "boolean", value);
     }
     function getOwnPropertyValueOrDefault(options, key, defaultValue) {
       return options == null || !ObjectPrototypeHasOwnProperty(options, key) ? defaultValue : options[key];
@@ -96599,17 +96623,17 @@ var require_validators = __commonJS({
       const allowFunction = getOwnPropertyValueOrDefault(options, "allowFunction", false);
       const nullable = getOwnPropertyValueOrDefault(options, "nullable", false);
       if (!nullable && value === null || !allowArray && ArrayIsArray(value) || typeof value !== "object" && (!allowFunction || typeof value !== "function")) {
-        throw new ERR_INVALID_ARG_TYPE2(name, "Object", value);
+        throw new ERR_INVALID_ARG_TYPE(name, "Object", value);
       }
     });
     var validateDictionary = hideStackFrames((value, name) => {
       if (value != null && typeof value !== "object" && typeof value !== "function") {
-        throw new ERR_INVALID_ARG_TYPE2(name, "a dictionary", value);
+        throw new ERR_INVALID_ARG_TYPE(name, "a dictionary", value);
       }
     });
     var validateArray = hideStackFrames((value, name, minLength = 0) => {
       if (!ArrayIsArray(value)) {
-        throw new ERR_INVALID_ARG_TYPE2(name, "Array", value);
+        throw new ERR_INVALID_ARG_TYPE(name, "Array", value);
       }
       if (value.length < minLength) {
         const reason = `must be longer than ${minLength}`;
@@ -96634,7 +96658,7 @@ var require_validators = __commonJS({
         const signal = value[i];
         const indexedName = `${name}[${i}]`;
         if (signal == null) {
-          throw new ERR_INVALID_ARG_TYPE2(indexedName, "AbortSignal", signal);
+          throw new ERR_INVALID_ARG_TYPE(indexedName, "AbortSignal", signal);
         }
         validateAbortSignal(signal, indexedName);
       }
@@ -96650,7 +96674,7 @@ var require_validators = __commonJS({
     }
     var validateBuffer = hideStackFrames((buffer, name = "buffer") => {
       if (!isArrayBufferView(buffer)) {
-        throw new ERR_INVALID_ARG_TYPE2(name, ["Buffer", "TypedArray", "DataView"], buffer);
+        throw new ERR_INVALID_ARG_TYPE(name, ["Buffer", "TypedArray", "DataView"], buffer);
       }
     });
     function validateEncoding(data, encoding) {
@@ -96668,21 +96692,21 @@ var require_validators = __commonJS({
     }
     var validateAbortSignal = hideStackFrames((signal, name) => {
       if (signal !== void 0 && (signal === null || typeof signal !== "object" || !("aborted" in signal))) {
-        throw new ERR_INVALID_ARG_TYPE2(name, "AbortSignal", signal);
+        throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
       }
     });
     var validateFunction = hideStackFrames((value, name) => {
-      if (typeof value !== "function") throw new ERR_INVALID_ARG_TYPE2(name, "Function", value);
+      if (typeof value !== "function") throw new ERR_INVALID_ARG_TYPE(name, "Function", value);
     });
     var validatePlainFunction = hideStackFrames((value, name) => {
-      if (typeof value !== "function" || isAsyncFunction(value)) throw new ERR_INVALID_ARG_TYPE2(name, "Function", value);
+      if (typeof value !== "function" || isAsyncFunction(value)) throw new ERR_INVALID_ARG_TYPE(name, "Function", value);
     });
     var validateUndefined = hideStackFrames((value, name) => {
-      if (value !== void 0) throw new ERR_INVALID_ARG_TYPE2(name, "undefined", value);
+      if (value !== void 0) throw new ERR_INVALID_ARG_TYPE(name, "undefined", value);
     });
     function validateUnion(value, name, union) {
       if (!ArrayPrototypeIncludes(union, value)) {
-        throw new ERR_INVALID_ARG_TYPE2(name, `('${ArrayPrototypeJoin(union, "|")}')`, value);
+        throw new ERR_INVALID_ARG_TYPE(name, `('${ArrayPrototypeJoin(union, "|")}')`, value);
       }
     }
     var linkValueRegExp = /^(?:<[^>]*>)(?:\s*;\s*[^;"\s]+(?:=(")?[^;"\s]*\1)?)*$/;
@@ -96971,9 +96995,10 @@ var require_utils7 = __commonJS({
 // node_modules/readable-stream/lib/internal/streams/end-of-stream.js
 var require_end_of_stream = __commonJS({
   "node_modules/readable-stream/lib/internal/streams/end-of-stream.js"(exports2, module2) {
+    "use strict";
     var process2 = require_process();
     var { AbortError, codes } = require_errors4();
-    var { ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2, ERR_STREAM_PREMATURE_CLOSE } = codes;
+    var { ERR_INVALID_ARG_TYPE, ERR_STREAM_PREMATURE_CLOSE } = codes;
     var { kEmptyObject, once } = require_util13();
     var { validateAbortSignal, validateFunction, validateObject, validateBoolean } = require_validators();
     var { Promise: Promise2, PromisePrototypeThen, SymbolDispose } = require_primordials();
@@ -97016,7 +97041,7 @@ var require_end_of_stream = __commonJS({
         return eosWeb(stream2, options, callback);
       }
       if (!isNodeStream(stream2)) {
-        throw new ERR_INVALID_ARG_TYPE2("stream", ["ReadableStream", "WritableStream", "Stream"], stream2);
+        throw new ERR_INVALID_ARG_TYPE("stream", ["ReadableStream", "WritableStream", "Stream"], stream2);
       }
       const readable = (_options$readable = options.readable) !== null && _options$readable !== void 0 ? _options$readable : isReadableNodeStream(stream2);
       const writable = (_options$writable = options.writable) !== null && _options$writable !== void 0 ? _options$writable : isWritableNodeStream(stream2);
@@ -97201,7 +97226,7 @@ var require_end_of_stream = __commonJS({
         validateBoolean(opts.cleanup, "cleanup");
         autoCleanup = opts.cleanup;
       }
-      return new Promise2((resolve13, reject) => {
+      return new Promise2((resolve14, reject) => {
         const cleanup = eos(stream2, opts, (err) => {
           if (autoCleanup) {
             cleanup();
@@ -97209,7 +97234,7 @@ var require_end_of_stream = __commonJS({
           if (err) {
             reject(err);
           } else {
-            resolve13();
+            resolve14();
           }
         });
       });
@@ -97570,17 +97595,17 @@ var require_add_abort_signal = __commonJS({
     var { AbortError, codes } = require_errors4();
     var { isNodeStream, isWebStream, kControllerErrorFunction } = require_utils7();
     var eos = require_end_of_stream();
-    var { ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2 } = codes;
+    var { ERR_INVALID_ARG_TYPE } = codes;
     var addAbortListener;
     var validateAbortSignal = (signal, name) => {
       if (typeof signal !== "object" || !("aborted" in signal)) {
-        throw new ERR_INVALID_ARG_TYPE2(name, "AbortSignal", signal);
+        throw new ERR_INVALID_ARG_TYPE(name, "AbortSignal", signal);
       }
     };
     module2.exports.addAbortSignal = function addAbortSignal(signal, stream2) {
       validateAbortSignal(signal, "signal");
       if (!isNodeStream(stream2) && !isWebStream(stream2)) {
-        throw new ERR_INVALID_ARG_TYPE2("stream", ["ReadableStream", "WritableStream", "Stream"], stream2);
+        throw new ERR_INVALID_ARG_TYPE("stream", ["ReadableStream", "WritableStream", "Stream"], stream2);
       }
       return module2.exports.addAbortSignalNoValidate(signal, stream2);
     };
@@ -97810,6 +97835,302 @@ var require_state3 = __commonJS({
   }
 });
 
+// node_modules/safe-buffer/index.js
+var require_safe_buffer2 = __commonJS({
+  "node_modules/safe-buffer/index.js"(exports2, module2) {
+    var buffer = require("buffer");
+    var Buffer2 = buffer.Buffer;
+    function copyProps(src, dst) {
+      for (var key in src) {
+        dst[key] = src[key];
+      }
+    }
+    if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
+      module2.exports = buffer;
+    } else {
+      copyProps(buffer, exports2);
+      exports2.Buffer = SafeBuffer;
+    }
+    function SafeBuffer(arg, encodingOrOffset, length) {
+      return Buffer2(arg, encodingOrOffset, length);
+    }
+    SafeBuffer.prototype = Object.create(Buffer2.prototype);
+    copyProps(Buffer2, SafeBuffer);
+    SafeBuffer.from = function(arg, encodingOrOffset, length) {
+      if (typeof arg === "number") {
+        throw new TypeError("Argument must not be a number");
+      }
+      return Buffer2(arg, encodingOrOffset, length);
+    };
+    SafeBuffer.alloc = function(size, fill, encoding) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      var buf = Buffer2(size);
+      if (fill !== void 0) {
+        if (typeof encoding === "string") {
+          buf.fill(fill, encoding);
+        } else {
+          buf.fill(fill);
+        }
+      } else {
+        buf.fill(0);
+      }
+      return buf;
+    };
+    SafeBuffer.allocUnsafe = function(size) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      return Buffer2(size);
+    };
+    SafeBuffer.allocUnsafeSlow = function(size) {
+      if (typeof size !== "number") {
+        throw new TypeError("Argument must be a number");
+      }
+      return buffer.SlowBuffer(size);
+    };
+  }
+});
+
+// node_modules/string_decoder/lib/string_decoder.js
+var require_string_decoder2 = __commonJS({
+  "node_modules/string_decoder/lib/string_decoder.js"(exports2) {
+    "use strict";
+    var Buffer2 = require_safe_buffer2().Buffer;
+    var isEncoding = Buffer2.isEncoding || function(encoding) {
+      encoding = "" + encoding;
+      switch (encoding && encoding.toLowerCase()) {
+        case "hex":
+        case "utf8":
+        case "utf-8":
+        case "ascii":
+        case "binary":
+        case "base64":
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+        case "raw":
+          return true;
+        default:
+          return false;
+      }
+    };
+    function _normalizeEncoding(enc) {
+      if (!enc) return "utf8";
+      var retried;
+      while (true) {
+        switch (enc) {
+          case "utf8":
+          case "utf-8":
+            return "utf8";
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return "utf16le";
+          case "latin1":
+          case "binary":
+            return "latin1";
+          case "base64":
+          case "ascii":
+          case "hex":
+            return enc;
+          default:
+            if (retried) return;
+            enc = ("" + enc).toLowerCase();
+            retried = true;
+        }
+      }
+    }
+    function normalizeEncoding(enc) {
+      var nenc = _normalizeEncoding(enc);
+      if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
+      return nenc || enc;
+    }
+    exports2.StringDecoder = StringDecoder;
+    function StringDecoder(encoding) {
+      this.encoding = normalizeEncoding(encoding);
+      var nb;
+      switch (this.encoding) {
+        case "utf16le":
+          this.text = utf16Text;
+          this.end = utf16End;
+          nb = 4;
+          break;
+        case "utf8":
+          this.fillLast = utf8FillLast;
+          nb = 4;
+          break;
+        case "base64":
+          this.text = base64Text;
+          this.end = base64End;
+          nb = 3;
+          break;
+        default:
+          this.write = simpleWrite;
+          this.end = simpleEnd;
+          return;
+      }
+      this.lastNeed = 0;
+      this.lastTotal = 0;
+      this.lastChar = Buffer2.allocUnsafe(nb);
+    }
+    StringDecoder.prototype.write = function(buf) {
+      if (buf.length === 0) return "";
+      var r;
+      var i;
+      if (this.lastNeed) {
+        r = this.fillLast(buf);
+        if (r === void 0) return "";
+        i = this.lastNeed;
+        this.lastNeed = 0;
+      } else {
+        i = 0;
+      }
+      if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
+      return r || "";
+    };
+    StringDecoder.prototype.end = utf8End;
+    StringDecoder.prototype.text = utf8Text;
+    StringDecoder.prototype.fillLast = function(buf) {
+      if (this.lastNeed <= buf.length) {
+        buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+      }
+      buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+      this.lastNeed -= buf.length;
+    };
+    function utf8CheckByte(byte) {
+      if (byte <= 127) return 0;
+      else if (byte >> 5 === 6) return 2;
+      else if (byte >> 4 === 14) return 3;
+      else if (byte >> 3 === 30) return 4;
+      return byte >> 6 === 2 ? -1 : -2;
+    }
+    function utf8CheckIncomplete(self2, buf, i) {
+      var j = buf.length - 1;
+      if (j < i) return 0;
+      var nb = utf8CheckByte(buf[j]);
+      if (nb >= 0) {
+        if (nb > 0) self2.lastNeed = nb - 1;
+        return nb;
+      }
+      if (--j < i || nb === -2) return 0;
+      nb = utf8CheckByte(buf[j]);
+      if (nb >= 0) {
+        if (nb > 0) self2.lastNeed = nb - 2;
+        return nb;
+      }
+      if (--j < i || nb === -2) return 0;
+      nb = utf8CheckByte(buf[j]);
+      if (nb >= 0) {
+        if (nb > 0) {
+          if (nb === 2) nb = 0;
+          else self2.lastNeed = nb - 3;
+        }
+        return nb;
+      }
+      return 0;
+    }
+    function utf8CheckExtraBytes(self2, buf, p) {
+      if ((buf[0] & 192) !== 128) {
+        self2.lastNeed = 0;
+        return "\uFFFD";
+      }
+      if (self2.lastNeed > 1 && buf.length > 1) {
+        if ((buf[1] & 192) !== 128) {
+          self2.lastNeed = 1;
+          return "\uFFFD";
+        }
+        if (self2.lastNeed > 2 && buf.length > 2) {
+          if ((buf[2] & 192) !== 128) {
+            self2.lastNeed = 2;
+            return "\uFFFD";
+          }
+        }
+      }
+    }
+    function utf8FillLast(buf) {
+      var p = this.lastTotal - this.lastNeed;
+      var r = utf8CheckExtraBytes(this, buf, p);
+      if (r !== void 0) return r;
+      if (this.lastNeed <= buf.length) {
+        buf.copy(this.lastChar, p, 0, this.lastNeed);
+        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+      }
+      buf.copy(this.lastChar, p, 0, buf.length);
+      this.lastNeed -= buf.length;
+    }
+    function utf8Text(buf, i) {
+      var total = utf8CheckIncomplete(this, buf, i);
+      if (!this.lastNeed) return buf.toString("utf8", i);
+      this.lastTotal = total;
+      var end = buf.length - (total - this.lastNeed);
+      buf.copy(this.lastChar, 0, end);
+      return buf.toString("utf8", i, end);
+    }
+    function utf8End(buf) {
+      var r = buf && buf.length ? this.write(buf) : "";
+      if (this.lastNeed) return r + "\uFFFD";
+      return r;
+    }
+    function utf16Text(buf, i) {
+      if ((buf.length - i) % 2 === 0) {
+        var r = buf.toString("utf16le", i);
+        if (r) {
+          var c = r.charCodeAt(r.length - 1);
+          if (c >= 55296 && c <= 56319) {
+            this.lastNeed = 2;
+            this.lastTotal = 4;
+            this.lastChar[0] = buf[buf.length - 2];
+            this.lastChar[1] = buf[buf.length - 1];
+            return r.slice(0, -1);
+          }
+        }
+        return r;
+      }
+      this.lastNeed = 1;
+      this.lastTotal = 2;
+      this.lastChar[0] = buf[buf.length - 1];
+      return buf.toString("utf16le", i, buf.length - 1);
+    }
+    function utf16End(buf) {
+      var r = buf && buf.length ? this.write(buf) : "";
+      if (this.lastNeed) {
+        var end = this.lastTotal - this.lastNeed;
+        return r + this.lastChar.toString("utf16le", 0, end);
+      }
+      return r;
+    }
+    function base64Text(buf, i) {
+      var n = (buf.length - i) % 3;
+      if (n === 0) return buf.toString("base64", i);
+      this.lastNeed = 3 - n;
+      this.lastTotal = 3;
+      if (n === 1) {
+        this.lastChar[0] = buf[buf.length - 1];
+      } else {
+        this.lastChar[0] = buf[buf.length - 2];
+        this.lastChar[1] = buf[buf.length - 1];
+      }
+      return buf.toString("base64", i, buf.length - n);
+    }
+    function base64End(buf) {
+      var r = buf && buf.length ? this.write(buf) : "";
+      if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
+      return r;
+    }
+    function simpleWrite(buf) {
+      return buf.toString(this.encoding);
+    }
+    function simpleEnd(buf) {
+      return buf && buf.length ? this.write(buf) : "";
+    }
+  }
+});
+
 // node_modules/readable-stream/lib/internal/streams/from.js
 var require_from = __commonJS({
   "node_modules/readable-stream/lib/internal/streams/from.js"(exports2, module2) {
@@ -97817,11 +98138,11 @@ var require_from = __commonJS({
     var process2 = require_process();
     var { PromisePrototypeThen, SymbolAsyncIterator, SymbolIterator } = require_primordials();
     var { Buffer: Buffer2 } = require("buffer");
-    var { ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2, ERR_STREAM_NULL_VALUES } = require_errors4().codes;
-    function from(Readable2, iterable, opts) {
+    var { ERR_INVALID_ARG_TYPE, ERR_STREAM_NULL_VALUES } = require_errors4().codes;
+    function from(Readable3, iterable, opts) {
       let iterator2;
       if (typeof iterable === "string" || iterable instanceof Buffer2) {
-        return new Readable2({
+        return new Readable3({
           objectMode: true,
           ...opts,
           read() {
@@ -97838,9 +98159,9 @@ var require_from = __commonJS({
         isAsync = false;
         iterator2 = iterable[SymbolIterator]();
       } else {
-        throw new ERR_INVALID_ARG_TYPE2("iterable", ["Iterable"], iterable);
+        throw new ERR_INVALID_ARG_TYPE("iterable", ["Iterable"], iterable);
       }
-      const readable = new Readable2({
+      const readable = new Readable3({
         objectMode: true,
         highWaterMark: 1,
         // TODO(ronag): What options should be allowed?
@@ -97908,6 +98229,7 @@ var require_from = __commonJS({
 // node_modules/readable-stream/lib/internal/streams/readable.js
 var require_readable3 = __commonJS({
   "node_modules/readable-stream/lib/internal/streams/readable.js"(exports2, module2) {
+    "use strict";
     var process2 = require_process();
     var {
       ArrayPrototypeIndexOf,
@@ -97923,8 +98245,8 @@ var require_readable3 = __commonJS({
       SymbolAsyncIterator,
       Symbol: Symbol2
     } = require_primordials();
-    module2.exports = Readable2;
-    Readable2.ReadableState = ReadableState;
+    module2.exports = Readable3;
+    Readable3.ReadableState = ReadableState;
     var { EventEmitter: EE } = require("events");
     var { Stream, prependListener } = require_legacy();
     var { Buffer: Buffer2 } = require("buffer");
@@ -97939,7 +98261,7 @@ var require_readable3 = __commonJS({
     var {
       aggregateTwoErrors,
       codes: {
-        ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2,
+        ERR_INVALID_ARG_TYPE,
         ERR_METHOD_NOT_IMPLEMENTED,
         ERR_OUT_OF_RANGE,
         ERR_STREAM_PUSH_AFTER_EOF,
@@ -97949,10 +98271,10 @@ var require_readable3 = __commonJS({
     } = require_errors4();
     var { validateObject } = require_validators();
     var kPaused = Symbol2("kPaused");
-    var { StringDecoder } = require("string_decoder");
+    var { StringDecoder } = require_string_decoder2();
     var from = require_from();
-    ObjectSetPrototypeOf(Readable2.prototype, Stream.prototype);
-    ObjectSetPrototypeOf(Readable2, Stream);
+    ObjectSetPrototypeOf(Readable3.prototype, Stream.prototype);
+    ObjectSetPrototypeOf(Readable3, Stream);
     var nop = () => {
     };
     var { errorOrDestroy } = destroyImpl;
@@ -98047,8 +98369,8 @@ var require_readable3 = __commonJS({
         this.encoding = options.encoding;
       }
     }
-    function Readable2(options) {
-      if (!(this instanceof Readable2)) return new Readable2(options);
+    function Readable3(options) {
+      if (!(this instanceof Readable3)) return new Readable3(options);
       const isDuplex = this instanceof require_duplex();
       this._readableState = new ReadableState(options, this, isDuplex);
       if (options) {
@@ -98064,26 +98386,26 @@ var require_readable3 = __commonJS({
         }
       });
     }
-    Readable2.prototype.destroy = destroyImpl.destroy;
-    Readable2.prototype._undestroy = destroyImpl.undestroy;
-    Readable2.prototype._destroy = function(err, cb) {
+    Readable3.prototype.destroy = destroyImpl.destroy;
+    Readable3.prototype._undestroy = destroyImpl.undestroy;
+    Readable3.prototype._destroy = function(err, cb) {
       cb(err);
     };
-    Readable2.prototype[EE.captureRejectionSymbol] = function(err) {
+    Readable3.prototype[EE.captureRejectionSymbol] = function(err) {
       this.destroy(err);
     };
-    Readable2.prototype[SymbolAsyncDispose] = function() {
+    Readable3.prototype[SymbolAsyncDispose] = function() {
       let error3;
       if (!this.destroyed) {
         error3 = this.readableEnded ? null : new AbortError();
         this.destroy(error3);
       }
-      return new Promise2((resolve13, reject) => eos(this, (err) => err && err !== error3 ? reject(err) : resolve13(null)));
+      return new Promise2((resolve14, reject) => eos(this, (err) => err && err !== error3 ? reject(err) : resolve14(null)));
     };
-    Readable2.prototype.push = function(chunk, encoding) {
+    Readable3.prototype.push = function(chunk, encoding) {
       return readableAddChunk(this, chunk, encoding, false);
     };
-    Readable2.prototype.unshift = function(chunk, encoding) {
+    Readable3.prototype.unshift = function(chunk, encoding) {
       return readableAddChunk(this, chunk, encoding, true);
     };
     function readableAddChunk(stream2, chunk, encoding, addToFront) {
@@ -98107,7 +98429,7 @@ var require_readable3 = __commonJS({
           chunk = Stream._uint8ArrayToBuffer(chunk);
           encoding = "";
         } else if (chunk != null) {
-          err = new ERR_INVALID_ARG_TYPE2("chunk", ["string", "Buffer", "Uint8Array"], chunk);
+          err = new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
         }
       }
       if (err) {
@@ -98157,11 +98479,11 @@ var require_readable3 = __commonJS({
       }
       maybeReadMore(stream2, state);
     }
-    Readable2.prototype.isPaused = function() {
+    Readable3.prototype.isPaused = function() {
       const state = this._readableState;
       return state[kPaused] === true || state.flowing === false;
     };
-    Readable2.prototype.setEncoding = function(enc) {
+    Readable3.prototype.setEncoding = function(enc) {
       const decoder = new StringDecoder(enc);
       this._readableState.decoder = decoder;
       this._readableState.encoding = this._readableState.decoder.encoding;
@@ -98200,7 +98522,7 @@ var require_readable3 = __commonJS({
       if (n <= state.length) return n;
       return state.ended ? state.length : 0;
     }
-    Readable2.prototype.read = function(n) {
+    Readable3.prototype.read = function(n) {
       debug6("read", n);
       if (n === void 0) {
         n = NaN;
@@ -98322,10 +98644,10 @@ var require_readable3 = __commonJS({
       }
       state.readingMore = false;
     }
-    Readable2.prototype._read = function(n) {
+    Readable3.prototype._read = function(n) {
       throw new ERR_METHOD_NOT_IMPLEMENTED("_read()");
     };
-    Readable2.prototype.pipe = function(dest, pipeOpts) {
+    Readable3.prototype.pipe = function(dest, pipeOpts) {
       const src = this;
       const state = this._readableState;
       if (state.pipes.length === 1) {
@@ -98450,7 +98772,7 @@ var require_readable3 = __commonJS({
         }
       };
     }
-    Readable2.prototype.unpipe = function(dest) {
+    Readable3.prototype.unpipe = function(dest) {
       const state = this._readableState;
       const unpipeInfo = {
         hasUnpiped: false
@@ -98466,14 +98788,14 @@ var require_readable3 = __commonJS({
           });
         return this;
       }
-      const index = ArrayPrototypeIndexOf(state.pipes, dest);
-      if (index === -1) return this;
-      state.pipes.splice(index, 1);
+      const index2 = ArrayPrototypeIndexOf(state.pipes, dest);
+      if (index2 === -1) return this;
+      state.pipes.splice(index2, 1);
       if (state.pipes.length === 0) this.pause();
       dest.emit("unpipe", this, unpipeInfo);
       return this;
     };
-    Readable2.prototype.on = function(ev, fn) {
+    Readable3.prototype.on = function(ev, fn) {
       const res = Stream.prototype.on.call(this, ev, fn);
       const state = this._readableState;
       if (ev === "data") {
@@ -98494,16 +98816,16 @@ var require_readable3 = __commonJS({
       }
       return res;
     };
-    Readable2.prototype.addListener = Readable2.prototype.on;
-    Readable2.prototype.removeListener = function(ev, fn) {
+    Readable3.prototype.addListener = Readable3.prototype.on;
+    Readable3.prototype.removeListener = function(ev, fn) {
       const res = Stream.prototype.removeListener.call(this, ev, fn);
       if (ev === "readable") {
         process2.nextTick(updateReadableListening, this);
       }
       return res;
     };
-    Readable2.prototype.off = Readable2.prototype.removeListener;
-    Readable2.prototype.removeAllListeners = function(ev) {
+    Readable3.prototype.off = Readable3.prototype.removeListener;
+    Readable3.prototype.removeAllListeners = function(ev) {
       const res = Stream.prototype.removeAllListeners.apply(this, arguments);
       if (ev === "readable" || ev === void 0) {
         process2.nextTick(updateReadableListening, this);
@@ -98525,7 +98847,7 @@ var require_readable3 = __commonJS({
       debug6("readable nexttick read 0");
       self2.read(0);
     }
-    Readable2.prototype.resume = function() {
+    Readable3.prototype.resume = function() {
       const state = this._readableState;
       if (!state.flowing) {
         debug6("resume");
@@ -98551,7 +98873,7 @@ var require_readable3 = __commonJS({
       flow(stream2);
       if (state.flowing && !state.reading) stream2.read(0);
     }
-    Readable2.prototype.pause = function() {
+    Readable3.prototype.pause = function() {
       debug6("call pause flowing=%j", this._readableState.flowing);
       if (this._readableState.flowing !== false) {
         debug6("pause");
@@ -98566,7 +98888,7 @@ var require_readable3 = __commonJS({
       debug6("flow", state.flowing);
       while (state.flowing && stream2.read() !== null) ;
     }
-    Readable2.prototype.wrap = function(stream2) {
+    Readable3.prototype.wrap = function(stream2) {
       let paused = false;
       stream2.on("data", (chunk) => {
         if (!this.push(chunk) && stream2.pause) {
@@ -98601,10 +98923,10 @@ var require_readable3 = __commonJS({
       }
       return this;
     };
-    Readable2.prototype[SymbolAsyncIterator] = function() {
+    Readable3.prototype[SymbolAsyncIterator] = function() {
       return streamToAsyncIterator(this);
     };
-    Readable2.prototype.iterator = function(options) {
+    Readable3.prototype.iterator = function(options) {
       if (options !== void 0) {
         validateObject(options, "options");
       }
@@ -98612,7 +98934,7 @@ var require_readable3 = __commonJS({
     };
     function streamToAsyncIterator(stream2, options) {
       if (typeof stream2.read !== "function") {
-        stream2 = Readable2.wrap(stream2, {
+        stream2 = Readable3.wrap(stream2, {
           objectMode: true
         });
       }
@@ -98622,12 +98944,12 @@ var require_readable3 = __commonJS({
     }
     async function* createAsyncIterator(stream2, options) {
       let callback = nop;
-      function next(resolve13) {
+      function next(resolve14) {
         if (this === stream2) {
           callback();
           callback = nop;
         } else {
-          callback = resolve13;
+          callback = resolve14;
         }
       }
       stream2.on("readable", next);
@@ -98668,7 +98990,7 @@ var require_readable3 = __commonJS({
         }
       }
     }
-    ObjectDefineProperties(Readable2.prototype, {
+    ObjectDefineProperties(Readable3.prototype, {
       readable: {
         __proto__: null,
         get() {
@@ -98795,7 +99117,7 @@ var require_readable3 = __commonJS({
         }
       }
     });
-    Readable2._fromList = fromList;
+    Readable3._fromList = fromList;
     function fromList(n, state) {
       if (state.length === 0) return null;
       let ret;
@@ -98842,23 +99164,23 @@ var require_readable3 = __commonJS({
         stream2.end();
       }
     }
-    Readable2.from = function(iterable, opts) {
-      return from(Readable2, iterable, opts);
+    Readable3.from = function(iterable, opts) {
+      return from(Readable3, iterable, opts);
     };
     var webStreamsAdapters;
     function lazyWebStreams() {
       if (webStreamsAdapters === void 0) webStreamsAdapters = {};
       return webStreamsAdapters;
     }
-    Readable2.fromWeb = function(readableStream, options) {
+    Readable3.fromWeb = function(readableStream, options) {
       return lazyWebStreams().newStreamReadableFromReadableStream(readableStream, options);
     };
-    Readable2.toWeb = function(streamReadable, options) {
+    Readable3.toWeb = function(streamReadable, options) {
       return lazyWebStreams().newReadableStreamFromStreamReadable(streamReadable, options);
     };
-    Readable2.wrap = function(src, options) {
+    Readable3.wrap = function(src, options) {
       var _ref, _src$readableObjectMo;
-      return new Readable2({
+      return new Readable3({
         objectMode: (_ref = (_src$readableObjectMo = src.readableObjectMode) !== null && _src$readableObjectMo !== void 0 ? _src$readableObjectMo : src.objectMode) !== null && _ref !== void 0 ? _ref : true,
         ...options,
         destroy(err, callback) {
@@ -98873,6 +99195,7 @@ var require_readable3 = __commonJS({
 // node_modules/readable-stream/lib/internal/streams/writable.js
 var require_writable = __commonJS({
   "node_modules/readable-stream/lib/internal/streams/writable.js"(exports2, module2) {
+    "use strict";
     var process2 = require_process();
     var {
       ArrayPrototypeSlice,
@@ -98894,7 +99217,7 @@ var require_writable = __commonJS({
     var { addAbortSignal } = require_add_abort_signal();
     var { getHighWaterMark, getDefaultHighWaterMark } = require_state3();
     var {
-      ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2,
+      ERR_INVALID_ARG_TYPE,
       ERR_METHOD_NOT_IMPLEMENTED,
       ERR_MULTIPLE_CALLBACK,
       ERR_STREAM_CANNOT_PIPE,
@@ -99016,7 +99339,7 @@ var require_writable = __commonJS({
           chunk = Stream._uint8ArrayToBuffer(chunk);
           encoding = "buffer";
         } else {
-          throw new ERR_INVALID_ARG_TYPE2("chunk", ["string", "Buffer", "Uint8Array"], chunk);
+          throw new ERR_INVALID_ARG_TYPE("chunk", ["string", "Buffer", "Uint8Array"], chunk);
         }
       }
       let err;
@@ -99509,11 +99832,11 @@ var require_duplexify = __commonJS({
     var eos = require_end_of_stream();
     var {
       AbortError,
-      codes: { ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2, ERR_INVALID_RETURN_VALUE }
+      codes: { ERR_INVALID_ARG_TYPE, ERR_INVALID_RETURN_VALUE }
     } = require_errors4();
     var { destroyer } = require_destroy2();
     var Duplex = require_duplex();
-    var Readable2 = require_readable3();
+    var Readable3 = require_readable3();
     var Writable = require_writable();
     var { createDeferredPromise } = require_util13();
     var from = require_from();
@@ -99563,7 +99886,7 @@ var require_duplexify = __commonJS({
       }
       if (isReadableStream(body)) {
         return _duplexify({
-          readable: Readable2.fromWeb(body)
+          readable: Readable3.fromWeb(body)
         });
       }
       if (isWritableStream(body)) {
@@ -99661,7 +99984,7 @@ var require_duplexify = __commonJS({
           }
         });
       }
-      throw new ERR_INVALID_ARG_TYPE2(
+      throw new ERR_INVALID_ARG_TYPE(
         name,
         [
           "Blob",
@@ -99678,7 +100001,7 @@ var require_duplexify = __commonJS({
       );
     };
     function fromAsyncGen(fn) {
-      let { promise, resolve: resolve13 } = createDeferredPromise();
+      let { promise, resolve: resolve14 } = createDeferredPromise();
       const ac = new AbortController2();
       const signal = ac.signal;
       const value = fn(
@@ -99693,7 +100016,7 @@ var require_duplexify = __commonJS({
               throw new AbortError(void 0, {
                 cause: signal.reason
               });
-            ({ promise, resolve: resolve13 } = createDeferredPromise());
+            ({ promise, resolve: resolve14 } = createDeferredPromise());
             yield chunk;
           }
         })(),
@@ -99704,8 +100027,8 @@ var require_duplexify = __commonJS({
       return {
         value,
         write(chunk, encoding, cb) {
-          const _resolve = resolve13;
-          resolve13 = null;
+          const _resolve = resolve14;
+          resolve14 = null;
           _resolve({
             chunk,
             done: false,
@@ -99713,8 +100036,8 @@ var require_duplexify = __commonJS({
           });
         },
         final(cb) {
-          const _resolve = resolve13;
-          resolve13 = null;
+          const _resolve = resolve14;
+          resolve14 = null;
           _resolve({
             done: true,
             cb
@@ -99727,7 +100050,7 @@ var require_duplexify = __commonJS({
       };
     }
     function _duplexify(pair) {
-      const r = pair.readable && typeof pair.readable.read !== "function" ? Readable2.wrap(pair.readable) : pair.readable;
+      const r = pair.readable && typeof pair.readable.read !== "function" ? Readable3.wrap(pair.readable) : pair.readable;
       const w = pair.writable;
       let readable = !!isReadable(r);
       let writable = !!isWritable(w);
@@ -99848,10 +100171,10 @@ var require_duplex = __commonJS({
       ObjectSetPrototypeOf
     } = require_primordials();
     module2.exports = Duplex;
-    var Readable2 = require_readable3();
+    var Readable3 = require_readable3();
     var Writable = require_writable();
-    ObjectSetPrototypeOf(Duplex.prototype, Readable2.prototype);
-    ObjectSetPrototypeOf(Duplex, Readable2);
+    ObjectSetPrototypeOf(Duplex.prototype, Readable3.prototype);
+    ObjectSetPrototypeOf(Duplex, Readable3);
     {
       const keys = ObjectKeys(Writable.prototype);
       for (let i = 0; i < keys.length; i++) {
@@ -99861,7 +100184,7 @@ var require_duplex = __commonJS({
     }
     function Duplex(options) {
       if (!(this instanceof Duplex)) return new Duplex(options);
-      Readable2.call(this, options);
+      Readable3.call(this, options);
       Writable.call(this, options);
       if (options) {
         this.allowHalfOpen = options.allowHalfOpen !== false;
@@ -99959,15 +100282,15 @@ var require_transform = __commonJS({
   "node_modules/readable-stream/lib/internal/streams/transform.js"(exports2, module2) {
     "use strict";
     var { ObjectSetPrototypeOf, Symbol: Symbol2 } = require_primordials();
-    module2.exports = Transform;
+    module2.exports = Transform5;
     var { ERR_METHOD_NOT_IMPLEMENTED } = require_errors4().codes;
     var Duplex = require_duplex();
     var { getHighWaterMark } = require_state3();
-    ObjectSetPrototypeOf(Transform.prototype, Duplex.prototype);
-    ObjectSetPrototypeOf(Transform, Duplex);
+    ObjectSetPrototypeOf(Transform5.prototype, Duplex.prototype);
+    ObjectSetPrototypeOf(Transform5, Duplex);
     var kCallback = Symbol2("kCallback");
-    function Transform(options) {
-      if (!(this instanceof Transform)) return new Transform(options);
+    function Transform5(options) {
+      if (!(this instanceof Transform5)) return new Transform5(options);
       const readableHighWaterMark = options ? getHighWaterMark(this, options, "readableHighWaterMark", true) : null;
       if (readableHighWaterMark === 0) {
         options = {
@@ -100021,11 +100344,11 @@ var require_transform = __commonJS({
         final.call(this);
       }
     }
-    Transform.prototype._final = final;
-    Transform.prototype._transform = function(chunk, encoding, callback) {
+    Transform5.prototype._final = final;
+    Transform5.prototype._transform = function(chunk, encoding, callback) {
       throw new ERR_METHOD_NOT_IMPLEMENTED("_transform()");
     };
-    Transform.prototype._write = function(chunk, encoding, callback) {
+    Transform5.prototype._write = function(chunk, encoding, callback) {
       const rState = this._readableState;
       const wState = this._writableState;
       const length = rState.length;
@@ -100046,7 +100369,7 @@ var require_transform = __commonJS({
         }
       });
     };
-    Transform.prototype._read = function() {
+    Transform5.prototype._read = function() {
       if (this[kCallback]) {
         const callback = this[kCallback];
         this[kCallback] = null;
@@ -100061,15 +100384,15 @@ var require_passthrough2 = __commonJS({
   "node_modules/readable-stream/lib/internal/streams/passthrough.js"(exports2, module2) {
     "use strict";
     var { ObjectSetPrototypeOf } = require_primordials();
-    module2.exports = PassThrough;
-    var Transform = require_transform();
-    ObjectSetPrototypeOf(PassThrough.prototype, Transform.prototype);
-    ObjectSetPrototypeOf(PassThrough, Transform);
-    function PassThrough(options) {
-      if (!(this instanceof PassThrough)) return new PassThrough(options);
-      Transform.call(this, options);
-    }
-    PassThrough.prototype._transform = function(chunk, encoding, cb) {
+    module2.exports = PassThrough3;
+    var Transform5 = require_transform();
+    ObjectSetPrototypeOf(PassThrough3.prototype, Transform5.prototype);
+    ObjectSetPrototypeOf(PassThrough3, Transform5);
+    function PassThrough3(options) {
+      if (!(this instanceof PassThrough3)) return new PassThrough3(options);
+      Transform5.call(this, options);
+    }
+    PassThrough3.prototype._transform = function(chunk, encoding, cb) {
       cb(null, chunk);
     };
   }
@@ -100087,7 +100410,7 @@ var require_pipeline4 = __commonJS({
     var {
       aggregateTwoErrors,
       codes: {
-        ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2,
+        ERR_INVALID_ARG_TYPE,
         ERR_INVALID_RETURN_VALUE,
         ERR_MISSING_ARGS,
         ERR_STREAM_DESTROYED,
@@ -100107,8 +100430,8 @@ var require_pipeline4 = __commonJS({
       isReadableFinished
     } = require_utils7();
     var AbortController2 = globalThis.AbortController || require_abort_controller().AbortController;
-    var PassThrough;
-    var Readable2;
+    var PassThrough3;
+    var Readable3;
     var addAbortListener;
     function destroyer(stream2, reading, writing) {
       let finished = false;
@@ -100144,13 +100467,13 @@ var require_pipeline4 = __commonJS({
       } else if (isReadableNodeStream(val)) {
         return fromReadable(val);
       }
-      throw new ERR_INVALID_ARG_TYPE2("val", ["Readable", "Iterable", "AsyncIterable"], val);
+      throw new ERR_INVALID_ARG_TYPE("val", ["Readable", "Iterable", "AsyncIterable"], val);
     }
     async function* fromReadable(val) {
-      if (!Readable2) {
-        Readable2 = require_readable3();
+      if (!Readable3) {
+        Readable3 = require_readable3();
       }
-      yield* Readable2.prototype[SymbolAsyncIterator].call(val);
+      yield* Readable3.prototype[SymbolAsyncIterator].call(val);
     }
     async function pumpToNode(iterable, writable, finish, { end }) {
       let error3;
@@ -100165,7 +100488,7 @@ var require_pipeline4 = __commonJS({
           callback();
         }
       };
-      const wait = () => new Promise2((resolve13, reject) => {
+      const wait = () => new Promise2((resolve14, reject) => {
         if (error3) {
           reject(error3);
         } else {
@@ -100173,7 +100496,7 @@ var require_pipeline4 = __commonJS({
             if (error3) {
               reject(error3);
             } else {
-              resolve13();
+              resolve14();
             }
           };
         }
@@ -100340,10 +100663,10 @@ var require_pipeline4 = __commonJS({
             }
           } else {
             var _ret2;
-            if (!PassThrough) {
-              PassThrough = require_passthrough2();
+            if (!PassThrough3) {
+              PassThrough3 = require_passthrough2();
             }
-            const pt = new PassThrough({
+            const pt = new PassThrough3({
               objectMode: true
             });
             const then = (_ret2 = ret) === null || _ret2 === void 0 ? void 0 : _ret2.then;
@@ -100408,7 +100731,7 @@ var require_pipeline4 = __commonJS({
               end
             });
           } else {
-            throw new ERR_INVALID_ARG_TYPE2(
+            throw new ERR_INVALID_ARG_TYPE(
               "val",
               ["Readable", "Iterable", "AsyncIterable", "ReadableStream", "TransformStream"],
               ret
@@ -100432,7 +100755,7 @@ var require_pipeline4 = __commonJS({
               end
             });
           } else {
-            throw new ERR_INVALID_ARG_TYPE2(
+            throw new ERR_INVALID_ARG_TYPE(
               "val",
               ["Readable", "Iterable", "AsyncIterable", "ReadableStream", "TransformStream"],
               ret
@@ -100702,7 +101025,7 @@ var require_operators = __commonJS({
     "use strict";
     var AbortController2 = globalThis.AbortController || require_abort_controller().AbortController;
     var {
-      codes: { ERR_INVALID_ARG_VALUE, ERR_INVALID_ARG_TYPE: ERR_INVALID_ARG_TYPE2, ERR_MISSING_ARGS, ERR_OUT_OF_RANGE },
+      codes: { ERR_INVALID_ARG_VALUE, ERR_INVALID_ARG_TYPE, ERR_MISSING_ARGS, ERR_OUT_OF_RANGE },
       AbortError
     } = require_errors4();
     var { validateAbortSignal, validateInteger, validateObject } = require_validators();
@@ -100745,7 +101068,7 @@ var require_operators = __commonJS({
     }
     function map(fn, options) {
       if (typeof fn !== "function") {
-        throw new ERR_INVALID_ARG_TYPE2("fn", ["Function", "AsyncFunction"], fn);
+        throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);
       }
       if (options != null) {
         validateObject(options, "options");
@@ -100769,7 +101092,7 @@ var require_operators = __commonJS({
           [options === null || options === void 0 ? void 0 : options.signal].filter(Boolean2)
         );
         const stream2 = this;
-        const queue = [];
+        const queue2 = [];
         const signalOpt = {
           signal
         };
@@ -100786,7 +101109,7 @@ var require_operators = __commonJS({
           maybeResume();
         }
         function maybeResume() {
-          if (resume && !done && cnt < concurrency && queue.length < highWaterMark) {
+          if (resume && !done && cnt < concurrency && queue2.length < highWaterMark) {
             resume();
             resume = null;
           }
@@ -100811,22 +101134,22 @@ var require_operators = __commonJS({
               }
               cnt += 1;
               PromisePrototypeThen(val, afterItemProcessed, onCatch);
-              queue.push(val);
+              queue2.push(val);
               if (next) {
                 next();
                 next = null;
               }
-              if (!done && (queue.length >= highWaterMark || cnt >= concurrency)) {
-                await new Promise2((resolve13) => {
-                  resume = resolve13;
+              if (!done && (queue2.length >= highWaterMark || cnt >= concurrency)) {
+                await new Promise2((resolve14) => {
+                  resume = resolve14;
                 });
               }
             }
-            queue.push(kEof);
+            queue2.push(kEof);
           } catch (err) {
             const val = PromiseReject(err);
             PromisePrototypeThen(val, afterItemProcessed, onCatch);
-            queue.push(val);
+            queue2.push(val);
           } finally {
             done = true;
             if (next) {
@@ -100838,8 +101161,8 @@ var require_operators = __commonJS({
         pump();
         try {
           while (true) {
-            while (queue.length > 0) {
-              const val = await queue[0];
+            while (queue2.length > 0) {
+              const val = await queue2[0];
               if (val === kEof) {
                 return;
               }
@@ -100849,11 +101172,11 @@ var require_operators = __commonJS({
               if (val !== kEmpty) {
                 yield val;
               }
-              queue.shift();
+              queue2.shift();
               maybeResume();
             }
-            await new Promise2((resolve13) => {
-              next = resolve13;
+            await new Promise2((resolve14) => {
+              next = resolve14;
             });
           }
         } finally {
@@ -100873,7 +101196,7 @@ var require_operators = __commonJS({
         validateAbortSignal(options.signal, "options.signal");
       }
       return async function* asIndexedPairs2() {
-        let index = 0;
+        let index2 = 0;
         for await (const val of this) {
           var _options$signal;
           if (options !== null && options !== void 0 && (_options$signal = options.signal) !== null && _options$signal !== void 0 && _options$signal.aborted) {
@@ -100881,19 +101204,19 @@ var require_operators = __commonJS({
               cause: options.signal.reason
             });
           }
-          yield [index++, val];
+          yield [index2++, val];
         }
       }.call(this);
     }
     async function some(fn, options = void 0) {
-      for await (const unused of filter.call(this, fn, options)) {
+      for await (const unused of filter2.call(this, fn, options)) {
         return true;
       }
       return false;
     }
     async function every(fn, options = void 0) {
       if (typeof fn !== "function") {
-        throw new ERR_INVALID_ARG_TYPE2("fn", ["Function", "AsyncFunction"], fn);
+        throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);
       }
       return !await some.call(
         this,
@@ -100904,14 +101227,14 @@ var require_operators = __commonJS({
       );
     }
     async function find3(fn, options) {
-      for await (const result of filter.call(this, fn, options)) {
+      for await (const result of filter2.call(this, fn, options)) {
         return result;
       }
       return void 0;
     }
     async function forEach(fn, options) {
       if (typeof fn !== "function") {
-        throw new ERR_INVALID_ARG_TYPE2("fn", ["Function", "AsyncFunction"], fn);
+        throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);
       }
       async function forEachFn(value, options2) {
         await fn(value, options2);
@@ -100919,9 +101242,9 @@ var require_operators = __commonJS({
       }
       for await (const unused of map.call(this, forEachFn, options)) ;
     }
-    function filter(fn, options) {
+    function filter2(fn, options) {
       if (typeof fn !== "function") {
-        throw new ERR_INVALID_ARG_TYPE2("fn", ["Function", "AsyncFunction"], fn);
+        throw new ERR_INVALID_ARG_TYPE("fn", ["Function", "AsyncFunction"], fn);
       }
       async function filterFn(value, options2) {
         if (await fn(value, options2)) {
@@ -100940,7 +101263,7 @@ var require_operators = __commonJS({
     async function reduce(reducer, initialValue, options) {
       var _options$signal2;
       if (typeof reducer !== "function") {
-        throw new ERR_INVALID_ARG_TYPE2("reducer", ["Function", "AsyncFunction"], reducer);
+        throw new ERR_INVALID_ARG_TYPE("reducer", ["Function", "AsyncFunction"], reducer);
       }
       if (options != null) {
         validateObject(options, "options");
@@ -101084,7 +101407,7 @@ var require_operators = __commonJS({
     module2.exports.streamReturningOperators = {
       asIndexedPairs: deprecate(asIndexedPairs, "readable.asIndexedPairs will be removed in a future version."),
       drop,
-      filter,
+      filter: filter2,
       flatMap,
       map,
       take,
@@ -101111,7 +101434,7 @@ var require_promises = __commonJS({
     var { finished } = require_end_of_stream();
     require_stream2();
     function pipeline(...streams) {
-      return new Promise2((resolve13, reject) => {
+      return new Promise2((resolve14, reject) => {
         let signal;
         let end;
         const lastArg = streams[streams.length - 1];
@@ -101126,7 +101449,7 @@ var require_promises = __commonJS({
             if (err) {
               reject(err);
             } else {
-              resolve13(value);
+              resolve14(value);
             }
           },
           {
@@ -101146,6 +101469,7 @@ var require_promises = __commonJS({
 // node_modules/readable-stream/lib/stream.js
 var require_stream2 = __commonJS({
   "node_modules/readable-stream/lib/stream.js"(exports2, module2) {
+    "use strict";
     var { Buffer: Buffer2 } = require("buffer");
     var { ObjectDefineProperty, ObjectKeys, ReflectApply } = require_primordials();
     var {
@@ -101170,57 +101494,53 @@ var require_stream2 = __commonJS({
     Stream.isWritable = utils.isWritable;
     Stream.Readable = require_readable3();
     for (const key of ObjectKeys(streamReturningOperators)) {
-      let fn2 = function(...args) {
+      let fn = function(...args) {
         if (new.target) {
           throw ERR_ILLEGAL_CONSTRUCTOR();
         }
         return Stream.Readable.from(ReflectApply(op, this, args));
       };
-      fn = fn2;
       const op = streamReturningOperators[key];
-      ObjectDefineProperty(fn2, "name", {
+      ObjectDefineProperty(fn, "name", {
         __proto__: null,
         value: op.name
       });
-      ObjectDefineProperty(fn2, "length", {
+      ObjectDefineProperty(fn, "length", {
         __proto__: null,
         value: op.length
       });
       ObjectDefineProperty(Stream.Readable.prototype, key, {
         __proto__: null,
-        value: fn2,
+        value: fn,
         enumerable: false,
         configurable: true,
         writable: true
       });
     }
-    var fn;
     for (const key of ObjectKeys(promiseReturningOperators)) {
-      let fn2 = function(...args) {
+      let fn = function(...args) {
         if (new.target) {
           throw ERR_ILLEGAL_CONSTRUCTOR();
         }
         return ReflectApply(op, this, args);
       };
-      fn = fn2;
       const op = promiseReturningOperators[key];
-      ObjectDefineProperty(fn2, "name", {
+      ObjectDefineProperty(fn, "name", {
         __proto__: null,
         value: op.name
       });
-      ObjectDefineProperty(fn2, "length", {
+      ObjectDefineProperty(fn, "length", {
         __proto__: null,
         value: op.length
       });
       ObjectDefineProperty(Stream.Readable.prototype, key, {
         __proto__: null,
-        value: fn2,
+        value: fn,
         enumerable: false,
         configurable: true,
         writable: true
       });
     }
-    var fn;
     Stream.Writable = require_writable();
     Stream.Duplex = require_duplex();
     Stream.Transform = require_transform();
@@ -101333,9 +101653,9 @@ var require_ours = __commonJS({
 var require_arrayPush = __commonJS({
   "node_modules/lodash/_arrayPush.js"(exports2, module2) {
     function arrayPush(array, values) {
-      var index = -1, length = values.length, offset = array.length;
-      while (++index < length) {
-        array[offset + index] = values[index];
+      var index2 = -1, length = values.length, offset = array.length;
+      while (++index2 < length) {
+        array[offset + index2] = values[index2];
       }
       return array;
     }
@@ -101363,11 +101683,11 @@ var require_baseFlatten = __commonJS({
     var arrayPush = require_arrayPush();
     var isFlattenable = require_isFlattenable();
     function baseFlatten(array, depth, predicate, isStrict, result) {
-      var index = -1, length = array.length;
+      var index2 = -1, length = array.length;
       predicate || (predicate = isFlattenable);
       result || (result = []);
-      while (++index < length) {
-        var value = array[index];
+      while (++index2 < length) {
+        var value = array[index2];
         if (depth > 0 && predicate(value)) {
           if (depth > 1) {
             baseFlatten(value, depth - 1, predicate, isStrict, result);
@@ -101486,10 +101806,10 @@ var require_Hash = __commonJS({
     var hashHas = require_hashHas();
     var hashSet = require_hashSet();
     function Hash(entries) {
-      var index = -1, length = entries == null ? 0 : entries.length;
+      var index2 = -1, length = entries == null ? 0 : entries.length;
       this.clear();
-      while (++index < length) {
-        var entry = entries[index];
+      while (++index2 < length) {
+        var entry = entries[index2];
         this.set(entry[0], entry[1]);
       }
     }
@@ -101537,15 +101857,15 @@ var require_listCacheDelete = __commonJS({
     var arrayProto = Array.prototype;
     var splice = arrayProto.splice;
     function listCacheDelete(key) {
-      var data = this.__data__, index = assocIndexOf(data, key);
-      if (index < 0) {
+      var data = this.__data__, index2 = assocIndexOf(data, key);
+      if (index2 < 0) {
         return false;
       }
       var lastIndex = data.length - 1;
-      if (index == lastIndex) {
+      if (index2 == lastIndex) {
         data.pop();
       } else {
-        splice.call(data, index, 1);
+        splice.call(data, index2, 1);
       }
       --this.size;
       return true;
@@ -101559,8 +101879,8 @@ var require_listCacheGet = __commonJS({
   "node_modules/lodash/_listCacheGet.js"(exports2, module2) {
     var assocIndexOf = require_assocIndexOf();
     function listCacheGet(key) {
-      var data = this.__data__, index = assocIndexOf(data, key);
-      return index < 0 ? void 0 : data[index][1];
+      var data = this.__data__, index2 = assocIndexOf(data, key);
+      return index2 < 0 ? void 0 : data[index2][1];
     }
     module2.exports = listCacheGet;
   }
@@ -101582,12 +101902,12 @@ var require_listCacheSet = __commonJS({
   "node_modules/lodash/_listCacheSet.js"(exports2, module2) {
     var assocIndexOf = require_assocIndexOf();
     function listCacheSet(key, value) {
-      var data = this.__data__, index = assocIndexOf(data, key);
-      if (index < 0) {
+      var data = this.__data__, index2 = assocIndexOf(data, key);
+      if (index2 < 0) {
         ++this.size;
         data.push([key, value]);
       } else {
-        data[index][1] = value;
+        data[index2][1] = value;
       }
       return this;
     }
@@ -101604,10 +101924,10 @@ var require_ListCache = __commonJS({
     var listCacheHas = require_listCacheHas();
     var listCacheSet = require_listCacheSet();
     function ListCache(entries) {
-      var index = -1, length = entries == null ? 0 : entries.length;
+      var index2 = -1, length = entries == null ? 0 : entries.length;
       this.clear();
-      while (++index < length) {
-        var entry = entries[index];
+      while (++index2 < length) {
+        var entry = entries[index2];
         this.set(entry[0], entry[1]);
       }
     }
@@ -101729,10 +102049,10 @@ var require_MapCache = __commonJS({
     var mapCacheHas = require_mapCacheHas();
     var mapCacheSet = require_mapCacheSet();
     function MapCache(entries) {
-      var index = -1, length = entries == null ? 0 : entries.length;
+      var index2 = -1, length = entries == null ? 0 : entries.length;
       this.clear();
-      while (++index < length) {
-        var entry = entries[index];
+      while (++index2 < length) {
+        var entry = entries[index2];
         this.set(entry[0], entry[1]);
       }
     }
@@ -101774,10 +102094,10 @@ var require_SetCache = __commonJS({
     var setCacheAdd = require_setCacheAdd();
     var setCacheHas = require_setCacheHas();
     function SetCache(values) {
-      var index = -1, length = values == null ? 0 : values.length;
+      var index2 = -1, length = values == null ? 0 : values.length;
       this.__data__ = new MapCache();
-      while (++index < length) {
-        this.add(values[index]);
+      while (++index2 < length) {
+        this.add(values[index2]);
       }
     }
     SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
@@ -101790,10 +102110,10 @@ var require_SetCache = __commonJS({
 var require_baseFindIndex = __commonJS({
   "node_modules/lodash/_baseFindIndex.js"(exports2, module2) {
     function baseFindIndex(array, predicate, fromIndex, fromRight) {
-      var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
-      while (fromRight ? index-- : ++index < length) {
-        if (predicate(array[index], index, array)) {
-          return index;
+      var length = array.length, index2 = fromIndex + (fromRight ? 1 : -1);
+      while (fromRight ? index2-- : ++index2 < length) {
+        if (predicate(array[index2], index2, array)) {
+          return index2;
         }
       }
       return -1;
@@ -101816,10 +102136,10 @@ var require_baseIsNaN = __commonJS({
 var require_strictIndexOf = __commonJS({
   "node_modules/lodash/_strictIndexOf.js"(exports2, module2) {
     function strictIndexOf(array, value, fromIndex) {
-      var index = fromIndex - 1, length = array.length;
-      while (++index < length) {
-        if (array[index] === value) {
-          return index;
+      var index2 = fromIndex - 1, length = array.length;
+      while (++index2 < length) {
+        if (array[index2] === value) {
+          return index2;
         }
       }
       return -1;
@@ -101857,9 +102177,9 @@ var require_arrayIncludes = __commonJS({
 var require_arrayIncludesWith = __commonJS({
   "node_modules/lodash/_arrayIncludesWith.js"(exports2, module2) {
     function arrayIncludesWith(array, value, comparator) {
-      var index = -1, length = array == null ? 0 : array.length;
-      while (++index < length) {
-        if (comparator(value, array[index])) {
+      var index2 = -1, length = array == null ? 0 : array.length;
+      while (++index2 < length) {
+        if (comparator(value, array[index2])) {
           return true;
         }
       }
@@ -101873,9 +102193,9 @@ var require_arrayIncludesWith = __commonJS({
 var require_arrayMap = __commonJS({
   "node_modules/lodash/_arrayMap.js"(exports2, module2) {
     function arrayMap(array, iteratee) {
-      var index = -1, length = array == null ? 0 : array.length, result = Array(length);
-      while (++index < length) {
-        result[index] = iteratee(array[index], index, array);
+      var index2 = -1, length = array == null ? 0 : array.length, result = Array(length);
+      while (++index2 < length) {
+        result[index2] = iteratee(array[index2], index2, array);
       }
       return result;
     }
@@ -101904,7 +102224,7 @@ var require_baseDifference = __commonJS({
     var cacheHas = require_cacheHas();
     var LARGE_ARRAY_SIZE = 200;
     function baseDifference(array, values, iteratee, comparator) {
-      var index = -1, includes = arrayIncludes, isCommon = true, length = array.length, result = [], valuesLength = values.length;
+      var index2 = -1, includes = arrayIncludes, isCommon = true, length = array.length, result = [], valuesLength = values.length;
       if (!length) {
         return result;
       }
@@ -101920,8 +102240,8 @@ var require_baseDifference = __commonJS({
         values = new SetCache(values);
       }
       outer:
-        while (++index < length) {
-          var value = array[index], computed = iteratee == null ? value : iteratee(value);
+        while (++index2 < length) {
+          var value = array[index2], computed = iteratee == null ? value : iteratee(value);
           value = comparator || value !== 0 ? value : 0;
           if (isCommon && computed === computed) {
             var valuesIndex = valuesLength;
@@ -101990,9 +102310,9 @@ var require_noop = __commonJS({
 var require_setToArray = __commonJS({
   "node_modules/lodash/_setToArray.js"(exports2, module2) {
     function setToArray(set) {
-      var index = -1, result = Array(set.size);
+      var index2 = -1, result = Array(set.size);
       set.forEach(function(value) {
-        result[++index] = value;
+        result[++index2] = value;
       });
       return result;
     }
@@ -102025,7 +102345,7 @@ var require_baseUniq = __commonJS({
     var setToArray = require_setToArray();
     var LARGE_ARRAY_SIZE = 200;
     function baseUniq(array, iteratee, comparator) {
-      var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
+      var index2 = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
       if (comparator) {
         isCommon = false;
         includes = arrayIncludesWith;
@@ -102041,8 +102361,8 @@ var require_baseUniq = __commonJS({
         seen = iteratee ? [] : result;
       }
       outer:
-        while (++index < length) {
-          var value = array[index], computed = iteratee ? iteratee(value) : value;
+        while (++index2 < length) {
+          var value = array[index2], computed = iteratee ? iteratee(value) : value;
           value = comparator || value !== 0 ? value : 0;
           if (isCommon && computed === computed) {
             var seenIndex = seen.length;
@@ -102136,9 +102456,9 @@ var require_commonjs18 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.range = exports2.balanced = void 0;
-    var balanced = (a, b, str) => {
-      const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
-      const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+    var balanced2 = (a, b, str) => {
+      const ma = a instanceof RegExp ? maybeMatch2(a, str) : a;
+      const mb = b instanceof RegExp ? maybeMatch2(b, str) : b;
       const r = ma !== null && mb != null && (0, exports2.range)(ma, mb, str);
       return r && {
         start: r[0],
@@ -102148,12 +102468,12 @@ var require_commonjs18 = __commonJS({
         post: str.slice(r[1] + mb.length)
       };
     };
-    exports2.balanced = balanced;
-    var maybeMatch = (reg, str) => {
+    exports2.balanced = balanced2;
+    var maybeMatch2 = (reg, str) => {
       const m = str.match(reg);
       return m ? m[0] : null;
     };
-    var range = (a, b, str) => {
+    var range2 = (a, b, str) => {
       let begs, beg, left, right = void 0, result;
       let ai = str.indexOf(a);
       let bi = str.indexOf(b, ai + 1);
@@ -102188,7 +102508,7 @@ var require_commonjs18 = __commonJS({
       }
       return result;
     };
-    exports2.range = range;
+    exports2.range = range2;
   }
 });
 
@@ -102198,34 +102518,34 @@ var require_commonjs19 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.EXPANSION_MAX = void 0;
-    exports2.expand = expand2;
+    exports2.expand = expand3;
     var balanced_match_1 = require_commonjs18();
-    var escSlash = "\0SLASH" + Math.random() + "\0";
-    var escOpen = "\0OPEN" + Math.random() + "\0";
-    var escClose = "\0CLOSE" + Math.random() + "\0";
-    var escComma = "\0COMMA" + Math.random() + "\0";
-    var escPeriod = "\0PERIOD" + Math.random() + "\0";
-    var escSlashPattern = new RegExp(escSlash, "g");
-    var escOpenPattern = new RegExp(escOpen, "g");
-    var escClosePattern = new RegExp(escClose, "g");
-    var escCommaPattern = new RegExp(escComma, "g");
-    var escPeriodPattern = new RegExp(escPeriod, "g");
-    var slashPattern = /\\\\/g;
-    var openPattern = /\\{/g;
-    var closePattern = /\\}/g;
-    var commaPattern = /\\,/g;
-    var periodPattern = /\\\./g;
+    var escSlash2 = "\0SLASH" + Math.random() + "\0";
+    var escOpen2 = "\0OPEN" + Math.random() + "\0";
+    var escClose2 = "\0CLOSE" + Math.random() + "\0";
+    var escComma2 = "\0COMMA" + Math.random() + "\0";
+    var escPeriod2 = "\0PERIOD" + Math.random() + "\0";
+    var escSlashPattern2 = new RegExp(escSlash2, "g");
+    var escOpenPattern2 = new RegExp(escOpen2, "g");
+    var escClosePattern2 = new RegExp(escClose2, "g");
+    var escCommaPattern2 = new RegExp(escComma2, "g");
+    var escPeriodPattern2 = new RegExp(escPeriod2, "g");
+    var slashPattern2 = /\\\\/g;
+    var openPattern2 = /\\{/g;
+    var closePattern2 = /\\}/g;
+    var commaPattern2 = /\\,/g;
+    var periodPattern2 = /\\\./g;
     exports2.EXPANSION_MAX = 1e5;
-    function numeric(str) {
+    function numeric2(str) {
       return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
     }
-    function escapeBraces(str) {
-      return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+    function escapeBraces2(str) {
+      return str.replace(slashPattern2, escSlash2).replace(openPattern2, escOpen2).replace(closePattern2, escClose2).replace(commaPattern2, escComma2).replace(periodPattern2, escPeriod2);
     }
-    function unescapeBraces(str) {
-      return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+    function unescapeBraces2(str) {
+      return str.replace(escSlashPattern2, "\\").replace(escOpenPattern2, "{").replace(escClosePattern2, "}").replace(escCommaPattern2, ",").replace(escPeriodPattern2, ".");
     }
-    function parseCommaParts(str) {
+    function parseCommaParts2(str) {
       if (!str) {
         return [""];
       }
@@ -102237,7 +102557,7 @@ var require_commonjs19 = __commonJS({
       const { pre, body, post } = m;
       const p = pre.split(",");
       p[p.length - 1] += "{" + body + "}";
-      const postParts = parseCommaParts(post);
+      const postParts = parseCommaParts2(post);
       if (post.length) {
         ;
         p[p.length - 1] += postParts.shift();
@@ -102246,7 +102566,7 @@ var require_commonjs19 = __commonJS({
       parts.push.apply(parts, p);
       return parts;
     }
-    function expand2(str, options = {}) {
+    function expand3(str, options = {}) {
       if (!str) {
         return [];
       }
@@ -102254,27 +102574,27 @@ var require_commonjs19 = __commonJS({
       if (str.slice(0, 2) === "{}") {
         str = "\\{\\}" + str.slice(2);
       }
-      return expand_(escapeBraces(str), max, true).map(unescapeBraces);
+      return expand_2(escapeBraces2(str), max, true).map(unescapeBraces2);
     }
-    function embrace(str) {
+    function embrace2(str) {
       return "{" + str + "}";
     }
-    function isPadded(el) {
+    function isPadded2(el) {
       return /^-?0\d/.test(el);
     }
-    function lte(i, y) {
+    function lte2(i, y) {
       return i <= y;
     }
-    function gte6(i, y) {
+    function gte7(i, y) {
       return i >= y;
     }
-    function expand_(str, max, isTop) {
+    function expand_2(str, max, isTop) {
       const expansions = [];
       const m = (0, balanced_match_1.balanced)("{", "}", str);
       if (!m)
         return [str];
       const pre = m.pre;
-      const post = m.post.length ? expand_(m.post, max, false) : [""];
+      const post = m.post.length ? expand_2(m.post, max, false) : [""];
       if (/\$$/.test(m.pre)) {
         for (let k = 0; k < post.length && k < max; k++) {
           const expansion = pre + "{" + m.body + "}" + post[k];
@@ -102287,8 +102607,8 @@ var require_commonjs19 = __commonJS({
         const isOptions = m.body.indexOf(",") >= 0;
         if (!isSequence && !isOptions) {
           if (m.post.match(/,(?!,).*\}/)) {
-            str = m.pre + "{" + m.body + escClose + m.post;
-            return expand_(str, max, true);
+            str = m.pre + "{" + m.body + escClose2 + m.post;
+            return expand_2(str, max, true);
           }
           return [str];
         }
@@ -102296,9 +102616,9 @@ var require_commonjs19 = __commonJS({
         if (isSequence) {
           n = m.body.split(/\.\./);
         } else {
-          n = parseCommaParts(m.body);
+          n = parseCommaParts2(m.body);
           if (n.length === 1 && n[0] !== void 0) {
-            n = expand_(n[0], max, false).map(embrace);
+            n = expand_2(n[0], max, false).map(embrace2);
             if (n.length === 1) {
               return post.map((p) => m.pre + n[0] + p);
             }
@@ -102306,17 +102626,17 @@ var require_commonjs19 = __commonJS({
         }
         let N;
         if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
-          const x = numeric(n[0]);
-          const y = numeric(n[1]);
+          const x = numeric2(n[0]);
+          const y = numeric2(n[1]);
           const width = Math.max(n[0].length, n[1].length);
-          let incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
-          let test = lte;
+          let incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric2(n[2])), 1) : 1;
+          let test = lte2;
           const reverse = y < x;
           if (reverse) {
             incr *= -1;
-            test = gte6;
+            test = gte7;
           }
-          const pad = n.some(isPadded);
+          const pad = n.some(isPadded2);
           N = [];
           for (let i = x; test(i, y) && N.length < max; i += incr) {
             let c;
@@ -102344,7 +102664,7 @@ var require_commonjs19 = __commonJS({
         } else {
           N = [];
           for (let j = 0; j < n.length; j++) {
-            N.push.apply(N, expand_(n[j], max, false));
+            N.push.apply(N, expand_2(n[j], max, false));
           }
         }
         for (let j = 0; j < N.length; j++) {
@@ -102367,16 +102687,16 @@ var require_assert_valid_pattern = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.assertValidPattern = void 0;
-    var MAX_PATTERN_LENGTH = 1024 * 64;
-    var assertValidPattern = (pattern) => {
+    var MAX_PATTERN_LENGTH2 = 1024 * 64;
+    var assertValidPattern2 = (pattern) => {
       if (typeof pattern !== "string") {
         throw new TypeError("invalid pattern");
       }
-      if (pattern.length > MAX_PATTERN_LENGTH) {
+      if (pattern.length > MAX_PATTERN_LENGTH2) {
         throw new TypeError("pattern is too long");
       }
     };
-    exports2.assertValidPattern = assertValidPattern;
+    exports2.assertValidPattern = assertValidPattern2;
   }
 });
 
@@ -102386,7 +102706,7 @@ var require_brace_expressions = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.parseClass = void 0;
-    var posixClasses = {
+    var posixClasses2 = {
       "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
       "[:alpha:]": ["\\p{L}\\p{Nl}", true],
       "[:ascii:]": ["\\x00-\\x7f", false],
@@ -102402,10 +102722,10 @@ var require_brace_expressions = __commonJS({
       "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
       "[:xdigit:]": ["A-Fa-f0-9", false]
     };
-    var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
-    var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-    var rangesToString = (ranges) => ranges.join("");
-    var parseClass = (glob2, position) => {
+    var braceEscape2 = (s) => s.replace(/[[\]\\-]/g, "\\$&");
+    var regexpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    var rangesToString2 = (ranges) => ranges.join("");
+    var parseClass2 = (glob2, position) => {
       const pos = position;
       if (glob2.charAt(pos) !== "[") {
         throw new Error("not in a brace expression");
@@ -102439,7 +102759,7 @@ var require_brace_expressions = __commonJS({
           }
         }
         if (c === "[" && !escaping) {
-          for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
+          for (const [cls, [unip, u, neg]] of Object.entries(posixClasses2)) {
             if (glob2.startsWith(cls, i)) {
               if (rangeStart) {
                 return ["$.", false, glob2.length - pos, true];
@@ -102457,16 +102777,16 @@ var require_brace_expressions = __commonJS({
         escaping = false;
         if (rangeStart) {
           if (c > rangeStart) {
-            ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
+            ranges.push(braceEscape2(rangeStart) + "-" + braceEscape2(c));
           } else if (c === rangeStart) {
-            ranges.push(braceEscape(c));
+            ranges.push(braceEscape2(c));
           }
           rangeStart = "";
           i++;
           continue;
         }
         if (glob2.startsWith("-]", i + 1)) {
-          ranges.push(braceEscape(c + "-"));
+          ranges.push(braceEscape2(c + "-"));
           i += 2;
           continue;
         }
@@ -102475,7 +102795,7 @@ var require_brace_expressions = __commonJS({
           i += 2;
           continue;
         }
-        ranges.push(braceEscape(c));
+        ranges.push(braceEscape2(c));
         i++;
       }
       if (endPos < i) {
@@ -102486,14 +102806,14 @@ var require_brace_expressions = __commonJS({
       }
       if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate2) {
         const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
-        return [regexpEscape(r), false, endPos - pos, false];
+        return [regexpEscape2(r), false, endPos - pos, false];
       }
-      const sranges = "[" + (negate2 ? "^" : "") + rangesToString(ranges) + "]";
-      const snegs = "[" + (negate2 ? "" : "^") + rangesToString(negs) + "]";
+      const sranges = "[" + (negate2 ? "^" : "") + rangesToString2(ranges) + "]";
+      const snegs = "[" + (negate2 ? "" : "^") + rangesToString2(negs) + "]";
       const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
       return [comb, uflag, endPos - pos, true];
     };
-    exports2.parseClass = parseClass;
+    exports2.parseClass = parseClass2;
   }
 });
 
@@ -102503,13 +102823,13 @@ var require_unescape = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.unescape = void 0;
-    var unescape2 = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
+    var unescape3 = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
       if (magicalBraces) {
         return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
       }
       return windowsPathsNoEscape ? s.replace(/\[([^\/\\{}])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
     };
-    exports2.unescape = unescape2;
+    exports2.unescape = unescape3;
   }
 });
 
@@ -102517,34 +102837,34 @@ var require_unescape = __commonJS({
 var require_ast = __commonJS({
   "node_modules/glob/node_modules/minimatch/dist/commonjs/ast.js"(exports2) {
     "use strict";
-    var _a;
+    var _a2;
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.AST = void 0;
     var brace_expressions_js_1 = require_brace_expressions();
     var unescape_js_1 = require_unescape();
-    var types2 = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
-    var isExtglobType = (c) => types2.has(c);
-    var isExtglobAST = (c) => isExtglobType(c.type);
-    var adoptionMap = /* @__PURE__ */ new Map([
+    var types3 = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
+    var isExtglobType2 = (c) => types3.has(c);
+    var isExtglobAST2 = (c) => isExtglobType2(c.type);
+    var adoptionMap2 = /* @__PURE__ */ new Map([
       ["!", ["@"]],
       ["?", ["?", "@"]],
       ["@", ["@"]],
       ["*", ["*", "+", "?", "@"]],
       ["+", ["+", "@"]]
     ]);
-    var adoptionWithSpaceMap = /* @__PURE__ */ new Map([
+    var adoptionWithSpaceMap2 = /* @__PURE__ */ new Map([
       ["!", ["?"]],
       ["@", ["?"]],
       ["+", ["?", "*"]]
     ]);
-    var adoptionAnyMap = /* @__PURE__ */ new Map([
+    var adoptionAnyMap2 = /* @__PURE__ */ new Map([
       ["!", ["?", "@"]],
       ["?", ["?", "@"]],
       ["@", ["?", "@"]],
       ["*", ["*", "+", "?", "@"]],
       ["+", ["+", "@", "?", "*"]]
     ]);
-    var usurpMap = /* @__PURE__ */ new Map([
+    var usurpMap2 = /* @__PURE__ */ new Map([
       ["!", /* @__PURE__ */ new Map([["!", "@"]])],
       [
         "?",
@@ -102571,17 +102891,17 @@ var require_ast = __commonJS({
         ])
       ]
     ]);
-    var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
-    var startNoDot = "(?!\\.)";
-    var addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
-    var justDots = /* @__PURE__ */ new Set(["..", "."]);
-    var reSpecials = new Set("().*{}+?[]^$\\!");
-    var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-    var qmark = "[^/]";
-    var star = qmark + "*?";
-    var starNoEmpty = qmark + "+?";
-    var ID = 0;
-    var AST = class {
+    var startNoTraversal2 = "(?!(?:^|/)\\.\\.?(?:$|/))";
+    var startNoDot2 = "(?!\\.)";
+    var addPatternStart2 = /* @__PURE__ */ new Set(["[", "."]);
+    var justDots2 = /* @__PURE__ */ new Set(["..", "."]);
+    var reSpecials2 = new Set("().*{}+?[]^$\\!");
+    var regExpEscape3 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    var qmark3 = "[^/]";
+    var star3 = qmark3 + "*?";
+    var starNoEmpty2 = qmark3 + "+?";
+    var ID2 = 0;
+    var AST2 = class {
       type;
       #root;
       #hasMagic;
@@ -102596,7 +102916,7 @@ var require_ast = __commonJS({
       // set to true if it's an extglob with no children
       // (which really means one child of '')
       #emptyExt = false;
-      id = ++ID;
+      id = ++ID2;
       get depth() {
         return (this.#parent?.depth ?? -1) + 1;
       }
@@ -102677,7 +102997,7 @@ var require_ast = __commonJS({
         for (const p of parts) {
           if (p === "")
             continue;
-          if (typeof p !== "string" && !(p instanceof _a && p.#parent === this)) {
+          if (typeof p !== "string" && !(p instanceof _a2 && p.#parent === this)) {
             throw new Error("invalid part: " + p);
           }
           this.#parts.push(p);
@@ -102702,7 +103022,7 @@ var require_ast = __commonJS({
         const p = this.#parent;
         for (let i = 0; i < this.#parentIndex; i++) {
           const pp = p.#parts[i];
-          if (!(pp instanceof _a && pp.type === "!")) {
+          if (!(pp instanceof _a2 && pp.type === "!")) {
             return false;
           }
         }
@@ -102727,7 +103047,7 @@ var require_ast = __commonJS({
           this.push(part.clone(this));
       }
       clone(parent) {
-        const c = new _a(this.type, parent);
+        const c = new _a2(this.type, parent);
         for (const p of this.#parts) {
           c.copyIn(p);
         }
@@ -102766,13 +103086,13 @@ var require_ast = __commonJS({
               acc2 += c;
               continue;
             }
-            const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i2) === "(" && extDepth <= maxDepth;
+            const doRecurse = !opt.noext && isExtglobType2(c) && str.charAt(i2) === "(" && extDepth <= maxDepth;
             if (doRecurse) {
               ast.push(acc2);
               acc2 = "";
-              const ext = new _a(c, ast);
-              i2 = _a.#parseAST(str, ext, i2, opt, extDepth + 1);
-              ast.push(ext);
+              const ext2 = new _a2(c, ast);
+              i2 = _a2.#parseAST(str, ext2, i2, opt, extDepth + 1);
+              ast.push(ext2);
               continue;
             }
             acc2 += c;
@@ -102781,7 +103101,7 @@ var require_ast = __commonJS({
           return i2;
         }
         let i = pos + 1;
-        let part = new _a(null, ast);
+        let part = new _a2(null, ast);
         const parts = [];
         let acc = "";
         while (i < str.length) {
@@ -102808,22 +103128,22 @@ var require_ast = __commonJS({
             acc += c;
             continue;
           }
-          const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
+          const doRecurse = !opt.noext && isExtglobType2(c) && str.charAt(i) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
           (extDepth <= maxDepth || ast && ast.#canAdoptType(c));
           if (doRecurse) {
             const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
             part.push(acc);
             acc = "";
-            const ext = new _a(c, part);
-            part.push(ext);
-            i = _a.#parseAST(str, ext, i, opt, extDepth + depthAdd);
+            const ext2 = new _a2(c, part);
+            part.push(ext2);
+            i = _a2.#parseAST(str, ext2, i, opt, extDepth + depthAdd);
             continue;
           }
           if (c === "|") {
             part.push(acc);
             acc = "";
             parts.push(part);
-            part = new _a(null, ast);
+            part = new _a2(null, ast);
             continue;
           }
           if (c === ")") {
@@ -102843,9 +103163,9 @@ var require_ast = __commonJS({
         return i;
       }
       #canAdoptWithSpace(child) {
-        return this.#canAdopt(child, adoptionWithSpaceMap);
+        return this.#canAdopt(child, adoptionWithSpaceMap2);
       }
-      #canAdopt(child, map = adoptionMap) {
+      #canAdopt(child, map = adoptionMap2) {
         if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null) {
           return false;
         }
@@ -102855,19 +103175,19 @@ var require_ast = __commonJS({
         }
         return this.#canAdoptType(gc.type, map);
       }
-      #canAdoptType(c, map = adoptionAnyMap) {
+      #canAdoptType(c, map = adoptionAnyMap2) {
         return !!map.get(this.type)?.includes(c);
       }
-      #adoptWithSpace(child, index) {
+      #adoptWithSpace(child, index2) {
         const gc = child.#parts[0];
-        const blank = new _a(null, gc, this.options);
+        const blank = new _a2(null, gc, this.options);
         blank.#parts.push("");
         gc.push(blank);
-        this.#adopt(child, index);
+        this.#adopt(child, index2);
       }
-      #adopt(child, index) {
+      #adopt(child, index2) {
         const gc = child.#parts[0];
-        this.#parts.splice(index, 1, ...gc.#parts);
+        this.#parts.splice(index2, 1, ...gc.#parts);
         for (const p of gc.#parts) {
           if (typeof p === "object")
             p.#parent = this;
@@ -102875,7 +103195,7 @@ var require_ast = __commonJS({
         this.#toString = void 0;
       }
       #canUsurpType(c) {
-        const m = usurpMap.get(this.type);
+        const m = usurpMap2.get(this.type);
         return !!m?.has(c);
       }
       #canUsurp(child) {
@@ -102889,7 +103209,7 @@ var require_ast = __commonJS({
         return this.#canUsurpType(gc.type);
       }
       #usurp(child) {
-        const m = usurpMap.get(this.type);
+        const m = usurpMap2.get(this.type);
         const gc = child.#parts[0];
         const nt = m?.get(gc.type);
         if (!nt)
@@ -102905,8 +103225,8 @@ var require_ast = __commonJS({
         this.#emptyExt = false;
       }
       static fromGlob(pattern, options = {}) {
-        const ast = new _a(null, void 0, options);
-        _a.#parseAST(pattern, ast, 0, options, 0);
+        const ast = new _a2(null, void 0, options);
+        _a2.#parseAST(pattern, ast, 0, options, 0);
         return ast;
       }
       // returns the regular expression if there's magic, or the unescaped
@@ -103004,10 +103324,10 @@ var require_ast = __commonJS({
           this.#flatten();
           this.#fillNegs();
         }
-        if (!isExtglobAST(this)) {
+        if (!isExtglobAST2(this)) {
           const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s) => typeof s !== "string");
           const src = this.#parts.map((p) => {
-            const [re, _2, hasMagic, uflag] = typeof p === "string" ? _a.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+            const [re, _2, hasMagic, uflag] = typeof p === "string" ? _a2.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
             this.#hasMagic = this.#hasMagic || hasMagic;
             this.#uflag = this.#uflag || uflag;
             return re;
@@ -103015,9 +103335,9 @@ var require_ast = __commonJS({
           let start2 = "";
           if (this.isStart()) {
             if (typeof this.#parts[0] === "string") {
-              const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
+              const dotTravAllowed = this.#parts.length === 1 && justDots2.has(this.#parts[0]);
               if (!dotTravAllowed) {
-                const aps = addPatternStart;
+                const aps = addPatternStart2;
                 const needNoTrav = (
                   // dots are allowed, and the pattern starts with [ or .
                   dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
@@ -103025,7 +103345,7 @@ var require_ast = __commonJS({
                   src.startsWith("\\.\\.") && aps.has(src.charAt(4))
                 );
                 const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
-                start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
+                start2 = needNoTrav ? startNoTraversal2 : needNoDot ? startNoDot2 : "";
               }
             }
           }
@@ -103052,7 +103372,7 @@ var require_ast = __commonJS({
           me.#hasMagic = void 0;
           return [s, (0, unescape_js_1.unescape)(this.toString()), false, false];
         }
-        let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
+        let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot2 ? "" : this.#partsToRegExp(true);
         if (bodyDotAllowed === body) {
           bodyDotAllowed = "";
         }
@@ -103061,11 +103381,11 @@ var require_ast = __commonJS({
         }
         let final = "";
         if (this.type === "!" && this.#emptyExt) {
-          final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
+          final = (this.isStart() && !dot ? startNoDot2 : "") + starNoEmpty2;
         } else {
           const close = this.type === "!" ? (
             // !() must match something,but !(x) can match ''
-            "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")"
+            "))" + (this.isStart() && !dot && !allowDot ? startNoDot2 : "") + star3 + ")"
           ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
           final = start + body + close;
         }
@@ -103077,7 +103397,7 @@ var require_ast = __commonJS({
         ];
       }
       #flatten() {
-        if (!isExtglobAST(this)) {
+        if (!isExtglobAST2(this)) {
           for (const p of this.#parts) {
             if (typeof p === "object") {
               p.#flatten();
@@ -103127,14 +103447,14 @@ var require_ast = __commonJS({
           const c = glob2.charAt(i);
           if (escaping) {
             escaping = false;
-            re += (reSpecials.has(c) ? "\\" : "") + c;
+            re += (reSpecials2.has(c) ? "\\" : "") + c;
             continue;
           }
           if (c === "*") {
             if (inStar)
               continue;
             inStar = true;
-            re += noEmpty && /^[*]+$/.test(glob2) ? starNoEmpty : star;
+            re += noEmpty && /^[*]+$/.test(glob2) ? starNoEmpty2 : star3;
             hasMagic = true;
             continue;
           } else {
@@ -103159,17 +103479,17 @@ var require_ast = __commonJS({
             }
           }
           if (c === "?") {
-            re += qmark;
+            re += qmark3;
             hasMagic = true;
             continue;
           }
-          re += regExpEscape(c);
+          re += regExpEscape3(c);
         }
         return [re, (0, unescape_js_1.unescape)(glob2), !!hasMagic, uflag];
       }
     };
-    exports2.AST = AST;
-    _a = AST;
+    exports2.AST = AST2;
+    _a2 = AST2;
   }
 });
 
@@ -103179,13 +103499,13 @@ var require_escape = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.escape = void 0;
-    var escape2 = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
+    var escape3 = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
       if (magicalBraces) {
         return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
       }
       return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
     };
-    exports2.escape = escape2;
+    exports2.escape = escape3;
   }
 });
 
@@ -103200,144 +103520,144 @@ var require_commonjs20 = __commonJS({
     var ast_js_1 = require_ast();
     var escape_js_1 = require_escape();
     var unescape_js_1 = require_unescape();
-    var minimatch = (p, pattern, options = {}) => {
+    var minimatch2 = (p, pattern, options = {}) => {
       (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
       if (!options.nocomment && pattern.charAt(0) === "#") {
         return false;
       }
-      return new Minimatch(pattern, options).match(p);
-    };
-    exports2.minimatch = minimatch;
-    var starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
-    var starDotExtTest = (ext2) => (f) => !f.startsWith(".") && f.endsWith(ext2);
-    var starDotExtTestDot = (ext2) => (f) => f.endsWith(ext2);
-    var starDotExtTestNocase = (ext2) => {
-      ext2 = ext2.toLowerCase();
-      return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext2);
-    };
-    var starDotExtTestNocaseDot = (ext2) => {
-      ext2 = ext2.toLowerCase();
-      return (f) => f.toLowerCase().endsWith(ext2);
-    };
-    var starDotStarRE = /^\*+\.\*+$/;
-    var starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
-    var starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
-    var dotStarRE = /^\.\*+$/;
-    var dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
-    var starRE = /^\*+$/;
-    var starTest = (f) => f.length !== 0 && !f.startsWith(".");
-    var starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
-    var qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
-    var qmarksTestNocase = ([$0, ext2 = ""]) => {
-      const noext = qmarksTestNoExt([$0]);
-      if (!ext2)
+      return new Minimatch2(pattern, options).match(p);
+    };
+    exports2.minimatch = minimatch2;
+    var starDotExtRE2 = /^\*+([^+@!?\*\[\(]*)$/;
+    var starDotExtTest2 = (ext3) => (f) => !f.startsWith(".") && f.endsWith(ext3);
+    var starDotExtTestDot2 = (ext3) => (f) => f.endsWith(ext3);
+    var starDotExtTestNocase2 = (ext3) => {
+      ext3 = ext3.toLowerCase();
+      return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext3);
+    };
+    var starDotExtTestNocaseDot2 = (ext3) => {
+      ext3 = ext3.toLowerCase();
+      return (f) => f.toLowerCase().endsWith(ext3);
+    };
+    var starDotStarRE2 = /^\*+\.\*+$/;
+    var starDotStarTest2 = (f) => !f.startsWith(".") && f.includes(".");
+    var starDotStarTestDot2 = (f) => f !== "." && f !== ".." && f.includes(".");
+    var dotStarRE2 = /^\.\*+$/;
+    var dotStarTest2 = (f) => f !== "." && f !== ".." && f.startsWith(".");
+    var starRE2 = /^\*+$/;
+    var starTest2 = (f) => f.length !== 0 && !f.startsWith(".");
+    var starTestDot2 = (f) => f.length !== 0 && f !== "." && f !== "..";
+    var qmarksRE2 = /^\?+([^+@!?\*\[\(]*)?$/;
+    var qmarksTestNocase2 = ([$0, ext3 = ""]) => {
+      const noext = qmarksTestNoExt2([$0]);
+      if (!ext3)
         return noext;
-      ext2 = ext2.toLowerCase();
-      return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+      ext3 = ext3.toLowerCase();
+      return (f) => noext(f) && f.toLowerCase().endsWith(ext3);
     };
-    var qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
-      const noext = qmarksTestNoExtDot([$0]);
-      if (!ext2)
+    var qmarksTestNocaseDot2 = ([$0, ext3 = ""]) => {
+      const noext = qmarksTestNoExtDot2([$0]);
+      if (!ext3)
         return noext;
-      ext2 = ext2.toLowerCase();
-      return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+      ext3 = ext3.toLowerCase();
+      return (f) => noext(f) && f.toLowerCase().endsWith(ext3);
     };
-    var qmarksTestDot = ([$0, ext2 = ""]) => {
-      const noext = qmarksTestNoExtDot([$0]);
-      return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+    var qmarksTestDot2 = ([$0, ext3 = ""]) => {
+      const noext = qmarksTestNoExtDot2([$0]);
+      return !ext3 ? noext : (f) => noext(f) && f.endsWith(ext3);
     };
-    var qmarksTest = ([$0, ext2 = ""]) => {
-      const noext = qmarksTestNoExt([$0]);
-      return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+    var qmarksTest2 = ([$0, ext3 = ""]) => {
+      const noext = qmarksTestNoExt2([$0]);
+      return !ext3 ? noext : (f) => noext(f) && f.endsWith(ext3);
     };
-    var qmarksTestNoExt = ([$0]) => {
+    var qmarksTestNoExt2 = ([$0]) => {
       const len = $0.length;
       return (f) => f.length === len && !f.startsWith(".");
     };
-    var qmarksTestNoExtDot = ([$0]) => {
+    var qmarksTestNoExtDot2 = ([$0]) => {
       const len = $0.length;
       return (f) => f.length === len && f !== "." && f !== "..";
     };
-    var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-    var path28 = {
+    var defaultPlatform2 = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+    var path29 = {
       win32: { sep: "\\" },
       posix: { sep: "/" }
     };
-    exports2.sep = defaultPlatform === "win32" ? path28.win32.sep : path28.posix.sep;
+    exports2.sep = defaultPlatform2 === "win32" ? path29.win32.sep : path29.posix.sep;
     exports2.minimatch.sep = exports2.sep;
     exports2.GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
     exports2.minimatch.GLOBSTAR = exports2.GLOBSTAR;
-    var qmark = "[^/]";
-    var star = qmark + "*?";
-    var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
-    var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
-    var filter = (pattern, options = {}) => (p) => (0, exports2.minimatch)(p, pattern, options);
-    exports2.filter = filter;
+    var qmark3 = "[^/]";
+    var star3 = qmark3 + "*?";
+    var twoStarDot2 = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+    var twoStarNoDot2 = "(?:(?!(?:\\/|^)\\.).)*?";
+    var filter2 = (pattern, options = {}) => (p) => (0, exports2.minimatch)(p, pattern, options);
+    exports2.filter = filter2;
     exports2.minimatch.filter = exports2.filter;
-    var ext = (a, b = {}) => Object.assign({}, a, b);
-    var defaults = (def) => {
+    var ext2 = (a, b = {}) => Object.assign({}, a, b);
+    var defaults2 = (def) => {
       if (!def || typeof def !== "object" || !Object.keys(def).length) {
         return exports2.minimatch;
       }
       const orig = exports2.minimatch;
-      const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
+      const m = (p, pattern, options = {}) => orig(p, pattern, ext2(def, options));
       return Object.assign(m, {
         Minimatch: class Minimatch extends orig.Minimatch {
           constructor(pattern, options = {}) {
-            super(pattern, ext(def, options));
+            super(pattern, ext2(def, options));
           }
           static defaults(options) {
-            return orig.defaults(ext(def, options)).Minimatch;
+            return orig.defaults(ext2(def, options)).Minimatch;
           }
         },
         AST: class AST extends orig.AST {
           /* c8 ignore start */
           constructor(type, parent, options = {}) {
-            super(type, parent, ext(def, options));
+            super(type, parent, ext2(def, options));
           }
           /* c8 ignore stop */
           static fromGlob(pattern, options = {}) {
-            return orig.AST.fromGlob(pattern, ext(def, options));
+            return orig.AST.fromGlob(pattern, ext2(def, options));
           }
         },
-        unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
-        escape: (s, options = {}) => orig.escape(s, ext(def, options)),
-        filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
-        defaults: (options) => orig.defaults(ext(def, options)),
-        makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
-        braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
-        match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
+        unescape: (s, options = {}) => orig.unescape(s, ext2(def, options)),
+        escape: (s, options = {}) => orig.escape(s, ext2(def, options)),
+        filter: (pattern, options = {}) => orig.filter(pattern, ext2(def, options)),
+        defaults: (options) => orig.defaults(ext2(def, options)),
+        makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext2(def, options)),
+        braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext2(def, options)),
+        match: (list, pattern, options = {}) => orig.match(list, pattern, ext2(def, options)),
         sep: orig.sep,
         GLOBSTAR: exports2.GLOBSTAR
       });
     };
-    exports2.defaults = defaults;
+    exports2.defaults = defaults2;
     exports2.minimatch.defaults = exports2.defaults;
-    var braceExpand = (pattern, options = {}) => {
+    var braceExpand2 = (pattern, options = {}) => {
       (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
       if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
         return [pattern];
       }
       return (0, brace_expansion_1.expand)(pattern, { max: options.braceExpandMax });
     };
-    exports2.braceExpand = braceExpand;
+    exports2.braceExpand = braceExpand2;
     exports2.minimatch.braceExpand = exports2.braceExpand;
-    var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
-    exports2.makeRe = makeRe;
+    var makeRe2 = (pattern, options = {}) => new Minimatch2(pattern, options).makeRe();
+    exports2.makeRe = makeRe2;
     exports2.minimatch.makeRe = exports2.makeRe;
-    var match = (list, pattern, options = {}) => {
-      const mm = new Minimatch(pattern, options);
+    var match2 = (list, pattern, options = {}) => {
+      const mm = new Minimatch2(pattern, options);
       list = list.filter((f) => mm.match(f));
       if (mm.options.nonull && !list.length) {
         list.push(pattern);
       }
       return list;
     };
-    exports2.match = match;
+    exports2.match = match2;
     exports2.minimatch.match = exports2.match;
-    var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
-    var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-    var Minimatch = class {
+    var globMagic2 = /[?*]|[+@!]\(.*?\)|\[|\]/;
+    var regExpEscape3 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+    var Minimatch2 = class {
       options;
       set;
       pattern;
@@ -103362,7 +103682,7 @@ var require_commonjs20 = __commonJS({
         this.options = options;
         this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;
         this.pattern = pattern;
-        this.platform = options.platform || defaultPlatform;
+        this.platform = options.platform || defaultPlatform2;
         this.isWindows = this.platform === "win32";
         const awe = "allowWindowsEscape";
         this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options[awe] === false;
@@ -103419,7 +103739,7 @@ var require_commonjs20 = __commonJS({
         this.debug(this.pattern, this.globParts);
         let set = this.globParts.map((s, _2, __) => {
           if (this.isWindows && this.windowsNoMagicRoot) {
-            const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
+            const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic2.test(s[2])) && !globMagic2.test(s[3]);
             const isDrive = /^[a-z]:/i.test(s[0]);
             if (isUNC) {
               return [
@@ -103874,16 +104194,16 @@ var require_commonjs20 = __commonJS({
           return "";
         let m;
         let fastTest = null;
-        if (m = pattern.match(starRE)) {
-          fastTest = options.dot ? starTestDot : starTest;
-        } else if (m = pattern.match(starDotExtRE)) {
-          fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
-        } else if (m = pattern.match(qmarksRE)) {
-          fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
-        } else if (m = pattern.match(starDotStarRE)) {
-          fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
-        } else if (m = pattern.match(dotStarRE)) {
-          fastTest = dotStarTest;
+        if (m = pattern.match(starRE2)) {
+          fastTest = options.dot ? starTestDot2 : starTest2;
+        } else if (m = pattern.match(starDotExtRE2)) {
+          fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot2 : starDotExtTestNocase2 : options.dot ? starDotExtTestDot2 : starDotExtTest2)(m[1]);
+        } else if (m = pattern.match(qmarksRE2)) {
+          fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot2 : qmarksTestNocase2 : options.dot ? qmarksTestDot2 : qmarksTest2)(m);
+        } else if (m = pattern.match(starDotStarRE2)) {
+          fastTest = options.dot ? starDotStarTestDot2 : starDotStarTest2;
+        } else if (m = pattern.match(dotStarRE2)) {
+          fastTest = dotStarTest2;
         }
         const re = ast_js_1.AST.fromGlob(pattern, this.options).toMMPattern();
         if (fastTest && typeof re === "object") {
@@ -103900,7 +104220,7 @@ var require_commonjs20 = __commonJS({
           return this.regexp;
         }
         const options = this.options;
-        const twoStar = options.noglobstar ? star : options.dot ? twoStarDot : twoStarNoDot;
+        const twoStar = options.noglobstar ? star3 : options.dot ? twoStarDot2 : twoStarNoDot2;
         const flags = new Set(options.nocase ? ["i"] : []);
         let re = set.map((pattern) => {
           const pp = pattern.map((p) => {
@@ -103908,7 +104228,7 @@ var require_commonjs20 = __commonJS({
               for (const f of p.flags.split(""))
                 flags.add(f);
             }
-            return typeof p === "string" ? regExpEscape(p) : p === exports2.GLOBSTAR ? exports2.GLOBSTAR : p._src;
+            return typeof p === "string" ? regExpEscape3(p) : p === exports2.GLOBSTAR ? exports2.GLOBSTAR : p._src;
           });
           pp.forEach((p, i) => {
             const next = pp[i + 1];
@@ -104010,7 +104330,7 @@ var require_commonjs20 = __commonJS({
         return exports2.minimatch.defaults(def).Minimatch;
       }
     };
-    exports2.Minimatch = Minimatch;
+    exports2.Minimatch = Minimatch2;
     var ast_js_2 = require_ast();
     Object.defineProperty(exports2, "AST", { enumerable: true, get: function() {
       return ast_js_2.AST;
@@ -104024,7 +104344,7 @@ var require_commonjs20 = __commonJS({
       return unescape_js_2.unescape;
     } });
     exports2.minimatch.AST = ast_js_1.AST;
-    exports2.minimatch.Minimatch = Minimatch;
+    exports2.minimatch.Minimatch = Minimatch2;
     exports2.minimatch.escape = escape_js_1.escape;
     exports2.minimatch.unescape = unescape_js_1.unescape;
   }
@@ -104232,11 +104552,11 @@ var require_commonjs21 = __commonJS({
           free: c.#free,
           // methods
           isBackgroundFetch: (p) => c.#isBackgroundFetch(p),
-          backgroundFetch: (k, index, options, context5) => c.#backgroundFetch(k, index, options, context5),
-          moveToTail: (index) => c.#moveToTail(index),
+          backgroundFetch: (k, index2, options, context5) => c.#backgroundFetch(k, index2, options, context5),
+          moveToTail: (index2) => c.#moveToTail(index2),
           indexes: (options) => c.#indexes(options),
           rindexes: (options) => c.#rindexes(options),
-          isStale: (index) => c.#isStale(index)
+          isStale: (index2) => c.#isStale(index2)
         };
       }
       // Protected read-only members
@@ -104401,13 +104721,13 @@ var require_commonjs21 = __commonJS({
         const starts = new ZeroArray(this.#max);
         this.#ttls = ttls;
         this.#starts = starts;
-        this.#setItemTTL = (index, ttl, start = perf.now()) => {
-          starts[index] = ttl !== 0 ? start : 0;
-          ttls[index] = ttl;
+        this.#setItemTTL = (index2, ttl, start = perf.now()) => {
+          starts[index2] = ttl !== 0 ? start : 0;
+          ttls[index2] = ttl;
           if (ttl !== 0 && this.ttlAutopurge) {
             const t = setTimeout(() => {
-              if (this.#isStale(index)) {
-                this.#delete(this.#keyList[index], "expire");
+              if (this.#isStale(index2)) {
+                this.#delete(this.#keyList[index2], "expire");
               }
             }, ttl + 1);
             if (t.unref) {
@@ -104415,13 +104735,13 @@ var require_commonjs21 = __commonJS({
             }
           }
         };
-        this.#updateItemAge = (index) => {
-          starts[index] = ttls[index] !== 0 ? perf.now() : 0;
+        this.#updateItemAge = (index2) => {
+          starts[index2] = ttls[index2] !== 0 ? perf.now() : 0;
         };
-        this.#statusTTL = (status, index) => {
-          if (ttls[index]) {
-            const ttl = ttls[index];
-            const start = starts[index];
+        this.#statusTTL = (status, index2) => {
+          if (ttls[index2]) {
+            const ttl = ttls[index2];
+            const start = starts[index2];
             if (!ttl || !start)
               return;
             status.ttl = ttl;
@@ -104444,21 +104764,21 @@ var require_commonjs21 = __commonJS({
           return n;
         };
         this.getRemainingTTL = (key) => {
-          const index = this.#keyMap.get(key);
-          if (index === void 0) {
+          const index2 = this.#keyMap.get(key);
+          if (index2 === void 0) {
             return 0;
           }
-          const ttl = ttls[index];
-          const start = starts[index];
+          const ttl = ttls[index2];
+          const start = starts[index2];
           if (!ttl || !start) {
             return Infinity;
           }
           const age = (cachedNow || getNow()) - start;
           return ttl - age;
         };
-        this.#isStale = (index) => {
-          const s = starts[index];
-          const t = ttls[index];
+        this.#isStale = (index2) => {
+          const s = starts[index2];
+          const t = ttls[index2];
           return !!t && !!s && (cachedNow || getNow()) - s > t;
         };
       }
@@ -104475,9 +104795,9 @@ var require_commonjs21 = __commonJS({
         const sizes = new ZeroArray(this.#max);
         this.#calculatedSize = 0;
         this.#sizes = sizes;
-        this.#removeItemSize = (index) => {
-          this.#calculatedSize -= sizes[index];
-          sizes[index] = 0;
+        this.#removeItemSize = (index2) => {
+          this.#calculatedSize -= sizes[index2];
+          sizes[index2] = 0;
         };
         this.#requireSize = (k, v, size, sizeCalculation) => {
           if (this.#isBackgroundFetch(v)) {
@@ -104498,15 +104818,15 @@ var require_commonjs21 = __commonJS({
           }
           return size;
         };
-        this.#addItemSize = (index, size, status) => {
-          sizes[index] = size;
+        this.#addItemSize = (index2, size, status) => {
+          sizes[index2] = size;
           if (this.#maxSize) {
-            const maxSize = this.#maxSize - sizes[index];
+            const maxSize = this.#maxSize - sizes[index2];
             while (this.#calculatedSize > maxSize) {
               this.#evict(true);
             }
           }
-          this.#calculatedSize += sizes[index];
+          this.#calculatedSize += sizes[index2];
           if (status) {
             status.entrySize = size;
             status.totalCalculatedSize = this.#calculatedSize;
@@ -104557,8 +104877,8 @@ var require_commonjs21 = __commonJS({
           }
         }
       }
-      #isValidIndex(index) {
-        return index !== void 0 && this.#keyMap.get(this.#keyList[index]) === index;
+      #isValidIndex(index2) {
+        return index2 !== void 0 && this.#keyMap.get(this.#keyList[index2]) === index2;
       }
       /**
        * Return a generator yielding `[key, value]` pairs,
@@ -104845,17 +105165,17 @@ var require_commonjs21 = __commonJS({
           this.#delete(k, "set");
           return this;
         }
-        let index = this.#size === 0 ? void 0 : this.#keyMap.get(k);
-        if (index === void 0) {
-          index = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
-          this.#keyList[index] = k;
-          this.#valList[index] = v;
-          this.#keyMap.set(k, index);
-          this.#next[this.#tail] = index;
-          this.#prev[index] = this.#tail;
-          this.#tail = index;
+        let index2 = this.#size === 0 ? void 0 : this.#keyMap.get(k);
+        if (index2 === void 0) {
+          index2 = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
+          this.#keyList[index2] = k;
+          this.#valList[index2] = v;
+          this.#keyMap.set(k, index2);
+          this.#next[this.#tail] = index2;
+          this.#prev[index2] = this.#tail;
+          this.#tail = index2;
           this.#size++;
-          this.#addItemSize(index, size, status);
+          this.#addItemSize(index2, size, status);
           if (status)
             status.set = "add";
           noUpdateTTL = false;
@@ -104863,8 +105183,8 @@ var require_commonjs21 = __commonJS({
             this.#onInsert?.(v, k, "add");
           }
         } else {
-          this.#moveToTail(index);
-          const oldVal = this.#valList[index];
+          this.#moveToTail(index2);
+          const oldVal = this.#valList[index2];
           if (v !== oldVal) {
             if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
               oldVal.__abortController.abort(new Error("replaced"));
@@ -104885,9 +105205,9 @@ var require_commonjs21 = __commonJS({
                 this.#disposed?.push([oldVal, k, "set"]);
               }
             }
-            this.#removeItemSize(index);
-            this.#addItemSize(index, size, status);
-            this.#valList[index] = v;
+            this.#removeItemSize(index2);
+            this.#addItemSize(index2, size, status);
+            this.#valList[index2] = v;
             if (status) {
               status.set = "replace";
               const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
@@ -104906,10 +105226,10 @@ var require_commonjs21 = __commonJS({
         }
         if (this.#ttls) {
           if (!noUpdateTTL) {
-            this.#setItemTTL(index, ttl, start);
+            this.#setItemTTL(index2, ttl, start);
           }
           if (status)
-            this.#statusTTL(status, index);
+            this.#statusTTL(status, index2);
         }
         if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
           const dt = this.#disposed;
@@ -104995,24 +105315,24 @@ var require_commonjs21 = __commonJS({
        */
       has(k, hasOptions = {}) {
         const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
-        const index = this.#keyMap.get(k);
-        if (index !== void 0) {
-          const v = this.#valList[index];
+        const index2 = this.#keyMap.get(k);
+        if (index2 !== void 0) {
+          const v = this.#valList[index2];
           if (this.#isBackgroundFetch(v) && v.__staleWhileFetching === void 0) {
             return false;
           }
-          if (!this.#isStale(index)) {
+          if (!this.#isStale(index2)) {
             if (updateAgeOnHas) {
-              this.#updateItemAge(index);
+              this.#updateItemAge(index2);
             }
             if (status) {
               status.has = "hit";
-              this.#statusTTL(status, index);
+              this.#statusTTL(status, index2);
             }
             return true;
           } else if (status) {
             status.has = "stale";
-            this.#statusTTL(status, index);
+            this.#statusTTL(status, index2);
           }
         } else if (status) {
           status.has = "miss";
@@ -105028,15 +105348,15 @@ var require_commonjs21 = __commonJS({
        */
       peek(k, peekOptions = {}) {
         const { allowStale = this.allowStale } = peekOptions;
-        const index = this.#keyMap.get(k);
-        if (index === void 0 || !allowStale && this.#isStale(index)) {
+        const index2 = this.#keyMap.get(k);
+        if (index2 === void 0 || !allowStale && this.#isStale(index2)) {
           return;
         }
-        const v = this.#valList[index];
+        const v = this.#valList[index2];
         return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
       }
-      #backgroundFetch(k, index, options, context5) {
-        const v = index === void 0 ? void 0 : this.#valList[index];
+      #backgroundFetch(k, index2, options, context5) {
+        const v = index2 === void 0 ? void 0 : this.#valList[index2];
         if (this.#isBackgroundFetch(v)) {
           return v;
         }
@@ -105067,10 +105387,10 @@ var require_commonjs21 = __commonJS({
             return fetchFail(ac.signal.reason);
           }
           const bf2 = p;
-          if (this.#valList[index] === p) {
+          if (this.#valList[index2] === p) {
             if (v2 === void 0) {
               if (bf2.__staleWhileFetching) {
-                this.#valList[index] = bf2.__staleWhileFetching;
+                this.#valList[index2] = bf2.__staleWhileFetching;
               } else {
                 this.#delete(k, "fetch");
               }
@@ -105095,12 +105415,12 @@ var require_commonjs21 = __commonJS({
           const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
           const noDelete = allowStale || options.noDeleteOnFetchRejection;
           const bf2 = p;
-          if (this.#valList[index] === p) {
+          if (this.#valList[index2] === p) {
             const del = !noDelete || bf2.__staleWhileFetching === void 0;
             if (del) {
               this.#delete(k, "fetch");
             } else if (!allowStaleAborted) {
-              this.#valList[index] = bf2.__staleWhileFetching;
+              this.#valList[index2] = bf2.__staleWhileFetching;
             }
           }
           if (allowStale) {
@@ -105134,11 +105454,11 @@ var require_commonjs21 = __commonJS({
           __staleWhileFetching: v,
           __returned: void 0
         });
-        if (index === void 0) {
+        if (index2 === void 0) {
           this.set(k, bf, { ...fetchOpts.options, status: void 0 });
-          index = this.#keyMap.get(k);
+          index2 = this.#keyMap.get(k);
         } else {
-          this.#valList[index] = bf;
+          this.#valList[index2] = bf;
         }
         return bf;
       }
@@ -105196,14 +105516,14 @@ var require_commonjs21 = __commonJS({
           status,
           signal
         };
-        let index = this.#keyMap.get(k);
-        if (index === void 0) {
+        let index2 = this.#keyMap.get(k);
+        if (index2 === void 0) {
           if (status)
             status.fetch = "miss";
-          const p = this.#backgroundFetch(k, index, options, context5);
+          const p = this.#backgroundFetch(k, index2, options, context5);
           return p.__returned = p;
         } else {
-          const v = this.#valList[index];
+          const v = this.#valList[index2];
           if (this.#isBackgroundFetch(v)) {
             const stale = allowStale && v.__staleWhileFetching !== void 0;
             if (status) {
@@ -105213,19 +105533,19 @@ var require_commonjs21 = __commonJS({
             }
             return stale ? v.__staleWhileFetching : v.__returned = v;
           }
-          const isStale = this.#isStale(index);
+          const isStale = this.#isStale(index2);
           if (!forceRefresh && !isStale) {
             if (status)
               status.fetch = "hit";
-            this.#moveToTail(index);
+            this.#moveToTail(index2);
             if (updateAgeOnGet) {
-              this.#updateItemAge(index);
+              this.#updateItemAge(index2);
             }
             if (status)
-              this.#statusTTL(status, index);
+              this.#statusTTL(status, index2);
             return v;
           }
-          const p = this.#backgroundFetch(k, index, options, context5);
+          const p = this.#backgroundFetch(k, index2, options, context5);
           const hasStale = p.__staleWhileFetching !== void 0;
           const staleVal = hasStale && allowStale;
           if (status) {
@@ -105266,13 +105586,13 @@ var require_commonjs21 = __commonJS({
        */
       get(k, getOptions = {}) {
         const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
-        const index = this.#keyMap.get(k);
-        if (index !== void 0) {
-          const value = this.#valList[index];
+        const index2 = this.#keyMap.get(k);
+        if (index2 !== void 0) {
+          const value = this.#valList[index2];
           const fetching = this.#isBackgroundFetch(value);
           if (status)
-            this.#statusTTL(status, index);
-          if (this.#isStale(index)) {
+            this.#statusTTL(status, index2);
+          if (this.#isStale(index2)) {
             if (status)
               status.get = "stale";
             if (!fetching) {
@@ -105294,9 +105614,9 @@ var require_commonjs21 = __commonJS({
             if (fetching) {
               return value.__staleWhileFetching;
             }
-            this.#moveToTail(index);
+            this.#moveToTail(index2);
             if (updateAgeOnGet) {
-              this.#updateItemAge(index);
+              this.#updateItemAge(index2);
             }
             return value;
           }
@@ -105308,15 +105628,15 @@ var require_commonjs21 = __commonJS({
         this.#prev[n] = p;
         this.#next[p] = n;
       }
-      #moveToTail(index) {
-        if (index !== this.#tail) {
-          if (index === this.#head) {
-            this.#head = this.#next[index];
+      #moveToTail(index2) {
+        if (index2 !== this.#tail) {
+          if (index2 === this.#head) {
+            this.#head = this.#next[index2];
           } else {
-            this.#connect(this.#prev[index], this.#next[index]);
+            this.#connect(this.#prev[index2], this.#next[index2]);
           }
-          this.#connect(this.#tail, index);
-          this.#tail = index;
+          this.#connect(this.#tail, index2);
+          this.#tail = index2;
         }
       }
       /**
@@ -105330,14 +105650,14 @@ var require_commonjs21 = __commonJS({
       #delete(k, reason) {
         let deleted = false;
         if (this.#size !== 0) {
-          const index = this.#keyMap.get(k);
-          if (index !== void 0) {
+          const index2 = this.#keyMap.get(k);
+          if (index2 !== void 0) {
             deleted = true;
             if (this.#size === 1) {
               this.#clear(reason);
             } else {
-              this.#removeItemSize(index);
-              const v = this.#valList[index];
+              this.#removeItemSize(index2);
+              const v = this.#valList[index2];
               if (this.#isBackgroundFetch(v)) {
                 v.__abortController.abort(new Error("deleted"));
               } else if (this.#hasDispose || this.#hasDisposeAfter) {
@@ -105349,20 +105669,20 @@ var require_commonjs21 = __commonJS({
                 }
               }
               this.#keyMap.delete(k);
-              this.#keyList[index] = void 0;
-              this.#valList[index] = void 0;
-              if (index === this.#tail) {
-                this.#tail = this.#prev[index];
-              } else if (index === this.#head) {
-                this.#head = this.#next[index];
+              this.#keyList[index2] = void 0;
+              this.#valList[index2] = void 0;
+              if (index2 === this.#tail) {
+                this.#tail = this.#prev[index2];
+              } else if (index2 === this.#head) {
+                this.#head = this.#next[index2];
               } else {
-                const pi = this.#prev[index];
-                this.#next[pi] = this.#next[index];
-                const ni = this.#next[index];
-                this.#prev[ni] = this.#prev[index];
+                const pi = this.#prev[index2];
+                this.#next[pi] = this.#next[index2];
+                const ni = this.#next[index2];
+                this.#prev[ni] = this.#prev[index2];
               }
               this.#size--;
-              this.#free.push(index);
+              this.#free.push(index2);
             }
           }
         }
@@ -105382,12 +105702,12 @@ var require_commonjs21 = __commonJS({
         return this.#clear("delete");
       }
       #clear(reason) {
-        for (const index of this.#rindexes({ allowStale: true })) {
-          const v = this.#valList[index];
+        for (const index2 of this.#rindexes({ allowStale: true })) {
+          const v = this.#valList[index2];
           if (this.#isBackgroundFetch(v)) {
             v.__abortController.abort(new Error("deleted"));
           } else {
-            const k = this.#keyList[index];
+            const k = this.#keyList[index2];
             if (this.#hasDispose) {
               this.#dispose?.(v, k, reason);
             }
@@ -105440,8 +105760,8 @@ var require_commonjs22 = __commonJS({
     var node_events_1 = require("node:events");
     var node_stream_1 = __importDefault2(require("node:stream"));
     var node_string_decoder_1 = require("node:string_decoder");
-    var isStream = (s) => !!s && typeof s === "object" && (s instanceof Minipass || s instanceof node_stream_1.default || (0, exports2.isReadable)(s) || (0, exports2.isWritable)(s));
-    exports2.isStream = isStream;
+    var isStream2 = (s) => !!s && typeof s === "object" && (s instanceof Minipass || s instanceof node_stream_1.default || (0, exports2.isReadable)(s) || (0, exports2.isWritable)(s));
+    exports2.isStream = isStream2;
     var isReadable = (s) => !!s && typeof s === "object" && s instanceof node_events_1.EventEmitter && typeof s.pipe === "function" && // node core Writable streams have a pipe() method, but it throws
     s.pipe !== node_stream_1.default.Writable.prototype.pipe;
     exports2.isReadable = isReadable;
@@ -106164,10 +106484,10 @@ var require_commonjs22 = __commonJS({
        * Return a void Promise that resolves once the stream ends.
        */
       async promise() {
-        return new Promise((resolve13, reject) => {
+        return new Promise((resolve14, reject) => {
           this.on(DESTROYED, () => reject(new Error("stream destroyed")));
           this.on("error", (er) => reject(er));
-          this.on("end", () => resolve13());
+          this.on("end", () => resolve14());
         });
       }
       /**
@@ -106191,7 +106511,7 @@ var require_commonjs22 = __commonJS({
             return Promise.resolve({ done: false, value: res });
           if (this[EOF2])
             return stop();
-          let resolve13;
+          let resolve14;
           let reject;
           const onerr = (er) => {
             this.off("data", ondata);
@@ -106205,19 +106525,19 @@ var require_commonjs22 = __commonJS({
             this.off("end", onend);
             this.off(DESTROYED, ondestroy);
             this.pause();
-            resolve13({ value, done: !!this[EOF2] });
+            resolve14({ value, done: !!this[EOF2] });
           };
           const onend = () => {
             this.off("error", onerr);
             this.off("data", ondata);
             this.off(DESTROYED, ondestroy);
             stop();
-            resolve13({ done: true, value: void 0 });
+            resolve14({ done: true, value: void 0 });
           };
           const ondestroy = () => onerr(new Error("stream destroyed"));
           return new Promise((res2, rej) => {
             reject = rej;
-            resolve13 = res2;
+            resolve14 = res2;
             this.once(DESTROYED, ondestroy);
             this.once("error", onerr);
             this.once("end", onend);
@@ -106622,12 +106942,12 @@ var require_commonjs23 = __commonJS({
       /**
        * Get the Path object referenced by the string path, resolved from this Path
        */
-      resolve(path28) {
-        if (!path28) {
+      resolve(path29) {
+        if (!path29) {
           return this;
         }
-        const rootPath = this.getRootString(path28);
-        const dir = path28.substring(rootPath.length);
+        const rootPath = this.getRootString(path29);
+        const dir = path29.substring(rootPath.length);
         const dirParts = dir.split(this.splitSep);
         const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
         return result;
@@ -107069,16 +107389,16 @@ var require_commonjs23 = __commonJS({
           return this.#readdirPromoteChild(e, pchild, p, c);
         }
       }
-      #readdirPromoteChild(e, p, index, c) {
+      #readdirPromoteChild(e, p, index2, c) {
         const v = p.name;
         p.#type = p.#type & IFMT_UNKNOWN | entToType(e);
         if (v !== e.name)
           p.name = e.name;
-        if (index !== c.provisional) {
-          if (index === c.length - 1)
+        if (index2 !== c.provisional) {
+          if (index2 === c.length - 1)
             c.pop();
           else
-            c.splice(index, 1);
+            c.splice(index2, 1);
           c.unshift(p);
         }
         c.provisional++;
@@ -107231,9 +107551,9 @@ var require_commonjs23 = __commonJS({
         if (this.#asyncReaddirInFlight) {
           await this.#asyncReaddirInFlight;
         } else {
-          let resolve13 = () => {
+          let resolve14 = () => {
           };
-          this.#asyncReaddirInFlight = new Promise((res) => resolve13 = res);
+          this.#asyncReaddirInFlight = new Promise((res) => resolve14 = res);
           try {
             for (const e of await this.#fs.promises.readdir(fullpath, {
               withFileTypes: true
@@ -107246,7 +107566,7 @@ var require_commonjs23 = __commonJS({
             children.provisional = 0;
           }
           this.#asyncReaddirInFlight = void 0;
-          resolve13();
+          resolve14();
         }
         return children.slice(0, children.provisional);
       }
@@ -107380,8 +107700,8 @@ var require_commonjs23 = __commonJS({
       /**
        * @internal
        */
-      getRootString(path28) {
-        return node_path_1.win32.parse(path28).root;
+      getRootString(path29) {
+        return node_path_1.win32.parse(path29).root;
       }
       /**
        * @internal
@@ -107428,8 +107748,8 @@ var require_commonjs23 = __commonJS({
       /**
        * @internal
        */
-      getRootString(path28) {
-        return path28.startsWith("/") ? "/" : "";
+      getRootString(path29) {
+        return path29.startsWith("/") ? "/" : "";
       }
       /**
        * @internal
@@ -107479,8 +107799,8 @@ var require_commonjs23 = __commonJS({
        *
        * @internal
        */
-      constructor(cwd = process.cwd(), pathImpl, sep6, { nocase, childrenCacheSize = 16 * 1024, fs: fs30 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs30);
+      constructor(cwd = process.cwd(), pathImpl, sep7, { nocase, childrenCacheSize = 16 * 1024, fs: fs31 = defaultFS } = {}) {
+        this.#fs = fsFromOption(fs31);
         if (cwd instanceof URL || cwd.startsWith("file://")) {
           cwd = (0, node_url_1.fileURLToPath)(cwd);
         }
@@ -107490,7 +107810,7 @@ var require_commonjs23 = __commonJS({
         this.#resolveCache = new ResolveCache();
         this.#resolvePosixCache = new ResolveCache();
         this.#children = new ChildrenCache(childrenCacheSize);
-        const split = cwdPath.substring(this.rootPath.length).split(sep6);
+        const split = cwdPath.substring(this.rootPath.length).split(sep7);
         if (split.length === 1 && !split[0]) {
           split.pop();
         }
@@ -107519,11 +107839,11 @@ var require_commonjs23 = __commonJS({
       /**
        * Get the depth of a provided path, string, or the cwd
        */
-      depth(path28 = this.cwd) {
-        if (typeof path28 === "string") {
-          path28 = this.cwd.resolve(path28);
+      depth(path29 = this.cwd) {
+        if (typeof path29 === "string") {
+          path29 = this.cwd.resolve(path29);
         }
-        return path28.depth();
+        return path29.depth();
       }
       /**
        * Return the cache of child entries.  Exposed so subclasses can create
@@ -107749,9 +108069,9 @@ var require_commonjs23 = __commonJS({
           opts = entry;
           entry = this.cwd;
         }
-        const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
+        const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
         const results = [];
-        if (!filter || filter(entry)) {
+        if (!filter2 || filter2(entry)) {
           results.push(withFileTypes ? entry : entry.fullpath());
         }
         const dirs = /* @__PURE__ */ new Set();
@@ -107770,7 +108090,7 @@ var require_commonjs23 = __commonJS({
               }
             };
             for (const e of entries) {
-              if (!filter || filter(e)) {
+              if (!filter2 || filter2(e)) {
                 results.push(withFileTypes ? e : e.fullpath());
               }
               if (follow && e.isSymbolicLink()) {
@@ -107801,16 +108121,16 @@ var require_commonjs23 = __commonJS({
           opts = entry;
           entry = this.cwd;
         }
-        const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
+        const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
         const results = [];
-        if (!filter || filter(entry)) {
+        if (!filter2 || filter2(entry)) {
           results.push(withFileTypes ? entry : entry.fullpath());
         }
         const dirs = /* @__PURE__ */ new Set([entry]);
         for (const dir of dirs) {
           const entries = dir.readdirSync();
           for (const e of entries) {
-            if (!filter || filter(e)) {
+            if (!filter2 || filter2(e)) {
               results.push(withFileTypes ? e : e.fullpath());
             }
             let r = e;
@@ -107863,15 +108183,15 @@ var require_commonjs23 = __commonJS({
           opts = entry;
           entry = this.cwd;
         }
-        const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
-        if (!filter || filter(entry)) {
+        const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
+        if (!filter2 || filter2(entry)) {
           yield withFileTypes ? entry : entry.fullpath();
         }
         const dirs = /* @__PURE__ */ new Set([entry]);
         for (const dir of dirs) {
           const entries = dir.readdirSync();
           for (const e of entries) {
-            if (!filter || filter(e)) {
+            if (!filter2 || filter2(e)) {
               yield withFileTypes ? e : e.fullpath();
             }
             let r = e;
@@ -107894,18 +108214,18 @@ var require_commonjs23 = __commonJS({
           opts = entry;
           entry = this.cwd;
         }
-        const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
+        const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
         const results = new minipass_1.Minipass({ objectMode: true });
-        if (!filter || filter(entry)) {
+        if (!filter2 || filter2(entry)) {
           results.write(withFileTypes ? entry : entry.fullpath());
         }
         const dirs = /* @__PURE__ */ new Set();
-        const queue = [entry];
+        const queue2 = [entry];
         let processing = 0;
         const process2 = () => {
           let paused = false;
           while (!paused) {
-            const dir = queue.shift();
+            const dir = queue2.shift();
             if (!dir) {
               if (processing === 0)
                 results.end();
@@ -107929,7 +108249,7 @@ var require_commonjs23 = __commonJS({
                 }
               }
               for (const e of entries) {
-                if (e && (!filter || filter(e))) {
+                if (e && (!filter2 || filter2(e))) {
                   if (!results.write(withFileTypes ? e : e.fullpath())) {
                     paused = true;
                   }
@@ -107939,7 +108259,7 @@ var require_commonjs23 = __commonJS({
               for (const e of entries) {
                 const r = e.realpathCached() || e;
                 if (r.shouldWalk(dirs, walkFilter)) {
-                  queue.push(r);
+                  queue2.push(r);
                 }
               }
               if (paused && !results.flowing) {
@@ -107963,18 +108283,18 @@ var require_commonjs23 = __commonJS({
           opts = entry;
           entry = this.cwd;
         }
-        const { withFileTypes = true, follow = false, filter, walkFilter } = opts;
+        const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
         const results = new minipass_1.Minipass({ objectMode: true });
         const dirs = /* @__PURE__ */ new Set();
-        if (!filter || filter(entry)) {
+        if (!filter2 || filter2(entry)) {
           results.write(withFileTypes ? entry : entry.fullpath());
         }
-        const queue = [entry];
+        const queue2 = [entry];
         let processing = 0;
         const process2 = () => {
           let paused = false;
           while (!paused) {
-            const dir = queue.shift();
+            const dir = queue2.shift();
             if (!dir) {
               if (processing === 0)
                 results.end();
@@ -107984,7 +108304,7 @@ var require_commonjs23 = __commonJS({
             dirs.add(dir);
             const entries = dir.readdirSync();
             for (const e of entries) {
-              if (!filter || filter(e)) {
+              if (!filter2 || filter2(e)) {
                 if (!results.write(withFileTypes ? e : e.fullpath())) {
                   paused = true;
                 }
@@ -108000,7 +108320,7 @@ var require_commonjs23 = __commonJS({
                   r.lstatSync();
               }
               if (r.shouldWalk(dirs, walkFilter)) {
-                queue.push(r);
+                queue2.push(r);
               }
             }
           }
@@ -108010,9 +108330,9 @@ var require_commonjs23 = __commonJS({
         process2();
         return results;
       }
-      chdir(path28 = this.cwd) {
+      chdir(path29 = this.cwd) {
         const oldCwd = this.cwd;
-        this.cwd = typeof path28 === "string" ? this.cwd.resolve(path28) : path28;
+        this.cwd = typeof path29 === "string" ? this.cwd.resolve(path29) : path29;
         this.cwd[setAsCwd](oldCwd);
       }
     };
@@ -108039,8 +108359,8 @@ var require_commonjs23 = __commonJS({
       /**
        * @internal
        */
-      newRoot(fs30) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs30 });
+      newRoot(fs31) {
+        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs31 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -108069,8 +108389,8 @@ var require_commonjs23 = __commonJS({
       /**
        * @internal
        */
-      newRoot(fs30) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs30 });
+      newRoot(fs31) {
+        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs31 });
       }
       /**
        * Return true if the provided path string is an absolute path
@@ -108113,7 +108433,7 @@ var require_pattern = __commonJS({
       #isUNC;
       #isAbsolute;
       #followGlobstar = true;
-      constructor(patternList, globList, index, platform2) {
+      constructor(patternList, globList, index2, platform2) {
         if (!isPatternList(patternList)) {
           throw new TypeError("empty pattern list");
         }
@@ -108124,12 +108444,12 @@ var require_pattern = __commonJS({
           throw new TypeError("mismatched pattern list and glob list lengths");
         }
         this.length = patternList.length;
-        if (index < 0 || index >= this.length) {
+        if (index2 < 0 || index2 >= this.length) {
           throw new TypeError("index out of range");
         }
         this.#patternList = patternList;
         this.#globList = globList;
-        this.#index = index;
+        this.#index = index2;
         this.#platform = platform2;
         if (this.#index === 0) {
           if (this.isUNC()) {
@@ -108274,7 +108594,7 @@ var require_ignore = __commonJS({
     exports2.Ignore = void 0;
     var minimatch_1 = require_commonjs20();
     var pattern_js_1 = require_pattern();
-    var defaultPlatform = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+    var defaultPlatform2 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
     var Ignore = class {
       relative;
       relativeChildren;
@@ -108282,7 +108602,7 @@ var require_ignore = __commonJS({
       absoluteChildren;
       platform;
       mmopts;
-      constructor(ignored, { nobrace, nocase, noext, noglobstar, platform: platform2 = defaultPlatform }) {
+      constructor(ignored, { nobrace, nocase, noext, noglobstar, platform: platform2 = defaultPlatform2 }) {
         this.relative = [];
         this.absolute = [];
         this.relativeChildren = [];
@@ -108400,8 +108720,8 @@ var require_processor = __commonJS({
       }
       // match, absolute, ifdir
       entries() {
-        return [...this.store.entries()].map(([path28, n]) => [
-          path28,
+        return [...this.store.entries()].map(([path29, n]) => [
+          path29,
           !!(n & 2),
           !!(n & 1)
         ]);
@@ -108619,9 +108939,9 @@ var require_walker = __commonJS({
       signal;
       maxDepth;
       includeChildMatches;
-      constructor(patterns, path28, opts) {
+      constructor(patterns, path29, opts) {
         this.patterns = patterns;
-        this.path = path28;
+        this.path = path29;
         this.opts = opts;
         this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
         this.includeChildMatches = opts.includeChildMatches !== false;
@@ -108640,11 +108960,11 @@ var require_walker = __commonJS({
           });
         }
       }
-      #ignored(path28) {
-        return this.seen.has(path28) || !!this.#ignore?.ignored?.(path28);
+      #ignored(path29) {
+        return this.seen.has(path29) || !!this.#ignore?.ignored?.(path29);
       }
-      #childrenIgnored(path28) {
-        return !!this.#ignore?.childrenIgnored?.(path28);
+      #childrenIgnored(path29) {
+        return !!this.#ignore?.childrenIgnored?.(path29);
       }
       // backpressure mechanism
       pause() {
@@ -108860,8 +109180,8 @@ var require_walker = __commonJS({
     exports2.GlobUtil = GlobUtil;
     var GlobWalker = class extends GlobUtil {
       matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path28, opts) {
-        super(patterns, path28, opts);
+      constructor(patterns, path29, opts) {
+        super(patterns, path29, opts);
       }
       matchEmit(e) {
         this.matches.add(e);
@@ -108899,8 +109219,8 @@ var require_walker = __commonJS({
     exports2.GlobWalker = GlobWalker;
     var GlobStream = class extends GlobUtil {
       results;
-      constructor(patterns, path28, opts) {
-        super(patterns, path28, opts);
+      constructor(patterns, path29, opts) {
+        super(patterns, path29, opts);
         this.results = new minipass_1.Minipass({
           signal: this.signal,
           objectMode: true
@@ -108947,7 +109267,7 @@ var require_glob2 = __commonJS({
     var path_scurry_1 = require_commonjs23();
     var pattern_js_1 = require_pattern();
     var walker_js_1 = require_walker();
-    var defaultPlatform = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+    var defaultPlatform2 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
     var Glob = class {
       absolute;
       cwd;
@@ -109039,7 +109359,7 @@ var require_glob2 = __commonJS({
           pattern = pattern.map((p) => p.includes("/") ? p : `./**/${p}`);
         }
         this.pattern = pattern;
-        this.platform = opts.platform || defaultPlatform;
+        this.platform = opts.platform || defaultPlatform2;
         this.opts = { ...opts, platform: this.platform };
         if (opts.scurry) {
           this.scurry = opts.scurry;
@@ -109255,8 +109575,8 @@ var require_commonjs24 = __commonJS({
 // node_modules/archiver-utils/file.js
 var require_file3 = __commonJS({
   "node_modules/archiver-utils/file.js"(exports2, module2) {
-    var fs30 = require_graceful_fs();
-    var path28 = require("path");
+    var fs31 = require_graceful_fs();
+    var path29 = require("path");
     var flatten = require_flatten();
     var difference = require_difference();
     var union = require_union();
@@ -109281,8 +109601,8 @@ var require_file3 = __commonJS({
       return result;
     };
     file.exists = function() {
-      var filepath = path28.join.apply(path28, arguments);
-      return fs30.existsSync(filepath);
+      var filepath = path29.join.apply(path29, arguments);
+      return fs31.existsSync(filepath);
     };
     file.expand = function(...args) {
       var options = isPlainObject3(args[0]) ? args.shift() : {};
@@ -109295,12 +109615,12 @@ var require_file3 = __commonJS({
       });
       if (options.filter) {
         matches = matches.filter(function(filepath) {
-          filepath = path28.join(options.cwd || "", filepath);
+          filepath = path29.join(options.cwd || "", filepath);
           try {
             if (typeof options.filter === "function") {
               return options.filter(filepath);
             } else {
-              return fs30.statSync(filepath)[options.filter]();
+              return fs31.statSync(filepath)[options.filter]();
             }
           } catch (e) {
             return false;
@@ -109312,7 +109632,7 @@ var require_file3 = __commonJS({
     file.expandMapping = function(patterns, destBase, options) {
       options = Object.assign({
         rename: function(destBase2, destPath) {
-          return path28.join(destBase2 || "", destPath);
+          return path29.join(destBase2 || "", destPath);
         }
       }, options);
       var files = [];
@@ -109320,14 +109640,14 @@ var require_file3 = __commonJS({
       file.expand(options, patterns).forEach(function(src) {
         var destPath = src;
         if (options.flatten) {
-          destPath = path28.basename(destPath);
+          destPath = path29.basename(destPath);
         }
         if (options.ext) {
           destPath = destPath.replace(/(\.[^\/]*)?$/, options.ext);
         }
         var dest = options.rename(destBase, destPath, options);
         if (options.cwd) {
-          src = path28.join(options.cwd, src);
+          src = path29.join(options.cwd, src);
         }
         dest = dest.replace(pathSeparatorRe, "/");
         src = src.replace(pathSeparatorRe, "/");
@@ -109408,14 +109728,14 @@ var require_file3 = __commonJS({
 // node_modules/archiver-utils/index.js
 var require_archiver_utils = __commonJS({
   "node_modules/archiver-utils/index.js"(exports2, module2) {
-    var fs30 = require_graceful_fs();
-    var path28 = require("path");
-    var isStream = require_is_stream();
+    var fs31 = require_graceful_fs();
+    var path29 = require("path");
+    var isStream2 = require_is_stream();
     var lazystream = require_lazystream();
-    var normalizePath = require_normalize_path();
-    var defaults = require_defaults();
+    var normalizePath4 = require_normalize_path();
+    var defaults2 = require_defaults();
     var Stream = require("stream").Stream;
-    var PassThrough = require_ours().PassThrough;
+    var PassThrough3 = require_ours().PassThrough;
     var utils = module2.exports = {};
     utils.file = require_file3();
     utils.collectStream = function(source, callback) {
@@ -109450,14 +109770,14 @@ var require_archiver_utils = __commonJS({
     utils.defaults = function(object, source, guard) {
       var args = arguments;
       args[0] = args[0] || {};
-      return defaults(...args);
+      return defaults2(...args);
     };
     utils.isStream = function(source) {
-      return isStream(source);
+      return isStream2(source);
     };
     utils.lazyReadStream = function(filepath) {
       return new lazystream.Readable(function() {
-        return fs30.createReadStream(filepath);
+        return fs31.createReadStream(filepath);
       });
     };
     utils.normalizeInputSource = function(source) {
@@ -109466,18 +109786,18 @@ var require_archiver_utils = __commonJS({
       } else if (typeof source === "string") {
         return Buffer.from(source);
       } else if (utils.isStream(source)) {
-        return source.pipe(new PassThrough());
+        return source.pipe(new PassThrough3());
       }
       return source;
     };
     utils.sanitizePath = function(filepath) {
-      return normalizePath(filepath, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
+      return normalizePath4(filepath, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
     };
     utils.trailingSlashIt = function(str) {
       return str.slice(-1) !== "/" ? str + "/" : str;
     };
     utils.unixifyPath = function(filepath) {
-      return normalizePath(filepath, false).replace(/^\w+:/, "");
+      return normalizePath4(filepath, false).replace(/^\w+:/, "");
     };
     utils.walkdir = function(dirpath, base, callback) {
       var results = [];
@@ -109485,7 +109805,7 @@ var require_archiver_utils = __commonJS({
         callback = base;
         base = dirpath;
       }
-      fs30.readdir(dirpath, function(err, list) {
+      fs31.readdir(dirpath, function(err, list) {
         var i = 0;
         var file;
         var filepath;
@@ -109497,11 +109817,11 @@ var require_archiver_utils = __commonJS({
           if (!file) {
             return callback(null, results);
           }
-          filepath = path28.join(dirpath, file);
-          fs30.stat(filepath, function(err2, stats) {
+          filepath = path29.join(dirpath, file);
+          fs31.stat(filepath, function(err2, stats) {
             results.push({
               path: filepath,
-              relative: path28.relative(base, filepath).replace(/\\/g, "/"),
+              relative: path29.relative(base, filepath).replace(/\\/g, "/"),
               stats
             });
             if (stats && stats.isDirectory()) {
@@ -109524,11 +109844,11 @@ var require_archiver_utils = __commonJS({
   }
 });
 
-// node_modules/archiver/lib/error.js
+// node_modules/@actions/artifact/node_modules/archiver/lib/error.js
 var require_error3 = __commonJS({
-  "node_modules/archiver/lib/error.js"(exports2, module2) {
-    var util = require("util");
-    var ERROR_CODES = {
+  "node_modules/@actions/artifact/node_modules/archiver/lib/error.js"(exports2, module2) {
+    var util3 = require("util");
+    var ERROR_CODES2 = {
       "ABORTED": "archive was aborted",
       "DIRECTORYDIRPATHREQUIRED": "diretory dirpath argument must be a non-empty string value",
       "DIRECTORYFUNCTIONINVALIDDATA": "invalid data returned by directory custom data function",
@@ -109546,42 +109866,42 @@ var require_error3 = __commonJS({
       "SYMLINKTARGETREQUIRED": "symlink target argument must be a non-empty string value",
       "ENTRYNOTSUPPORTED": "entry not supported"
     };
-    function ArchiverError(code, data) {
+    function ArchiverError2(code, data) {
       Error.captureStackTrace(this, this.constructor);
-      this.message = ERROR_CODES[code] || code;
+      this.message = ERROR_CODES2[code] || code;
       this.code = code;
       this.data = data;
     }
-    util.inherits(ArchiverError, Error);
-    exports2 = module2.exports = ArchiverError;
+    util3.inherits(ArchiverError2, Error);
+    exports2 = module2.exports = ArchiverError2;
   }
 });
 
-// node_modules/archiver/lib/core.js
+// node_modules/@actions/artifact/node_modules/archiver/lib/core.js
 var require_core3 = __commonJS({
-  "node_modules/archiver/lib/core.js"(exports2, module2) {
-    var fs30 = require("fs");
+  "node_modules/@actions/artifact/node_modules/archiver/lib/core.js"(exports2, module2) {
+    var fs31 = require("fs");
     var glob2 = require_readdir_glob();
     var async = require_async();
-    var path28 = require("path");
-    var util = require_archiver_utils();
+    var path29 = require("path");
+    var util3 = require_archiver_utils();
     var inherits = require("util").inherits;
-    var ArchiverError = require_error3();
-    var Transform = require_ours().Transform;
-    var win32 = process.platform === "win32";
-    var Archiver = function(format, options) {
-      if (!(this instanceof Archiver)) {
-        return new Archiver(format, options);
+    var ArchiverError2 = require_error3();
+    var Transform5 = require_ours().Transform;
+    var win322 = process.platform === "win32";
+    var Archiver2 = function(format, options) {
+      if (!(this instanceof Archiver2)) {
+        return new Archiver2(format, options);
       }
       if (typeof format !== "string") {
         options = format;
         format = "zip";
       }
-      options = this.options = util.defaults(options, {
+      options = this.options = util3.defaults(options, {
         highWaterMark: 1024 * 1024,
         statConcurrency: 4
       });
-      Transform.call(this, options);
+      Transform5.call(this, options);
       this._format = false;
       this._module = false;
       this._pending = 0;
@@ -109603,8 +109923,8 @@ var require_core3 = __commonJS({
       };
       this._streams = [];
     };
-    inherits(Archiver, Transform);
-    Archiver.prototype._abort = function() {
+    inherits(Archiver2, Transform5);
+    Archiver2.prototype._abort = function() {
       this._state.aborted = true;
       this._queue.kill();
       this._statQueue.kill();
@@ -109612,7 +109932,7 @@ var require_core3 = __commonJS({
         this._shutdown();
       }
     };
-    Archiver.prototype._append = function(filepath, data) {
+    Archiver2.prototype._append = function(filepath, data) {
       data = data || {};
       var task = {
         source: null,
@@ -109624,7 +109944,7 @@ var require_core3 = __commonJS({
       data.sourcePath = filepath;
       task.data = data;
       this._entriesCount++;
-      if (data.stats && data.stats instanceof fs30.Stats) {
+      if (data.stats && data.stats instanceof fs31.Stats) {
         task = this._updateQueueTaskWithStats(task, data.stats);
         if (task) {
           if (data.stats.size) {
@@ -109636,7 +109956,7 @@ var require_core3 = __commonJS({
         this._statQueue.push(task);
       }
     };
-    Archiver.prototype._finalize = function() {
+    Archiver2.prototype._finalize = function() {
       if (this._state.finalizing || this._state.finalized || this._state.aborted) {
         return;
       }
@@ -109645,7 +109965,7 @@ var require_core3 = __commonJS({
       this._state.finalizing = false;
       this._state.finalized = true;
     };
-    Archiver.prototype._maybeFinalize = function() {
+    Archiver2.prototype._maybeFinalize = function() {
       if (this._state.finalizing || this._state.finalized || this._state.aborted) {
         return false;
       }
@@ -109655,7 +109975,7 @@ var require_core3 = __commonJS({
       }
       return false;
     };
-    Archiver.prototype._moduleAppend = function(source, data, callback) {
+    Archiver2.prototype._moduleAppend = function(source, data, callback) {
       if (this._state.aborted) {
         callback();
         return;
@@ -109689,32 +110009,32 @@ var require_core3 = __commonJS({
         setImmediate(callback);
       }.bind(this));
     };
-    Archiver.prototype._moduleFinalize = function() {
+    Archiver2.prototype._moduleFinalize = function() {
       if (typeof this._module.finalize === "function") {
         this._module.finalize();
       } else if (typeof this._module.end === "function") {
         this._module.end();
       } else {
-        this.emit("error", new ArchiverError("NOENDMETHOD"));
+        this.emit("error", new ArchiverError2("NOENDMETHOD"));
       }
     };
-    Archiver.prototype._modulePipe = function() {
+    Archiver2.prototype._modulePipe = function() {
       this._module.on("error", this._onModuleError.bind(this));
       this._module.pipe(this);
       this._state.modulePiped = true;
     };
-    Archiver.prototype._moduleSupports = function(key) {
+    Archiver2.prototype._moduleSupports = function(key) {
       if (!this._module.supports || !this._module.supports[key]) {
         return false;
       }
       return this._module.supports[key];
     };
-    Archiver.prototype._moduleUnpipe = function() {
+    Archiver2.prototype._moduleUnpipe = function() {
       this._module.unpipe(this);
       this._state.modulePiped = false;
     };
-    Archiver.prototype._normalizeEntryData = function(data, stats) {
-      data = util.defaults(data, {
+    Archiver2.prototype._normalizeEntryData = function(data, stats) {
+      data = util3.defaults(data, {
         type: "file",
         name: null,
         date: null,
@@ -109732,7 +110052,7 @@ var require_core3 = __commonJS({
           data.name = data.prefix + "/" + data.name;
           data.prefix = null;
         }
-        data.name = util.sanitizePath(data.name);
+        data.name = util3.sanitizePath(data.name);
         if (data.type !== "symlink" && data.name.slice(-1) === "/") {
           isDir = true;
           data.type = "directory";
@@ -109741,18 +110061,18 @@ var require_core3 = __commonJS({
         }
       }
       if (typeof data.mode === "number") {
-        if (win32) {
+        if (win322) {
           data.mode &= 511;
         } else {
           data.mode &= 4095;
         }
       } else if (data.stats && data.mode === null) {
-        if (win32) {
+        if (win322) {
           data.mode = data.stats.mode & 511;
         } else {
           data.mode = data.stats.mode & 4095;
         }
-        if (win32 && isDir) {
+        if (win322 && isDir) {
           data.mode = 493;
         }
       } else if (data.mode === null) {
@@ -109761,14 +110081,14 @@ var require_core3 = __commonJS({
       if (data.stats && data.date === null) {
         data.date = data.stats.mtime;
       } else {
-        data.date = util.dateify(data.date);
+        data.date = util3.dateify(data.date);
       }
       return data;
     };
-    Archiver.prototype._onModuleError = function(err) {
+    Archiver2.prototype._onModuleError = function(err) {
       this.emit("error", err);
     };
-    Archiver.prototype._onQueueDrain = function() {
+    Archiver2.prototype._onQueueDrain = function() {
       if (this._state.finalizing || this._state.finalized || this._state.aborted) {
         return;
       }
@@ -109776,7 +110096,7 @@ var require_core3 = __commonJS({
         this._finalize();
       }
     };
-    Archiver.prototype._onQueueTask = function(task, callback) {
+    Archiver2.prototype._onQueueTask = function(task, callback) {
       var fullCallback = () => {
         if (task.data.callback) {
           task.data.callback();
@@ -109790,12 +110110,12 @@ var require_core3 = __commonJS({
       this._task = task;
       this._moduleAppend(task.source, task.data, fullCallback);
     };
-    Archiver.prototype._onStatQueueTask = function(task, callback) {
+    Archiver2.prototype._onStatQueueTask = function(task, callback) {
       if (this._state.finalizing || this._state.finalized || this._state.aborted) {
         callback();
         return;
       }
-      fs30.lstat(task.filepath, function(err, stats) {
+      fs31.lstat(task.filepath, function(err, stats) {
         if (this._state.aborted) {
           setImmediate(callback);
           return;
@@ -109816,75 +110136,75 @@ var require_core3 = __commonJS({
         setImmediate(callback);
       }.bind(this));
     };
-    Archiver.prototype._shutdown = function() {
+    Archiver2.prototype._shutdown = function() {
       this._moduleUnpipe();
       this.end();
     };
-    Archiver.prototype._transform = function(chunk, encoding, callback) {
+    Archiver2.prototype._transform = function(chunk, encoding, callback) {
       if (chunk) {
         this._pointer += chunk.length;
       }
       callback(null, chunk);
     };
-    Archiver.prototype._updateQueueTaskWithStats = function(task, stats) {
+    Archiver2.prototype._updateQueueTaskWithStats = function(task, stats) {
       if (stats.isFile()) {
         task.data.type = "file";
         task.data.sourceType = "stream";
-        task.source = util.lazyReadStream(task.filepath);
+        task.source = util3.lazyReadStream(task.filepath);
       } else if (stats.isDirectory() && this._moduleSupports("directory")) {
-        task.data.name = util.trailingSlashIt(task.data.name);
+        task.data.name = util3.trailingSlashIt(task.data.name);
         task.data.type = "directory";
-        task.data.sourcePath = util.trailingSlashIt(task.filepath);
+        task.data.sourcePath = util3.trailingSlashIt(task.filepath);
         task.data.sourceType = "buffer";
         task.source = Buffer.concat([]);
       } else if (stats.isSymbolicLink() && this._moduleSupports("symlink")) {
-        var linkPath = fs30.readlinkSync(task.filepath);
-        var dirName = path28.dirname(task.filepath);
+        var linkPath = fs31.readlinkSync(task.filepath);
+        var dirName = path29.dirname(task.filepath);
         task.data.type = "symlink";
-        task.data.linkname = path28.relative(dirName, path28.resolve(dirName, linkPath));
+        task.data.linkname = path29.relative(dirName, path29.resolve(dirName, linkPath));
         task.data.sourceType = "buffer";
         task.source = Buffer.concat([]);
       } else {
         if (stats.isDirectory()) {
-          this.emit("warning", new ArchiverError("DIRECTORYNOTSUPPORTED", task.data));
+          this.emit("warning", new ArchiverError2("DIRECTORYNOTSUPPORTED", task.data));
         } else if (stats.isSymbolicLink()) {
-          this.emit("warning", new ArchiverError("SYMLINKNOTSUPPORTED", task.data));
+          this.emit("warning", new ArchiverError2("SYMLINKNOTSUPPORTED", task.data));
         } else {
-          this.emit("warning", new ArchiverError("ENTRYNOTSUPPORTED", task.data));
+          this.emit("warning", new ArchiverError2("ENTRYNOTSUPPORTED", task.data));
         }
         return null;
       }
       task.data = this._normalizeEntryData(task.data, stats);
       return task;
     };
-    Archiver.prototype.abort = function() {
+    Archiver2.prototype.abort = function() {
       if (this._state.aborted || this._state.finalized) {
         return this;
       }
       this._abort();
       return this;
     };
-    Archiver.prototype.append = function(source, data) {
+    Archiver2.prototype.append = function(source, data) {
       if (this._state.finalize || this._state.aborted) {
-        this.emit("error", new ArchiverError("QUEUECLOSED"));
+        this.emit("error", new ArchiverError2("QUEUECLOSED"));
         return this;
       }
       data = this._normalizeEntryData(data);
       if (typeof data.name !== "string" || data.name.length === 0) {
-        this.emit("error", new ArchiverError("ENTRYNAMEREQUIRED"));
+        this.emit("error", new ArchiverError2("ENTRYNAMEREQUIRED"));
         return this;
       }
       if (data.type === "directory" && !this._moduleSupports("directory")) {
-        this.emit("error", new ArchiverError("DIRECTORYNOTSUPPORTED", { name: data.name }));
+        this.emit("error", new ArchiverError2("DIRECTORYNOTSUPPORTED", { name: data.name }));
         return this;
       }
-      source = util.normalizeInputSource(source);
+      source = util3.normalizeInputSource(source);
       if (Buffer.isBuffer(source)) {
         data.sourceType = "buffer";
-      } else if (util.isStream(source)) {
+      } else if (util3.isStream(source)) {
         data.sourceType = "stream";
       } else {
-        this.emit("error", new ArchiverError("INPUTSTEAMBUFFERREQUIRED", { name: data.name }));
+        this.emit("error", new ArchiverError2("INPUTSTEAMBUFFERREQUIRED", { name: data.name }));
         return this;
       }
       this._entriesCount++;
@@ -109894,13 +110214,13 @@ var require_core3 = __commonJS({
       });
       return this;
     };
-    Archiver.prototype.directory = function(dirpath, destpath, data) {
+    Archiver2.prototype.directory = function(dirpath, destpath, data) {
       if (this._state.finalize || this._state.aborted) {
-        this.emit("error", new ArchiverError("QUEUECLOSED"));
+        this.emit("error", new ArchiverError2("QUEUECLOSED"));
         return this;
       }
       if (typeof dirpath !== "string" || dirpath.length === 0) {
-        this.emit("error", new ArchiverError("DIRECTORYDIRPATHREQUIRED"));
+        this.emit("error", new ArchiverError2("DIRECTORYDIRPATHREQUIRED"));
         return this;
       }
       this._pending++;
@@ -109927,13 +110247,13 @@ var require_core3 = __commonJS({
       function onGlobError(err) {
         this.emit("error", err);
       }
-      function onGlobMatch(match) {
+      function onGlobMatch(match2) {
         globber.pause();
         var ignoreMatch = false;
         var entryData = Object.assign({}, data);
-        entryData.name = match.relative;
+        entryData.name = match2.relative;
         entryData.prefix = destpath;
-        entryData.stats = match.stat;
+        entryData.stats = match2.stat;
         entryData.callback = globber.resume.bind(globber);
         try {
           if (dataFunction) {
@@ -109941,7 +110261,7 @@ var require_core3 = __commonJS({
             if (entryData === false) {
               ignoreMatch = true;
             } else if (typeof entryData !== "object") {
-              throw new ArchiverError("DIRECTORYFUNCTIONINVALIDDATA", { dirpath });
+              throw new ArchiverError2("DIRECTORYFUNCTIONINVALIDDATA", { dirpath });
             }
           }
         } catch (e) {
@@ -109952,7 +110272,7 @@ var require_core3 = __commonJS({
           globber.resume();
           return;
         }
-        this._append(match.absolute, entryData);
+        this._append(match2.absolute, entryData);
       }
       var globber = glob2(dirpath, globOptions);
       globber.on("error", onGlobError.bind(this));
@@ -109960,21 +110280,21 @@ var require_core3 = __commonJS({
       globber.on("end", onGlobEnd.bind(this));
       return this;
     };
-    Archiver.prototype.file = function(filepath, data) {
+    Archiver2.prototype.file = function(filepath, data) {
       if (this._state.finalize || this._state.aborted) {
-        this.emit("error", new ArchiverError("QUEUECLOSED"));
+        this.emit("error", new ArchiverError2("QUEUECLOSED"));
         return this;
       }
       if (typeof filepath !== "string" || filepath.length === 0) {
-        this.emit("error", new ArchiverError("FILEFILEPATHREQUIRED"));
+        this.emit("error", new ArchiverError2("FILEFILEPATHREQUIRED"));
         return this;
       }
       this._append(filepath, data);
       return this;
     };
-    Archiver.prototype.glob = function(pattern, options, data) {
+    Archiver2.prototype.glob = function(pattern, options, data) {
       this._pending++;
-      options = util.defaults(options, {
+      options = util3.defaults(options, {
         stat: true,
         pattern
       });
@@ -109985,13 +110305,13 @@ var require_core3 = __commonJS({
       function onGlobError(err) {
         this.emit("error", err);
       }
-      function onGlobMatch(match) {
+      function onGlobMatch(match2) {
         globber.pause();
         var entryData = Object.assign({}, data);
         entryData.callback = globber.resume.bind(globber);
-        entryData.stats = match.stat;
-        entryData.name = match.relative;
-        this._append(match.absolute, entryData);
+        entryData.stats = match2.stat;
+        entryData.name = match2.relative;
+        this._append(match2.absolute, entryData);
       }
       var globber = glob2(options.cwd || ".", options);
       globber.on("error", onGlobError.bind(this));
@@ -109999,14 +110319,14 @@ var require_core3 = __commonJS({
       globber.on("end", onGlobEnd.bind(this));
       return this;
     };
-    Archiver.prototype.finalize = function() {
+    Archiver2.prototype.finalize = function() {
       if (this._state.aborted) {
-        var abortedError = new ArchiverError("ABORTED");
+        var abortedError = new ArchiverError2("ABORTED");
         this.emit("error", abortedError);
         return Promise.reject(abortedError);
       }
       if (this._state.finalize) {
-        var finalizingError = new ArchiverError("FINALIZING");
+        var finalizingError = new ArchiverError2("FINALIZING");
         this.emit("error", finalizingError);
         return Promise.reject(finalizingError);
       }
@@ -110015,11 +110335,11 @@ var require_core3 = __commonJS({
         this._finalize();
       }
       var self2 = this;
-      return new Promise(function(resolve13, reject) {
+      return new Promise(function(resolve14, reject) {
         var errored;
         self2._module.on("end", function() {
           if (!errored) {
-            resolve13();
+            resolve14();
           }
         });
         self2._module.on("error", function(err) {
@@ -110028,42 +110348,42 @@ var require_core3 = __commonJS({
         });
       });
     };
-    Archiver.prototype.setFormat = function(format) {
+    Archiver2.prototype.setFormat = function(format) {
       if (this._format) {
-        this.emit("error", new ArchiverError("FORMATSET"));
+        this.emit("error", new ArchiverError2("FORMATSET"));
         return this;
       }
       this._format = format;
       return this;
     };
-    Archiver.prototype.setModule = function(module3) {
+    Archiver2.prototype.setModule = function(module3) {
       if (this._state.aborted) {
-        this.emit("error", new ArchiverError("ABORTED"));
+        this.emit("error", new ArchiverError2("ABORTED"));
         return this;
       }
       if (this._state.module) {
-        this.emit("error", new ArchiverError("MODULESET"));
+        this.emit("error", new ArchiverError2("MODULESET"));
         return this;
       }
       this._module = module3;
       this._modulePipe();
       return this;
     };
-    Archiver.prototype.symlink = function(filepath, target, mode) {
+    Archiver2.prototype.symlink = function(filepath, target, mode) {
       if (this._state.finalize || this._state.aborted) {
-        this.emit("error", new ArchiverError("QUEUECLOSED"));
+        this.emit("error", new ArchiverError2("QUEUECLOSED"));
         return this;
       }
       if (typeof filepath !== "string" || filepath.length === 0) {
-        this.emit("error", new ArchiverError("SYMLINKFILEPATHREQUIRED"));
+        this.emit("error", new ArchiverError2("SYMLINKFILEPATHREQUIRED"));
         return this;
       }
       if (typeof target !== "string" || target.length === 0) {
-        this.emit("error", new ArchiverError("SYMLINKTARGETREQUIRED", { filepath }));
+        this.emit("error", new ArchiverError2("SYMLINKTARGETREQUIRED", { filepath }));
         return this;
       }
       if (!this._moduleSupports("symlink")) {
-        this.emit("error", new ArchiverError("SYMLINKNOTSUPPORTED", { filepath }));
+        this.emit("error", new ArchiverError2("SYMLINKNOTSUPPORTED", { filepath }));
         return this;
       }
       var data = {};
@@ -110081,38 +110401,38 @@ var require_core3 = __commonJS({
       });
       return this;
     };
-    Archiver.prototype.pointer = function() {
+    Archiver2.prototype.pointer = function() {
       return this._pointer;
     };
-    Archiver.prototype.use = function(plugin) {
+    Archiver2.prototype.use = function(plugin) {
       this._streams.push(plugin);
       return this;
     };
-    module2.exports = Archiver;
+    module2.exports = Archiver2;
   }
 });
 
-// node_modules/compress-commons/lib/archivers/archive-entry.js
+// node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/archive-entry.js
 var require_archive_entry = __commonJS({
-  "node_modules/compress-commons/lib/archivers/archive-entry.js"(exports2, module2) {
-    var ArchiveEntry = module2.exports = function() {
+  "node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/archive-entry.js"(exports2, module2) {
+    var ArchiveEntry2 = module2.exports = function() {
     };
-    ArchiveEntry.prototype.getName = function() {
+    ArchiveEntry2.prototype.getName = function() {
     };
-    ArchiveEntry.prototype.getSize = function() {
+    ArchiveEntry2.prototype.getSize = function() {
     };
-    ArchiveEntry.prototype.getLastModifiedDate = function() {
+    ArchiveEntry2.prototype.getLastModifiedDate = function() {
     };
-    ArchiveEntry.prototype.isDirectory = function() {
+    ArchiveEntry2.prototype.isDirectory = function() {
     };
   }
 });
 
-// node_modules/compress-commons/lib/archivers/zip/util.js
+// node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/zip/util.js
 var require_util14 = __commonJS({
-  "node_modules/compress-commons/lib/archivers/zip/util.js"(exports2, module2) {
-    var util = module2.exports = {};
-    util.dateToDos = function(d, forceLocalTime) {
+  "node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/zip/util.js"(exports2, module2) {
+    var util3 = module2.exports = {};
+    util3.dateToDos = function(d, forceLocalTime) {
       forceLocalTime = forceLocalTime || false;
       var year = forceLocalTime ? d.getFullYear() : d.getUTCFullYear();
       if (year < 1980) {
@@ -110130,53 +110450,53 @@ var require_util14 = __commonJS({
       };
       return val.year - 1980 << 25 | val.month + 1 << 21 | val.date << 16 | val.hours << 11 | val.minutes << 5 | val.seconds / 2;
     };
-    util.dosToDate = function(dos) {
+    util3.dosToDate = function(dos) {
       return new Date((dos >> 25 & 127) + 1980, (dos >> 21 & 15) - 1, dos >> 16 & 31, dos >> 11 & 31, dos >> 5 & 63, (dos & 31) << 1);
     };
-    util.fromDosTime = function(buf) {
-      return util.dosToDate(buf.readUInt32LE(0));
+    util3.fromDosTime = function(buf) {
+      return util3.dosToDate(buf.readUInt32LE(0));
     };
-    util.getEightBytes = function(v) {
+    util3.getEightBytes = function(v) {
       var buf = Buffer.alloc(8);
       buf.writeUInt32LE(v % 4294967296, 0);
       buf.writeUInt32LE(v / 4294967296 | 0, 4);
       return buf;
     };
-    util.getShortBytes = function(v) {
+    util3.getShortBytes = function(v) {
       var buf = Buffer.alloc(2);
       buf.writeUInt16LE((v & 65535) >>> 0, 0);
       return buf;
     };
-    util.getShortBytesValue = function(buf, offset) {
+    util3.getShortBytesValue = function(buf, offset) {
       return buf.readUInt16LE(offset);
     };
-    util.getLongBytes = function(v) {
+    util3.getLongBytes = function(v) {
       var buf = Buffer.alloc(4);
       buf.writeUInt32LE((v & 4294967295) >>> 0, 0);
       return buf;
     };
-    util.getLongBytesValue = function(buf, offset) {
+    util3.getLongBytesValue = function(buf, offset) {
       return buf.readUInt32LE(offset);
     };
-    util.toDosTime = function(d) {
-      return util.getLongBytes(util.dateToDos(d));
+    util3.toDosTime = function(d) {
+      return util3.getLongBytes(util3.dateToDos(d));
     };
   }
 });
 
-// node_modules/compress-commons/lib/archivers/zip/general-purpose-bit.js
+// node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/zip/general-purpose-bit.js
 var require_general_purpose_bit = __commonJS({
-  "node_modules/compress-commons/lib/archivers/zip/general-purpose-bit.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/zip/general-purpose-bit.js"(exports2, module2) {
     var zipUtil = require_util14();
-    var DATA_DESCRIPTOR_FLAG = 1 << 3;
-    var ENCRYPTION_FLAG = 1 << 0;
-    var NUMBER_OF_SHANNON_FANO_TREES_FLAG = 1 << 2;
-    var SLIDING_DICTIONARY_SIZE_FLAG = 1 << 1;
-    var STRONG_ENCRYPTION_FLAG = 1 << 6;
-    var UFT8_NAMES_FLAG = 1 << 11;
-    var GeneralPurposeBit = module2.exports = function() {
-      if (!(this instanceof GeneralPurposeBit)) {
-        return new GeneralPurposeBit();
+    var DATA_DESCRIPTOR_FLAG2 = 1 << 3;
+    var ENCRYPTION_FLAG2 = 1 << 0;
+    var NUMBER_OF_SHANNON_FANO_TREES_FLAG2 = 1 << 2;
+    var SLIDING_DICTIONARY_SIZE_FLAG2 = 1 << 1;
+    var STRONG_ENCRYPTION_FLAG2 = 1 << 6;
+    var UFT8_NAMES_FLAG2 = 1 << 11;
+    var GeneralPurposeBit2 = module2.exports = function() {
+      if (!(this instanceof GeneralPurposeBit2)) {
+        return new GeneralPurposeBit2();
       }
       this.descriptor = false;
       this.encryption = false;
@@ -110186,64 +110506,64 @@ var require_general_purpose_bit = __commonJS({
       this.slidingDictionarySize = 0;
       return this;
     };
-    GeneralPurposeBit.prototype.encode = function() {
+    GeneralPurposeBit2.prototype.encode = function() {
       return zipUtil.getShortBytes(
-        (this.descriptor ? DATA_DESCRIPTOR_FLAG : 0) | (this.utf8 ? UFT8_NAMES_FLAG : 0) | (this.encryption ? ENCRYPTION_FLAG : 0) | (this.strongEncryption ? STRONG_ENCRYPTION_FLAG : 0)
+        (this.descriptor ? DATA_DESCRIPTOR_FLAG2 : 0) | (this.utf8 ? UFT8_NAMES_FLAG2 : 0) | (this.encryption ? ENCRYPTION_FLAG2 : 0) | (this.strongEncryption ? STRONG_ENCRYPTION_FLAG2 : 0)
       );
     };
-    GeneralPurposeBit.prototype.parse = function(buf, offset) {
+    GeneralPurposeBit2.prototype.parse = function(buf, offset) {
       var flag = zipUtil.getShortBytesValue(buf, offset);
-      var gbp = new GeneralPurposeBit();
-      gbp.useDataDescriptor((flag & DATA_DESCRIPTOR_FLAG) !== 0);
-      gbp.useUTF8ForNames((flag & UFT8_NAMES_FLAG) !== 0);
-      gbp.useStrongEncryption((flag & STRONG_ENCRYPTION_FLAG) !== 0);
-      gbp.useEncryption((flag & ENCRYPTION_FLAG) !== 0);
-      gbp.setSlidingDictionarySize((flag & SLIDING_DICTIONARY_SIZE_FLAG) !== 0 ? 8192 : 4096);
-      gbp.setNumberOfShannonFanoTrees((flag & NUMBER_OF_SHANNON_FANO_TREES_FLAG) !== 0 ? 3 : 2);
+      var gbp = new GeneralPurposeBit2();
+      gbp.useDataDescriptor((flag & DATA_DESCRIPTOR_FLAG2) !== 0);
+      gbp.useUTF8ForNames((flag & UFT8_NAMES_FLAG2) !== 0);
+      gbp.useStrongEncryption((flag & STRONG_ENCRYPTION_FLAG2) !== 0);
+      gbp.useEncryption((flag & ENCRYPTION_FLAG2) !== 0);
+      gbp.setSlidingDictionarySize((flag & SLIDING_DICTIONARY_SIZE_FLAG2) !== 0 ? 8192 : 4096);
+      gbp.setNumberOfShannonFanoTrees((flag & NUMBER_OF_SHANNON_FANO_TREES_FLAG2) !== 0 ? 3 : 2);
       return gbp;
     };
-    GeneralPurposeBit.prototype.setNumberOfShannonFanoTrees = function(n) {
+    GeneralPurposeBit2.prototype.setNumberOfShannonFanoTrees = function(n) {
       this.numberOfShannonFanoTrees = n;
     };
-    GeneralPurposeBit.prototype.getNumberOfShannonFanoTrees = function() {
+    GeneralPurposeBit2.prototype.getNumberOfShannonFanoTrees = function() {
       return this.numberOfShannonFanoTrees;
     };
-    GeneralPurposeBit.prototype.setSlidingDictionarySize = function(n) {
+    GeneralPurposeBit2.prototype.setSlidingDictionarySize = function(n) {
       this.slidingDictionarySize = n;
     };
-    GeneralPurposeBit.prototype.getSlidingDictionarySize = function() {
+    GeneralPurposeBit2.prototype.getSlidingDictionarySize = function() {
       return this.slidingDictionarySize;
     };
-    GeneralPurposeBit.prototype.useDataDescriptor = function(b) {
+    GeneralPurposeBit2.prototype.useDataDescriptor = function(b) {
       this.descriptor = b;
     };
-    GeneralPurposeBit.prototype.usesDataDescriptor = function() {
+    GeneralPurposeBit2.prototype.usesDataDescriptor = function() {
       return this.descriptor;
     };
-    GeneralPurposeBit.prototype.useEncryption = function(b) {
+    GeneralPurposeBit2.prototype.useEncryption = function(b) {
       this.encryption = b;
     };
-    GeneralPurposeBit.prototype.usesEncryption = function() {
+    GeneralPurposeBit2.prototype.usesEncryption = function() {
       return this.encryption;
     };
-    GeneralPurposeBit.prototype.useStrongEncryption = function(b) {
+    GeneralPurposeBit2.prototype.useStrongEncryption = function(b) {
       this.strongEncryption = b;
     };
-    GeneralPurposeBit.prototype.usesStrongEncryption = function() {
+    GeneralPurposeBit2.prototype.usesStrongEncryption = function() {
       return this.strongEncryption;
     };
-    GeneralPurposeBit.prototype.useUTF8ForNames = function(b) {
+    GeneralPurposeBit2.prototype.useUTF8ForNames = function(b) {
       this.utf8 = b;
     };
-    GeneralPurposeBit.prototype.usesUTF8ForNames = function() {
+    GeneralPurposeBit2.prototype.usesUTF8ForNames = function() {
       return this.utf8;
     };
   }
 });
 
-// node_modules/compress-commons/lib/archivers/zip/unix-stat.js
+// node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/zip/unix-stat.js
 var require_unix_stat = __commonJS({
-  "node_modules/compress-commons/lib/archivers/zip/unix-stat.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/zip/unix-stat.js"(exports2, module2) {
     module2.exports = {
       /**
        * Bits used for permissions (and sticky bit)
@@ -110293,9 +110613,9 @@ var require_unix_stat = __commonJS({
   }
 });
 
-// node_modules/compress-commons/lib/archivers/zip/constants.js
+// node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/zip/constants.js
 var require_constants13 = __commonJS({
-  "node_modules/compress-commons/lib/archivers/zip/constants.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/zip/constants.js"(exports2, module2) {
     module2.exports = {
       WORD: 4,
       DWORD: 8,
@@ -110370,27 +110690,27 @@ var require_constants13 = __commonJS({
   }
 });
 
-// node_modules/compress-commons/lib/archivers/zip/zip-archive-entry.js
+// node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/zip/zip-archive-entry.js
 var require_zip_archive_entry = __commonJS({
-  "node_modules/compress-commons/lib/archivers/zip/zip-archive-entry.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/zip/zip-archive-entry.js"(exports2, module2) {
     var inherits = require("util").inherits;
-    var normalizePath = require_normalize_path();
-    var ArchiveEntry = require_archive_entry();
-    var GeneralPurposeBit = require_general_purpose_bit();
+    var normalizePath4 = require_normalize_path();
+    var ArchiveEntry2 = require_archive_entry();
+    var GeneralPurposeBit2 = require_general_purpose_bit();
     var UnixStat = require_unix_stat();
     var constants = require_constants13();
     var zipUtil = require_util14();
-    var ZipArchiveEntry = module2.exports = function(name) {
-      if (!(this instanceof ZipArchiveEntry)) {
-        return new ZipArchiveEntry(name);
+    var ZipArchiveEntry2 = module2.exports = function(name) {
+      if (!(this instanceof ZipArchiveEntry2)) {
+        return new ZipArchiveEntry2(name);
       }
-      ArchiveEntry.call(this);
+      ArchiveEntry2.call(this);
       this.platform = constants.PLATFORM_FAT;
       this.method = -1;
       this.name = null;
       this.size = 0;
       this.csize = 0;
-      this.gpb = new GeneralPurposeBit();
+      this.gpb = new GeneralPurposeBit2();
       this.crc = 0;
       this.time = -1;
       this.minver = constants.MIN_VERSION_INITIAL;
@@ -110403,102 +110723,102 @@ var require_zip_archive_entry = __commonJS({
         this.setName(name);
       }
     };
-    inherits(ZipArchiveEntry, ArchiveEntry);
-    ZipArchiveEntry.prototype.getCentralDirectoryExtra = function() {
+    inherits(ZipArchiveEntry2, ArchiveEntry2);
+    ZipArchiveEntry2.prototype.getCentralDirectoryExtra = function() {
       return this.getExtra();
     };
-    ZipArchiveEntry.prototype.getComment = function() {
+    ZipArchiveEntry2.prototype.getComment = function() {
       return this.comment !== null ? this.comment : "";
     };
-    ZipArchiveEntry.prototype.getCompressedSize = function() {
+    ZipArchiveEntry2.prototype.getCompressedSize = function() {
       return this.csize;
     };
-    ZipArchiveEntry.prototype.getCrc = function() {
+    ZipArchiveEntry2.prototype.getCrc = function() {
       return this.crc;
     };
-    ZipArchiveEntry.prototype.getExternalAttributes = function() {
+    ZipArchiveEntry2.prototype.getExternalAttributes = function() {
       return this.exattr;
     };
-    ZipArchiveEntry.prototype.getExtra = function() {
+    ZipArchiveEntry2.prototype.getExtra = function() {
       return this.extra !== null ? this.extra : constants.EMPTY;
     };
-    ZipArchiveEntry.prototype.getGeneralPurposeBit = function() {
+    ZipArchiveEntry2.prototype.getGeneralPurposeBit = function() {
       return this.gpb;
     };
-    ZipArchiveEntry.prototype.getInternalAttributes = function() {
+    ZipArchiveEntry2.prototype.getInternalAttributes = function() {
       return this.inattr;
     };
-    ZipArchiveEntry.prototype.getLastModifiedDate = function() {
+    ZipArchiveEntry2.prototype.getLastModifiedDate = function() {
       return this.getTime();
     };
-    ZipArchiveEntry.prototype.getLocalFileDataExtra = function() {
+    ZipArchiveEntry2.prototype.getLocalFileDataExtra = function() {
       return this.getExtra();
     };
-    ZipArchiveEntry.prototype.getMethod = function() {
+    ZipArchiveEntry2.prototype.getMethod = function() {
       return this.method;
     };
-    ZipArchiveEntry.prototype.getName = function() {
+    ZipArchiveEntry2.prototype.getName = function() {
       return this.name;
     };
-    ZipArchiveEntry.prototype.getPlatform = function() {
+    ZipArchiveEntry2.prototype.getPlatform = function() {
       return this.platform;
     };
-    ZipArchiveEntry.prototype.getSize = function() {
+    ZipArchiveEntry2.prototype.getSize = function() {
       return this.size;
     };
-    ZipArchiveEntry.prototype.getTime = function() {
+    ZipArchiveEntry2.prototype.getTime = function() {
       return this.time !== -1 ? zipUtil.dosToDate(this.time) : -1;
     };
-    ZipArchiveEntry.prototype.getTimeDos = function() {
+    ZipArchiveEntry2.prototype.getTimeDos = function() {
       return this.time !== -1 ? this.time : 0;
     };
-    ZipArchiveEntry.prototype.getUnixMode = function() {
+    ZipArchiveEntry2.prototype.getUnixMode = function() {
       return this.platform !== constants.PLATFORM_UNIX ? 0 : this.getExternalAttributes() >> constants.SHORT_SHIFT & constants.SHORT_MASK;
     };
-    ZipArchiveEntry.prototype.getVersionNeededToExtract = function() {
+    ZipArchiveEntry2.prototype.getVersionNeededToExtract = function() {
       return this.minver;
     };
-    ZipArchiveEntry.prototype.setComment = function(comment) {
+    ZipArchiveEntry2.prototype.setComment = function(comment) {
       if (Buffer.byteLength(comment) !== comment.length) {
         this.getGeneralPurposeBit().useUTF8ForNames(true);
       }
       this.comment = comment;
     };
-    ZipArchiveEntry.prototype.setCompressedSize = function(size) {
+    ZipArchiveEntry2.prototype.setCompressedSize = function(size) {
       if (size < 0) {
         throw new Error("invalid entry compressed size");
       }
       this.csize = size;
     };
-    ZipArchiveEntry.prototype.setCrc = function(crc) {
+    ZipArchiveEntry2.prototype.setCrc = function(crc) {
       if (crc < 0) {
         throw new Error("invalid entry crc32");
       }
       this.crc = crc;
     };
-    ZipArchiveEntry.prototype.setExternalAttributes = function(attr) {
+    ZipArchiveEntry2.prototype.setExternalAttributes = function(attr) {
       this.exattr = attr >>> 0;
     };
-    ZipArchiveEntry.prototype.setExtra = function(extra) {
+    ZipArchiveEntry2.prototype.setExtra = function(extra) {
       this.extra = extra;
     };
-    ZipArchiveEntry.prototype.setGeneralPurposeBit = function(gpb) {
-      if (!(gpb instanceof GeneralPurposeBit)) {
+    ZipArchiveEntry2.prototype.setGeneralPurposeBit = function(gpb) {
+      if (!(gpb instanceof GeneralPurposeBit2)) {
         throw new Error("invalid entry GeneralPurposeBit");
       }
       this.gpb = gpb;
     };
-    ZipArchiveEntry.prototype.setInternalAttributes = function(attr) {
+    ZipArchiveEntry2.prototype.setInternalAttributes = function(attr) {
       this.inattr = attr;
     };
-    ZipArchiveEntry.prototype.setMethod = function(method) {
+    ZipArchiveEntry2.prototype.setMethod = function(method) {
       if (method < 0) {
         throw new Error("invalid entry compression method");
       }
       this.method = method;
     };
-    ZipArchiveEntry.prototype.setName = function(name, prependSlash = false) {
-      name = normalizePath(name, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
+    ZipArchiveEntry2.prototype.setName = function(name, prependSlash = false) {
+      name = normalizePath4(name, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
       if (prependSlash) {
         name = `/${name}`;
       }
@@ -110507,22 +110827,22 @@ var require_zip_archive_entry = __commonJS({
       }
       this.name = name;
     };
-    ZipArchiveEntry.prototype.setPlatform = function(platform2) {
+    ZipArchiveEntry2.prototype.setPlatform = function(platform2) {
       this.platform = platform2;
     };
-    ZipArchiveEntry.prototype.setSize = function(size) {
+    ZipArchiveEntry2.prototype.setSize = function(size) {
       if (size < 0) {
         throw new Error("invalid entry size");
       }
       this.size = size;
     };
-    ZipArchiveEntry.prototype.setTime = function(time, forceLocalTime) {
+    ZipArchiveEntry2.prototype.setTime = function(time, forceLocalTime) {
       if (!(time instanceof Date)) {
         throw new Error("invalid entry time");
       }
       this.time = zipUtil.dateToDos(time, forceLocalTime);
     };
-    ZipArchiveEntry.prototype.setUnixMode = function(mode) {
+    ZipArchiveEntry2.prototype.setUnixMode = function(mode) {
       mode |= this.isDirectory() ? constants.S_IFDIR : constants.S_IFREG;
       var extattr = 0;
       extattr |= mode << constants.SHORT_SHIFT | (this.isDirectory() ? constants.S_DOS_D : constants.S_DOS_A);
@@ -110530,48 +110850,48 @@ var require_zip_archive_entry = __commonJS({
       this.mode = mode & constants.MODE_MASK;
       this.platform = constants.PLATFORM_UNIX;
     };
-    ZipArchiveEntry.prototype.setVersionNeededToExtract = function(minver) {
+    ZipArchiveEntry2.prototype.setVersionNeededToExtract = function(minver) {
       this.minver = minver;
     };
-    ZipArchiveEntry.prototype.isDirectory = function() {
+    ZipArchiveEntry2.prototype.isDirectory = function() {
       return this.getName().slice(-1) === "/";
     };
-    ZipArchiveEntry.prototype.isUnixSymlink = function() {
+    ZipArchiveEntry2.prototype.isUnixSymlink = function() {
       return (this.getUnixMode() & UnixStat.FILE_TYPE_FLAG) === UnixStat.LINK_FLAG;
     };
-    ZipArchiveEntry.prototype.isZip64 = function() {
+    ZipArchiveEntry2.prototype.isZip64 = function() {
       return this.csize > constants.ZIP64_MAGIC || this.size > constants.ZIP64_MAGIC;
     };
   }
 });
 
-// node_modules/compress-commons/node_modules/is-stream/index.js
+// node_modules/@actions/artifact/node_modules/is-stream/index.js
 var require_is_stream2 = __commonJS({
-  "node_modules/compress-commons/node_modules/is-stream/index.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/is-stream/index.js"(exports2, module2) {
     "use strict";
-    var isStream = (stream2) => stream2 !== null && typeof stream2 === "object" && typeof stream2.pipe === "function";
-    isStream.writable = (stream2) => isStream(stream2) && stream2.writable !== false && typeof stream2._write === "function" && typeof stream2._writableState === "object";
-    isStream.readable = (stream2) => isStream(stream2) && stream2.readable !== false && typeof stream2._read === "function" && typeof stream2._readableState === "object";
-    isStream.duplex = (stream2) => isStream.writable(stream2) && isStream.readable(stream2);
-    isStream.transform = (stream2) => isStream.duplex(stream2) && typeof stream2._transform === "function";
-    module2.exports = isStream;
+    var isStream2 = (stream2) => stream2 !== null && typeof stream2 === "object" && typeof stream2.pipe === "function";
+    isStream2.writable = (stream2) => isStream2(stream2) && stream2.writable !== false && typeof stream2._write === "function" && typeof stream2._writableState === "object";
+    isStream2.readable = (stream2) => isStream2(stream2) && stream2.readable !== false && typeof stream2._read === "function" && typeof stream2._readableState === "object";
+    isStream2.duplex = (stream2) => isStream2.writable(stream2) && isStream2.readable(stream2);
+    isStream2.transform = (stream2) => isStream2.duplex(stream2) && typeof stream2._transform === "function";
+    module2.exports = isStream2;
   }
 });
 
-// node_modules/compress-commons/lib/util/index.js
+// node_modules/@actions/artifact/node_modules/compress-commons/lib/util/index.js
 var require_util15 = __commonJS({
-  "node_modules/compress-commons/lib/util/index.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/compress-commons/lib/util/index.js"(exports2, module2) {
     var Stream = require("stream").Stream;
-    var PassThrough = require_ours().PassThrough;
-    var isStream = require_is_stream2();
-    var util = module2.exports = {};
-    util.normalizeInputSource = function(source) {
+    var PassThrough3 = require_ours().PassThrough;
+    var isStream2 = require_is_stream2();
+    var util3 = module2.exports = {};
+    util3.normalizeInputSource = function(source) {
       if (source === null) {
         return Buffer.alloc(0);
       } else if (typeof source === "string") {
         return Buffer.from(source);
-      } else if (isStream(source) && !source._readableState) {
-        var normalized = new PassThrough();
+      } else if (isStream2(source) && !source._readableState) {
+        var normalized = new PassThrough3();
         source.pipe(normalized);
         return normalized;
       }
@@ -110580,19 +110900,19 @@ var require_util15 = __commonJS({
   }
 });
 
-// node_modules/compress-commons/lib/archivers/archive-output-stream.js
+// node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/archive-output-stream.js
 var require_archive_output_stream = __commonJS({
-  "node_modules/compress-commons/lib/archivers/archive-output-stream.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/archive-output-stream.js"(exports2, module2) {
     var inherits = require("util").inherits;
-    var isStream = require_is_stream2();
-    var Transform = require_ours().Transform;
-    var ArchiveEntry = require_archive_entry();
-    var util = require_util15();
-    var ArchiveOutputStream = module2.exports = function(options) {
-      if (!(this instanceof ArchiveOutputStream)) {
-        return new ArchiveOutputStream(options);
-      }
-      Transform.call(this, options);
+    var isStream2 = require_is_stream2();
+    var Transform5 = require_ours().Transform;
+    var ArchiveEntry2 = require_archive_entry();
+    var util3 = require_util15();
+    var ArchiveOutputStream2 = module2.exports = function(options) {
+      if (!(this instanceof ArchiveOutputStream2)) {
+        return new ArchiveOutputStream2(options);
+      }
+      Transform5.call(this, options);
       this.offset = 0;
       this._archive = {
         finish: false,
@@ -110600,29 +110920,29 @@ var require_archive_output_stream = __commonJS({
         processing: false
       };
     };
-    inherits(ArchiveOutputStream, Transform);
-    ArchiveOutputStream.prototype._appendBuffer = function(zae, source, callback) {
+    inherits(ArchiveOutputStream2, Transform5);
+    ArchiveOutputStream2.prototype._appendBuffer = function(zae, source, callback) {
     };
-    ArchiveOutputStream.prototype._appendStream = function(zae, source, callback) {
+    ArchiveOutputStream2.prototype._appendStream = function(zae, source, callback) {
     };
-    ArchiveOutputStream.prototype._emitErrorCallback = function(err) {
+    ArchiveOutputStream2.prototype._emitErrorCallback = function(err) {
       if (err) {
         this.emit("error", err);
       }
     };
-    ArchiveOutputStream.prototype._finish = function(ae) {
+    ArchiveOutputStream2.prototype._finish = function(ae) {
     };
-    ArchiveOutputStream.prototype._normalizeEntry = function(ae) {
+    ArchiveOutputStream2.prototype._normalizeEntry = function(ae) {
     };
-    ArchiveOutputStream.prototype._transform = function(chunk, encoding, callback) {
+    ArchiveOutputStream2.prototype._transform = function(chunk, encoding, callback) {
       callback(null, chunk);
     };
-    ArchiveOutputStream.prototype.entry = function(ae, source, callback) {
+    ArchiveOutputStream2.prototype.entry = function(ae, source, callback) {
       source = source || null;
       if (typeof callback !== "function") {
         callback = this._emitErrorCallback.bind(this);
       }
-      if (!(ae instanceof ArchiveEntry)) {
+      if (!(ae instanceof ArchiveEntry2)) {
         callback(new Error("not a valid instance of ArchiveEntry"));
         return;
       }
@@ -110637,10 +110957,10 @@ var require_archive_output_stream = __commonJS({
       this._archive.processing = true;
       this._normalizeEntry(ae);
       this._entry = ae;
-      source = util.normalizeInputSource(source);
+      source = util3.normalizeInputSource(source);
       if (Buffer.isBuffer(source)) {
         this._appendBuffer(ae, source, callback);
-      } else if (isStream(source)) {
+      } else if (isStream2(source)) {
         this._appendStream(ae, source, callback);
       } else {
         this._archive.processing = false;
@@ -110649,21 +110969,21 @@ var require_archive_output_stream = __commonJS({
       }
       return this;
     };
-    ArchiveOutputStream.prototype.finish = function() {
+    ArchiveOutputStream2.prototype.finish = function() {
       if (this._archive.processing) {
         this._archive.finish = true;
         return;
       }
       this._finish();
     };
-    ArchiveOutputStream.prototype.getBytesWritten = function() {
+    ArchiveOutputStream2.prototype.getBytesWritten = function() {
       return this.offset;
     };
-    ArchiveOutputStream.prototype.write = function(chunk, cb) {
+    ArchiveOutputStream2.prototype.write = function(chunk, cb) {
       if (chunk) {
         this.offset += chunk.length;
       }
-      return Transform.prototype.write.call(this, chunk, cb);
+      return Transform5.prototype.write.call(this, chunk, cb);
     };
   }
 });
@@ -110766,13 +111086,13 @@ var require_crc32 = __commonJS({
   }
 });
 
-// node_modules/crc32-stream/lib/crc32-stream.js
+// node_modules/@actions/artifact/node_modules/crc32-stream/lib/crc32-stream.js
 var require_crc32_stream = __commonJS({
-  "node_modules/crc32-stream/lib/crc32-stream.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/crc32-stream/lib/crc32-stream.js"(exports2, module2) {
     "use strict";
-    var { Transform } = require_ours();
-    var crc32 = require_crc32();
-    var CRC32Stream = class extends Transform {
+    var { Transform: Transform5 } = require_ours();
+    var crc325 = require_crc32();
+    var CRC32Stream2 = class extends Transform5 {
       constructor(options) {
         super(options);
         this.checksum = Buffer.allocUnsafe(4);
@@ -110781,7 +111101,7 @@ var require_crc32_stream = __commonJS({
       }
       _transform(chunk, encoding, callback) {
         if (chunk) {
-          this.checksum = crc32.buf(chunk, this.checksum) >>> 0;
+          this.checksum = crc325.buf(chunk, this.checksum) >>> 0;
           this.rawSize += chunk.length;
         }
         callback(null, chunk);
@@ -110798,17 +111118,17 @@ var require_crc32_stream = __commonJS({
         return this.rawSize;
       }
     };
-    module2.exports = CRC32Stream;
+    module2.exports = CRC32Stream2;
   }
 });
 
-// node_modules/crc32-stream/lib/deflate-crc32-stream.js
+// node_modules/@actions/artifact/node_modules/crc32-stream/lib/deflate-crc32-stream.js
 var require_deflate_crc32_stream = __commonJS({
-  "node_modules/crc32-stream/lib/deflate-crc32-stream.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/crc32-stream/lib/deflate-crc32-stream.js"(exports2, module2) {
     "use strict";
-    var { DeflateRaw } = require("zlib");
-    var crc32 = require_crc32();
-    var DeflateCRC32Stream = class extends DeflateRaw {
+    var { DeflateRaw: DeflateRaw2 } = require("zlib");
+    var crc325 = require_crc32();
+    var DeflateCRC32Stream2 = class extends DeflateRaw2 {
       constructor(options) {
         super(options);
         this.checksum = Buffer.allocUnsafe(4);
@@ -110824,7 +111144,7 @@ var require_deflate_crc32_stream = __commonJS({
       }
       _transform(chunk, encoding, callback) {
         if (chunk) {
-          this.checksum = crc32.buf(chunk, this.checksum) >>> 0;
+          this.checksum = crc325.buf(chunk, this.checksum) >>> 0;
           this.rawSize += chunk.length;
         }
         super._transform(chunk, encoding, callback);
@@ -110845,13 +111165,13 @@ var require_deflate_crc32_stream = __commonJS({
         }
       }
     };
-    module2.exports = DeflateCRC32Stream;
+    module2.exports = DeflateCRC32Stream2;
   }
 });
 
-// node_modules/crc32-stream/lib/index.js
+// node_modules/@actions/artifact/node_modules/crc32-stream/lib/index.js
 var require_lib3 = __commonJS({
-  "node_modules/crc32-stream/lib/index.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/crc32-stream/lib/index.js"(exports2, module2) {
     "use strict";
     module2.exports = {
       CRC32Stream: require_crc32_stream(),
@@ -110860,25 +111180,25 @@ var require_lib3 = __commonJS({
   }
 });
 
-// node_modules/compress-commons/lib/archivers/zip/zip-archive-output-stream.js
+// node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/zip/zip-archive-output-stream.js
 var require_zip_archive_output_stream = __commonJS({
-  "node_modules/compress-commons/lib/archivers/zip/zip-archive-output-stream.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/compress-commons/lib/archivers/zip/zip-archive-output-stream.js"(exports2, module2) {
     var inherits = require("util").inherits;
-    var crc32 = require_crc32();
-    var { CRC32Stream } = require_lib3();
-    var { DeflateCRC32Stream } = require_lib3();
-    var ArchiveOutputStream = require_archive_output_stream();
-    var ZipArchiveEntry = require_zip_archive_entry();
-    var GeneralPurposeBit = require_general_purpose_bit();
+    var crc325 = require_crc32();
+    var { CRC32Stream: CRC32Stream2 } = require_lib3();
+    var { DeflateCRC32Stream: DeflateCRC32Stream2 } = require_lib3();
+    var ArchiveOutputStream2 = require_archive_output_stream();
+    var ZipArchiveEntry2 = require_zip_archive_entry();
+    var GeneralPurposeBit2 = require_general_purpose_bit();
     var constants = require_constants13();
-    var util = require_util15();
+    var util3 = require_util15();
     var zipUtil = require_util14();
-    var ZipArchiveOutputStream = module2.exports = function(options) {
-      if (!(this instanceof ZipArchiveOutputStream)) {
-        return new ZipArchiveOutputStream(options);
+    var ZipArchiveOutputStream2 = module2.exports = function(options) {
+      if (!(this instanceof ZipArchiveOutputStream2)) {
+        return new ZipArchiveOutputStream2(options);
       }
       options = this.options = this._defaults(options);
-      ArchiveOutputStream.call(this, options);
+      ArchiveOutputStream2.call(this, options);
       this._entry = null;
       this._entries = [];
       this._archive = {
@@ -110892,8 +111212,8 @@ var require_zip_archive_output_stream = __commonJS({
         forceLocalTime: options.forceLocalTime
       };
     };
-    inherits(ZipArchiveOutputStream, ArchiveOutputStream);
-    ZipArchiveOutputStream.prototype._afterAppend = function(ae) {
+    inherits(ZipArchiveOutputStream2, ArchiveOutputStream2);
+    ZipArchiveOutputStream2.prototype._afterAppend = function(ae) {
       this._entries.push(ae);
       if (ae.getGeneralPurposeBit().usesDataDescriptor()) {
         this._writeDataDescriptor(ae);
@@ -110904,7 +111224,7 @@ var require_zip_archive_output_stream = __commonJS({
         this._finish();
       }
     };
-    ZipArchiveOutputStream.prototype._appendBuffer = function(ae, source, callback) {
+    ZipArchiveOutputStream2.prototype._appendBuffer = function(ae, source, callback) {
       if (source.length === 0) {
         ae.setMethod(constants.METHOD_STORED);
       }
@@ -110912,7 +111232,7 @@ var require_zip_archive_output_stream = __commonJS({
       if (method === constants.METHOD_STORED) {
         ae.setSize(source.length);
         ae.setCompressedSize(source.length);
-        ae.setCrc(crc32.buf(source) >>> 0);
+        ae.setCrc(crc325.buf(source) >>> 0);
       }
       this._writeLocalFileHeader(ae);
       if (method === constants.METHOD_STORED) {
@@ -110928,7 +111248,7 @@ var require_zip_archive_output_stream = __commonJS({
         return;
       }
     };
-    ZipArchiveOutputStream.prototype._appendStream = function(ae, source, callback) {
+    ZipArchiveOutputStream2.prototype._appendStream = function(ae, source, callback) {
       ae.getGeneralPurposeBit().useDataDescriptor(true);
       ae.setVersionNeededToExtract(constants.MIN_VERSION_DATA_DESCRIPTOR);
       this._writeLocalFileHeader(ae);
@@ -110939,7 +111259,7 @@ var require_zip_archive_output_stream = __commonJS({
       });
       source.pipe(smart);
     };
-    ZipArchiveOutputStream.prototype._defaults = function(o) {
+    ZipArchiveOutputStream2.prototype._defaults = function(o) {
       if (typeof o !== "object") {
         o = {};
       }
@@ -110953,7 +111273,7 @@ var require_zip_archive_output_stream = __commonJS({
       o.forceLocalTime = !!o.forceLocalTime;
       return o;
     };
-    ZipArchiveOutputStream.prototype._finish = function() {
+    ZipArchiveOutputStream2.prototype._finish = function() {
       this._archive.centralOffset = this.offset;
       this._entries.forEach(function(ae) {
         this._writeCentralFileHeader(ae);
@@ -110968,7 +111288,7 @@ var require_zip_archive_output_stream = __commonJS({
       this._archive.finished = true;
       this.end();
     };
-    ZipArchiveOutputStream.prototype._normalizeEntry = function(ae) {
+    ZipArchiveOutputStream2.prototype._normalizeEntry = function(ae) {
       if (ae.getMethod() === -1) {
         ae.setMethod(constants.METHOD_DEFLATED);
       }
@@ -110985,9 +111305,9 @@ var require_zip_archive_output_stream = __commonJS({
         contents: 0
       };
     };
-    ZipArchiveOutputStream.prototype._smartStream = function(ae, callback) {
+    ZipArchiveOutputStream2.prototype._smartStream = function(ae, callback) {
       var deflate = ae.getMethod() === constants.METHOD_DEFLATED;
-      var process2 = deflate ? new DeflateCRC32Stream(this.options.zlib) : new CRC32Stream();
+      var process2 = deflate ? new DeflateCRC32Stream2(this.options.zlib) : new CRC32Stream2();
       var error3 = null;
       function handleStuff() {
         var digest = process2.digest().readUInt32BE(0);
@@ -111004,7 +111324,7 @@ var require_zip_archive_output_stream = __commonJS({
       process2.pipe(this, { end: false });
       return process2;
     };
-    ZipArchiveOutputStream.prototype._writeCentralDirectoryEnd = function() {
+    ZipArchiveOutputStream2.prototype._writeCentralDirectoryEnd = function() {
       var records = this._entries.length;
       var size = this._archive.centralLength;
       var offset = this._archive.centralOffset;
@@ -111025,7 +111345,7 @@ var require_zip_archive_output_stream = __commonJS({
       this.write(zipUtil.getShortBytes(commentLength));
       this.write(comment);
     };
-    ZipArchiveOutputStream.prototype._writeCentralDirectoryZip64 = function() {
+    ZipArchiveOutputStream2.prototype._writeCentralDirectoryZip64 = function() {
       this.write(zipUtil.getLongBytes(constants.SIG_ZIP64_EOCD));
       this.write(zipUtil.getEightBytes(44));
       this.write(zipUtil.getShortBytes(constants.MIN_VERSION_ZIP64));
@@ -111041,7 +111361,7 @@ var require_zip_archive_output_stream = __commonJS({
       this.write(zipUtil.getEightBytes(this._archive.centralOffset + this._archive.centralLength));
       this.write(zipUtil.getLongBytes(1));
     };
-    ZipArchiveOutputStream.prototype._writeCentralFileHeader = function(ae) {
+    ZipArchiveOutputStream2.prototype._writeCentralFileHeader = function(ae) {
       var gpb = ae.getGeneralPurposeBit();
       var method = ae.getMethod();
       var fileOffset = ae._offsets.file;
@@ -111088,7 +111408,7 @@ var require_zip_archive_output_stream = __commonJS({
       this.write(extra);
       this.write(comment);
     };
-    ZipArchiveOutputStream.prototype._writeDataDescriptor = function(ae) {
+    ZipArchiveOutputStream2.prototype._writeDataDescriptor = function(ae) {
       this.write(zipUtil.getLongBytes(constants.SIG_DD));
       this.write(zipUtil.getLongBytes(ae.getCrc()));
       if (ae.isZip64()) {
@@ -111099,7 +111419,7 @@ var require_zip_archive_output_stream = __commonJS({
         this.write(zipUtil.getLongBytes(ae.getSize()));
       }
     };
-    ZipArchiveOutputStream.prototype._writeLocalFileHeader = function(ae) {
+    ZipArchiveOutputStream2.prototype._writeLocalFileHeader = function(ae) {
       var gpb = ae.getGeneralPurposeBit();
       var method = ae.getMethod();
       var name = ae.getName();
@@ -111133,21 +111453,21 @@ var require_zip_archive_output_stream = __commonJS({
       this.write(extra);
       ae._offsets.contents = this.offset;
     };
-    ZipArchiveOutputStream.prototype.getComment = function(comment) {
+    ZipArchiveOutputStream2.prototype.getComment = function(comment) {
       return this._archive.comment !== null ? this._archive.comment : "";
     };
-    ZipArchiveOutputStream.prototype.isZip64 = function() {
+    ZipArchiveOutputStream2.prototype.isZip64 = function() {
       return this._archive.forceZip64 || this._entries.length > constants.ZIP64_MAGIC_SHORT || this._archive.centralLength > constants.ZIP64_MAGIC || this._archive.centralOffset > constants.ZIP64_MAGIC;
     };
-    ZipArchiveOutputStream.prototype.setComment = function(comment) {
+    ZipArchiveOutputStream2.prototype.setComment = function(comment) {
       this._archive.comment = comment;
     };
   }
 });
 
-// node_modules/compress-commons/lib/compress-commons.js
+// node_modules/@actions/artifact/node_modules/compress-commons/lib/compress-commons.js
 var require_compress_commons = __commonJS({
-  "node_modules/compress-commons/lib/compress-commons.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/compress-commons/lib/compress-commons.js"(exports2, module2) {
     module2.exports = {
       ArchiveEntry: require_archive_entry(),
       ZipArchiveEntry: require_zip_archive_entry(),
@@ -111157,20 +111477,20 @@ var require_compress_commons = __commonJS({
   }
 });
 
-// node_modules/zip-stream/index.js
+// node_modules/@actions/artifact/node_modules/zip-stream/index.js
 var require_zip_stream = __commonJS({
-  "node_modules/zip-stream/index.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/zip-stream/index.js"(exports2, module2) {
     var inherits = require("util").inherits;
-    var ZipArchiveOutputStream = require_compress_commons().ZipArchiveOutputStream;
-    var ZipArchiveEntry = require_compress_commons().ZipArchiveEntry;
-    var util = require_archiver_utils();
-    var ZipStream = module2.exports = function(options) {
-      if (!(this instanceof ZipStream)) {
-        return new ZipStream(options);
+    var ZipArchiveOutputStream2 = require_compress_commons().ZipArchiveOutputStream;
+    var ZipArchiveEntry2 = require_compress_commons().ZipArchiveEntry;
+    var util3 = require_archiver_utils();
+    var ZipStream2 = module2.exports = function(options) {
+      if (!(this instanceof ZipStream2)) {
+        return new ZipStream2(options);
       }
       options = this.options = options || {};
       options.zlib = options.zlib || {};
-      ZipArchiveOutputStream.call(this, options);
+      ZipArchiveOutputStream2.call(this, options);
       if (typeof options.level === "number" && options.level >= 0) {
         options.zlib.level = options.level;
         delete options.level;
@@ -111183,9 +111503,9 @@ var require_zip_stream = __commonJS({
         this.setComment(options.comment);
       }
     };
-    inherits(ZipStream, ZipArchiveOutputStream);
-    ZipStream.prototype._normalizeFileData = function(data) {
-      data = util.defaults(data, {
+    inherits(ZipStream2, ZipArchiveOutputStream2);
+    ZipStream2.prototype._normalizeFileData = function(data) {
+      data = util3.defaults(data, {
         type: "file",
         name: null,
         namePrependSlash: this.options.namePrependSlash,
@@ -111198,7 +111518,7 @@ var require_zip_stream = __commonJS({
       var isDir = data.type === "directory";
       var isSymlink = data.type === "symlink";
       if (data.name) {
-        data.name = util.sanitizePath(data.name);
+        data.name = util3.sanitizePath(data.name);
         if (!isSymlink && data.name.slice(-1) === "/") {
           isDir = true;
           data.type = "directory";
@@ -111209,10 +111529,10 @@ var require_zip_stream = __commonJS({
       if (isDir || isSymlink) {
         data.store = true;
       }
-      data.date = util.dateify(data.date);
+      data.date = util3.dateify(data.date);
       return data;
     };
-    ZipStream.prototype.entry = function(source, data, callback) {
+    ZipStream2.prototype.entry = function(source, data, callback) {
       if (typeof callback !== "function") {
         callback = this._emitErrorCallback.bind(this);
       }
@@ -111229,7 +111549,7 @@ var require_zip_stream = __commonJS({
         callback(new Error("entry linkname must be a non-empty string value when type equals symlink"));
         return;
       }
-      var entry = new ZipArchiveEntry(data.name);
+      var entry = new ZipArchiveEntry2(data.name);
       entry.setTime(data.date, this.options.forceLocalTime);
       if (data.namePrependSlash) {
         entry.setName(data.name, true);
@@ -111252,24 +111572,24 @@ var require_zip_stream = __commonJS({
       if (data.type === "symlink" && typeof data.linkname === "string") {
         source = Buffer.from(data.linkname);
       }
-      return ZipArchiveOutputStream.prototype.entry.call(this, entry, source, callback);
+      return ZipArchiveOutputStream2.prototype.entry.call(this, entry, source, callback);
     };
-    ZipStream.prototype.finalize = function() {
+    ZipStream2.prototype.finalize = function() {
       this.finish();
     };
   }
 });
 
-// node_modules/archiver/lib/plugins/zip.js
+// node_modules/@actions/artifact/node_modules/archiver/lib/plugins/zip.js
 var require_zip = __commonJS({
-  "node_modules/archiver/lib/plugins/zip.js"(exports2, module2) {
-    var engine = require_zip_stream();
-    var util = require_archiver_utils();
-    var Zip = function(options) {
-      if (!(this instanceof Zip)) {
-        return new Zip(options);
-      }
-      options = this.options = util.defaults(options, {
+  "node_modules/@actions/artifact/node_modules/archiver/lib/plugins/zip.js"(exports2, module2) {
+    var engine2 = require_zip_stream();
+    var util3 = require_archiver_utils();
+    var Zip2 = function(options) {
+      if (!(this instanceof Zip2)) {
+        return new Zip2(options);
+      }
+      options = this.options = util3.defaults(options, {
         comment: "",
         forceUTC: false,
         namePrependSlash: false,
@@ -111279,24 +111599,24 @@ var require_zip = __commonJS({
         directory: true,
         symlink: true
       };
-      this.engine = new engine(options);
+      this.engine = new engine2(options);
     };
-    Zip.prototype.append = function(source, data, callback) {
+    Zip2.prototype.append = function(source, data, callback) {
       this.engine.entry(source, data, callback);
     };
-    Zip.prototype.finalize = function() {
+    Zip2.prototype.finalize = function() {
       this.engine.finalize();
     };
-    Zip.prototype.on = function() {
+    Zip2.prototype.on = function() {
       return this.engine.on.apply(this.engine, arguments);
     };
-    Zip.prototype.pipe = function() {
+    Zip2.prototype.pipe = function() {
       return this.engine.pipe.apply(this.engine, arguments);
     };
-    Zip.prototype.unpipe = function() {
+    Zip2.prototype.unpipe = function() {
       return this.engine.unpipe.apply(this.engine, arguments);
     };
-    module2.exports = Zip;
+    module2.exports = Zip2;
   }
 });
 
@@ -111728,7 +112048,7 @@ var require_text_decoder = __commonJS({
 // node_modules/streamx/index.js
 var require_streamx = __commonJS({
   "node_modules/streamx/index.js"(exports2, module2) {
-    var { EventEmitter } = require("events");
+    var { EventEmitter: EventEmitter2 } = require("events");
     var STREAM_DESTROYED = new Error("Stream was destroyed");
     var PREMATURE_CLOSE = new Error("Premature close");
     var queueTick = require_process_next_tick();
@@ -112216,7 +112536,7 @@ var require_streamx = __commonJS({
         }
       }
     }
-    var Stream = class extends EventEmitter {
+    var Stream = class extends EventEmitter2 {
       constructor(opts) {
         super();
         this._duplexState = 0;
@@ -112272,7 +112592,7 @@ var require_streamx = __commonJS({
         }
       }
     };
-    var Readable2 = class _Readable extends Stream {
+    var Readable3 = class _Readable extends Stream {
       constructor(opts) {
         super(opts);
         this._duplexState |= OPENING | WRITE_DONE | READ_READ_AHEAD;
@@ -112378,8 +112698,8 @@ var require_streamx = __commonJS({
             return this;
           },
           next() {
-            return new Promise(function(resolve13, reject) {
-              promiseResolve = resolve13;
+            return new Promise(function(resolve14, reject) {
+              promiseResolve = resolve14;
               promiseReject = reject;
               const data = stream2.read();
               if (data !== null) ondata(data);
@@ -112408,11 +112728,11 @@ var require_streamx = __commonJS({
         }
         function destroy(err) {
           stream2.destroy(err);
-          return new Promise((resolve13, reject) => {
-            if (stream2._duplexState & DESTROYED) return resolve13({ value: void 0, done: true });
+          return new Promise((resolve14, reject) => {
+            if (stream2._duplexState & DESTROYED) return resolve14({ value: void 0, done: true });
             stream2.once("close", function() {
               if (err) reject(err);
-              else resolve13({ value: void 0, done: true });
+              else resolve14({ value: void 0, done: true });
             });
           });
         }
@@ -112456,8 +112776,8 @@ var require_streamx = __commonJS({
         const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0);
         if (writes === 0) return Promise.resolve(true);
         if (state.drains === null) state.drains = [];
-        return new Promise((resolve13) => {
-          state.drains.push({ writes, resolve: resolve13 });
+        return new Promise((resolve14) => {
+          state.drains.push({ writes, resolve: resolve14 });
         });
       }
       write(data) {
@@ -112470,7 +112790,7 @@ var require_streamx = __commonJS({
         return this;
       }
     };
-    var Duplex = class extends Readable2 {
+    var Duplex = class extends Readable3 {
       // and Writable
       constructor(opts) {
         super(opts);
@@ -112508,7 +112828,7 @@ var require_streamx = __commonJS({
         return this;
       }
     };
-    var Transform = class extends Duplex {
+    var Transform5 = class extends Duplex {
       constructor(opts) {
         super(opts);
         this._transformState = new TransformState(this);
@@ -112552,7 +112872,7 @@ var require_streamx = __commonJS({
         this._flush(transformAfterFlush.bind(this));
       }
     };
-    var PassThrough = class extends Transform {
+    var PassThrough3 = class extends Transform5 {
     };
     function transformAfterFlush(err, data) {
       const cb = this._transformState.afterFinal;
@@ -112562,10 +112882,10 @@ var require_streamx = __commonJS({
       cb(null);
     }
     function pipelinePromise(...streams) {
-      return new Promise((resolve13, reject) => {
+      return new Promise((resolve14, reject) => {
         return pipeline(...streams, (err) => {
           if (err) return reject(err);
-          resolve13();
+          resolve14();
         });
       });
     }
@@ -112620,11 +112940,11 @@ var require_streamx = __commonJS({
     function echo(s) {
       return s;
     }
-    function isStream(stream2) {
+    function isStream2(stream2) {
       return !!stream2._readableState || !!stream2._writableState;
     }
     function isStreamx(stream2) {
-      return typeof stream2._duplexState === "number" && isStream(stream2);
+      return typeof stream2._duplexState === "number" && isStream2(stream2);
     }
     function isEnded(stream2) {
       return !!stream2._readableState && stream2._readableState.ended;
@@ -112656,18 +112976,18 @@ var require_streamx = __commonJS({
     module2.exports = {
       pipeline,
       pipelinePromise,
-      isStream,
+      isStream: isStream2,
       isStreamx,
       isEnded,
       isFinished,
       getStreamError,
       Stream,
       Writable,
-      Readable: Readable2,
+      Readable: Readable3,
       Duplex,
-      Transform,
+      Transform: Transform5,
       // Export PassThrough for compatibility with Node.js core's stream module
-      PassThrough
+      PassThrough: PassThrough3
     };
   }
 });
@@ -112796,13 +113116,13 @@ var require_headers2 = __commonJS({
     function isGNU(buf) {
       return b4a.equals(GNU_MAGIC, buf.subarray(MAGIC_OFFSET, MAGIC_OFFSET + 6)) && b4a.equals(GNU_VER, buf.subarray(VERSION_OFFSET, VERSION_OFFSET + 2));
     }
-    function clamp(index, len, defaultValue) {
-      if (typeof index !== "number") return defaultValue;
-      index = ~~index;
-      if (index >= len) return len;
-      if (index >= 0) return index;
-      index += len;
-      if (index >= 0) return index;
+    function clamp(index2, len, defaultValue) {
+      if (typeof index2 !== "number") return defaultValue;
+      index2 = ~~index2;
+      if (index2 >= len) return len;
+      if (index2 >= 0) return index2;
+      index2 += len;
+      if (index2 >= 0) return index2;
       return 0;
     }
     function toType(flag) {
@@ -112936,11 +113256,11 @@ var require_headers2 = __commonJS({
 // node_modules/tar-stream/extract.js
 var require_extract = __commonJS({
   "node_modules/tar-stream/extract.js"(exports2, module2) {
-    var { Writable, Readable: Readable2, getStreamError } = require_streamx();
+    var { Writable, Readable: Readable3, getStreamError } = require_streamx();
     var FIFO = require_fast_fifo();
     var b4a = require_b4a();
     var headers = require_headers2();
-    var EMPTY = b4a.alloc(0);
+    var EMPTY2 = b4a.alloc(0);
     var BufferList = class {
       constructor() {
         this.buffered = 0;
@@ -112957,7 +113277,7 @@ var require_extract = __commonJS({
       }
       shift(size) {
         if (size > this.buffered) return null;
-        if (size === 0) return EMPTY;
+        if (size === 0) return EMPTY2;
         let chunk = this._next(size);
         if (size === chunk.byteLength) return chunk;
         const chunks = [chunk];
@@ -112983,7 +113303,7 @@ var require_extract = __commonJS({
         return buf.subarray(this._offset, this._offset += size);
       }
     };
-    var Source = class extends Readable2 {
+    var Source = class extends Readable3 {
       constructor(self2, header, offset) {
         super();
         this.header = header;
@@ -113208,16 +113528,16 @@ var require_extract = __commonJS({
           entryCallback = null;
           cb(err);
         }
-        function onnext(resolve13, reject) {
+        function onnext(resolve14, reject) {
           if (error3) {
             return reject(error3);
           }
           if (entryStream) {
-            resolve13({ value: entryStream, done: false });
+            resolve14({ value: entryStream, done: false });
             entryStream = null;
             return;
           }
-          promiseResolve = resolve13;
+          promiseResolve = resolve14;
           promiseReject = reject;
           consumeCallback(null);
           if (extract2._finished && promiseResolve) {
@@ -113245,11 +113565,11 @@ var require_extract = __commonJS({
         function destroy(err) {
           extract2.destroy(err);
           consumeCallback(err);
-          return new Promise((resolve13, reject) => {
-            if (extract2.destroyed) return resolve13({ value: void 0, done: true });
+          return new Promise((resolve14, reject) => {
+            if (extract2.destroyed) return resolve14({ value: void 0, done: true });
             extract2.once("close", function() {
               if (err) reject(err);
-              else resolve13({ value: void 0, done: true });
+              else resolve14({ value: void 0, done: true });
             });
           });
         }
@@ -113290,7 +113610,7 @@ var require_constants14 = __commonJS({
 // node_modules/tar-stream/pack.js
 var require_pack = __commonJS({
   "node_modules/tar-stream/pack.js"(exports2, module2) {
-    var { Readable: Readable2, Writable, getStreamError } = require_streamx();
+    var { Readable: Readable3, Writable, getStreamError } = require_streamx();
     var b4a = require_b4a();
     var constants = require_constants14();
     var headers = require_headers2();
@@ -113383,7 +113703,7 @@ var require_pack = __commonJS({
         cb();
       }
     };
-    var Pack = class extends Readable2 {
+    var Pack = class extends Readable3 {
       constructor(opts) {
         super(opts);
         this._drain = noop3;
@@ -113529,17 +113849,17 @@ var require_tar_stream = __commonJS({
   }
 });
 
-// node_modules/archiver/lib/plugins/tar.js
+// node_modules/@actions/artifact/node_modules/archiver/lib/plugins/tar.js
 var require_tar2 = __commonJS({
-  "node_modules/archiver/lib/plugins/tar.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/archiver/lib/plugins/tar.js"(exports2, module2) {
     var zlib3 = require("zlib");
-    var engine = require_tar_stream();
-    var util = require_archiver_utils();
-    var Tar = function(options) {
-      if (!(this instanceof Tar)) {
-        return new Tar(options);
+    var engine2 = require_tar_stream();
+    var util3 = require_archiver_utils();
+    var Tar2 = function(options) {
+      if (!(this instanceof Tar2)) {
+        return new Tar2(options);
       }
-      options = this.options = util.defaults(options, {
+      options = this.options = util3.defaults(options, {
         gzip: false
       });
       if (typeof options.gzipOptions !== "object") {
@@ -113549,17 +113869,17 @@ var require_tar2 = __commonJS({
         directory: true,
         symlink: true
       };
-      this.engine = engine.pack(options);
+      this.engine = engine2.pack(options);
       this.compressor = false;
       if (options.gzip) {
         this.compressor = zlib3.createGzip(options.gzipOptions);
         this.compressor.on("error", this._onCompressorError.bind(this));
       }
     };
-    Tar.prototype._onCompressorError = function(err) {
+    Tar2.prototype._onCompressorError = function(err) {
       this.engine.emit("error", err);
     };
-    Tar.prototype.append = function(source, data, callback) {
+    Tar2.prototype.append = function(source, data, callback) {
       var self2 = this;
       data.mtime = data.date;
       function append(err, sourceBuffer) {
@@ -113580,30 +113900,30 @@ var require_tar2 = __commonJS({
         });
         source.pipe(entry);
       } else if (data.sourceType === "stream") {
-        util.collectStream(source, append);
+        util3.collectStream(source, append);
       }
     };
-    Tar.prototype.finalize = function() {
+    Tar2.prototype.finalize = function() {
       this.engine.finalize();
     };
-    Tar.prototype.on = function() {
+    Tar2.prototype.on = function() {
       return this.engine.on.apply(this.engine, arguments);
     };
-    Tar.prototype.pipe = function(destination, options) {
+    Tar2.prototype.pipe = function(destination, options) {
       if (this.compressor) {
         return this.engine.pipe.apply(this.engine, [this.compressor]).pipe(destination, options);
       } else {
         return this.engine.pipe.apply(this.engine, arguments);
       }
     };
-    Tar.prototype.unpipe = function() {
+    Tar2.prototype.unpipe = function() {
       if (this.compressor) {
         return this.compressor.unpipe.apply(this.compressor, arguments);
       } else {
         return this.engine.unpipe.apply(this.engine, arguments);
       }
     };
-    module2.exports = Tar;
+    module2.exports = Tar2;
   }
 });
 
@@ -113614,7 +113934,7 @@ var require_dist5 = __commonJS({
     function getDefaultExportFromCjs(x) {
       return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
     }
-    var CRC_TABLE = new Int32Array([
+    var CRC_TABLE2 = new Int32Array([
       0,
       1996959894,
       3993919788,
@@ -113872,7 +114192,7 @@ var require_dist5 = __commonJS({
       1510334235,
       755167117
     ]);
-    function ensureBuffer(input) {
+    function ensureBuffer2(input) {
       if (Buffer.isBuffer(input)) {
         return input;
       }
@@ -113884,65 +114204,65 @@ var require_dist5 = __commonJS({
         throw new Error("input must be buffer, number, or string, received " + typeof input);
       }
     }
-    function bufferizeInt(num) {
-      const tmp = ensureBuffer(4);
+    function bufferizeInt2(num) {
+      const tmp = ensureBuffer2(4);
       tmp.writeInt32BE(num, 0);
       return tmp;
     }
-    function _crc32(buf, previous) {
-      buf = ensureBuffer(buf);
+    function _crc322(buf, previous) {
+      buf = ensureBuffer2(buf);
       if (Buffer.isBuffer(previous)) {
         previous = previous.readUInt32BE(0);
       }
       let crc = ~~previous ^ -1;
       for (var n = 0; n < buf.length; n++) {
-        crc = CRC_TABLE[(crc ^ buf[n]) & 255] ^ crc >>> 8;
+        crc = CRC_TABLE2[(crc ^ buf[n]) & 255] ^ crc >>> 8;
       }
       return crc ^ -1;
     }
-    function crc32() {
-      return bufferizeInt(_crc32.apply(null, arguments));
+    function crc325() {
+      return bufferizeInt2(_crc322.apply(null, arguments));
     }
-    crc32.signed = function() {
-      return _crc32.apply(null, arguments);
+    crc325.signed = function() {
+      return _crc322.apply(null, arguments);
     };
-    crc32.unsigned = function() {
-      return _crc32.apply(null, arguments) >>> 0;
+    crc325.unsigned = function() {
+      return _crc322.apply(null, arguments) >>> 0;
     };
-    var bufferCrc32 = crc32;
-    var index = /* @__PURE__ */ getDefaultExportFromCjs(bufferCrc32);
-    module2.exports = index;
+    var bufferCrc32 = crc325;
+    var index2 = /* @__PURE__ */ getDefaultExportFromCjs(bufferCrc32);
+    module2.exports = index2;
   }
 });
 
-// node_modules/archiver/lib/plugins/json.js
+// node_modules/@actions/artifact/node_modules/archiver/lib/plugins/json.js
 var require_json2 = __commonJS({
-  "node_modules/archiver/lib/plugins/json.js"(exports2, module2) {
+  "node_modules/@actions/artifact/node_modules/archiver/lib/plugins/json.js"(exports2, module2) {
     var inherits = require("util").inherits;
-    var Transform = require_ours().Transform;
-    var crc32 = require_dist5();
-    var util = require_archiver_utils();
-    var Json = function(options) {
-      if (!(this instanceof Json)) {
-        return new Json(options);
-      }
-      options = this.options = util.defaults(options, {});
-      Transform.call(this, options);
+    var Transform5 = require_ours().Transform;
+    var crc325 = require_dist5();
+    var util3 = require_archiver_utils();
+    var Json2 = function(options) {
+      if (!(this instanceof Json2)) {
+        return new Json2(options);
+      }
+      options = this.options = util3.defaults(options, {});
+      Transform5.call(this, options);
       this.supports = {
         directory: true,
         symlink: true
       };
       this.files = [];
     };
-    inherits(Json, Transform);
-    Json.prototype._transform = function(chunk, encoding, callback) {
+    inherits(Json2, Transform5);
+    Json2.prototype._transform = function(chunk, encoding, callback) {
       callback(null, chunk);
     };
-    Json.prototype._writeStringified = function() {
+    Json2.prototype._writeStringified = function() {
       var fileString = JSON.stringify(this.files);
       this.write(fileString);
     };
-    Json.prototype.append = function(source, data, callback) {
+    Json2.prototype.append = function(source, data, callback) {
       var self2 = this;
       data.crc32 = 0;
       function onend(err, sourceBuffer) {
@@ -113951,35 +114271,35 @@ var require_json2 = __commonJS({
           return;
         }
         data.size = sourceBuffer.length || 0;
-        data.crc32 = crc32.unsigned(sourceBuffer);
+        data.crc32 = crc325.unsigned(sourceBuffer);
         self2.files.push(data);
         callback(null, data);
       }
       if (data.sourceType === "buffer") {
         onend(null, source);
       } else if (data.sourceType === "stream") {
-        util.collectStream(source, onend);
+        util3.collectStream(source, onend);
       }
     };
-    Json.prototype.finalize = function() {
+    Json2.prototype.finalize = function() {
       this._writeStringified();
       this.end();
     };
-    module2.exports = Json;
+    module2.exports = Json2;
   }
 });
 
-// node_modules/archiver/index.js
+// node_modules/@actions/artifact/node_modules/archiver/index.js
 var require_archiver = __commonJS({
-  "node_modules/archiver/index.js"(exports2, module2) {
-    var Archiver = require_core3();
+  "node_modules/@actions/artifact/node_modules/archiver/index.js"(exports2, module2) {
+    var Archiver2 = require_core3();
     var formats = {};
     var vending = function(format, options) {
       return vending.create(format, options);
     };
     vending.create = function(format, options) {
       if (formats[format]) {
-        var instance = new Archiver(format, options);
+        var instance = new Archiver2(format, options);
         instance.setFormat(format);
         instance.setModule(new formats[format](options));
         return instance;
@@ -114045,11 +114365,11 @@ var require_zip2 = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -114065,7 +114385,7 @@ var require_zip2 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -114074,7 +114394,7 @@ var require_zip2 = __commonJS({
     exports2.createZipUploadStream = exports2.ZipUploadStream = exports2.DEFAULT_COMPRESSION_LEVEL = void 0;
     var stream2 = __importStar2(require("stream"));
     var promises_1 = require("fs/promises");
-    var archiver2 = __importStar2(require_archiver());
+    var archiver = __importStar2(require_archiver());
     var core30 = __importStar2(require_core());
     var config_1 = require_config2();
     exports2.DEFAULT_COMPRESSION_LEVEL = 6;
@@ -114093,7 +114413,7 @@ var require_zip2 = __commonJS({
     function createZipUploadStream(uploadSpecification_1) {
       return __awaiter2(this, arguments, void 0, function* (uploadSpecification, compressionLevel = exports2.DEFAULT_COMPRESSION_LEVEL) {
         core30.debug(`Creating Artifact archive with compressionLevel: ${compressionLevel}`);
-        const zip = archiver2.create("zip", {
+        const zip = archiver.create("zip", {
           highWaterMark: (0, config_1.getUploadChunkSize)(),
           zlib: { level: compressionLevel }
         });
@@ -114180,11 +114500,11 @@ var require_upload_artifact = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -114200,7 +114520,7 @@ var require_upload_artifact = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -114285,14 +114605,14 @@ var require_context2 = __commonJS({
        * Hydrate the context from the environment
        */
       constructor() {
-        var _a, _b, _c;
+        var _a2, _b, _c;
         this.payload = {};
         if (process.env.GITHUB_EVENT_PATH) {
           if ((0, fs_1.existsSync)(process.env.GITHUB_EVENT_PATH)) {
             this.payload = JSON.parse((0, fs_1.readFileSync)(process.env.GITHUB_EVENT_PATH, { encoding: "utf8" }));
           } else {
-            const path28 = process.env.GITHUB_EVENT_PATH;
-            process.stdout.write(`GITHUB_EVENT_PATH ${path28} does not exist${os_1.EOL}`);
+            const path29 = process.env.GITHUB_EVENT_PATH;
+            process.stdout.write(`GITHUB_EVENT_PATH ${path29} does not exist${os_1.EOL}`);
           }
         }
         this.eventName = process.env.GITHUB_EVENT_NAME;
@@ -114305,7 +114625,7 @@ var require_context2 = __commonJS({
         this.runAttempt = parseInt(process.env.GITHUB_RUN_ATTEMPT, 10);
         this.runNumber = parseInt(process.env.GITHUB_RUN_NUMBER, 10);
         this.runId = parseInt(process.env.GITHUB_RUN_ID, 10);
-        this.apiUrl = (_a = process.env.GITHUB_API_URL) !== null && _a !== void 0 ? _a : `https://api.github.com`;
+        this.apiUrl = (_a2 = process.env.GITHUB_API_URL) !== null && _a2 !== void 0 ? _a2 : `https://api.github.com`;
         this.serverUrl = (_b = process.env.GITHUB_SERVER_URL) !== null && _b !== void 0 ? _b : `https://github.com`;
         this.graphqlUrl = (_c = process.env.GITHUB_GRAPHQL_URL) !== null && _c !== void 0 ? _c : `https://api.github.com/graphql`;
       }
@@ -114352,7 +114672,7 @@ var require_proxy2 = __commonJS({
       if (proxyVar) {
         try {
           return new DecodedURL(proxyVar);
-        } catch (_a) {
+        } catch (_a2) {
           if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://"))
             return new DecodedURL(`http://${proxyVar}`);
         }
@@ -114446,11 +114766,11 @@ var require_lib4 = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -114466,7 +114786,7 @@ var require_lib4 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -114552,26 +114872,26 @@ var require_lib4 = __commonJS({
       }
       readBody() {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13) => __awaiter2(this, void 0, void 0, function* () {
+          return new Promise((resolve14) => __awaiter2(this, void 0, void 0, function* () {
             let output = Buffer.alloc(0);
             this.message.on("data", (chunk) => {
               output = Buffer.concat([output, chunk]);
             });
             this.message.on("end", () => {
-              resolve13(output.toString());
+              resolve14(output.toString());
             });
           }));
         });
       }
       readBodyBuffer() {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13) => __awaiter2(this, void 0, void 0, function* () {
+          return new Promise((resolve14) => __awaiter2(this, void 0, void 0, function* () {
             const chunks = [];
             this.message.on("data", (chunk) => {
               chunks.push(chunk);
             });
             this.message.on("end", () => {
-              resolve13(Buffer.concat(chunks));
+              resolve14(Buffer.concat(chunks));
             });
           }));
         });
@@ -114780,14 +115100,14 @@ var require_lib4 = __commonJS({
        */
       requestRaw(info8, data) {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13, reject) => {
+          return new Promise((resolve14, reject) => {
             function callbackForResult(err, res) {
               if (err) {
                 reject(err);
               } else if (!res) {
                 reject(new Error("Unknown error"));
               } else {
-                resolve13(res);
+                resolve14(res);
               }
             }
             this.requestRawWithCallback(info8, data, callbackForResult);
@@ -114969,12 +115289,12 @@ var require_lib4 = __commonJS({
         return __awaiter2(this, void 0, void 0, function* () {
           retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
           const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
-          return new Promise((resolve13) => setTimeout(() => resolve13(), ms));
+          return new Promise((resolve14) => setTimeout(() => resolve14(), ms));
         });
       }
       _processResponse(res, options) {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13, reject) => __awaiter2(this, void 0, void 0, function* () {
+          return new Promise((resolve14, reject) => __awaiter2(this, void 0, void 0, function* () {
             const statusCode = res.message.statusCode || 0;
             const response = {
               statusCode,
@@ -114982,7 +115302,7 @@ var require_lib4 = __commonJS({
               headers: {}
             };
             if (statusCode === HttpCodes.NotFound) {
-              resolve13(response);
+              resolve14(response);
             }
             function dateTimeDeserializer(key, value) {
               if (typeof value === "string") {
@@ -115021,7 +115341,7 @@ var require_lib4 = __commonJS({
               err.result = response.result;
               reject(err);
             } else {
-              resolve13(response);
+              resolve14(response);
             }
           }));
         });
@@ -115065,11 +115385,11 @@ var require_utils8 = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -115085,7 +115405,7 @@ var require_utils8 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -115222,13 +115542,13 @@ var require_remove = __commonJS({
       if (!state.registry[name]) {
         return;
       }
-      var index = state.registry[name].map(function(registered) {
+      var index2 = state.registry[name].map(function(registered) {
         return registered.orig;
       }).indexOf(method);
-      if (index === -1) {
+      if (index2 === -1) {
         return;
       }
-      state.registry[name].splice(index, 1);
+      state.registry[name].splice(index2, 1);
     }
   }
 });
@@ -115349,14 +115669,14 @@ var require_dist_node2 = __commonJS({
       const Ctor = Object.prototype.hasOwnProperty.call(proto, "constructor") && proto.constructor;
       return typeof Ctor === "function" && Ctor instanceof Ctor && Function.prototype.call(Ctor) === Function.prototype.call(value);
     }
-    function mergeDeep2(defaults, options) {
-      const result = Object.assign({}, defaults);
+    function mergeDeep2(defaults2, options) {
+      const result = Object.assign({}, defaults2);
       Object.keys(options).forEach((key) => {
         if (isPlainObject3(options[key])) {
-          if (!(key in defaults))
+          if (!(key in defaults2))
             Object.assign(result, { [key]: options[key] });
           else
-            result[key] = mergeDeep2(defaults[key], options[key]);
+            result[key] = mergeDeep2(defaults2[key], options[key]);
         } else {
           Object.assign(result, { [key]: options[key] });
         }
@@ -115371,7 +115691,7 @@ var require_dist_node2 = __commonJS({
       }
       return obj;
     }
-    function merge2(defaults, route, options) {
+    function merge2(defaults2, route, options) {
       if (typeof route === "string") {
         let [method, url2] = route.split(" ");
         options = Object.assign(url2 ? { method, url: url2 } : { url: method }, options);
@@ -115381,10 +115701,10 @@ var require_dist_node2 = __commonJS({
       options.headers = lowercaseKeys2(options.headers);
       removeUndefinedProperties2(options);
       removeUndefinedProperties2(options.headers);
-      const mergedOptions = mergeDeep2(defaults || {}, options);
+      const mergedOptions = mergeDeep2(defaults2 || {}, options);
       if (options.url === "/graphql") {
-        if (defaults && defaults.mediaType.previews?.length) {
-          mergedOptions.mediaType.previews = defaults.mediaType.previews.filter(
+        if (defaults2 && defaults2.mediaType.previews?.length) {
+          mergedOptions.mediaType.previews = defaults2.mediaType.previews.filter(
             (preview) => !mergedOptions.mediaType.previews.includes(preview)
           ).concat(mergedOptions.mediaType.previews);
         }
@@ -115514,10 +115834,10 @@ var require_dist_node2 = __commonJS({
     }
     function parseUrl2(template) {
       return {
-        expand: expand2.bind(null, template)
+        expand: expand3.bind(null, template)
       };
     }
-    function expand2(template, context5) {
+    function expand3(template, context5) {
       var operators = ["+", "#", ".", "/", ";", "?", "&"];
       template = template.replace(
         /\{([^\{\}]+)\}|([^\{\}]+)/g,
@@ -115618,8 +115938,8 @@ var require_dist_node2 = __commonJS({
         options.request ? { request: options.request } : null
       );
     }
-    function endpointWithDefaults2(defaults, route, options) {
-      return parse2(merge2(defaults, route, options));
+    function endpointWithDefaults2(defaults2, route, options) {
+      return parse2(merge2(defaults2, route, options));
     }
     function withDefaults4(oldDefaults, newDefaults) {
       const DEFAULTS22 = merge2(oldDefaults, newDefaults);
@@ -115864,9 +116184,9 @@ var require_dist_node5 = __commonJS({
       return response.arrayBuffer();
     }
     function fetchWrapper2(requestOptions) {
-      var _a, _b, _c, _d;
+      var _a2, _b, _c, _d;
       const log = requestOptions.request && requestOptions.request.log ? requestOptions.request.log : console;
-      const parseSuccessResponseBody = ((_a = requestOptions.request) == null ? void 0 : _a.parseSuccessResponseBody) !== false;
+      const parseSuccessResponseBody = ((_a2 = requestOptions.request) == null ? void 0 : _a2.parseSuccessResponseBody) !== false;
       if (isPlainObject3(requestOptions.body) || Array.isArray(requestOptions.body)) {
         requestOptions.body = JSON.stringify(requestOptions.body);
       }
@@ -116293,21 +116613,21 @@ var require_dist_node8 = __commonJS({
       static {
         this.VERSION = VERSION8;
       }
-      static defaults(defaults) {
+      static defaults(defaults2) {
         const OctokitWithDefaults = class extends this {
           constructor(...args) {
             const options = args[0] || {};
-            if (typeof defaults === "function") {
-              super(defaults(options));
+            if (typeof defaults2 === "function") {
+              super(defaults2(options));
               return;
             }
             super(
               Object.assign(
                 {},
-                defaults,
+                defaults2,
                 options,
-                options.userAgent && defaults.userAgent ? {
-                  userAgent: `${options.userAgent} ${defaults.userAgent}`
+                options.userAgent && defaults2.userAgent ? {
+                  userAgent: `${options.userAgent} ${defaults2.userAgent}`
                 } : null
               )
             );
@@ -118423,14 +118743,14 @@ var require_dist_node9 = __commonJS({
     var endpointMethodsMap2 = /* @__PURE__ */ new Map();
     for (const [scope, endpoints] of Object.entries(endpoints_default2)) {
       for (const [methodName, endpoint2] of Object.entries(endpoints)) {
-        const [route, defaults, decorations] = endpoint2;
+        const [route, defaults2, decorations] = endpoint2;
         const [method, url2] = route.split(/ /);
         const endpointDefaults = Object.assign(
           {
             method,
             url: url2
           },
-          defaults
+          defaults2
         );
         if (!endpointMethodsMap2.has(scope)) {
           endpointMethodsMap2.set(scope, /* @__PURE__ */ new Map());
@@ -118500,8 +118820,8 @@ var require_dist_node9 = __commonJS({
       }
       return newMethods;
     }
-    function decorate2(octokit, scope, methodName, defaults, decorations) {
-      const requestWithDefaults = octokit.request.defaults(defaults);
+    function decorate2(octokit, scope, methodName, defaults2, decorations) {
+      const requestWithDefaults = octokit.request.defaults(defaults2);
       function withDecorations(...args) {
         let options = requestWithDefaults.endpoint.merge(...args);
         if (decorations.mapToData) {
@@ -119188,7 +119508,7 @@ var require_traverse = __commonJS({
       })(this.value);
     };
     function walk(root, cb, immutable) {
-      var path28 = [];
+      var path29 = [];
       var parents = [];
       var alive = true;
       return (function walker(node_) {
@@ -119197,11 +119517,11 @@ var require_traverse = __commonJS({
         var state = {
           node,
           node_,
-          path: [].concat(path28),
+          path: [].concat(path29),
           parent: parents.slice(-1)[0],
-          key: path28.slice(-1)[0],
-          isRoot: path28.length === 0,
-          level: path28.length,
+          key: path29.slice(-1)[0],
+          isRoot: path29.length === 0,
+          level: path29.length,
           circular: null,
           update: function(x) {
             if (!state.isRoot) {
@@ -119256,7 +119576,7 @@ var require_traverse = __commonJS({
           parents.push(state);
           var keys = Object.keys(state.node);
           keys.forEach(function(key, i2) {
-            path28.push(key);
+            path29.push(key);
             if (modifiers.pre) modifiers.pre.call(state, state.node[key], key);
             var child = walker(state.node[key]);
             if (immutable && Object.hasOwnProperty.call(state.node, key)) {
@@ -119265,7 +119585,7 @@ var require_traverse = __commonJS({
             child.isLast = i2 == keys.length - 1;
             child.isFirst = i2 == 0;
             if (modifiers.post) modifiers.post.call(state, child);
-            path28.pop();
+            path29.pop();
           });
           parents.pop();
         }
@@ -119309,7 +119629,7 @@ var require_traverse = __commonJS({
 var require_chainsaw = __commonJS({
   "node_modules/chainsaw/index.js"(exports2, module2) {
     var Traverse = require_traverse();
-    var EventEmitter = require("events").EventEmitter;
+    var EventEmitter2 = require("events").EventEmitter;
     module2.exports = Chainsaw;
     function Chainsaw(builder) {
       var saw = Chainsaw.saw(builder, {});
@@ -119325,7 +119645,7 @@ var require_chainsaw = __commonJS({
       return saw.chain();
     };
     Chainsaw.saw = function(builder, handlers) {
-      var saw = new EventEmitter();
+      var saw = new EventEmitter2();
       saw.handlers = handlers;
       saw.actions = [];
       saw.chain = function() {
@@ -119467,12 +119787,12 @@ var require_buffers = __commonJS({
     };
     Buffers.prototype.splice = function(i, howMany) {
       var buffers = this.buffers;
-      var index = i >= 0 ? i : this.length - i;
+      var index2 = i >= 0 ? i : this.length - i;
       var reps = [].slice.call(arguments, 2);
       if (howMany === void 0) {
-        howMany = this.length - index;
-      } else if (howMany > this.length - index) {
-        howMany = this.length - index;
+        howMany = this.length - index2;
+      } else if (howMany > this.length - index2) {
+        howMany = this.length - index2;
       }
       for (var i = 0; i < reps.length; i++) {
         this.length += reps[i].length;
@@ -119480,11 +119800,11 @@ var require_buffers = __commonJS({
       var removed = new Buffers();
       var bytes = 0;
       var startBytes = 0;
-      for (var ii = 0; ii < buffers.length && startBytes + buffers[ii].length < index; ii++) {
+      for (var ii = 0; ii < buffers.length && startBytes + buffers[ii].length < index2; ii++) {
         startBytes += buffers[ii].length;
       }
-      if (index - startBytes > 0) {
-        var start = index - startBytes;
+      if (index2 - startBytes > 0) {
+        var start = index2 - startBytes;
         if (start + howMany < buffers[ii].length) {
           removed.push(buffers[ii].slice(start, start + howMany));
           var orig = buffers[ii];
@@ -119586,7 +119906,7 @@ var require_buffers = __commonJS({
       if (!this.length) {
         return -1;
       }
-      var i = 0, j = 0, match = 0, mstart, pos = 0;
+      var i = 0, j = 0, match2 = 0, mstart, pos = 0;
       if (offset) {
         var p = this.pos(offset);
         i = p.buf;
@@ -119602,23 +119922,23 @@ var require_buffers = __commonJS({
           }
         }
         var char = this.buffers[i][j];
-        if (char == needle[match]) {
-          if (match == 0) {
+        if (char == needle[match2]) {
+          if (match2 == 0) {
             mstart = {
               i,
               j,
               pos
             };
           }
-          match++;
-          if (match == needle.length) {
+          match2++;
+          if (match2 == needle.length) {
             return mstart.pos;
           }
-        } else if (match != 0) {
+        } else if (match2 != 0) {
           i = mstart.i;
           j = mstart.j;
           pos = mstart.pos;
-          match = 0;
+          match2 = 0;
         }
         j++;
         pos++;
@@ -119669,7 +119989,7 @@ var require_vars = __commonJS({
 var require_binary2 = __commonJS({
   "node_modules/binary/index.js"(exports2, module2) {
     var Chainsaw = require_chainsaw();
-    var EventEmitter = require("events").EventEmitter;
+    var EventEmitter2 = require("events").EventEmitter;
     var Buffers = require_buffers();
     var Vars = require_vars();
     var Stream = require("stream").Stream;
@@ -119855,8 +120175,8 @@ var require_binary2 = __commonJS({
         caughtEnd = true;
       };
       stream2.pipe = Stream.prototype.pipe;
-      Object.getOwnPropertyNames(EventEmitter.prototype).forEach(function(name) {
-        stream2[name] = EventEmitter.prototype[name];
+      Object.getOwnPropertyNames(EventEmitter2.prototype).forEach(function(name) {
+        stream2[name] = EventEmitter2.prototype[name];
       });
       return stream2;
     };
@@ -119993,13 +120313,13 @@ var require_binary2 = __commonJS({
 // node_modules/unzip-stream/lib/matcher-stream.js
 var require_matcher_stream = __commonJS({
   "node_modules/unzip-stream/lib/matcher-stream.js"(exports2, module2) {
-    var Transform = require("stream").Transform;
-    var util = require("util");
+    var Transform5 = require("stream").Transform;
+    var util3 = require("util");
     function MatcherStream(patternDesc, matchFn) {
       if (!(this instanceof MatcherStream)) {
         return new MatcherStream();
       }
-      Transform.call(this);
+      Transform5.call(this);
       var p = typeof patternDesc === "object" ? patternDesc.pattern : patternDesc;
       this.pattern = Buffer.isBuffer(p) ? p : Buffer.from(p);
       this.requiredLength = this.pattern.length;
@@ -120008,7 +120328,7 @@ var require_matcher_stream = __commonJS({
       this.bytesSoFar = 0;
       this.matchFn = matchFn;
     }
-    util.inherits(MatcherStream, Transform);
+    util3.inherits(MatcherStream, Transform5);
     MatcherStream.prototype.checkDataChunk = function(ignoreMatchZero) {
       var enoughData = this.data.length >= this.requiredLength;
       if (!enoughData) {
@@ -120101,7 +120421,7 @@ var require_unzip_stream = __commonJS({
     "use strict";
     var binary = require_binary2();
     var stream2 = require("stream");
-    var util = require("util");
+    var util3 = require("util");
     var zlib3 = require("zlib");
     var MatcherStream = require_matcher_stream();
     var Entry = require_entry();
@@ -120142,7 +120462,7 @@ var require_unzip_stream = __commonJS({
       this.parsedEntity = null;
       this.outStreamInfo = {};
     }
-    util.inherits(UnzipStream, stream2.Transform);
+    util3.inherits(UnzipStream, stream2.Transform);
     UnzipStream.prototype.processDataChunk = function(chunk) {
       var requiredLength;
       switch (this.state) {
@@ -120286,11 +120606,11 @@ var require_unzip_stream = __commonJS({
           return requiredLength;
         case states.CENTRAL_DIRECTORY_FILE_HEADER_SUFFIX:
           var isUtf8 = (this.parsedEntity.flags & 2048) !== 0;
-          var path28 = this._decodeString(chunk.slice(0, this.parsedEntity.fileNameLength), isUtf8);
+          var path29 = this._decodeString(chunk.slice(0, this.parsedEntity.fileNameLength), isUtf8);
           var extraDataBuffer = chunk.slice(this.parsedEntity.fileNameLength, this.parsedEntity.fileNameLength + this.parsedEntity.extraFieldLength);
           var extra = this._readExtraFields(extraDataBuffer);
           if (extra && extra.parsed && extra.parsed.path && !isUtf8) {
-            path28 = extra.parsed.path;
+            path29 = extra.parsed.path;
           }
           this.parsedEntity.extra = extra.parsed;
           var isUnix = (this.parsedEntity.versionMadeBy & 65280) >> 8 === 3;
@@ -120302,7 +120622,7 @@ var require_unzip_stream = __commonJS({
           }
           if (this.options.debug) {
             const debugObj = Object.assign({}, this.parsedEntity, {
-              path: path28,
+              path: path29,
               flags: "0x" + this.parsedEntity.flags.toString(16),
               unixAttrs: unixAttrs && "0" + unixAttrs.toString(8),
               isSymlink,
@@ -120433,15 +120753,15 @@ var require_unzip_stream = __commonJS({
       if (this.options.debug) {
         result.debug = [];
       }
-      var index = 0;
-      while (index < data.length) {
-        var vars = binary.parse(data).skip(index).word16lu("extraId").word16lu("extraSize").vars;
-        index += 4;
+      var index2 = 0;
+      while (index2 < data.length) {
+        var vars = binary.parse(data).skip(index2).word16lu("extraId").word16lu("extraSize").vars;
+        index2 += 4;
         var fieldType = void 0;
         switch (vars.extraId) {
           case 1:
             fieldType = "Zip64 extended information extra field";
-            var z64vars = binary.parse(data.slice(index, index + vars.extraSize)).word64lu("uncompressedSize").word64lu("compressedSize").word64lu("offsetToLocalHeader").word32lu("diskStartNumber").vars;
+            var z64vars = binary.parse(data.slice(index2, index2 + vars.extraSize)).word64lu("uncompressedSize").word64lu("compressedSize").word64lu("offsetToLocalHeader").word32lu("diskStartNumber").vars;
             if (z64vars.uncompressedSize !== null) {
               extra.uncompressedSize = z64vars.uncompressedSize;
             }
@@ -120455,28 +120775,28 @@ var require_unzip_stream = __commonJS({
             break;
           case 21589:
             fieldType = "extended timestamp";
-            var timestampFields = data.readUInt8(index);
+            var timestampFields = data.readUInt8(index2);
             var offset = 1;
             if (vars.extraSize >= offset + 4 && timestampFields & 1) {
-              extra.mtime = new Date(data.readUInt32LE(index + offset) * 1e3);
+              extra.mtime = new Date(data.readUInt32LE(index2 + offset) * 1e3);
               offset += 4;
             }
             if (vars.extraSize >= offset + 4 && timestampFields & 2) {
-              extra.atime = new Date(data.readUInt32LE(index + offset) * 1e3);
+              extra.atime = new Date(data.readUInt32LE(index2 + offset) * 1e3);
               offset += 4;
             }
             if (vars.extraSize >= offset + 4 && timestampFields & 4) {
-              extra.ctime = new Date(data.readUInt32LE(index + offset) * 1e3);
+              extra.ctime = new Date(data.readUInt32LE(index2 + offset) * 1e3);
             }
             break;
           case 28789:
             fieldType = "Info-ZIP Unicode Path Extra Field";
-            var fieldVer = data.readUInt8(index);
+            var fieldVer = data.readUInt8(index2);
             if (fieldVer === 1) {
               var offset = 1;
-              var nameCrc32 = data.readUInt32LE(index + offset);
+              var nameCrc32 = data.readUInt32LE(index2 + offset);
               offset += 4;
-              var pathBuffer = data.slice(index + offset);
+              var pathBuffer = data.slice(index2 + offset);
               extra.path = pathBuffer.toString();
             }
             break;
@@ -120485,16 +120805,16 @@ var require_unzip_stream = __commonJS({
             fieldType = vars.extraId === 13 ? "PKWARE Unix" : "Info-ZIP UNIX (type 1)";
             var offset = 0;
             if (vars.extraSize >= 8) {
-              var atime = new Date(data.readUInt32LE(index + offset) * 1e3);
+              var atime = new Date(data.readUInt32LE(index2 + offset) * 1e3);
               offset += 4;
-              var mtime = new Date(data.readUInt32LE(index + offset) * 1e3);
+              var mtime = new Date(data.readUInt32LE(index2 + offset) * 1e3);
               offset += 4;
               extra.atime = atime;
               extra.mtime = mtime;
               if (vars.extraSize >= 12) {
-                var uid = data.readUInt16LE(index + offset);
+                var uid = data.readUInt16LE(index2 + offset);
                 offset += 2;
-                var gid = data.readUInt16LE(index + offset);
+                var gid = data.readUInt16LE(index2 + offset);
                 offset += 2;
                 extra.uid = uid;
                 extra.gid = gid;
@@ -120505,9 +120825,9 @@ var require_unzip_stream = __commonJS({
             fieldType = "Info-ZIP UNIX (type 2)";
             var offset = 0;
             if (vars.extraSize >= 4) {
-              var uid = data.readUInt16LE(index + offset);
+              var uid = data.readUInt16LE(index2 + offset);
               offset += 2;
-              var gid = data.readUInt16LE(index + offset);
+              var gid = data.readUInt16LE(index2 + offset);
               offset += 2;
               extra.uid = uid;
               extra.gid = gid;
@@ -120516,19 +120836,19 @@ var require_unzip_stream = __commonJS({
           case 30837:
             fieldType = "Info-ZIP New Unix";
             var offset = 0;
-            var extraVer = data.readUInt8(index);
+            var extraVer = data.readUInt8(index2);
             offset += 1;
             if (extraVer === 1) {
-              var uidSize = data.readUInt8(index + offset);
+              var uidSize = data.readUInt8(index2 + offset);
               offset += 1;
               if (uidSize <= 6) {
-                extra.uid = data.readUIntLE(index + offset, uidSize);
+                extra.uid = data.readUIntLE(index2 + offset, uidSize);
               }
               offset += uidSize;
-              var gidSize = data.readUInt8(index + offset);
+              var gidSize = data.readUInt8(index2 + offset);
               offset += 1;
               if (gidSize <= 6) {
-                extra.gid = data.readUIntLE(index + offset, gidSize);
+                extra.gid = data.readUIntLE(index2 + offset, gidSize);
               }
             }
             break;
@@ -120536,22 +120856,22 @@ var require_unzip_stream = __commonJS({
             fieldType = "ASi Unix";
             var offset = 0;
             if (vars.extraSize >= 14) {
-              var crc = data.readUInt32LE(index + offset);
+              var crc = data.readUInt32LE(index2 + offset);
               offset += 4;
-              var mode = data.readUInt16LE(index + offset);
+              var mode = data.readUInt16LE(index2 + offset);
               offset += 2;
-              var sizdev = data.readUInt32LE(index + offset);
+              var sizdev = data.readUInt32LE(index2 + offset);
               offset += 4;
-              var uid = data.readUInt16LE(index + offset);
+              var uid = data.readUInt16LE(index2 + offset);
               offset += 2;
-              var gid = data.readUInt16LE(index + offset);
+              var gid = data.readUInt16LE(index2 + offset);
               offset += 2;
               extra.mode = mode;
               extra.uid = uid;
               extra.gid = gid;
               if (vars.extraSize > 14) {
-                var start = index + offset;
-                var end = index + vars.extraSize - 14;
+                var start = index2 + offset;
+                var end = index2 + vars.extraSize - 14;
                 var symlinkName = this._decodeString(data.slice(start, end));
                 extra.symlink = symlinkName;
               }
@@ -120562,10 +120882,10 @@ var require_unzip_stream = __commonJS({
           result.debug.push({
             extraId: "0x" + vars.extraId.toString(16),
             description: fieldType,
-            data: data.slice(index, index + vars.extraSize).inspect()
+            data: data.slice(index2, index2 + vars.extraSize).inspect()
           });
         }
-        index += vars.extraSize;
+        index2 += vars.extraSize;
       }
       return result;
     };
@@ -120688,15 +121008,15 @@ var require_unzip_stream = __commonJS({
 // node_modules/unzip-stream/lib/parser-stream.js
 var require_parser_stream = __commonJS({
   "node_modules/unzip-stream/lib/parser-stream.js"(exports2, module2) {
-    var Transform = require("stream").Transform;
-    var util = require("util");
+    var Transform5 = require("stream").Transform;
+    var util3 = require("util");
     var UnzipStream = require_unzip_stream();
     function ParserStream(opts) {
       if (!(this instanceof ParserStream)) {
         return new ParserStream(opts);
       }
       var transformOpts = opts || {};
-      Transform.call(this, { readableObjectMode: true });
+      Transform5.call(this, { readableObjectMode: true });
       this.opts = opts || {};
       this.unzipStream = new UnzipStream(this.opts);
       var self2 = this;
@@ -120707,7 +121027,7 @@ var require_parser_stream = __commonJS({
         self2.emit("error", error3);
       });
     }
-    util.inherits(ParserStream, Transform);
+    util3.inherits(ParserStream, Transform5);
     ParserStream.prototype._transform = function(chunk, encoding, cb) {
       this.unzipStream.write(chunk, encoding, cb);
     };
@@ -120722,13 +121042,13 @@ var require_parser_stream = __commonJS({
     };
     ParserStream.prototype.on = function(eventName, fn) {
       if (eventName === "entry") {
-        return Transform.prototype.on.call(this, "data", fn);
+        return Transform5.prototype.on.call(this, "data", fn);
       }
-      return Transform.prototype.on.call(this, eventName, fn);
+      return Transform5.prototype.on.call(this, eventName, fn);
     };
     ParserStream.prototype.drainAll = function() {
       this.unzipStream.drainAll();
-      return this.pipe(new Transform({ objectMode: true, transform: function(d, e, cb) {
+      return this.pipe(new Transform5({ objectMode: true, transform: function(d, e, cb) {
         cb();
       } }));
     };
@@ -120739,8 +121059,8 @@ var require_parser_stream = __commonJS({
 // node_modules/mkdirp/index.js
 var require_mkdirp = __commonJS({
   "node_modules/mkdirp/index.js"(exports2, module2) {
-    var path28 = require("path");
-    var fs30 = require("fs");
+    var path29 = require("path");
+    var fs31 = require("fs");
     var _0777 = parseInt("0777", 8);
     module2.exports = mkdirP.mkdirp = mkdirP.mkdirP = mkdirP;
     function mkdirP(p, opts, f, made) {
@@ -120751,7 +121071,7 @@ var require_mkdirp = __commonJS({
         opts = { mode: opts };
       }
       var mode = opts.mode;
-      var xfs = opts.fs || fs30;
+      var xfs = opts.fs || fs31;
       if (mode === void 0) {
         mode = _0777;
       }
@@ -120759,7 +121079,7 @@ var require_mkdirp = __commonJS({
       var cb = f || /* istanbul ignore next */
       function() {
       };
-      p = path28.resolve(p);
+      p = path29.resolve(p);
       xfs.mkdir(p, mode, function(er) {
         if (!er) {
           made = made || p;
@@ -120767,8 +121087,8 @@ var require_mkdirp = __commonJS({
         }
         switch (er.code) {
           case "ENOENT":
-            if (path28.dirname(p) === p) return cb(er);
-            mkdirP(path28.dirname(p), opts, function(er2, made2) {
+            if (path29.dirname(p) === p) return cb(er);
+            mkdirP(path29.dirname(p), opts, function(er2, made2) {
               if (er2) cb(er2, made2);
               else mkdirP(p, opts, cb, made2);
             });
@@ -120777,8 +121097,8 @@ var require_mkdirp = __commonJS({
           // there already.  If so, then hooray!  If not, then something
           // is borked.
           default:
-            xfs.stat(p, function(er2, stat) {
-              if (er2 || !stat.isDirectory()) cb(er, made);
+            xfs.stat(p, function(er2, stat2) {
+              if (er2 || !stat2.isDirectory()) cb(er, made);
               else cb(null, made);
             });
             break;
@@ -120790,32 +121110,32 @@ var require_mkdirp = __commonJS({
         opts = { mode: opts };
       }
       var mode = opts.mode;
-      var xfs = opts.fs || fs30;
+      var xfs = opts.fs || fs31;
       if (mode === void 0) {
         mode = _0777;
       }
       if (!made) made = null;
-      p = path28.resolve(p);
+      p = path29.resolve(p);
       try {
         xfs.mkdirSync(p, mode);
         made = made || p;
       } catch (err0) {
         switch (err0.code) {
           case "ENOENT":
-            made = sync(path28.dirname(p), opts, made);
+            made = sync(path29.dirname(p), opts, made);
             sync(p, opts, made);
             break;
           // In the case of any other error, just see if there's a dir
           // there already.  If so, then hooray!  If not, then something
           // is borked.
           default:
-            var stat;
+            var stat2;
             try {
-              stat = xfs.statSync(p);
+              stat2 = xfs.statSync(p);
             } catch (err1) {
               throw err0;
             }
-            if (!stat.isDirectory()) throw err0;
+            if (!stat2.isDirectory()) throw err0;
             break;
         }
       }
@@ -120827,16 +121147,16 @@ var require_mkdirp = __commonJS({
 // node_modules/unzip-stream/lib/extract.js
 var require_extract2 = __commonJS({
   "node_modules/unzip-stream/lib/extract.js"(exports2, module2) {
-    var fs30 = require("fs");
-    var path28 = require("path");
-    var util = require("util");
+    var fs31 = require("fs");
+    var path29 = require("path");
+    var util3 = require("util");
     var mkdirp = require_mkdirp();
-    var Transform = require("stream").Transform;
+    var Transform5 = require("stream").Transform;
     var UnzipStream = require_unzip_stream();
     function Extract(opts) {
       if (!(this instanceof Extract))
         return new Extract(opts);
-      Transform.call(this);
+      Transform5.call(this);
       this.opts = opts || {};
       this.unzipStream = new UnzipStream(this.opts);
       this.unfinishedEntries = 0;
@@ -120848,7 +121168,7 @@ var require_extract2 = __commonJS({
         self2.emit("error", error3);
       });
     }
-    util.inherits(Extract, Transform);
+    util3.inherits(Extract, Transform5);
     Extract.prototype._transform = function(chunk, encoding, cb) {
       this.unzipStream.write(chunk, encoding, cb);
     };
@@ -120870,11 +121190,11 @@ var require_extract2 = __commonJS({
     };
     Extract.prototype._processEntry = function(entry) {
       var self2 = this;
-      var destPath = path28.join(this.opts.path, entry.path);
-      var directory = entry.isDirectory ? destPath : path28.dirname(destPath);
+      var destPath = path29.join(this.opts.path, entry.path);
+      var directory = entry.isDirectory ? destPath : path29.dirname(destPath);
       this.unfinishedEntries++;
       var writeFileFn = function() {
-        var pipedStream = fs30.createWriteStream(destPath);
+        var pipedStream = fs31.createWriteStream(destPath);
         pipedStream.on("close", function() {
           self2.unfinishedEntries--;
           self2._notifyAwaiter();
@@ -120950,11 +121270,11 @@ var require_download_artifact = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -120970,7 +121290,7 @@ var require_download_artifact = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -120998,10 +121318,10 @@ var require_download_artifact = __commonJS({
       parsed.search = "";
       return parsed.toString();
     };
-    function exists(path28) {
+    function exists(path29) {
       return __awaiter2(this, void 0, void 0, function* () {
         try {
-          yield promises_1.default.access(path28);
+          yield promises_1.default.access(path29);
           return true;
         } catch (error3) {
           if (error3.code === "ENOENT") {
@@ -121021,7 +121341,7 @@ var require_download_artifact = __commonJS({
           } catch (error3) {
             retryCount++;
             core30.debug(`Failed to download artifact after ${retryCount} retries due to ${error3.message}. Retrying in 5 seconds...`);
-            yield new Promise((resolve13) => setTimeout(resolve13, 5e3));
+            yield new Promise((resolve14) => setTimeout(resolve14, 5e3));
           }
         }
         throw new Error(`Artifact download failed after ${retryCount} retries.`);
@@ -121035,7 +121355,7 @@ var require_download_artifact = __commonJS({
           throw new Error(`Unexpected HTTP response from blob storage: ${response.message.statusCode} ${response.message.statusMessage}`);
         }
         let sha256Digest = void 0;
-        return new Promise((resolve13, reject) => {
+        return new Promise((resolve14, reject) => {
           const timerFn = () => {
             const timeoutError = new Error(`Blob storage chunk did not respond in ${opts.timeout}ms`);
             response.message.destroy(timeoutError);
@@ -121060,7 +121380,7 @@ var require_download_artifact = __commonJS({
               sha256Digest = hashStream.read();
               core30.info(`SHA256 digest of downloaded artifact is ${sha256Digest}`);
             }
-            resolve13({ sha256Digest: `sha256:${sha256Digest}` });
+            resolve14({ sha256Digest: `sha256:${sha256Digest}` });
           }).on("error", (error3) => {
             reject(error3);
           });
@@ -121204,7 +121524,7 @@ var require_retry_options = __commonJS({
     var defaultMaxRetryNumber = 5;
     var defaultExemptStatusCodes = [400, 401, 403, 404, 422];
     function getRetryOptions(defaultOptions, retries = defaultMaxRetryNumber, exemptStatusCodes = defaultExemptStatusCodes) {
-      var _a;
+      var _a2;
       if (retries <= 0) {
         return [{ enabled: false }, defaultOptions.request];
       }
@@ -121215,7 +121535,7 @@ var require_retry_options = __commonJS({
         retryOptions.doNotRetry = exemptStatusCodes;
       }
       const requestOptions = Object.assign(Object.assign({}, defaultOptions.request), { retries });
-      core30.debug(`GitHub client configured with: (retries: ${requestOptions.retries}, retry-exempt-status-code: ${(_a = retryOptions.doNotRetry) !== null && _a !== void 0 ? _a : "octokit default: [400, 401, 403, 404, 422]"})`);
+      core30.debug(`GitHub client configured with: (retries: ${requestOptions.retries}, retry-exempt-status-code: ${(_a2 = retryOptions.doNotRetry) !== null && _a2 !== void 0 ? _a2 : "octokit default: [400, 401, 403, 404, 422]"})`);
       return [retryOptions, requestOptions];
     }
     exports2.getRetryOptions = getRetryOptions;
@@ -121233,12 +121553,12 @@ var require_dist_node11 = __commonJS({
         octokit.log.debug("request", options);
         const start = Date.now();
         const requestOptions = octokit.request.endpoint.parse(options);
-        const path28 = requestOptions.url.replace(options.baseUrl, "");
+        const path29 = requestOptions.url.replace(options.baseUrl, "");
         return request3(options).then((response) => {
-          octokit.log.info(`${requestOptions.method} ${path28} - ${response.status} in ${Date.now() - start}ms`);
+          octokit.log.info(`${requestOptions.method} ${path29} - ${response.status} in ${Date.now() - start}ms`);
           return response;
         }).catch((error3) => {
-          octokit.log.info(`${requestOptions.method} ${path28} - ${error3.status} in ${Date.now() - start}ms`);
+          octokit.log.info(`${requestOptions.method} ${path29} - ${error3.status} in ${Date.now() - start}ms`);
           throw error3;
         });
       });
@@ -121343,11 +121663,11 @@ var require_get_artifact = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -121363,7 +121683,7 @@ var require_get_artifact = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -121383,7 +121703,7 @@ var require_get_artifact = __commonJS({
     var errors_1 = require_errors3();
     function getArtifactPublic(artifactName, workflowRunId, repositoryOwner, repositoryName, token) {
       return __awaiter2(this, void 0, void 0, function* () {
-        var _a;
+        var _a2;
         const [retryOpts, requestOpts] = (0, retry_options_1.getRetryOptions)(utils_1.defaults);
         const opts = {
           log: void 0,
@@ -121400,7 +121720,7 @@ var require_get_artifact = __commonJS({
           name: artifactName
         });
         if (getArtifactResp.status !== 200) {
-          throw new errors_1.InvalidResponseError(`Invalid response from GitHub API: ${getArtifactResp.status} (${(_a = getArtifactResp === null || getArtifactResp === void 0 ? void 0 : getArtifactResp.headers) === null || _a === void 0 ? void 0 : _a["x-github-request-id"]})`);
+          throw new errors_1.InvalidResponseError(`Invalid response from GitHub API: ${getArtifactResp.status} (${(_a2 = getArtifactResp === null || getArtifactResp === void 0 ? void 0 : getArtifactResp.headers) === null || _a2 === void 0 ? void 0 : _a2["x-github-request-id"]})`);
         }
         if (getArtifactResp.data.artifacts.length === 0) {
           throw new errors_1.ArtifactNotFoundError(`Artifact not found for name: ${artifactName}
@@ -121426,7 +121746,7 @@ var require_get_artifact = __commonJS({
     exports2.getArtifactPublic = getArtifactPublic;
     function getArtifactInternal(artifactName) {
       return __awaiter2(this, void 0, void 0, function* () {
-        var _a;
+        var _a2;
         const artifactClient = (0, artifact_twirp_client_1.internalArtifactTwirpClient)();
         const { workflowRunBackendId, workflowJobRunBackendId } = (0, util_1.getBackendIdsFromToken)();
         const req = {
@@ -121451,7 +121771,7 @@ var require_get_artifact = __commonJS({
             id: Number(artifact2.databaseId),
             size: Number(artifact2.size),
             createdAt: artifact2.createdAt ? generated_1.Timestamp.toDate(artifact2.createdAt) : void 0,
-            digest: (_a = artifact2.digest) === null || _a === void 0 ? void 0 : _a.value
+            digest: (_a2 = artifact2.digest) === null || _a2 === void 0 ? void 0 : _a2.value
           }
         };
       });
@@ -121466,11 +121786,11 @@ var require_delete_artifact = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -121486,7 +121806,7 @@ var require_delete_artifact = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -121507,7 +121827,7 @@ var require_delete_artifact = __commonJS({
     var errors_1 = require_errors3();
     function deleteArtifactPublic(artifactName, workflowRunId, repositoryOwner, repositoryName, token) {
       return __awaiter2(this, void 0, void 0, function* () {
-        var _a;
+        var _a2;
         const [retryOpts, requestOpts] = (0, retry_options_1.getRetryOptions)(utils_1.defaults);
         const opts = {
           log: void 0,
@@ -121524,7 +121844,7 @@ var require_delete_artifact = __commonJS({
           artifact_id: getArtifactResp.artifact.id
         });
         if (deleteArtifactResp.status !== 204) {
-          throw new errors_1.InvalidResponseError(`Invalid response from GitHub API: ${deleteArtifactResp.status} (${(_a = deleteArtifactResp === null || deleteArtifactResp === void 0 ? void 0 : deleteArtifactResp.headers) === null || _a === void 0 ? void 0 : _a["x-github-request-id"]})`);
+          throw new errors_1.InvalidResponseError(`Invalid response from GitHub API: ${deleteArtifactResp.status} (${(_a2 = deleteArtifactResp === null || deleteArtifactResp === void 0 ? void 0 : deleteArtifactResp.headers) === null || _a2 === void 0 ? void 0 : _a2["x-github-request-id"]})`);
         }
         return {
           id: getArtifactResp.artifact.id
@@ -121572,11 +121892,11 @@ var require_list_artifacts = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -121592,7 +121912,7 @@ var require_list_artifacts = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -121689,13 +122009,13 @@ var require_list_artifacts = __commonJS({
         };
         const res = yield artifactClient.ListArtifacts(req);
         let artifacts = res.artifacts.map((artifact2) => {
-          var _a;
+          var _a2;
           return {
             name: artifact2.name,
             id: Number(artifact2.databaseId),
             size: Number(artifact2.size),
             createdAt: artifact2.createdAt ? generated_1.Timestamp.toDate(artifact2.createdAt) : void 0,
-            digest: (_a = artifact2.digest) === null || _a === void 0 ? void 0 : _a.value
+            digest: (_a2 = artifact2.digest) === null || _a2 === void 0 ? void 0 : _a2.value
           };
         });
         if (latest) {
@@ -121729,11 +122049,11 @@ var require_client2 = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -121749,7 +122069,7 @@ var require_client2 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -122072,7 +122392,7 @@ var require_file_command2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.prepareKeyValueMessage = exports2.issueFileCommand = void 0;
     var crypto3 = __importStar2(require("crypto"));
-    var fs30 = __importStar2(require("fs"));
+    var fs31 = __importStar2(require("fs"));
     var os7 = __importStar2(require("os"));
     var utils_1 = require_utils10();
     function issueFileCommand(command, message) {
@@ -122080,10 +122400,10 @@ var require_file_command2 = __commonJS({
       if (!filePath) {
         throw new Error(`Unable to find environment variable for file command ${command}`);
       }
-      if (!fs30.existsSync(filePath)) {
+      if (!fs31.existsSync(filePath)) {
         throw new Error(`Missing file at path: ${filePath}`);
       }
-      fs30.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os7.EOL}`, {
+      fs31.appendFileSync(filePath, `${(0, utils_1.toCommandValue)(message)}${os7.EOL}`, {
         encoding: "utf8"
       });
     }
@@ -122124,7 +122444,7 @@ var require_proxy3 = __commonJS({
       if (proxyVar) {
         try {
           return new DecodedURL(proxyVar);
-        } catch (_a) {
+        } catch (_a2) {
           if (!proxyVar.startsWith("http://") && !proxyVar.startsWith("https://"))
             return new DecodedURL(`http://${proxyVar}`);
         }
@@ -122218,11 +122538,11 @@ var require_lib5 = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -122238,7 +122558,7 @@ var require_lib5 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -122324,26 +122644,26 @@ var require_lib5 = __commonJS({
       }
       readBody() {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13) => __awaiter2(this, void 0, void 0, function* () {
+          return new Promise((resolve14) => __awaiter2(this, void 0, void 0, function* () {
             let output = Buffer.alloc(0);
             this.message.on("data", (chunk) => {
               output = Buffer.concat([output, chunk]);
             });
             this.message.on("end", () => {
-              resolve13(output.toString());
+              resolve14(output.toString());
             });
           }));
         });
       }
       readBodyBuffer() {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13) => __awaiter2(this, void 0, void 0, function* () {
+          return new Promise((resolve14) => __awaiter2(this, void 0, void 0, function* () {
             const chunks = [];
             this.message.on("data", (chunk) => {
               chunks.push(chunk);
             });
             this.message.on("end", () => {
-              resolve13(Buffer.concat(chunks));
+              resolve14(Buffer.concat(chunks));
             });
           }));
         });
@@ -122552,14 +122872,14 @@ var require_lib5 = __commonJS({
        */
       requestRaw(info8, data) {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13, reject) => {
+          return new Promise((resolve14, reject) => {
             function callbackForResult(err, res) {
               if (err) {
                 reject(err);
               } else if (!res) {
                 reject(new Error("Unknown error"));
               } else {
-                resolve13(res);
+                resolve14(res);
               }
             }
             this.requestRawWithCallback(info8, data, callbackForResult);
@@ -122741,12 +123061,12 @@ var require_lib5 = __commonJS({
         return __awaiter2(this, void 0, void 0, function* () {
           retryNumber = Math.min(ExponentialBackoffCeiling, retryNumber);
           const ms = ExponentialBackoffTimeSlice * Math.pow(2, retryNumber);
-          return new Promise((resolve13) => setTimeout(() => resolve13(), ms));
+          return new Promise((resolve14) => setTimeout(() => resolve14(), ms));
         });
       }
       _processResponse(res, options) {
         return __awaiter2(this, void 0, void 0, function* () {
-          return new Promise((resolve13, reject) => __awaiter2(this, void 0, void 0, function* () {
+          return new Promise((resolve14, reject) => __awaiter2(this, void 0, void 0, function* () {
             const statusCode = res.message.statusCode || 0;
             const response = {
               statusCode,
@@ -122754,7 +123074,7 @@ var require_lib5 = __commonJS({
               headers: {}
             };
             if (statusCode === HttpCodes.NotFound) {
-              resolve13(response);
+              resolve14(response);
             }
             function dateTimeDeserializer(key, value) {
               if (typeof value === "string") {
@@ -122793,7 +123113,7 @@ var require_lib5 = __commonJS({
               err.result = response.result;
               reject(err);
             } else {
-              resolve13(response);
+              resolve14(response);
             }
           }));
         });
@@ -122810,11 +123130,11 @@ var require_auth2 = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -122830,7 +123150,7 @@ var require_auth2 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -122914,11 +123234,11 @@ var require_oidc_utils2 = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -122934,7 +123254,7 @@ var require_oidc_utils2 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -122967,7 +123287,7 @@ var require_oidc_utils2 = __commonJS({
         return runtimeUrl;
       }
       static getCall(id_token_url) {
-        var _a;
+        var _a2;
         return __awaiter2(this, void 0, void 0, function* () {
           const httpclient = _OidcClient.createHttpClient();
           const res = yield httpclient.getJson(id_token_url).catch((error3) => {
@@ -122977,7 +123297,7 @@ var require_oidc_utils2 = __commonJS({
  
         Error Message: ${error3.message}`);
           });
-          const id_token = (_a = res.result) === null || _a === void 0 ? void 0 : _a.value;
+          const id_token = (_a2 = res.result) === null || _a2 === void 0 ? void 0 : _a2.value;
           if (!id_token) {
             throw new Error("Response json body do not have ID Token field");
           }
@@ -123012,11 +123332,11 @@ var require_summary2 = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -123032,7 +123352,7 @@ var require_summary2 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -123065,7 +123385,7 @@ var require_summary2 = __commonJS({
           }
           try {
             yield access(pathFromEnv, fs_1.constants.R_OK | fs_1.constants.W_OK);
-          } catch (_a) {
+          } catch (_a2) {
             throw new Error(`Unable to access summary file: '${pathFromEnv}'. Check if the file has correct read/write permissions.`);
           }
           this._filePath = pathFromEnv;
@@ -123333,7 +123653,7 @@ var require_path_utils2 = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.toPlatformPath = exports2.toWin32Path = exports2.toPosixPath = void 0;
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     function toPosixPath(pth) {
       return pth.replace(/[\\]/g, "/");
     }
@@ -123343,7 +123663,7 @@ var require_path_utils2 = __commonJS({
     }
     exports2.toWin32Path = toWin32Path;
     function toPlatformPath(pth) {
-      return pth.replace(/[/\\]/g, path28.sep);
+      return pth.replace(/[/\\]/g, path29.sep);
     }
     exports2.toPlatformPath = toPlatformPath;
   }
@@ -123378,11 +123698,11 @@ var require_io_util2 = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -123398,20 +123718,20 @@ var require_io_util2 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
     };
-    var _a;
+    var _a2;
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getCmdPath = exports2.tryGetExecutablePath = exports2.isRooted = exports2.isDirectory = exports2.exists = exports2.READONLY = exports2.UV_FS_O_EXLOCK = exports2.IS_WINDOWS = exports2.unlink = exports2.symlink = exports2.stat = exports2.rmdir = exports2.rm = exports2.rename = exports2.readlink = exports2.readdir = exports2.open = exports2.mkdir = exports2.lstat = exports2.copyFile = exports2.chmod = void 0;
-    var fs30 = __importStar2(require("fs"));
-    var path28 = __importStar2(require("path"));
-    _a = fs30.promises, exports2.chmod = _a.chmod, exports2.copyFile = _a.copyFile, exports2.lstat = _a.lstat, exports2.mkdir = _a.mkdir, exports2.open = _a.open, exports2.readdir = _a.readdir, exports2.readlink = _a.readlink, exports2.rename = _a.rename, exports2.rm = _a.rm, exports2.rmdir = _a.rmdir, exports2.stat = _a.stat, exports2.symlink = _a.symlink, exports2.unlink = _a.unlink;
+    var fs31 = __importStar2(require("fs"));
+    var path29 = __importStar2(require("path"));
+    _a2 = fs31.promises, exports2.chmod = _a2.chmod, exports2.copyFile = _a2.copyFile, exports2.lstat = _a2.lstat, exports2.mkdir = _a2.mkdir, exports2.open = _a2.open, exports2.readdir = _a2.readdir, exports2.readlink = _a2.readlink, exports2.rename = _a2.rename, exports2.rm = _a2.rm, exports2.rmdir = _a2.rmdir, exports2.stat = _a2.stat, exports2.symlink = _a2.symlink, exports2.unlink = _a2.unlink;
     exports2.IS_WINDOWS = process.platform === "win32";
     exports2.UV_FS_O_EXLOCK = 268435456;
-    exports2.READONLY = fs30.constants.O_RDONLY;
+    exports2.READONLY = fs31.constants.O_RDONLY;
     function exists(fsPath) {
       return __awaiter2(this, void 0, void 0, function* () {
         try {
@@ -123456,7 +123776,7 @@ var require_io_util2 = __commonJS({
         }
         if (stats && stats.isFile()) {
           if (exports2.IS_WINDOWS) {
-            const upperExt = path28.extname(filePath).toUpperCase();
+            const upperExt = path29.extname(filePath).toUpperCase();
             if (extensions.some((validExt) => validExt.toUpperCase() === upperExt)) {
               return filePath;
             }
@@ -123480,11 +123800,11 @@ var require_io_util2 = __commonJS({
           if (stats && stats.isFile()) {
             if (exports2.IS_WINDOWS) {
               try {
-                const directory = path28.dirname(filePath);
-                const upperName = path28.basename(filePath).toUpperCase();
+                const directory = path29.dirname(filePath);
+                const upperName = path29.basename(filePath).toUpperCase();
                 for (const actualName of yield exports2.readdir(directory)) {
                   if (upperName === actualName.toUpperCase()) {
-                    filePath = path28.join(directory, actualName);
+                    filePath = path29.join(directory, actualName);
                     break;
                   }
                 }
@@ -123515,8 +123835,8 @@ var require_io_util2 = __commonJS({
       return (stats.mode & 1) > 0 || (stats.mode & 8) > 0 && stats.gid === process.getgid() || (stats.mode & 64) > 0 && stats.uid === process.getuid();
     }
     function getCmdPath() {
-      var _a2;
-      return (_a2 = process.env["COMSPEC"]) !== null && _a2 !== void 0 ? _a2 : `cmd.exe`;
+      var _a3;
+      return (_a3 = process.env["COMSPEC"]) !== null && _a3 !== void 0 ? _a3 : `cmd.exe`;
     }
     exports2.getCmdPath = getCmdPath;
   }
@@ -123551,11 +123871,11 @@ var require_io2 = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -123571,7 +123891,7 @@ var require_io2 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -123579,7 +123899,7 @@ var require_io2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.findInPath = exports2.which = exports2.mkdirP = exports2.rmRF = exports2.mv = exports2.cp = void 0;
     var assert_1 = require("assert");
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var ioUtil = __importStar2(require_io_util2());
     function cp(source, dest, options = {}) {
       return __awaiter2(this, void 0, void 0, function* () {
@@ -123588,7 +123908,7 @@ var require_io2 = __commonJS({
         if (destStat && destStat.isFile() && !force) {
           return;
         }
-        const newDest = destStat && destStat.isDirectory() && copySourceDirectory ? path28.join(dest, path28.basename(source)) : dest;
+        const newDest = destStat && destStat.isDirectory() && copySourceDirectory ? path29.join(dest, path29.basename(source)) : dest;
         if (!(yield ioUtil.exists(source))) {
           throw new Error(`no such file or directory: ${source}`);
         }
@@ -123600,7 +123920,7 @@ var require_io2 = __commonJS({
             yield cpDirRecursive(source, newDest, 0, force);
           }
         } else {
-          if (path28.relative(source, newDest) === "") {
+          if (path29.relative(source, newDest) === "") {
             throw new Error(`'${newDest}' and '${source}' are the same file`);
           }
           yield copyFile2(source, newDest, force);
@@ -123613,7 +123933,7 @@ var require_io2 = __commonJS({
         if (yield ioUtil.exists(dest)) {
           let destExists = true;
           if (yield ioUtil.isDirectory(dest)) {
-            dest = path28.join(dest, path28.basename(source));
+            dest = path29.join(dest, path29.basename(source));
             destExists = yield ioUtil.exists(dest);
           }
           if (destExists) {
@@ -123624,7 +123944,7 @@ var require_io2 = __commonJS({
             }
           }
         }
-        yield mkdirP(path28.dirname(dest));
+        yield mkdirP(path29.dirname(dest));
         yield ioUtil.rename(source, dest);
       });
     }
@@ -123687,7 +124007,7 @@ var require_io2 = __commonJS({
         }
         const extensions = [];
         if (ioUtil.IS_WINDOWS && process.env["PATHEXT"]) {
-          for (const extension of process.env["PATHEXT"].split(path28.delimiter)) {
+          for (const extension of process.env["PATHEXT"].split(path29.delimiter)) {
             if (extension) {
               extensions.push(extension);
             }
@@ -123700,12 +124020,12 @@ var require_io2 = __commonJS({
           }
           return [];
         }
-        if (tool.includes(path28.sep)) {
+        if (tool.includes(path29.sep)) {
           return [];
         }
         const directories = [];
         if (process.env.PATH) {
-          for (const p of process.env.PATH.split(path28.delimiter)) {
+          for (const p of process.env.PATH.split(path29.delimiter)) {
             if (p) {
               directories.push(p);
             }
@@ -123713,7 +124033,7 @@ var require_io2 = __commonJS({
         }
         const matches = [];
         for (const directory of directories) {
-          const filePath = yield ioUtil.tryGetExecutablePath(path28.join(directory, tool), extensions);
+          const filePath = yield ioUtil.tryGetExecutablePath(path29.join(directory, tool), extensions);
           if (filePath) {
             matches.push(filePath);
           }
@@ -123799,11 +124119,11 @@ var require_toolrunner2 = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -123819,7 +124139,7 @@ var require_toolrunner2 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -123829,7 +124149,7 @@ var require_toolrunner2 = __commonJS({
     var os7 = __importStar2(require("os"));
     var events = __importStar2(require("events"));
     var child = __importStar2(require("child_process"));
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var io9 = __importStar2(require_io2());
     var ioUtil = __importStar2(require_io_util2());
     var timers_1 = require("timers");
@@ -124044,10 +124364,10 @@ var require_toolrunner2 = __commonJS({
       exec() {
         return __awaiter2(this, void 0, void 0, function* () {
           if (!ioUtil.isRooted(this.toolPath) && (this.toolPath.includes("/") || IS_WINDOWS && this.toolPath.includes("\\"))) {
-            this.toolPath = path28.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
+            this.toolPath = path29.resolve(process.cwd(), this.options.cwd || process.cwd(), this.toolPath);
           }
           this.toolPath = yield io9.which(this.toolPath, true);
-          return new Promise((resolve13, reject) => __awaiter2(this, void 0, void 0, function* () {
+          return new Promise((resolve14, reject) => __awaiter2(this, void 0, void 0, function* () {
             this._debug(`exec tool: ${this.toolPath}`);
             this._debug("arguments:");
             for (const arg of this.args) {
@@ -124130,7 +124450,7 @@ var require_toolrunner2 = __commonJS({
               if (error3) {
                 reject(error3);
               } else {
-                resolve13(exitCode);
+                resolve14(exitCode);
               }
             });
             if (this.options.input) {
@@ -124283,11 +124603,11 @@ var require_exec2 = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -124303,7 +124623,7 @@ var require_exec2 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -124326,13 +124646,13 @@ var require_exec2 = __commonJS({
     }
     exports2.exec = exec3;
     function getExecOutput(commandLine, args, options) {
-      var _a, _b;
+      var _a2, _b;
       return __awaiter2(this, void 0, void 0, function* () {
         let stdout = "";
         let stderr = "";
         const stdoutDecoder = new string_decoder_1.StringDecoder("utf8");
         const stderrDecoder = new string_decoder_1.StringDecoder("utf8");
-        const originalStdoutListener = (_a = options === null || options === void 0 ? void 0 : options.listeners) === null || _a === void 0 ? void 0 : _a.stdout;
+        const originalStdoutListener = (_a2 = options === null || options === void 0 ? void 0 : options.listeners) === null || _a2 === void 0 ? void 0 : _a2.stdout;
         const originalStdErrListener = (_b = options === null || options === void 0 ? void 0 : options.listeners) === null || _b === void 0 ? void 0 : _b.stderr;
         const stdErrListener = (data) => {
           stderr += stderrDecoder.write(data);
@@ -124394,11 +124714,11 @@ var require_platform2 = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -124414,7 +124734,7 @@ var require_platform2 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -124439,11 +124759,11 @@ var require_platform2 = __commonJS({
       };
     });
     var getMacOsInfo = () => __awaiter2(void 0, void 0, void 0, function* () {
-      var _a, _b, _c, _d;
+      var _a2, _b, _c, _d;
       const { stdout } = yield exec3.getExecOutput("sw_vers", void 0, {
         silent: true
       });
-      const version = (_b = (_a = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : "";
+      const version = (_b = (_a2 = stdout.match(/ProductVersion:\s*(.+)/)) === null || _a2 === void 0 ? void 0 : _a2[1]) !== null && _b !== void 0 ? _b : "";
       const name = (_d = (_c = stdout.match(/ProductName:\s*(.+)/)) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : "";
       return {
         name,
@@ -124513,11 +124833,11 @@ var require_core4 = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -124533,7 +124853,7 @@ var require_core4 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -124544,7 +124864,7 @@ var require_core4 = __commonJS({
     var file_command_1 = require_file_command2();
     var utils_1 = require_utils10();
     var os7 = __importStar2(require("os"));
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     var oidc_utils_1 = require_oidc_utils2();
     var ExitCode;
     (function(ExitCode2) {
@@ -124572,7 +124892,7 @@ var require_core4 = __commonJS({
       } else {
         (0, command_1.issueCommand)("add-path", {}, inputPath);
       }
-      process.env["PATH"] = `${inputPath}${path28.delimiter}${process.env["PATH"]}`;
+      process.env["PATH"] = `${inputPath}${path29.delimiter}${process.env["PATH"]}`;
     }
     exports2.addPath = addPath2;
     function getInput2(name, options) {
@@ -124748,13 +125068,13 @@ These characters are not allowed in the artifact name due to limitations with ce
       (0, core_1.info)(`Artifact name is valid!`);
     }
     exports2.checkArtifactName = checkArtifactName;
-    function checkArtifactFilePath(path28) {
-      if (!path28) {
-        throw new Error(`Artifact path: ${path28}, is incorrectly provided`);
+    function checkArtifactFilePath(path29) {
+      if (!path29) {
+        throw new Error(`Artifact path: ${path29}, is incorrectly provided`);
       }
       for (const [invalidCharacterKey, errorMessageForCharacter] of invalidArtifactFilePathCharacters) {
-        if (path28.includes(invalidCharacterKey)) {
-          throw new Error(`Artifact path is not valid: ${path28}. Contains the following character: ${errorMessageForCharacter}
+        if (path29.includes(invalidCharacterKey)) {
+          throw new Error(`Artifact path is not valid: ${path29}. Contains the following character: ${errorMessageForCharacter}
           
 Invalid characters include: ${Array.from(invalidArtifactFilePathCharacters.values()).toString()}
           
@@ -124800,25 +125120,25 @@ var require_upload_specification = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getUploadSpecification = void 0;
-    var fs30 = __importStar2(require("fs"));
+    var fs31 = __importStar2(require("fs"));
     var core_1 = require_core4();
     var path_1 = require("path");
     var path_and_artifact_name_validation_1 = require_path_and_artifact_name_validation2();
     function getUploadSpecification(artifactName, rootDirectory, artifactFiles) {
       const specifications = [];
-      if (!fs30.existsSync(rootDirectory)) {
+      if (!fs31.existsSync(rootDirectory)) {
         throw new Error(`Provided rootDirectory ${rootDirectory} does not exist`);
       }
-      if (!fs30.statSync(rootDirectory).isDirectory()) {
+      if (!fs31.statSync(rootDirectory).isDirectory()) {
         throw new Error(`Provided rootDirectory ${rootDirectory} is not a valid directory`);
       }
       rootDirectory = (0, path_1.normalize)(rootDirectory);
       rootDirectory = (0, path_1.resolve)(rootDirectory);
       for (let file of artifactFiles) {
-        if (!fs30.existsSync(file)) {
+        if (!fs31.existsSync(file)) {
           throw new Error(`File ${file} does not exist`);
         }
-        if (!fs30.statSync(file).isDirectory()) {
+        if (!fs31.statSync(file).isDirectory()) {
           file = (0, path_1.normalize)(file);
           file = (0, path_1.resolve)(file);
           if (!file.startsWith(rootDirectory)) {
@@ -124843,11 +125163,11 @@ var require_upload_specification = __commonJS({
 // node_modules/tmp/lib/tmp.js
 var require_tmp = __commonJS({
   "node_modules/tmp/lib/tmp.js"(exports2, module2) {
-    var fs30 = require("fs");
+    var fs31 = require("fs");
     var os7 = require("os");
-    var path28 = require("path");
+    var path29 = require("path");
     var crypto3 = require("crypto");
-    var _c = { fs: fs30.constants, os: os7.constants };
+    var _c = { fs: fs31.constants, os: os7.constants };
     var RANDOM_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
     var TEMPLATE_PATTERN = /XXXXXX/;
     var DEFAULT_TRIES = 3;
@@ -124859,13 +125179,13 @@ var require_tmp = __commonJS({
     var FILE_MODE = 384;
     var EXIT = "exit";
     var _removeObjects = [];
-    var FN_RMDIR_SYNC = fs30.rmdirSync.bind(fs30);
+    var FN_RMDIR_SYNC = fs31.rmdirSync.bind(fs31);
     var _gracefulCleanup = false;
     function rimraf(dirPath, callback) {
-      return fs30.rm(dirPath, { recursive: true }, callback);
+      return fs31.rm(dirPath, { recursive: true }, callback);
     }
     function FN_RIMRAF_SYNC(dirPath) {
-      return fs30.rmSync(dirPath, { recursive: true });
+      return fs31.rmSync(dirPath, { recursive: true });
     }
     function tmpName(options, callback) {
       const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
@@ -124875,7 +125195,7 @@ var require_tmp = __commonJS({
         (function _getUniqueName() {
           try {
             const name = _generateTmpName(sanitizedOptions);
-            fs30.stat(name, function(err2) {
+            fs31.stat(name, function(err2) {
               if (!err2) {
                 if (tries-- > 0) return _getUniqueName();
                 return cb(new Error("Could not get a unique tmp filename, max tries reached " + name));
@@ -124895,7 +125215,7 @@ var require_tmp = __commonJS({
       do {
         const name = _generateTmpName(sanitizedOptions);
         try {
-          fs30.statSync(name);
+          fs31.statSync(name);
         } catch (e) {
           return name;
         }
@@ -124906,10 +125226,10 @@ var require_tmp = __commonJS({
       const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
       tmpName(opts, function _tmpNameCreated(err, name) {
         if (err) return cb(err);
-        fs30.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
+        fs31.open(name, CREATE_FLAGS, opts.mode || FILE_MODE, function _fileCreated(err2, fd) {
           if (err2) return cb(err2);
           if (opts.discardDescriptor) {
-            return fs30.close(fd, function _discardCallback(possibleErr) {
+            return fs31.close(fd, function _discardCallback(possibleErr) {
               return cb(possibleErr, name, void 0, _prepareTmpFileRemoveCallback(name, -1, opts, false));
             });
           } else {
@@ -124923,9 +125243,9 @@ var require_tmp = __commonJS({
       const args = _parseArguments(options), opts = args[0];
       const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
       const name = tmpNameSync(opts);
-      let fd = fs30.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
+      let fd = fs31.openSync(name, CREATE_FLAGS, opts.mode || FILE_MODE);
       if (opts.discardDescriptor) {
-        fs30.closeSync(fd);
+        fs31.closeSync(fd);
         fd = void 0;
       }
       return {
@@ -124938,7 +125258,7 @@ var require_tmp = __commonJS({
       const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
       tmpName(opts, function _tmpNameCreated(err, name) {
         if (err) return cb(err);
-        fs30.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
+        fs31.mkdir(name, opts.mode || DIR_MODE, function _dirCreated(err2) {
           if (err2) return cb(err2);
           cb(null, name, _prepareTmpDirRemoveCallback(name, opts, false));
         });
@@ -124947,7 +125267,7 @@ var require_tmp = __commonJS({
     function dirSync(options) {
       const args = _parseArguments(options), opts = args[0];
       const name = tmpNameSync(opts);
-      fs30.mkdirSync(name, opts.mode || DIR_MODE);
+      fs31.mkdirSync(name, opts.mode || DIR_MODE);
       return {
         name,
         removeCallback: _prepareTmpDirRemoveCallback(name, opts, true)
@@ -124961,20 +125281,20 @@ var require_tmp = __commonJS({
         next();
       };
       if (0 <= fdPath[0])
-        fs30.close(fdPath[0], function() {
-          fs30.unlink(fdPath[1], _handler);
+        fs31.close(fdPath[0], function() {
+          fs31.unlink(fdPath[1], _handler);
         });
-      else fs30.unlink(fdPath[1], _handler);
+      else fs31.unlink(fdPath[1], _handler);
     }
     function _removeFileSync(fdPath) {
       let rethrownException = null;
       try {
-        if (0 <= fdPath[0]) fs30.closeSync(fdPath[0]);
+        if (0 <= fdPath[0]) fs31.closeSync(fdPath[0]);
       } catch (e) {
         if (!_isEBADF(e) && !_isENOENT(e)) throw e;
       } finally {
         try {
-          fs30.unlinkSync(fdPath[1]);
+          fs31.unlinkSync(fdPath[1]);
         } catch (e) {
           if (!_isENOENT(e)) rethrownException = e;
         }
@@ -124990,7 +125310,7 @@ var require_tmp = __commonJS({
       return sync ? removeCallbackSync : removeCallback;
     }
     function _prepareTmpDirRemoveCallback(name, opts, sync) {
-      const removeFunction = opts.unsafeCleanup ? rimraf : fs30.rmdir.bind(fs30);
+      const removeFunction = opts.unsafeCleanup ? rimraf : fs31.rmdir.bind(fs31);
       const removeFunctionSync = opts.unsafeCleanup ? FN_RIMRAF_SYNC : FN_RMDIR_SYNC;
       const removeCallbackSync = _prepareRemoveCallback(removeFunctionSync, name, sync);
       const removeCallback = _prepareRemoveCallback(removeFunction, name, sync, removeCallbackSync);
@@ -125002,8 +125322,8 @@ var require_tmp = __commonJS({
       return function _cleanupCallback(next) {
         if (!called) {
           const toRemove = cleanupCallbackSync || _cleanupCallback;
-          const index = _removeObjects.indexOf(toRemove);
-          if (index >= 0) _removeObjects.splice(index, 1);
+          const index2 = _removeObjects.indexOf(toRemove);
+          if (index2 >= 0) _removeObjects.splice(index2, 1);
           called = true;
           if (sync || removeFunction === FN_RMDIR_SYNC || removeFunction === FN_RIMRAF_SYNC) {
             return removeFunction(fileOrDirName);
@@ -125052,35 +125372,35 @@ var require_tmp = __commonJS({
       return [actualOptions, callback];
     }
     function _resolvePath(name, tmpDir, cb) {
-      const pathToResolve = path28.isAbsolute(name) ? name : path28.join(tmpDir, name);
-      fs30.stat(pathToResolve, function(err) {
+      const pathToResolve = path29.isAbsolute(name) ? name : path29.join(tmpDir, name);
+      fs31.stat(pathToResolve, function(err) {
         if (err) {
-          fs30.realpath(path28.dirname(pathToResolve), function(err2, parentDir) {
+          fs31.realpath(path29.dirname(pathToResolve), function(err2, parentDir) {
             if (err2) return cb(err2);
-            cb(null, path28.join(parentDir, path28.basename(pathToResolve)));
+            cb(null, path29.join(parentDir, path29.basename(pathToResolve)));
           });
         } else {
-          fs30.realpath(pathToResolve, cb);
+          fs31.realpath(pathToResolve, cb);
         }
       });
     }
     function _resolvePathSync(name, tmpDir) {
-      const pathToResolve = path28.isAbsolute(name) ? name : path28.join(tmpDir, name);
+      const pathToResolve = path29.isAbsolute(name) ? name : path29.join(tmpDir, name);
       try {
-        fs30.statSync(pathToResolve);
-        return fs30.realpathSync(pathToResolve);
+        fs31.statSync(pathToResolve);
+        return fs31.realpathSync(pathToResolve);
       } catch (_err) {
-        const parentDir = fs30.realpathSync(path28.dirname(pathToResolve));
-        return path28.join(parentDir, path28.basename(pathToResolve));
+        const parentDir = fs31.realpathSync(path29.dirname(pathToResolve));
+        return path29.join(parentDir, path29.basename(pathToResolve));
       }
     }
     function _generateTmpName(opts) {
       const tmpDir = opts.tmpdir;
       if (!_isUndefined(opts.name)) {
-        return path28.join(tmpDir, opts.dir, opts.name);
+        return path29.join(tmpDir, opts.dir, opts.name);
       }
       if (!_isUndefined(opts.template)) {
-        return path28.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
+        return path29.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
       }
       const name = [
         opts.prefix ? opts.prefix : "tmp",
@@ -125090,7 +125410,7 @@ var require_tmp = __commonJS({
         _randomChars(12),
         opts.postfix ? "-" + opts.postfix : ""
       ].join("");
-      return path28.join(tmpDir, opts.dir, name);
+      return path29.join(tmpDir, opts.dir, name);
     }
     function _assertPath(option, value) {
       if (typeof value !== "string") {
@@ -125104,8 +125424,8 @@ var require_tmp = __commonJS({
     function _assertOptionsBase(options) {
       if (!_isUndefined(options.name)) {
         const name = options.name;
-        if (path28.isAbsolute(name)) throw new Error(`name option must not contain an absolute path, found "${name}".`);
-        const basename2 = path28.basename(name);
+        if (path29.isAbsolute(name)) throw new Error(`name option must not contain an absolute path, found "${name}".`);
+        const basename2 = path29.basename(name);
         if (basename2 === ".." || basename2 === "." || basename2 !== name) {
           throw new Error(`name option must not contain a path, found "${name}".`);
         }
@@ -125134,21 +125454,21 @@ var require_tmp = __commonJS({
       if (_isUndefined(name)) return cb(null);
       _resolvePath(name, tmpDir, function(err, resolvedPath) {
         if (err) return cb(err);
-        const relativePath = path28.relative(tmpDir, resolvedPath);
-        if (relativePath.startsWith("..") || path28.isAbsolute(relativePath)) {
-          return cb(new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`));
+        const relativePath2 = path29.relative(tmpDir, resolvedPath);
+        if (relativePath2.startsWith("..") || path29.isAbsolute(relativePath2)) {
+          return cb(new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath2}".`));
         }
-        cb(null, relativePath);
+        cb(null, relativePath2);
       });
     }
     function _getRelativePathSync(option, name, tmpDir) {
       if (_isUndefined(name)) return;
       const resolvedPath = _resolvePathSync(name, tmpDir);
-      const relativePath = path28.relative(tmpDir, resolvedPath);
-      if (relativePath.startsWith("..") || path28.isAbsolute(relativePath)) {
-        throw new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`);
+      const relativePath2 = path29.relative(tmpDir, resolvedPath);
+      if (relativePath2.startsWith("..") || path29.isAbsolute(relativePath2)) {
+        throw new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath2}".`);
       }
-      return relativePath;
+      return relativePath2;
     }
     function _assertAndSanitizeOptions(options, cb) {
       _getTmpDir(options, function(err, tmpDir) {
@@ -125191,10 +125511,10 @@ var require_tmp = __commonJS({
       _gracefulCleanup = true;
     }
     function _getTmpDir(options, cb) {
-      return fs30.realpath(options && options.tmpdir || os7.tmpdir(), cb);
+      return fs31.realpath(options && options.tmpdir || os7.tmpdir(), cb);
     }
     function _getTmpDirSync(options) {
-      return fs30.realpathSync(options && options.tmpdir || os7.tmpdir());
+      return fs31.realpathSync(options && options.tmpdir || os7.tmpdir());
     }
     process.addListener(EXIT, _garbageCollector);
     Object.defineProperty(module2.exports, "tmpdir", {
@@ -125224,14 +125544,14 @@ var require_tmp_promise = __commonJS({
     var fileWithOptions = promisify(
       (options, cb) => tmp.file(
         options,
-        (err, path28, fd, cleanup) => err ? cb(err) : cb(void 0, { path: path28, fd, cleanup: promisify(cleanup) })
+        (err, path29, fd, cleanup) => err ? cb(err) : cb(void 0, { path: path29, fd, cleanup: promisify(cleanup) })
       )
     );
     module2.exports.file = async (options) => fileWithOptions(options);
     module2.exports.withFile = async function withFile(fn, options) {
-      const { path: path28, fd, cleanup } = await module2.exports.file(options);
+      const { path: path29, fd, cleanup } = await module2.exports.file(options);
       try {
-        return await fn({ path: path28, fd });
+        return await fn({ path: path29, fd });
       } finally {
         await cleanup();
       }
@@ -125240,14 +125560,14 @@ var require_tmp_promise = __commonJS({
     var dirWithOptions = promisify(
       (options, cb) => tmp.dir(
         options,
-        (err, path28, cleanup) => err ? cb(err) : cb(void 0, { path: path28, cleanup: promisify(cleanup) })
+        (err, path29, cleanup) => err ? cb(err) : cb(void 0, { path: path29, cleanup: promisify(cleanup) })
       )
     );
     module2.exports.dir = async (options) => dirWithOptions(options);
     module2.exports.withDir = async function withDir(fn, options) {
-      const { path: path28, cleanup } = await module2.exports.dir(options);
+      const { path: path29, cleanup } = await module2.exports.dir(options);
       try {
-        return await fn({ path: path28 });
+        return await fn({ path: path29 });
       } finally {
         await cleanup();
       }
@@ -125636,11 +125956,11 @@ var require_utils11 = __commonJS({
     "use strict";
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -125656,7 +125976,7 @@ var require_utils11 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -125866,19 +126186,19 @@ Header Information: ${JSON.stringify(response.message.headers, void 0, 2)}
     exports2.getProperRetention = getProperRetention;
     function sleep(milliseconds) {
       return __awaiter2(this, void 0, void 0, function* () {
-        return new Promise((resolve13) => setTimeout(resolve13, milliseconds));
+        return new Promise((resolve14) => setTimeout(resolve14, milliseconds));
       });
     }
     exports2.sleep = sleep;
     function digestForStream(stream2) {
       return __awaiter2(this, void 0, void 0, function* () {
-        return new Promise((resolve13, reject) => {
+        return new Promise((resolve14, reject) => {
           const crc64 = new crc64_1.default();
           const md5 = crypto_1.default.createHash("md5");
           stream2.on("data", (data) => {
             crc64.update(data);
             md5.update(data);
-          }).on("end", () => resolve13({
+          }).on("end", () => resolve14({
             crc64: crc64.digest("base64"),
             md5: md5.digest("base64")
           })).on("error", reject);
@@ -125950,18 +126270,18 @@ var require_http_manager = __commonJS({
         this.userAgent = userAgent2;
         this.clients = new Array(clientCount).fill((0, utils_1.createHttpClient)(userAgent2));
       }
-      getClient(index) {
-        return this.clients[index];
+      getClient(index2) {
+        return this.clients[index2];
       }
       // client disposal is necessary if a keep-alive connection is used to properly close the connection
       // for more information see: https://github.com/actions/http-client/blob/04e5ad73cd3fd1f5610a32116b0759eddf6570d2/index.ts#L292
-      disposeAndReplaceClient(index) {
-        this.clients[index].dispose();
-        this.clients[index] = (0, utils_1.createHttpClient)(this.userAgent);
+      disposeAndReplaceClient(index2) {
+        this.clients[index2].dispose();
+        this.clients[index2] = (0, utils_1.createHttpClient)(this.userAgent);
       }
       disposeAndReplaceAllClients() {
-        for (const [index] of this.clients.entries()) {
-          this.disposeAndReplaceClient(index);
+        for (const [index2] of this.clients.entries()) {
+          this.disposeAndReplaceClient(index2);
         }
       }
     };
@@ -126002,11 +126322,11 @@ var require_upload_gzip = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -126022,7 +126342,7 @@ var require_upload_gzip = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -126035,23 +126355,23 @@ var require_upload_gzip = __commonJS({
       }, i);
       function verb(n) {
         i[n] = o[n] && function(v) {
-          return new Promise(function(resolve13, reject) {
-            v = o[n](v), settle(resolve13, reject, v.done, v.value);
+          return new Promise(function(resolve14, reject) {
+            v = o[n](v), settle(resolve14, reject, v.done, v.value);
           });
         };
       }
-      function settle(resolve13, reject, d, v) {
+      function settle(resolve14, reject, d, v) {
         Promise.resolve(v).then(function(v2) {
-          resolve13({ value: v2, done: d });
+          resolve14({ value: v2, done: d });
         }, reject);
       }
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.createGZipFileInBuffer = exports2.createGZipFileOnDisk = void 0;
-    var fs30 = __importStar2(require("fs"));
+    var fs31 = __importStar2(require("fs"));
     var zlib3 = __importStar2(require("zlib"));
     var util_1 = require("util");
-    var stat = (0, util_1.promisify)(fs30.stat);
+    var stat2 = (0, util_1.promisify)(fs31.stat);
     var gzipExemptFileExtensions = [
       ".gz",
       ".gzip",
@@ -126083,14 +126403,14 @@ var require_upload_gzip = __commonJS({
             return Number.MAX_SAFE_INTEGER;
           }
         }
-        return new Promise((resolve13, reject) => {
-          const inputStream = fs30.createReadStream(originalFilePath);
+        return new Promise((resolve14, reject) => {
+          const inputStream = fs31.createReadStream(originalFilePath);
           const gzip = zlib3.createGzip();
-          const outputStream = fs30.createWriteStream(tempFilePath);
+          const outputStream = fs31.createWriteStream(tempFilePath);
           inputStream.pipe(gzip).pipe(outputStream);
           outputStream.on("finish", () => __awaiter2(this, void 0, void 0, function* () {
-            const size = (yield stat(tempFilePath)).size;
-            resolve13(size);
+            const size = (yield stat2(tempFilePath)).size;
+            resolve14(size);
           }));
           outputStream.on("error", (error3) => {
             console.log(error3);
@@ -126102,14 +126422,14 @@ var require_upload_gzip = __commonJS({
     exports2.createGZipFileOnDisk = createGZipFileOnDisk;
     function createGZipFileInBuffer(originalFilePath) {
       return __awaiter2(this, void 0, void 0, function* () {
-        return new Promise((resolve13) => __awaiter2(this, void 0, void 0, function* () {
-          var _a, e_1, _b, _c;
-          const inputStream = fs30.createReadStream(originalFilePath);
+        return new Promise((resolve14) => __awaiter2(this, void 0, void 0, function* () {
+          var _a2, e_1, _b, _c;
+          const inputStream = fs31.createReadStream(originalFilePath);
           const gzip = zlib3.createGzip();
           inputStream.pipe(gzip);
           const chunks = [];
           try {
-            for (var _d = true, gzip_1 = __asyncValues2(gzip), gzip_1_1; gzip_1_1 = yield gzip_1.next(), _a = gzip_1_1.done, !_a; ) {
+            for (var _d = true, gzip_1 = __asyncValues2(gzip), gzip_1_1; gzip_1_1 = yield gzip_1.next(), _a2 = gzip_1_1.done, !_a2; ) {
               _c = gzip_1_1.value;
               _d = false;
               try {
@@ -126123,12 +126443,12 @@ var require_upload_gzip = __commonJS({
             e_1 = { error: e_1_1 };
           } finally {
             try {
-              if (!_d && !_a && (_b = gzip_1.return)) yield _b.call(gzip_1);
+              if (!_d && !_a2 && (_b = gzip_1.return)) yield _b.call(gzip_1);
             } finally {
               if (e_1) throw e_1.error;
             }
           }
-          resolve13(Buffer.concat(chunks));
+          resolve14(Buffer.concat(chunks));
         }));
       });
     }
@@ -126169,11 +126489,11 @@ var require_requestUtils2 = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -126189,7 +126509,7 @@ var require_requestUtils2 = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -126286,11 +126606,11 @@ var require_upload_http_client = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -126306,14 +126626,14 @@ var require_upload_http_client = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.UploadHttpClient = void 0;
-    var fs30 = __importStar2(require("fs"));
+    var fs31 = __importStar2(require("fs"));
     var core30 = __importStar2(require_core4());
     var tmp = __importStar2(require_tmp_promise());
     var stream2 = __importStar2(require("stream"));
@@ -126327,7 +126647,7 @@ var require_upload_http_client = __commonJS({
     var http_manager_1 = require_http_manager();
     var upload_gzip_1 = require_upload_gzip();
     var requestUtils_1 = require_requestUtils2();
-    var stat = (0, util_1.promisify)(fs30.stat);
+    var stat2 = (0, util_1.promisify)(fs31.stat);
     var UploadHttpClient = class {
       constructor() {
         this.uploadHttpManager = new http_manager_1.HttpManager((0, config_variables_1.getUploadFileConcurrency)(), "@actions/artifact-upload");
@@ -126406,7 +126726,7 @@ var require_upload_http_client = __commonJS({
           let abortPendingFileUploads = false;
           this.statusReporter.setTotalNumberOfFilesToProcess(filesToUpload.length);
           this.statusReporter.start();
-          yield Promise.all(parallelUploads.map((index) => __awaiter2(this, void 0, void 0, function* () {
+          yield Promise.all(parallelUploads.map((index2) => __awaiter2(this, void 0, void 0, function* () {
             while (currentFile < filesToUpload.length) {
               const currentFileParameters = parameters[currentFile];
               currentFile += 1;
@@ -126415,7 +126735,7 @@ var require_upload_http_client = __commonJS({
                 continue;
               }
               const startTime = perf_hooks_1.performance.now();
-              const uploadFileResult = yield this.uploadFileAsync(index, currentFileParameters);
+              const uploadFileResult = yield this.uploadFileAsync(index2, currentFileParameters);
               if (core30.isDebug()) {
                 core30.debug(`File: ${++completedFiles}/${filesToUpload.length}. ${currentFileParameters.file} took ${(perf_hooks_1.performance.now() - startTime).toFixed(3)} milliseconds to finish upload`);
               }
@@ -126450,7 +126770,7 @@ var require_upload_http_client = __commonJS({
        */
       uploadFileAsync(httpClientIndex, parameters) {
         return __awaiter2(this, void 0, void 0, function* () {
-          const fileStat = yield stat(parameters.file);
+          const fileStat = yield stat2(parameters.file);
           const totalFileSize = fileStat.size;
           const isFIFO = fileStat.isFIFO();
           let offset = 0;
@@ -126464,7 +126784,7 @@ var require_upload_http_client = __commonJS({
             let openUploadStream;
             if (totalFileSize < buffer.byteLength) {
               core30.debug(`The gzip file created for ${parameters.file} did not help with reducing the size of the file. The original file will be uploaded as-is`);
-              openUploadStream = () => fs30.createReadStream(parameters.file);
+              openUploadStream = () => fs31.createReadStream(parameters.file);
               isGzip = false;
               uploadFileSize = totalFileSize;
             } else {
@@ -126510,7 +126830,7 @@ var require_upload_http_client = __commonJS({
                 failedChunkSizes += chunkSize;
                 continue;
               }
-              const result = yield this.uploadChunk(httpClientIndex, parameters.resourceUrl, () => fs30.createReadStream(uploadFilePath, {
+              const result = yield this.uploadChunk(httpClientIndex, parameters.resourceUrl, () => fs31.createReadStream(uploadFilePath, {
                 start: startChunkIndex,
                 end: endChunkIndex,
                 autoClose: false
@@ -126678,11 +126998,11 @@ var require_download_http_client = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -126698,14 +127018,14 @@ var require_download_http_client = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DownloadHttpClient = void 0;
-    var fs30 = __importStar2(require("fs"));
+    var fs31 = __importStar2(require("fs"));
     var core30 = __importStar2(require_core4());
     var zlib3 = __importStar2(require("zlib"));
     var utils_1 = require_utils11();
@@ -126767,12 +127087,12 @@ var require_download_http_client = __commonJS({
           core30.info(`Total number of files that will be downloaded: ${downloadItems.length}`);
           this.statusReporter.setTotalNumberOfFilesToProcess(downloadItems.length);
           this.statusReporter.start();
-          yield Promise.all(parallelDownloads.map((index) => __awaiter2(this, void 0, void 0, function* () {
+          yield Promise.all(parallelDownloads.map((index2) => __awaiter2(this, void 0, void 0, function* () {
             while (currentFile < downloadItems.length) {
               const currentFileToDownload = downloadItems[currentFile];
               currentFile += 1;
               const startTime = perf_hooks_1.performance.now();
-              yield this.downloadIndividualFile(index, currentFileToDownload.sourceLocation, currentFileToDownload.targetPath);
+              yield this.downloadIndividualFile(index2, currentFileToDownload.sourceLocation, currentFileToDownload.targetPath);
               if (core30.isDebug()) {
                 core30.debug(`File: ${++downloadedFiles}/${downloadItems.length}. ${currentFileToDownload.targetPath} took ${(perf_hooks_1.performance.now() - startTime).toFixed(3)} milliseconds to finish downloading`);
               }
@@ -126796,7 +127116,7 @@ var require_download_http_client = __commonJS({
         return __awaiter2(this, void 0, void 0, function* () {
           let retryCount = 0;
           const retryLimit = (0, config_variables_1.getRetryLimit)();
-          let destinationStream = fs30.createWriteStream(downloadPath);
+          let destinationStream = fs31.createWriteStream(downloadPath);
           const headers = (0, utils_1.getDownloadHeaders)("application/json", true, true);
           const makeDownloadRequest = () => __awaiter2(this, void 0, void 0, function* () {
             const client = this.downloadHttpManager.getClient(httpClientIndex);
@@ -126831,14 +127151,14 @@ var require_download_http_client = __commonJS({
           };
           const resetDestinationStream = (fileDownloadPath) => __awaiter2(this, void 0, void 0, function* () {
             destinationStream.close();
-            yield new Promise((resolve13) => {
-              destinationStream.on("close", resolve13);
+            yield new Promise((resolve14) => {
+              destinationStream.on("close", resolve14);
               if (destinationStream.writableFinished) {
-                resolve13();
+                resolve14();
               }
             });
             yield (0, utils_1.rmFile)(fileDownloadPath);
-            destinationStream = fs30.createWriteStream(fileDownloadPath);
+            destinationStream = fs31.createWriteStream(fileDownloadPath);
           });
           while (retryCount <= retryLimit) {
             let response;
@@ -126883,7 +127203,7 @@ var require_download_http_client = __commonJS({
        */
       pipeResponseToFile(response, destinationStream, isGzip) {
         return __awaiter2(this, void 0, void 0, function* () {
-          yield new Promise((resolve13, reject) => {
+          yield new Promise((resolve14, reject) => {
             if (isGzip) {
               const gunzip = zlib3.createGunzip();
               response.message.on("error", (error3) => {
@@ -126896,7 +127216,7 @@ var require_download_http_client = __commonJS({
                 destinationStream.close();
                 reject(error3);
               }).pipe(destinationStream).on("close", () => {
-                resolve13();
+                resolve14();
               }).on("error", (error3) => {
                 core30.info(`An error occurred while writing a downloaded file to ${destinationStream.path}`);
                 reject(error3);
@@ -126907,7 +127227,7 @@ var require_download_http_client = __commonJS({
                 destinationStream.close();
                 reject(error3);
               }).pipe(destinationStream).on("close", () => {
-                resolve13();
+                resolve14();
               }).on("error", (error3) => {
                 core30.info(`An error occurred while writing a downloaded file to ${destinationStream.path}`);
                 reject(error3);
@@ -126955,21 +127275,21 @@ var require_download_specification = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getDownloadSpecification = void 0;
-    var path28 = __importStar2(require("path"));
+    var path29 = __importStar2(require("path"));
     function getDownloadSpecification(artifactName, artifactEntries, downloadPath, includeRootDirectory) {
       const directories = /* @__PURE__ */ new Set();
       const specifications = {
-        rootDownloadLocation: includeRootDirectory ? path28.join(downloadPath, artifactName) : downloadPath,
+        rootDownloadLocation: includeRootDirectory ? path29.join(downloadPath, artifactName) : downloadPath,
         directoryStructure: [],
         emptyFilesToCreate: [],
         filesToDownload: []
       };
       for (const entry of artifactEntries) {
         if (entry.path.startsWith(`${artifactName}/`) || entry.path.startsWith(`${artifactName}\\`)) {
-          const normalizedPathEntry = path28.normalize(entry.path);
-          const filePath = path28.join(downloadPath, includeRootDirectory ? normalizedPathEntry : normalizedPathEntry.replace(artifactName, ""));
+          const normalizedPathEntry = path29.normalize(entry.path);
+          const filePath = path29.join(downloadPath, includeRootDirectory ? normalizedPathEntry : normalizedPathEntry.replace(artifactName, ""));
           if (entry.itemType === "file") {
-            directories.add(path28.dirname(filePath));
+            directories.add(path29.dirname(filePath));
             if (entry.fileLength === 0) {
               specifications.emptyFilesToCreate.push(filePath);
             } else {
@@ -127021,11 +127341,11 @@ var require_artifact_client = __commonJS({
     };
     var __awaiter2 = exports2 && exports2.__awaiter || function(thisArg, _arguments, P, generator) {
       function adopt(value) {
-        return value instanceof P ? value : new P(function(resolve13) {
-          resolve13(value);
+        return value instanceof P ? value : new P(function(resolve14) {
+          resolve14(value);
         });
       }
-      return new (P || (P = Promise))(function(resolve13, reject) {
+      return new (P || (P = Promise))(function(resolve14, reject) {
         function fulfilled(value) {
           try {
             step(generator.next(value));
@@ -127041,7 +127361,7 @@ var require_artifact_client = __commonJS({
           }
         }
         function step(result) {
-          result.done ? resolve13(result.value) : adopt(result.value).then(fulfilled, rejected);
+          result.done ? resolve14(result.value) : adopt(result.value).then(fulfilled, rejected);
         }
         step((generator = generator.apply(thisArg, _arguments || [])).next());
       });
@@ -127111,7 +127431,7 @@ Note: The size of downloaded zips can differ significantly from the reported siz
           return uploadResponse;
         });
       }
-      downloadArtifact(name, path28, options) {
+      downloadArtifact(name, path29, options) {
         return __awaiter2(this, void 0, void 0, function* () {
           const downloadHttpClient = new download_http_client_1.DownloadHttpClient();
           const artifacts = yield downloadHttpClient.listArtifacts();
@@ -127125,12 +127445,12 @@ Note: The size of downloaded zips can differ significantly from the reported siz
             throw new Error(`Unable to find an artifact with the name: ${name}`);
           }
           const items = yield downloadHttpClient.getContainerItems(artifactToDownload.name, artifactToDownload.fileContainerResourceUrl);
-          if (!path28) {
-            path28 = (0, config_variables_1.getWorkSpaceDirectory)();
+          if (!path29) {
+            path29 = (0, config_variables_1.getWorkSpaceDirectory)();
           }
-          path28 = (0, path_1.normalize)(path28);
-          path28 = (0, path_1.resolve)(path28);
-          const downloadSpecification = (0, download_specification_1.getDownloadSpecification)(name, items.value, path28, (options === null || options === void 0 ? void 0 : options.createArtifactFolder) || false);
+          path29 = (0, path_1.normalize)(path29);
+          path29 = (0, path_1.resolve)(path29);
+          const downloadSpecification = (0, download_specification_1.getDownloadSpecification)(name, items.value, path29, (options === null || options === void 0 ? void 0 : options.createArtifactFolder) || false);
           if (downloadSpecification.filesToDownload.length === 0) {
             core30.info(`No downloadable files were found for the artifact: ${artifactToDownload.name}`);
           } else {
@@ -127145,7 +127465,7 @@ Note: The size of downloaded zips can differ significantly from the reported siz
           };
         });
       }
-      downloadAllArtifacts(path28) {
+      downloadAllArtifacts(path29) {
         return __awaiter2(this, void 0, void 0, function* () {
           const downloadHttpClient = new download_http_client_1.DownloadHttpClient();
           const response = [];
@@ -127154,18 +127474,18 @@ Note: The size of downloaded zips can differ significantly from the reported siz
             core30.info("Unable to find any artifacts for the associated workflow");
             return response;
           }
-          if (!path28) {
-            path28 = (0, config_variables_1.getWorkSpaceDirectory)();
+          if (!path29) {
+            path29 = (0, config_variables_1.getWorkSpaceDirectory)();
           }
-          path28 = (0, path_1.normalize)(path28);
-          path28 = (0, path_1.resolve)(path28);
+          path29 = (0, path_1.normalize)(path29);
+          path29 = (0, path_1.resolve)(path29);
           let downloadedArtifacts = 0;
           while (downloadedArtifacts < artifacts.count) {
             const currentArtifactToDownload = artifacts.value[downloadedArtifacts];
             downloadedArtifacts += 1;
             core30.info(`starting download of artifact ${currentArtifactToDownload.name} : ${downloadedArtifacts}/${artifacts.count}`);
             const items = yield downloadHttpClient.getContainerItems(currentArtifactToDownload.name, currentArtifactToDownload.fileContainerResourceUrl);
-            const downloadSpecification = (0, download_specification_1.getDownloadSpecification)(currentArtifactToDownload.name, items.value, path28, true);
+            const downloadSpecification = (0, download_specification_1.getDownloadSpecification)(currentArtifactToDownload.name, items.value, path29, true);
             if (downloadSpecification.filesToDownload.length === 0) {
               core30.info(`No downloadable files were found for any artifact ${currentArtifactToDownload.name}`);
             } else {
@@ -127331,27 +127651,27 @@ var require_util16 = __commonJS({
   "node_modules/node-forge/lib/util.js"(exports2, module2) {
     var forge = require_forge();
     var baseN = require_baseN();
-    var util = module2.exports = forge.util = forge.util || {};
+    var util3 = module2.exports = forge.util = forge.util || {};
     (function() {
       if (typeof process !== "undefined" && process.nextTick && !process.browser) {
-        util.nextTick = process.nextTick;
+        util3.nextTick = process.nextTick;
         if (typeof setImmediate === "function") {
-          util.setImmediate = setImmediate;
+          util3.setImmediate = setImmediate;
         } else {
-          util.setImmediate = util.nextTick;
+          util3.setImmediate = util3.nextTick;
         }
         return;
       }
       if (typeof setImmediate === "function") {
-        util.setImmediate = function() {
+        util3.setImmediate = function() {
           return setImmediate.apply(void 0, arguments);
         };
-        util.nextTick = function(callback) {
+        util3.nextTick = function(callback) {
           return setImmediate(callback);
         };
         return;
       }
-      util.setImmediate = function(callback) {
+      util3.setImmediate = function(callback) {
         setTimeout(callback, 0);
       };
       if (typeof window !== "undefined" && typeof window.postMessage === "function") {
@@ -127368,7 +127688,7 @@ var require_util16 = __commonJS({
         var handler2 = handler3;
         var msg = "forge.setImmediate";
         var callbacks = [];
-        util.setImmediate = function(callback) {
+        util3.setImmediate = function(callback) {
           callbacks.push(callback);
           if (callbacks.length === 1) {
             window.postMessage(msg, "*");
@@ -127388,8 +127708,8 @@ var require_util16 = __commonJS({
             callback();
           });
         }).observe(div, { attributes: true });
-        var oldSetImmediate = util.setImmediate;
-        util.setImmediate = function(callback) {
+        var oldSetImmediate = util3.setImmediate;
+        util3.setImmediate = function(callback) {
           if (Date.now() - now > 15) {
             now = Date.now();
             oldSetImmediate(callback);
@@ -127401,36 +127721,36 @@ var require_util16 = __commonJS({
           }
         };
       }
-      util.nextTick = util.setImmediate;
+      util3.nextTick = util3.setImmediate;
     })();
-    util.isNodejs = typeof process !== "undefined" && process.versions && process.versions.node;
-    util.globalScope = (function() {
-      if (util.isNodejs) {
+    util3.isNodejs = typeof process !== "undefined" && process.versions && process.versions.node;
+    util3.globalScope = (function() {
+      if (util3.isNodejs) {
         return global;
       }
       return typeof self === "undefined" ? window : self;
     })();
-    util.isArray = Array.isArray || function(x) {
+    util3.isArray = Array.isArray || function(x) {
       return Object.prototype.toString.call(x) === "[object Array]";
     };
-    util.isArrayBuffer = function(x) {
+    util3.isArrayBuffer = function(x) {
       return typeof ArrayBuffer !== "undefined" && x instanceof ArrayBuffer;
     };
-    util.isArrayBufferView = function(x) {
-      return x && util.isArrayBuffer(x.buffer) && x.byteLength !== void 0;
+    util3.isArrayBufferView = function(x) {
+      return x && util3.isArrayBuffer(x.buffer) && x.byteLength !== void 0;
     };
     function _checkBitsParam(n) {
       if (!(n === 8 || n === 16 || n === 24 || n === 32)) {
         throw new Error("Only 8, 16, 24, or 32 bits supported: " + n);
       }
     }
-    util.ByteBuffer = ByteStringBuffer;
+    util3.ByteBuffer = ByteStringBuffer;
     function ByteStringBuffer(b) {
       this.data = "";
       this.read = 0;
       if (typeof b === "string") {
         this.data = b;
-      } else if (util.isArrayBuffer(b) || util.isArrayBufferView(b)) {
+      } else if (util3.isArrayBuffer(b) || util3.isArrayBufferView(b)) {
         if (typeof Buffer !== "undefined" && b instanceof Buffer) {
           this.data = b.toString("binary");
         } else {
@@ -127449,25 +127769,25 @@ var require_util16 = __commonJS({
       }
       this._constructedStringLength = 0;
     }
-    util.ByteStringBuffer = ByteStringBuffer;
+    util3.ByteStringBuffer = ByteStringBuffer;
     var _MAX_CONSTRUCTED_STRING_LENGTH = 4096;
-    util.ByteStringBuffer.prototype._optimizeConstructedString = function(x) {
+    util3.ByteStringBuffer.prototype._optimizeConstructedString = function(x) {
       this._constructedStringLength += x;
       if (this._constructedStringLength > _MAX_CONSTRUCTED_STRING_LENGTH) {
         this.data.substr(0, 1);
         this._constructedStringLength = 0;
       }
     };
-    util.ByteStringBuffer.prototype.length = function() {
+    util3.ByteStringBuffer.prototype.length = function() {
       return this.data.length - this.read;
     };
-    util.ByteStringBuffer.prototype.isEmpty = function() {
+    util3.ByteStringBuffer.prototype.isEmpty = function() {
       return this.length() <= 0;
     };
-    util.ByteStringBuffer.prototype.putByte = function(b) {
+    util3.ByteStringBuffer.prototype.putByte = function(b) {
       return this.putBytes(String.fromCharCode(b));
     };
-    util.ByteStringBuffer.prototype.fillWithByte = function(b, n) {
+    util3.ByteStringBuffer.prototype.fillWithByte = function(b, n) {
       b = String.fromCharCode(b);
       var d = this.data;
       while (n > 0) {
@@ -127483,45 +127803,45 @@ var require_util16 = __commonJS({
       this._optimizeConstructedString(n);
       return this;
     };
-    util.ByteStringBuffer.prototype.putBytes = function(bytes) {
+    util3.ByteStringBuffer.prototype.putBytes = function(bytes) {
       this.data += bytes;
       this._optimizeConstructedString(bytes.length);
       return this;
     };
-    util.ByteStringBuffer.prototype.putString = function(str) {
-      return this.putBytes(util.encodeUtf8(str));
+    util3.ByteStringBuffer.prototype.putString = function(str) {
+      return this.putBytes(util3.encodeUtf8(str));
     };
-    util.ByteStringBuffer.prototype.putInt16 = function(i) {
+    util3.ByteStringBuffer.prototype.putInt16 = function(i) {
       return this.putBytes(
         String.fromCharCode(i >> 8 & 255) + String.fromCharCode(i & 255)
       );
     };
-    util.ByteStringBuffer.prototype.putInt24 = function(i) {
+    util3.ByteStringBuffer.prototype.putInt24 = function(i) {
       return this.putBytes(
         String.fromCharCode(i >> 16 & 255) + String.fromCharCode(i >> 8 & 255) + String.fromCharCode(i & 255)
       );
     };
-    util.ByteStringBuffer.prototype.putInt32 = function(i) {
+    util3.ByteStringBuffer.prototype.putInt32 = function(i) {
       return this.putBytes(
         String.fromCharCode(i >> 24 & 255) + String.fromCharCode(i >> 16 & 255) + String.fromCharCode(i >> 8 & 255) + String.fromCharCode(i & 255)
       );
     };
-    util.ByteStringBuffer.prototype.putInt16Le = function(i) {
+    util3.ByteStringBuffer.prototype.putInt16Le = function(i) {
       return this.putBytes(
         String.fromCharCode(i & 255) + String.fromCharCode(i >> 8 & 255)
       );
     };
-    util.ByteStringBuffer.prototype.putInt24Le = function(i) {
+    util3.ByteStringBuffer.prototype.putInt24Le = function(i) {
       return this.putBytes(
         String.fromCharCode(i & 255) + String.fromCharCode(i >> 8 & 255) + String.fromCharCode(i >> 16 & 255)
       );
     };
-    util.ByteStringBuffer.prototype.putInt32Le = function(i) {
+    util3.ByteStringBuffer.prototype.putInt32Le = function(i) {
       return this.putBytes(
         String.fromCharCode(i & 255) + String.fromCharCode(i >> 8 & 255) + String.fromCharCode(i >> 16 & 255) + String.fromCharCode(i >> 24 & 255)
       );
     };
-    util.ByteStringBuffer.prototype.putInt = function(i, n) {
+    util3.ByteStringBuffer.prototype.putInt = function(i, n) {
       _checkBitsParam(n);
       var bytes = "";
       do {
@@ -127530,49 +127850,49 @@ var require_util16 = __commonJS({
       } while (n > 0);
       return this.putBytes(bytes);
     };
-    util.ByteStringBuffer.prototype.putSignedInt = function(i, n) {
+    util3.ByteStringBuffer.prototype.putSignedInt = function(i, n) {
       if (i < 0) {
         i += 2 << n - 1;
       }
       return this.putInt(i, n);
     };
-    util.ByteStringBuffer.prototype.putBuffer = function(buffer) {
+    util3.ByteStringBuffer.prototype.putBuffer = function(buffer) {
       return this.putBytes(buffer.getBytes());
     };
-    util.ByteStringBuffer.prototype.getByte = function() {
+    util3.ByteStringBuffer.prototype.getByte = function() {
       return this.data.charCodeAt(this.read++);
     };
-    util.ByteStringBuffer.prototype.getInt16 = function() {
+    util3.ByteStringBuffer.prototype.getInt16 = function() {
       var rval = this.data.charCodeAt(this.read) << 8 ^ this.data.charCodeAt(this.read + 1);
       this.read += 2;
       return rval;
     };
-    util.ByteStringBuffer.prototype.getInt24 = function() {
+    util3.ByteStringBuffer.prototype.getInt24 = function() {
       var rval = this.data.charCodeAt(this.read) << 16 ^ this.data.charCodeAt(this.read + 1) << 8 ^ this.data.charCodeAt(this.read + 2);
       this.read += 3;
       return rval;
     };
-    util.ByteStringBuffer.prototype.getInt32 = function() {
+    util3.ByteStringBuffer.prototype.getInt32 = function() {
       var rval = this.data.charCodeAt(this.read) << 24 ^ this.data.charCodeAt(this.read + 1) << 16 ^ this.data.charCodeAt(this.read + 2) << 8 ^ this.data.charCodeAt(this.read + 3);
       this.read += 4;
       return rval;
     };
-    util.ByteStringBuffer.prototype.getInt16Le = function() {
+    util3.ByteStringBuffer.prototype.getInt16Le = function() {
       var rval = this.data.charCodeAt(this.read) ^ this.data.charCodeAt(this.read + 1) << 8;
       this.read += 2;
       return rval;
     };
-    util.ByteStringBuffer.prototype.getInt24Le = function() {
+    util3.ByteStringBuffer.prototype.getInt24Le = function() {
       var rval = this.data.charCodeAt(this.read) ^ this.data.charCodeAt(this.read + 1) << 8 ^ this.data.charCodeAt(this.read + 2) << 16;
       this.read += 3;
       return rval;
     };
-    util.ByteStringBuffer.prototype.getInt32Le = function() {
+    util3.ByteStringBuffer.prototype.getInt32Le = function() {
       var rval = this.data.charCodeAt(this.read) ^ this.data.charCodeAt(this.read + 1) << 8 ^ this.data.charCodeAt(this.read + 2) << 16 ^ this.data.charCodeAt(this.read + 3) << 24;
       this.read += 4;
       return rval;
     };
-    util.ByteStringBuffer.prototype.getInt = function(n) {
+    util3.ByteStringBuffer.prototype.getInt = function(n) {
       _checkBitsParam(n);
       var rval = 0;
       do {
@@ -127581,7 +127901,7 @@ var require_util16 = __commonJS({
       } while (n > 0);
       return rval;
     };
-    util.ByteStringBuffer.prototype.getSignedInt = function(n) {
+    util3.ByteStringBuffer.prototype.getSignedInt = function(n) {
       var x = this.getInt(n);
       var max = 2 << n - 2;
       if (x >= max) {
@@ -127589,7 +127909,7 @@ var require_util16 = __commonJS({
       }
       return x;
     };
-    util.ByteStringBuffer.prototype.getBytes = function(count) {
+    util3.ByteStringBuffer.prototype.getBytes = function(count) {
       var rval;
       if (count) {
         count = Math.min(this.length(), count);
@@ -127603,43 +127923,43 @@ var require_util16 = __commonJS({
       }
       return rval;
     };
-    util.ByteStringBuffer.prototype.bytes = function(count) {
+    util3.ByteStringBuffer.prototype.bytes = function(count) {
       return typeof count === "undefined" ? this.data.slice(this.read) : this.data.slice(this.read, this.read + count);
     };
-    util.ByteStringBuffer.prototype.at = function(i) {
+    util3.ByteStringBuffer.prototype.at = function(i) {
       return this.data.charCodeAt(this.read + i);
     };
-    util.ByteStringBuffer.prototype.setAt = function(i, b) {
+    util3.ByteStringBuffer.prototype.setAt = function(i, b) {
       this.data = this.data.substr(0, this.read + i) + String.fromCharCode(b) + this.data.substr(this.read + i + 1);
       return this;
     };
-    util.ByteStringBuffer.prototype.last = function() {
+    util3.ByteStringBuffer.prototype.last = function() {
       return this.data.charCodeAt(this.data.length - 1);
     };
-    util.ByteStringBuffer.prototype.copy = function() {
-      var c = util.createBuffer(this.data);
+    util3.ByteStringBuffer.prototype.copy = function() {
+      var c = util3.createBuffer(this.data);
       c.read = this.read;
       return c;
     };
-    util.ByteStringBuffer.prototype.compact = function() {
+    util3.ByteStringBuffer.prototype.compact = function() {
       if (this.read > 0) {
         this.data = this.data.slice(this.read);
         this.read = 0;
       }
       return this;
     };
-    util.ByteStringBuffer.prototype.clear = function() {
+    util3.ByteStringBuffer.prototype.clear = function() {
       this.data = "";
       this.read = 0;
       return this;
     };
-    util.ByteStringBuffer.prototype.truncate = function(count) {
+    util3.ByteStringBuffer.prototype.truncate = function(count) {
       var len = Math.max(0, this.length() - count);
       this.data = this.data.substr(this.read, len);
       this.read = 0;
       return this;
     };
-    util.ByteStringBuffer.prototype.toHex = function() {
+    util3.ByteStringBuffer.prototype.toHex = function() {
       var rval = "";
       for (var i = this.read; i < this.data.length; ++i) {
         var b = this.data.charCodeAt(i);
@@ -127650,15 +127970,15 @@ var require_util16 = __commonJS({
       }
       return rval;
     };
-    util.ByteStringBuffer.prototype.toString = function() {
-      return util.decodeUtf8(this.bytes());
+    util3.ByteStringBuffer.prototype.toString = function() {
+      return util3.decodeUtf8(this.bytes());
     };
     function DataBuffer(b, options) {
       options = options || {};
       this.read = options.readOffset || 0;
       this.growSize = options.growSize || 1024;
-      var isArrayBuffer = util.isArrayBuffer(b);
-      var isArrayBufferView = util.isArrayBufferView(b);
+      var isArrayBuffer = util3.isArrayBuffer(b);
+      var isArrayBufferView = util3.isArrayBufferView(b);
       if (isArrayBuffer || isArrayBufferView) {
         if (isArrayBuffer) {
           this.data = new DataView(b);
@@ -127677,14 +127997,14 @@ var require_util16 = __commonJS({
         this.write = options.writeOffset;
       }
     }
-    util.DataBuffer = DataBuffer;
-    util.DataBuffer.prototype.length = function() {
+    util3.DataBuffer = DataBuffer;
+    util3.DataBuffer.prototype.length = function() {
       return this.write - this.read;
     };
-    util.DataBuffer.prototype.isEmpty = function() {
+    util3.DataBuffer.prototype.isEmpty = function() {
       return this.length() <= 0;
     };
-    util.DataBuffer.prototype.accommodate = function(amount, growSize) {
+    util3.DataBuffer.prototype.accommodate = function(amount, growSize) {
       if (this.length() >= amount) {
         return this;
       }
@@ -127699,20 +128019,20 @@ var require_util16 = __commonJS({
       this.data = new DataView(dst.buffer);
       return this;
     };
-    util.DataBuffer.prototype.putByte = function(b) {
+    util3.DataBuffer.prototype.putByte = function(b) {
       this.accommodate(1);
       this.data.setUint8(this.write++, b);
       return this;
     };
-    util.DataBuffer.prototype.fillWithByte = function(b, n) {
+    util3.DataBuffer.prototype.fillWithByte = function(b, n) {
       this.accommodate(n);
       for (var i = 0; i < n; ++i) {
         this.data.setUint8(b);
       }
       return this;
     };
-    util.DataBuffer.prototype.putBytes = function(bytes, encoding) {
-      if (util.isArrayBufferView(bytes)) {
+    util3.DataBuffer.prototype.putBytes = function(bytes, encoding) {
+      if (util3.isArrayBufferView(bytes)) {
         var src = new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
         var len = src.byteLength - src.byteOffset;
         this.accommodate(len);
@@ -127721,7 +128041,7 @@ var require_util16 = __commonJS({
         this.write += len;
         return this;
       }
-      if (util.isArrayBuffer(bytes)) {
+      if (util3.isArrayBuffer(bytes)) {
         var src = new Uint8Array(bytes);
         this.accommodate(src.byteLength);
         var dst = new Uint8Array(this.data.buffer);
@@ -127729,7 +128049,7 @@ var require_util16 = __commonJS({
         this.write += src.byteLength;
         return this;
       }
-      if (bytes instanceof util.DataBuffer || typeof bytes === "object" && typeof bytes.read === "number" && typeof bytes.write === "number" && util.isArrayBufferView(bytes.data)) {
+      if (bytes instanceof util3.DataBuffer || typeof bytes === "object" && typeof bytes.read === "number" && typeof bytes.write === "number" && util3.isArrayBufferView(bytes.data)) {
         var src = new Uint8Array(bytes.data.byteLength, bytes.read, bytes.length());
         this.accommodate(src.byteLength);
         var dst = new Uint8Array(bytes.data.byteLength, this.write);
@@ -127737,7 +128057,7 @@ var require_util16 = __commonJS({
         this.write += src.byteLength;
         return this;
       }
-      if (bytes instanceof util.ByteStringBuffer) {
+      if (bytes instanceof util3.ByteStringBuffer) {
         bytes = bytes.data;
         encoding = "binary";
       }
@@ -127747,82 +128067,82 @@ var require_util16 = __commonJS({
         if (encoding === "hex") {
           this.accommodate(Math.ceil(bytes.length / 2));
           view = new Uint8Array(this.data.buffer, this.write);
-          this.write += util.binary.hex.decode(bytes, view, this.write);
+          this.write += util3.binary.hex.decode(bytes, view, this.write);
           return this;
         }
         if (encoding === "base64") {
           this.accommodate(Math.ceil(bytes.length / 4) * 3);
           view = new Uint8Array(this.data.buffer, this.write);
-          this.write += util.binary.base64.decode(bytes, view, this.write);
+          this.write += util3.binary.base64.decode(bytes, view, this.write);
           return this;
         }
         if (encoding === "utf8") {
-          bytes = util.encodeUtf8(bytes);
+          bytes = util3.encodeUtf8(bytes);
           encoding = "binary";
         }
         if (encoding === "binary" || encoding === "raw") {
           this.accommodate(bytes.length);
           view = new Uint8Array(this.data.buffer, this.write);
-          this.write += util.binary.raw.decode(view);
+          this.write += util3.binary.raw.decode(view);
           return this;
         }
         if (encoding === "utf16") {
           this.accommodate(bytes.length * 2);
           view = new Uint16Array(this.data.buffer, this.write);
-          this.write += util.text.utf16.encode(view);
+          this.write += util3.text.utf16.encode(view);
           return this;
         }
         throw new Error("Invalid encoding: " + encoding);
       }
       throw Error("Invalid parameter: " + bytes);
     };
-    util.DataBuffer.prototype.putBuffer = function(buffer) {
+    util3.DataBuffer.prototype.putBuffer = function(buffer) {
       this.putBytes(buffer);
       buffer.clear();
       return this;
     };
-    util.DataBuffer.prototype.putString = function(str) {
+    util3.DataBuffer.prototype.putString = function(str) {
       return this.putBytes(str, "utf16");
     };
-    util.DataBuffer.prototype.putInt16 = function(i) {
+    util3.DataBuffer.prototype.putInt16 = function(i) {
       this.accommodate(2);
       this.data.setInt16(this.write, i);
       this.write += 2;
       return this;
     };
-    util.DataBuffer.prototype.putInt24 = function(i) {
+    util3.DataBuffer.prototype.putInt24 = function(i) {
       this.accommodate(3);
       this.data.setInt16(this.write, i >> 8 & 65535);
       this.data.setInt8(this.write, i >> 16 & 255);
       this.write += 3;
       return this;
     };
-    util.DataBuffer.prototype.putInt32 = function(i) {
+    util3.DataBuffer.prototype.putInt32 = function(i) {
       this.accommodate(4);
       this.data.setInt32(this.write, i);
       this.write += 4;
       return this;
     };
-    util.DataBuffer.prototype.putInt16Le = function(i) {
+    util3.DataBuffer.prototype.putInt16Le = function(i) {
       this.accommodate(2);
       this.data.setInt16(this.write, i, true);
       this.write += 2;
       return this;
     };
-    util.DataBuffer.prototype.putInt24Le = function(i) {
+    util3.DataBuffer.prototype.putInt24Le = function(i) {
       this.accommodate(3);
       this.data.setInt8(this.write, i >> 16 & 255);
       this.data.setInt16(this.write, i >> 8 & 65535, true);
       this.write += 3;
       return this;
     };
-    util.DataBuffer.prototype.putInt32Le = function(i) {
+    util3.DataBuffer.prototype.putInt32Le = function(i) {
       this.accommodate(4);
       this.data.setInt32(this.write, i, true);
       this.write += 4;
       return this;
     };
-    util.DataBuffer.prototype.putInt = function(i, n) {
+    util3.DataBuffer.prototype.putInt = function(i, n) {
       _checkBitsParam(n);
       this.accommodate(n / 8);
       do {
@@ -127831,7 +128151,7 @@ var require_util16 = __commonJS({
       } while (n > 0);
       return this;
     };
-    util.DataBuffer.prototype.putSignedInt = function(i, n) {
+    util3.DataBuffer.prototype.putSignedInt = function(i, n) {
       _checkBitsParam(n);
       this.accommodate(n / 8);
       if (i < 0) {
@@ -127839,40 +128159,40 @@ var require_util16 = __commonJS({
       }
       return this.putInt(i, n);
     };
-    util.DataBuffer.prototype.getByte = function() {
+    util3.DataBuffer.prototype.getByte = function() {
       return this.data.getInt8(this.read++);
     };
-    util.DataBuffer.prototype.getInt16 = function() {
+    util3.DataBuffer.prototype.getInt16 = function() {
       var rval = this.data.getInt16(this.read);
       this.read += 2;
       return rval;
     };
-    util.DataBuffer.prototype.getInt24 = function() {
+    util3.DataBuffer.prototype.getInt24 = function() {
       var rval = this.data.getInt16(this.read) << 8 ^ this.data.getInt8(this.read + 2);
       this.read += 3;
       return rval;
     };
-    util.DataBuffer.prototype.getInt32 = function() {
+    util3.DataBuffer.prototype.getInt32 = function() {
       var rval = this.data.getInt32(this.read);
       this.read += 4;
       return rval;
     };
-    util.DataBuffer.prototype.getInt16Le = function() {
+    util3.DataBuffer.prototype.getInt16Le = function() {
       var rval = this.data.getInt16(this.read, true);
       this.read += 2;
       return rval;
     };
-    util.DataBuffer.prototype.getInt24Le = function() {
+    util3.DataBuffer.prototype.getInt24Le = function() {
       var rval = this.data.getInt8(this.read) ^ this.data.getInt16(this.read + 1, true) << 8;
       this.read += 3;
       return rval;
     };
-    util.DataBuffer.prototype.getInt32Le = function() {
+    util3.DataBuffer.prototype.getInt32Le = function() {
       var rval = this.data.getInt32(this.read, true);
       this.read += 4;
       return rval;
     };
-    util.DataBuffer.prototype.getInt = function(n) {
+    util3.DataBuffer.prototype.getInt = function(n) {
       _checkBitsParam(n);
       var rval = 0;
       do {
@@ -127881,7 +128201,7 @@ var require_util16 = __commonJS({
       } while (n > 0);
       return rval;
     };
-    util.DataBuffer.prototype.getSignedInt = function(n) {
+    util3.DataBuffer.prototype.getSignedInt = function(n) {
       var x = this.getInt(n);
       var max = 2 << n - 2;
       if (x >= max) {
@@ -127889,7 +128209,7 @@ var require_util16 = __commonJS({
       }
       return x;
     };
-    util.DataBuffer.prototype.getBytes = function(count) {
+    util3.DataBuffer.prototype.getBytes = function(count) {
       var rval;
       if (count) {
         count = Math.min(this.length(), count);
@@ -127903,23 +128223,23 @@ var require_util16 = __commonJS({
       }
       return rval;
     };
-    util.DataBuffer.prototype.bytes = function(count) {
+    util3.DataBuffer.prototype.bytes = function(count) {
       return typeof count === "undefined" ? this.data.slice(this.read) : this.data.slice(this.read, this.read + count);
     };
-    util.DataBuffer.prototype.at = function(i) {
+    util3.DataBuffer.prototype.at = function(i) {
       return this.data.getUint8(this.read + i);
     };
-    util.DataBuffer.prototype.setAt = function(i, b) {
+    util3.DataBuffer.prototype.setAt = function(i, b) {
       this.data.setUint8(i, b);
       return this;
     };
-    util.DataBuffer.prototype.last = function() {
+    util3.DataBuffer.prototype.last = function() {
       return this.data.getUint8(this.write - 1);
     };
-    util.DataBuffer.prototype.copy = function() {
-      return new util.DataBuffer(this);
+    util3.DataBuffer.prototype.copy = function() {
+      return new util3.DataBuffer(this);
     };
-    util.DataBuffer.prototype.compact = function() {
+    util3.DataBuffer.prototype.compact = function() {
       if (this.read > 0) {
         var src = new Uint8Array(this.data.buffer, this.read);
         var dst = new Uint8Array(src.byteLength);
@@ -127930,17 +128250,17 @@ var require_util16 = __commonJS({
       }
       return this;
     };
-    util.DataBuffer.prototype.clear = function() {
+    util3.DataBuffer.prototype.clear = function() {
       this.data = new DataView(new ArrayBuffer(0));
       this.read = this.write = 0;
       return this;
     };
-    util.DataBuffer.prototype.truncate = function(count) {
+    util3.DataBuffer.prototype.truncate = function(count) {
       this.write = Math.max(0, this.length() - count);
       this.read = Math.min(this.read, this.write);
       return this;
     };
-    util.DataBuffer.prototype.toHex = function() {
+    util3.DataBuffer.prototype.toHex = function() {
       var rval = "";
       for (var i = this.read; i < this.data.byteLength; ++i) {
         var b = this.data.getUint8(i);
@@ -127951,34 +128271,34 @@ var require_util16 = __commonJS({
       }
       return rval;
     };
-    util.DataBuffer.prototype.toString = function(encoding) {
+    util3.DataBuffer.prototype.toString = function(encoding) {
       var view = new Uint8Array(this.data, this.read, this.length());
       encoding = encoding || "utf8";
       if (encoding === "binary" || encoding === "raw") {
-        return util.binary.raw.encode(view);
+        return util3.binary.raw.encode(view);
       }
       if (encoding === "hex") {
-        return util.binary.hex.encode(view);
+        return util3.binary.hex.encode(view);
       }
       if (encoding === "base64") {
-        return util.binary.base64.encode(view);
+        return util3.binary.base64.encode(view);
       }
       if (encoding === "utf8") {
-        return util.text.utf8.decode(view);
+        return util3.text.utf8.decode(view);
       }
       if (encoding === "utf16") {
-        return util.text.utf16.decode(view);
+        return util3.text.utf16.decode(view);
       }
       throw new Error("Invalid encoding: " + encoding);
     };
-    util.createBuffer = function(input, encoding) {
+    util3.createBuffer = function(input, encoding) {
       encoding = encoding || "raw";
       if (input !== void 0 && encoding === "utf8") {
-        input = util.encodeUtf8(input);
+        input = util3.encodeUtf8(input);
       }
-      return new util.ByteBuffer(input);
+      return new util3.ByteBuffer(input);
     };
-    util.fillString = function(c, n) {
+    util3.fillString = function(c, n) {
       var s = "";
       while (n > 0) {
         if (n & 1) {
@@ -127991,7 +128311,7 @@ var require_util16 = __commonJS({
       }
       return s;
     };
-    util.xorBytes = function(s1, s2, n) {
+    util3.xorBytes = function(s1, s2, n) {
       var s3 = "";
       var b = "";
       var t = "";
@@ -128010,7 +128330,7 @@ var require_util16 = __commonJS({
       s3 += t;
       return s3;
     };
-    util.hexToBytes = function(hex) {
+    util3.hexToBytes = function(hex) {
       var rval = "";
       var i = 0;
       if (hex.length & true) {
@@ -128022,10 +128342,10 @@ var require_util16 = __commonJS({
       }
       return rval;
     };
-    util.bytesToHex = function(bytes) {
-      return util.createBuffer(bytes).toHex();
+    util3.bytesToHex = function(bytes) {
+      return util3.createBuffer(bytes).toHex();
     };
-    util.int32ToBytes = function(i) {
+    util3.int32ToBytes = function(i) {
       return String.fromCharCode(i >> 24 & 255) + String.fromCharCode(i >> 16 & 255) + String.fromCharCode(i >> 8 & 255) + String.fromCharCode(i & 255);
     };
     var _base64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
@@ -128124,7 +128444,7 @@ var require_util16 = __commonJS({
       51
     ];
     var _base58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-    util.encode64 = function(input, maxline) {
+    util3.encode64 = function(input, maxline) {
       var line = "";
       var output = "";
       var chr1, chr2, chr3;
@@ -128149,7 +128469,7 @@ var require_util16 = __commonJS({
       output += line;
       return output;
     };
-    util.decode64 = function(input) {
+    util3.decode64 = function(input) {
       input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
       var output = "";
       var enc1, enc2, enc3, enc4;
@@ -128169,13 +128489,13 @@ var require_util16 = __commonJS({
       }
       return output;
     };
-    util.encodeUtf8 = function(str) {
+    util3.encodeUtf8 = function(str) {
       return unescape(encodeURIComponent(str));
     };
-    util.decodeUtf8 = function(str) {
+    util3.decodeUtf8 = function(str) {
       return decodeURIComponent(escape(str));
     };
-    util.binary = {
+    util3.binary = {
       raw: {},
       hex: {},
       base64: {},
@@ -128185,10 +128505,10 @@ var require_util16 = __commonJS({
         decode: baseN.decode
       }
     };
-    util.binary.raw.encode = function(bytes) {
+    util3.binary.raw.encode = function(bytes) {
       return String.fromCharCode.apply(null, bytes);
     };
-    util.binary.raw.decode = function(str, output, offset) {
+    util3.binary.raw.decode = function(str, output, offset) {
       var out = output;
       if (!out) {
         out = new Uint8Array(str.length);
@@ -128200,8 +128520,8 @@ var require_util16 = __commonJS({
       }
       return output ? j - offset : out;
     };
-    util.binary.hex.encode = util.bytesToHex;
-    util.binary.hex.decode = function(hex, output, offset) {
+    util3.binary.hex.encode = util3.bytesToHex;
+    util3.binary.hex.decode = function(hex, output, offset) {
       var out = output;
       if (!out) {
         out = new Uint8Array(Math.ceil(hex.length / 2));
@@ -128217,7 +128537,7 @@ var require_util16 = __commonJS({
       }
       return output ? j - offset : out;
     };
-    util.binary.base64.encode = function(input, maxline) {
+    util3.binary.base64.encode = function(input, maxline) {
       var line = "";
       var output = "";
       var chr1, chr2, chr3;
@@ -128242,7 +128562,7 @@ var require_util16 = __commonJS({
       output += line;
       return output;
     };
-    util.binary.base64.decode = function(input, output, offset) {
+    util3.binary.base64.decode = function(input, output, offset) {
       var out = output;
       if (!out) {
         out = new Uint8Array(Math.ceil(input.length / 4) * 3);
@@ -128266,18 +128586,18 @@ var require_util16 = __commonJS({
       }
       return output ? j - offset : out.subarray(0, j);
     };
-    util.binary.base58.encode = function(input, maxline) {
-      return util.binary.baseN.encode(input, _base58, maxline);
+    util3.binary.base58.encode = function(input, maxline) {
+      return util3.binary.baseN.encode(input, _base58, maxline);
     };
-    util.binary.base58.decode = function(input, maxline) {
-      return util.binary.baseN.decode(input, _base58, maxline);
+    util3.binary.base58.decode = function(input, maxline) {
+      return util3.binary.baseN.decode(input, _base58, maxline);
     };
-    util.text = {
+    util3.text = {
       utf8: {},
       utf16: {}
     };
-    util.text.utf8.encode = function(str, output, offset) {
-      str = util.encodeUtf8(str);
+    util3.text.utf8.encode = function(str, output, offset) {
+      str = util3.encodeUtf8(str);
       var out = output;
       if (!out) {
         out = new Uint8Array(str.length);
@@ -128289,10 +128609,10 @@ var require_util16 = __commonJS({
       }
       return output ? j - offset : out;
     };
-    util.text.utf8.decode = function(bytes) {
-      return util.decodeUtf8(String.fromCharCode.apply(null, bytes));
+    util3.text.utf8.decode = function(bytes) {
+      return util3.decodeUtf8(String.fromCharCode.apply(null, bytes));
     };
-    util.text.utf16.encode = function(str, output, offset) {
+    util3.text.utf16.encode = function(str, output, offset) {
       var out = output;
       if (!out) {
         out = new Uint8Array(str.length * 2);
@@ -128307,11 +128627,11 @@ var require_util16 = __commonJS({
       }
       return output ? j - offset : out;
     };
-    util.text.utf16.decode = function(bytes) {
+    util3.text.utf16.decode = function(bytes) {
       return String.fromCharCode.apply(null, new Uint16Array(bytes.buffer));
     };
-    util.deflate = function(api, bytes, raw) {
-      bytes = util.decode64(api.deflate(util.encode64(bytes)).rval);
+    util3.deflate = function(api, bytes, raw) {
+      bytes = util3.decode64(api.deflate(util3.encode64(bytes)).rval);
       if (raw) {
         var start = 2;
         var flg = bytes.charCodeAt(1);
@@ -128322,9 +128642,9 @@ var require_util16 = __commonJS({
       }
       return bytes;
     };
-    util.inflate = function(api, bytes, raw) {
-      var rval = api.inflate(util.encode64(bytes)).rval;
-      return rval === null ? null : util.decode64(rval);
+    util3.inflate = function(api, bytes, raw) {
+      var rval = api.inflate(util3.encode64(bytes)).rval;
+      return rval === null ? null : util3.decode64(rval);
     };
     var _setStorageObject = function(api, id, obj) {
       if (!api) {
@@ -128334,7 +128654,7 @@ var require_util16 = __commonJS({
       if (obj === null) {
         rval = api.removeItem(id);
       } else {
-        obj = util.encode64(JSON.stringify(obj));
+        obj = util3.encode64(JSON.stringify(obj));
         rval = api.setItem(id, obj);
       }
       if (typeof rval !== "undefined" && rval.rval !== true) {
@@ -128363,7 +128683,7 @@ var require_util16 = __commonJS({
         }
       }
       if (rval !== null) {
-        rval = JSON.parse(util.decode64(rval));
+        rval = JSON.parse(util3.decode64(rval));
       }
       return rval;
     };
@@ -128435,19 +128755,19 @@ var require_util16 = __commonJS({
       }
       return rval;
     };
-    util.setItem = function(api, id, key, data, location) {
+    util3.setItem = function(api, id, key, data, location) {
       _callStorageFunction(_setItem, arguments, location);
     };
-    util.getItem = function(api, id, key, location) {
+    util3.getItem = function(api, id, key, location) {
       return _callStorageFunction(_getItem, arguments, location);
     };
-    util.removeItem = function(api, id, key, location) {
+    util3.removeItem = function(api, id, key, location) {
       _callStorageFunction(_removeItem, arguments, location);
     };
-    util.clearItems = function(api, id, location) {
+    util3.clearItems = function(api, id, location) {
       _callStorageFunction(_clearItems, arguments, location);
     };
-    util.isEmpty = function(obj) {
+    util3.isEmpty = function(obj) {
       for (var prop in obj) {
         if (obj.hasOwnProperty(prop)) {
           return false;
@@ -128455,20 +128775,20 @@ var require_util16 = __commonJS({
       }
       return true;
     };
-    util.format = function(format) {
+    util3.format = function(format) {
       var re = /%./g;
-      var match;
+      var match2;
       var part;
       var argi = 0;
       var parts = [];
       var last = 0;
-      while (match = re.exec(format)) {
+      while (match2 = re.exec(format)) {
         part = format.substring(last, re.lastIndex - 2);
         if (part.length > 0) {
           parts.push(part);
         }
         last = re.lastIndex;
-        var code = match[0][1];
+        var code = match2[0][1];
         switch (code) {
           case "s":
           case "o":
@@ -128491,7 +128811,7 @@ var require_util16 = __commonJS({
       parts.push(format.substring(last));
       return parts.join("");
     };
-    util.formatNumber = function(number, decimals, dec_point, thousands_sep) {
+    util3.formatNumber = function(number, decimals, dec_point, thousands_sep) {
       var n = number, c = isNaN(decimals = Math.abs(decimals)) ? 2 : decimals;
       var d = dec_point === void 0 ? "," : dec_point;
       var t = thousands_sep === void 0 ? "." : thousands_sep, s = n < 0 ? "-" : "";
@@ -128499,33 +128819,33 @@ var require_util16 = __commonJS({
       var j = i.length > 3 ? i.length % 3 : 0;
       return s + (j ? i.substr(0, j) + t : "") + i.substr(j).replace(/(\d{3})(?=\d)/g, "$1" + t) + (c ? d + Math.abs(n - i).toFixed(c).slice(2) : "");
     };
-    util.formatSize = function(size) {
+    util3.formatSize = function(size) {
       if (size >= 1073741824) {
-        size = util.formatNumber(size / 1073741824, 2, ".", "") + " GiB";
+        size = util3.formatNumber(size / 1073741824, 2, ".", "") + " GiB";
       } else if (size >= 1048576) {
-        size = util.formatNumber(size / 1048576, 2, ".", "") + " MiB";
+        size = util3.formatNumber(size / 1048576, 2, ".", "") + " MiB";
       } else if (size >= 1024) {
-        size = util.formatNumber(size / 1024, 0) + " KiB";
+        size = util3.formatNumber(size / 1024, 0) + " KiB";
       } else {
-        size = util.formatNumber(size, 0) + " bytes";
+        size = util3.formatNumber(size, 0) + " bytes";
       }
       return size;
     };
-    util.bytesFromIP = function(ip) {
+    util3.bytesFromIP = function(ip) {
       if (ip.indexOf(".") !== -1) {
-        return util.bytesFromIPv4(ip);
+        return util3.bytesFromIPv4(ip);
       }
       if (ip.indexOf(":") !== -1) {
-        return util.bytesFromIPv6(ip);
+        return util3.bytesFromIPv6(ip);
       }
       return null;
     };
-    util.bytesFromIPv4 = function(ip) {
+    util3.bytesFromIPv4 = function(ip) {
       ip = ip.split(".");
       if (ip.length !== 4) {
         return null;
       }
-      var b = util.createBuffer();
+      var b = util3.createBuffer();
       for (var i = 0; i < ip.length; ++i) {
         var num = parseInt(ip[i], 10);
         if (isNaN(num)) {
@@ -128535,21 +128855,21 @@ var require_util16 = __commonJS({
       }
       return b.getBytes();
     };
-    util.bytesFromIPv6 = function(ip) {
+    util3.bytesFromIPv6 = function(ip) {
       var blanks = 0;
       ip = ip.split(":").filter(function(e) {
         if (e.length === 0) ++blanks;
         return true;
       });
       var zeros = (8 - ip.length + blanks) * 2;
-      var b = util.createBuffer();
+      var b = util3.createBuffer();
       for (var i = 0; i < 8; ++i) {
         if (!ip[i] || ip[i].length === 0) {
           b.fillWithByte(0, zeros);
           zeros = 0;
           continue;
         }
-        var bytes = util.hexToBytes(ip[i]);
+        var bytes = util3.hexToBytes(ip[i]);
         if (bytes.length < 2) {
           b.putByte(0);
         }
@@ -128557,16 +128877,16 @@ var require_util16 = __commonJS({
       }
       return b.getBytes();
     };
-    util.bytesToIP = function(bytes) {
+    util3.bytesToIP = function(bytes) {
       if (bytes.length === 4) {
-        return util.bytesToIPv4(bytes);
+        return util3.bytesToIPv4(bytes);
       }
       if (bytes.length === 16) {
-        return util.bytesToIPv6(bytes);
+        return util3.bytesToIPv6(bytes);
       }
       return null;
     };
-    util.bytesToIPv4 = function(bytes) {
+    util3.bytesToIPv4 = function(bytes) {
       if (bytes.length !== 4) {
         return null;
       }
@@ -128576,7 +128896,7 @@ var require_util16 = __commonJS({
       }
       return ip.join(".");
     };
-    util.bytesToIPv6 = function(bytes) {
+    util3.bytesToIPv6 = function(bytes) {
       if (bytes.length !== 16) {
         return null;
       }
@@ -128584,7 +128904,7 @@ var require_util16 = __commonJS({
       var zeroGroups = [];
       var zeroMaxGroup = 0;
       for (var i = 0; i < bytes.length; i += 2) {
-        var hex = util.bytesToHex(bytes[i] + bytes[i + 1]);
+        var hex = util3.bytesToHex(bytes[i] + bytes[i + 1]);
         while (hex[0] === "0" && hex !== "0") {
           hex = hex.substr(1);
         }
@@ -128616,26 +128936,26 @@ var require_util16 = __commonJS({
       }
       return ip.join(":");
     };
-    util.estimateCores = function(options, callback) {
+    util3.estimateCores = function(options, callback) {
       if (typeof options === "function") {
         callback = options;
         options = {};
       }
       options = options || {};
-      if ("cores" in util && !options.update) {
-        return callback(null, util.cores);
+      if ("cores" in util3 && !options.update) {
+        return callback(null, util3.cores);
       }
       if (typeof navigator !== "undefined" && "hardwareConcurrency" in navigator && navigator.hardwareConcurrency > 0) {
-        util.cores = navigator.hardwareConcurrency;
-        return callback(null, util.cores);
+        util3.cores = navigator.hardwareConcurrency;
+        return callback(null, util3.cores);
       }
       if (typeof Worker === "undefined") {
-        util.cores = 1;
-        return callback(null, util.cores);
+        util3.cores = 1;
+        return callback(null, util3.cores);
       }
       if (typeof Blob === "undefined") {
-        util.cores = 2;
-        return callback(null, util.cores);
+        util3.cores = 2;
+        return callback(null, util3.cores);
       }
       var blobUrl = URL.createObjectURL(new Blob([
         "(",
@@ -128655,9 +128975,9 @@ var require_util16 = __commonJS({
           var avg = Math.floor(max.reduce(function(avg2, x) {
             return avg2 + x;
           }, 0) / max.length);
-          util.cores = Math.max(1, avg);
+          util3.cores = Math.max(1, avg);
           URL.revokeObjectURL(blobUrl);
-          return callback(null, util.cores);
+          return callback(null, util3.cores);
         }
         map(numWorkers, function(err, results) {
           max.push(reduce(numWorkers, results));
@@ -131141,13 +131461,13 @@ var require_pem = __commonJS({
       var rMessage = /\s*-----BEGIN ([A-Z0-9- ]+)-----\r?\n?([\x21-\x7e\s]+?(?:\r?\n\r?\n))?([:A-Za-z0-9+\/=\s]+?)-----END \1-----/g;
       var rHeader = /([\x21-\x7e]+):\s*([\x21-\x7e\s^:]+)/;
       var rCRLF = /\r?\n/;
-      var match;
+      var match2;
       while (true) {
-        match = rMessage.exec(str);
-        if (!match) {
+        match2 = rMessage.exec(str);
+        if (!match2) {
           break;
         }
-        var type = match[1];
+        var type = match2[1];
         if (type === "NEW CERTIFICATE REQUEST") {
           type = "CERTIFICATE REQUEST";
         }
@@ -131157,15 +131477,15 @@ var require_pem = __commonJS({
           contentDomain: null,
           dekInfo: null,
           headers: [],
-          body: forge.util.decode64(match[3])
+          body: forge.util.decode64(match2[3])
         };
         rval.push(msg);
-        if (!match[2]) {
+        if (!match2[2]) {
           continue;
         }
-        var lines = match[2].split(rCRLF);
+        var lines = match2[2].split(rCRLF);
         var li = 0;
-        while (match && li < lines.length) {
+        while (match2 && li < lines.length) {
           var line = lines[li].replace(/\s+$/, "");
           for (var nl = li + 1; nl < lines.length; ++nl) {
             var next = lines[nl];
@@ -131175,10 +131495,10 @@ var require_pem = __commonJS({
             line += next;
             li = nl;
           }
-          match = line.match(rHeader);
-          if (match) {
-            var header = { name: match[1], values: [] };
-            var values = match[2].split(",");
+          match2 = line.match(rHeader);
+          if (match2) {
+            var header = { name: match2[1], values: [] };
+            var values = match2[2].split(",");
             for (var vi = 0; vi < values.length; ++vi) {
               header.values.push(ltrim(values[vi]));
             }
@@ -131214,7 +131534,7 @@ var require_pem = __commonJS({
     function foldHeader(header) {
       var rval = header.name + ": ";
       var values = [];
-      var insertSpace = function(match, $1) {
+      var insertSpace = function(match2, $1) {
         return " " + $1;
       };
       for (var i = 0; i < header.values.length; ++i) {
@@ -134142,19 +134462,19 @@ var require_pkcs1 = __commonJS({
         error3 |= lHash.charAt(i) !== lHashPrime.charAt(i);
       }
       var in_ps = 1;
-      var index = md2.digestLength;
+      var index2 = md2.digestLength;
       for (var j = md2.digestLength; j < db.length; j++) {
         var code = db.charCodeAt(j);
         var is_0 = code & 1 ^ 1;
         var error_mask = in_ps ? 65534 : 0;
         error3 |= code & error_mask;
         in_ps = in_ps & is_0;
-        index += in_ps;
+        index2 += in_ps;
       }
-      if (error3 || db.charCodeAt(index) !== 1) {
+      if (error3 || db.charCodeAt(index2) !== 1) {
         throw new Error("Invalid RSAES-OAEP padding.");
       }
-      return db.substring(index + 1);
+      return db.substring(index2 + 1);
     };
     function rsa_mgf1(seed, maskLength, hash2) {
       if (!hash2) {
@@ -134265,7 +134585,7 @@ var require_prime = __commonJS({
         var num = generateRandom(bits, rng2);
         var numWorkers = options.workers;
         var workLoad = options.workLoad || 100;
-        var range = workLoad * 30 / 8;
+        var range2 = workLoad * 30 / 8;
         var workerScript = options.workerScript || "forge/prime.worker.js";
         if (numWorkers === -1) {
           return forge.util.estimateCores(function(err, cores) {
@@ -134309,7 +134629,7 @@ var require_prime = __commonJS({
               hex,
               workLoad
             });
-            num.dAddOffset(range, 0);
+            num.dAddOffset(range2, 0);
           }
         }
       }
@@ -134357,7 +134677,7 @@ var require_rsa = __commonJS({
     var BigInteger;
     var _crypto = forge.util.isNodejs ? require("crypto") : null;
     var asn1 = forge.asn1;
-    var util = forge.util;
+    var util3 = forge.util;
     forge.pki = forge.pki || {};
     module2.exports = forge.pki.rsa = forge.rsa = forge.rsa || {};
     var pki2 = forge.pki;
@@ -134897,13 +135217,13 @@ var require_rsa = __commonJS({
             });
           }
           if (_detectSubtleCrypto("generateKey") && _detectSubtleCrypto("exportKey")) {
-            return util.globalScope.crypto.subtle.generateKey({
+            return util3.globalScope.crypto.subtle.generateKey({
               name: "RSASSA-PKCS1-v1_5",
               modulusLength: bits,
               publicExponent: _intToUint8Array(e),
               hash: { name: "SHA-256" }
             }, true, ["sign", "verify"]).then(function(pair) {
-              return util.globalScope.crypto.subtle.exportKey(
+              return util3.globalScope.crypto.subtle.exportKey(
                 "pkcs8",
                 pair.privateKey
               );
@@ -134922,7 +135242,7 @@ var require_rsa = __commonJS({
             });
           }
           if (_detectSubtleMsCrypto("generateKey") && _detectSubtleMsCrypto("exportKey")) {
-            var genOp = util.globalScope.msCrypto.subtle.generateKey({
+            var genOp = util3.globalScope.msCrypto.subtle.generateKey({
               name: "RSASSA-PKCS1-v1_5",
               modulusLength: bits,
               publicExponent: _intToUint8Array(e),
@@ -134930,7 +135250,7 @@ var require_rsa = __commonJS({
             }, true, ["sign", "verify"]);
             genOp.oncomplete = function(e2) {
               var pair = e2.target.result;
-              var exportOp = util.globalScope.msCrypto.subtle.exportKey(
+              var exportOp = util3.globalScope.msCrypto.subtle.exportKey(
                 "pkcs8",
                 pair.privateKey
               );
@@ -135525,10 +135845,10 @@ var require_rsa = __commonJS({
       return forge.util.isNodejs && typeof _crypto[fn] === "function";
     }
     function _detectSubtleCrypto(fn) {
-      return typeof util.globalScope !== "undefined" && typeof util.globalScope.crypto === "object" && typeof util.globalScope.crypto.subtle === "object" && typeof util.globalScope.crypto.subtle[fn] === "function";
+      return typeof util3.globalScope !== "undefined" && typeof util3.globalScope.crypto === "object" && typeof util3.globalScope.crypto.subtle === "object" && typeof util3.globalScope.crypto.subtle[fn] === "function";
     }
     function _detectSubtleMsCrypto(fn) {
-      return typeof util.globalScope !== "undefined" && typeof util.globalScope.msCrypto === "object" && typeof util.globalScope.msCrypto.subtle === "object" && typeof util.globalScope.msCrypto.subtle[fn] === "function";
+      return typeof util3.globalScope !== "undefined" && typeof util3.globalScope.msCrypto === "object" && typeof util3.globalScope.msCrypto.subtle === "object" && typeof util3.globalScope.msCrypto.subtle[fn] === "function";
     }
     function _intToUint8Array(x) {
       var bytes = forge.util.hexToBytes(x.toString(16));
@@ -137516,13 +137836,13 @@ var require_x509 = __commonJS({
           options = { name: options };
         }
         var rval = null;
-        var ext;
+        var ext2;
         for (var i = 0; rval === null && i < cert.extensions.length; ++i) {
-          ext = cert.extensions[i];
-          if (options.id && ext.id === options.id) {
-            rval = ext;
-          } else if (options.name && ext.name === options.name) {
-            rval = ext;
+          ext2 = cert.extensions[i];
+          if (options.id && ext2.id === options.id) {
+            rval = ext2;
+          } else if (options.name && ext2.name === options.name) {
+            rval = ext2;
           }
         }
         return rval;
@@ -137600,10 +137920,10 @@ var require_x509 = __commonJS({
       cert.verifySubjectKeyIdentifier = function() {
         var oid = oids["subjectKeyIdentifier"];
         for (var i = 0; i < cert.extensions.length; ++i) {
-          var ext = cert.extensions[i];
-          if (ext.id === oid) {
+          var ext2 = cert.extensions[i];
+          if (ext2.id === oid) {
             var ski = cert.generateSubjectKeyIdentifier().getBytes();
-            return forge.util.hexToBytes(ext.subjectKeyIdentifier) === ski;
+            return forge.util.hexToBytes(ext2.subjectKeyIdentifier) === ski;
           }
         }
         return false;
@@ -137721,15 +138041,15 @@ var require_x509 = __commonJS({
       }
       return rval;
     };
-    pki2.certificateExtensionFromAsn1 = function(ext) {
+    pki2.certificateExtensionFromAsn1 = function(ext2) {
       var e = {};
-      e.id = asn1.derToOid(ext.value[0].value);
+      e.id = asn1.derToOid(ext2.value[0].value);
       e.critical = false;
-      if (ext.value[1].type === asn1.Type.BOOLEAN) {
-        e.critical = ext.value[1].value.charCodeAt(0) !== 0;
-        e.value = ext.value[2].value;
+      if (ext2.value[1].type === asn1.Type.BOOLEAN) {
+        e.critical = ext2.value[1].value.charCodeAt(0) !== 0;
+        e.value = ext2.value[2].value;
       } else {
-        e.value = ext.value[1].value;
+        e.value = ext2.value[1].value;
       }
       if (e.id in oids) {
         e.name = oids[e.id];
@@ -138588,15 +138908,15 @@ var require_x509 = __commonJS({
       }
       return rval;
     };
-    pki2.certificateExtensionToAsn1 = function(ext) {
+    pki2.certificateExtensionToAsn1 = function(ext2) {
       var extseq = asn1.create(asn1.Class.UNIVERSAL, asn1.Type.SEQUENCE, true, []);
       extseq.value.push(asn1.create(
         asn1.Class.UNIVERSAL,
         asn1.Type.OID,
         false,
-        asn1.oidToDer(ext.id).getBytes()
+        asn1.oidToDer(ext2.id).getBytes()
       ));
-      if (ext.critical) {
+      if (ext2.critical) {
         extseq.value.push(asn1.create(
           asn1.Class.UNIVERSAL,
           asn1.Type.BOOLEAN,
@@ -138604,8 +138924,8 @@ var require_x509 = __commonJS({
           String.fromCharCode(255)
         ));
       }
-      var value = ext.value;
-      if (typeof ext.value !== "string") {
+      var value = ext2.value;
+      if (typeof ext2.value !== "string") {
         value = asn1.toDer(value).getBytes();
       }
       extseq.value.push(asn1.create(
@@ -138673,16 +138993,16 @@ var require_x509 = __commonJS({
         if (typeof cert2 === "string") {
           cert2 = forge.pki.certificateFromPem(cert2);
         }
-        var match = getBySubject(cert2.subject);
-        if (!match) {
+        var match2 = getBySubject(cert2.subject);
+        if (!match2) {
           return false;
         }
-        if (!forge.util.isArray(match)) {
-          match = [match];
+        if (!forge.util.isArray(match2)) {
+          match2 = [match2];
         }
         var der1 = asn1.toDer(pki2.certificateToAsn1(cert2)).getBytes();
-        for (var i2 = 0; i2 < match.length; ++i2) {
-          var der2 = asn1.toDer(pki2.certificateToAsn1(match[i2])).getBytes();
+        for (var i2 = 0; i2 < match2.length; ++i2) {
+          var der2 = asn1.toDer(pki2.certificateToAsn1(match2[i2])).getBytes();
           if (der1 === der2) {
             return true;
           }
@@ -138714,21 +139034,21 @@ var require_x509 = __commonJS({
         if (!caStore.hasCertificate(cert2)) {
           return null;
         }
-        var match = getBySubject(cert2.subject);
-        if (!forge.util.isArray(match)) {
+        var match2 = getBySubject(cert2.subject);
+        if (!forge.util.isArray(match2)) {
           result = caStore.certs[cert2.subject.hash];
           delete caStore.certs[cert2.subject.hash];
           return result;
         }
         var der1 = asn1.toDer(pki2.certificateToAsn1(cert2)).getBytes();
-        for (var i2 = 0; i2 < match.length; ++i2) {
-          var der2 = asn1.toDer(pki2.certificateToAsn1(match[i2])).getBytes();
+        for (var i2 = 0; i2 < match2.length; ++i2) {
+          var der2 = asn1.toDer(pki2.certificateToAsn1(match2[i2])).getBytes();
           if (der1 === der2) {
-            result = match[i2];
-            match.splice(i2, 1);
+            result = match2[i2];
+            match2.splice(i2, 1);
           }
         }
-        if (match.length === 0) {
+        if (match2.length === 0) {
           delete caStore.certs[cert2.subject.hash];
         }
         return result;
@@ -138838,8 +139158,8 @@ var require_x509 = __commonJS({
             basicConstraints: true
           };
           for (var i = 0; error3 === null && i < cert.extensions.length; ++i) {
-            var ext = cert.extensions[i];
-            if (ext.critical && !(ext.name in se)) {
+            var ext2 = cert.extensions[i];
+            if (ext2.critical && !(ext2.name in se)) {
               error3 = {
                 message: "Certificate has an unsupported critical extension.",
                 error: pki2.certificateError.unsupported_certificate
@@ -139137,20 +139457,20 @@ var require_pkcs12 = __commonJS({
          *           attribute was given but a bag type, the map key will be the
          *           bag type.
          */
-        getBags: function(filter) {
+        getBags: function(filter2) {
           var rval = {};
           var localKeyId;
-          if ("localKeyId" in filter) {
-            localKeyId = filter.localKeyId;
-          } else if ("localKeyIdHex" in filter) {
-            localKeyId = forge.util.hexToBytes(filter.localKeyIdHex);
+          if ("localKeyId" in filter2) {
+            localKeyId = filter2.localKeyId;
+          } else if ("localKeyIdHex" in filter2) {
+            localKeyId = forge.util.hexToBytes(filter2.localKeyIdHex);
           }
-          if (localKeyId === void 0 && !("friendlyName" in filter) && "bagType" in filter) {
-            rval[filter.bagType] = _getBagsByAttribute(
+          if (localKeyId === void 0 && !("friendlyName" in filter2) && "bagType" in filter2) {
+            rval[filter2.bagType] = _getBagsByAttribute(
               pfx.safeContents,
               null,
               null,
-              filter.bagType
+              filter2.bagType
             );
           }
           if (localKeyId !== void 0) {
@@ -139158,15 +139478,15 @@ var require_pkcs12 = __commonJS({
               pfx.safeContents,
               "localKeyId",
               localKeyId,
-              filter.bagType
+              filter2.bagType
             );
           }
-          if ("friendlyName" in filter) {
+          if ("friendlyName" in filter2) {
             rval.friendlyName = _getBagsByAttribute(
               pfx.safeContents,
               "friendlyName",
-              filter.friendlyName,
-              filter.bagType
+              filter2.friendlyName,
+              filter2.bagType
             );
           }
           return rval;
@@ -140112,9 +140432,9 @@ var require_tls = __commonJS({
           }
           if (!client) {
             for (var i = 0; i < msg.extensions.length; ++i) {
-              var ext = msg.extensions[i];
-              if (ext.type[0] === 0 && ext.type[1] === 0) {
-                var snl = readVector(ext.data, 2);
+              var ext2 = msg.extensions[i];
+              if (ext2.type[0] === 0 && ext2.type[1] === 0) {
+                var snl = readVector(ext2.data, 2);
                 while (snl.length() > 0) {
                   var snType = snl.getByte();
                   if (snType !== 0) {
@@ -141110,16 +141430,16 @@ var require_tls = __commonJS({
       var cMethods = compressionMethods.length();
       var extensions = forge.util.createBuffer();
       if (c.virtualHost) {
-        var ext = forge.util.createBuffer();
-        ext.putByte(0);
-        ext.putByte(0);
+        var ext2 = forge.util.createBuffer();
+        ext2.putByte(0);
+        ext2.putByte(0);
         var serverName = forge.util.createBuffer();
         serverName.putByte(0);
         writeVector(serverName, 2, forge.util.createBuffer(c.virtualHost));
         var snList = forge.util.createBuffer();
         writeVector(snList, 2, serverName);
-        writeVector(ext, 2, snList);
-        extensions.putBuffer(ext);
+        writeVector(ext2, 2, snList);
+        extensions.putBuffer(ext2);
       }
       var extLength = extensions.length();
       if (extLength > 0) {
@@ -144405,14 +144725,14 @@ var require_pkcs7 = __commonJS({
             if (rAttr.length !== sAttr.length) {
               continue;
             }
-            var match = true;
+            var match2 = true;
             for (var j = 0; j < sAttr.length; ++j) {
               if (rAttr[j].type !== sAttr[j].type || rAttr[j].value !== sAttr[j].value) {
-                match = false;
+                match2 = false;
                 break;
               }
             }
-            if (match) {
+            if (match2) {
               return r;
             }
           }
@@ -145073,21 +145393,21 @@ async function getFolderSize(itemPath, options) {
 getFolderSize.loose = async (itemPath, options) => await core(itemPath, options);
 getFolderSize.strict = async (itemPath, options) => await core(itemPath, options, { strict: true });
 async function core(rootItemPath, options = {}, returnType = {}) {
-  const fs30 = options.fs || await import("node:fs/promises");
+  const fs31 = options.fs || await import("node:fs/promises");
   let folderSize = 0n;
   const foundInos = /* @__PURE__ */ new Set();
   const errors = [];
   await processItem(rootItemPath);
   async function processItem(itemPath) {
     if (options.ignore?.test(itemPath)) return;
-    const stats = returnType.strict ? await fs30.lstat(itemPath, { bigint: true }) : await fs30.lstat(itemPath, { bigint: true }).catch((error3) => errors.push(error3));
+    const stats = returnType.strict ? await fs31.lstat(itemPath, { bigint: true }) : await fs31.lstat(itemPath, { bigint: true }).catch((error3) => errors.push(error3));
     if (typeof stats !== "object") return;
     if (!foundInos.has(stats.ino)) {
       foundInos.add(stats.ino);
       folderSize += stats.size;
     }
     if (stats.isDirectory()) {
-      const directoryItems = returnType.strict ? await fs30.readdir(itemPath) : await fs30.readdir(itemPath).catch((error3) => errors.push(error3));
+      const directoryItems = returnType.strict ? await fs31.readdir(itemPath) : await fs31.readdir(itemPath).catch((error3) => errors.push(error3));
       if (typeof directoryItems !== "object") return;
       await Promise.all(
         directoryItems.map(
@@ -145157,8 +145477,8 @@ var require_common = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
   function extend(target, source) {
     if (source) {
       const sourceKeys = Object.keys(source);
-      for (let index = 0, length = sourceKeys.length; index < length; index += 1) {
-        const key = sourceKeys[index];
+      for (let index2 = 0, length = sourceKeys.length; index2 < length; index2 += 1) {
+        const key = sourceKeys[index2];
         target[key] = source[key];
       }
     }
@@ -145237,12 +145557,12 @@ var require_snippet = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     const re = /\r?\n|\r|\0/g;
     const lineStarts = [0];
     const lineEnds = [];
-    let match;
+    let match2;
     let 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;
+    while (match2 = re.exec(mark.buffer)) {
+      lineEnds.push(match2.index);
+      lineStarts.push(match2.index + match2[0].length);
+      if (mark.position <= match2.index && foundLineNo < 0) foundLineNo = lineStarts.length - 2;
     }
     if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
     let result = "";
@@ -145351,7 +145671,7 @@ var require_schema = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
         result.multi["fallback"].push(type);
       } else result[type.kind][type.tag] = result["fallback"][type.tag] = type;
     }
-    for (let index = 0, length = arguments.length; index < length; index += 1) arguments[index].forEach(collectType);
+    for (let index2 = 0, length = arguments.length; index2 < length; index2 += 1) arguments[index2].forEach(collectType);
     return result;
   }
   function Schema2(definition) {
@@ -145500,42 +145820,42 @@ var require_int = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
   function resolveYamlInteger(data) {
     if (data === null) return false;
     const max = data.length;
-    let index = 0;
+    let index2 = 0;
     let hasDigits = false;
     if (!max) return false;
-    let ch = data[index];
-    if (ch === "-" || ch === "+") ch = data[++index];
+    let ch = data[index2];
+    if (ch === "-" || ch === "+") ch = data[++index2];
     if (ch === "0") {
-      if (index + 1 === max) return true;
-      ch = data[++index];
+      if (index2 + 1 === max) return true;
+      ch = data[++index2];
       if (ch === "b") {
-        index++;
-        for (; index < max; index++) {
-          ch = data[index];
+        index2++;
+        for (; index2 < max; index2++) {
+          ch = data[index2];
           if (ch !== "0" && ch !== "1") return false;
           hasDigits = true;
         }
         return hasDigits && Number.isFinite(parseYamlInteger(data));
       }
       if (ch === "x") {
-        index++;
-        for (; index < max; index++) {
-          if (!isHexCode(data.charCodeAt(index))) return false;
+        index2++;
+        for (; index2 < max; index2++) {
+          if (!isHexCode(data.charCodeAt(index2))) return false;
           hasDigits = true;
         }
         return hasDigits && Number.isFinite(parseYamlInteger(data));
       }
       if (ch === "o") {
-        index++;
-        for (; index < max; index++) {
-          if (!isOctCode(data.charCodeAt(index))) return false;
+        index2++;
+        for (; index2 < max; index2++) {
+          if (!isOctCode(data.charCodeAt(index2))) return false;
           hasDigits = true;
         }
         return hasDigits && Number.isFinite(parseYamlInteger(data));
       }
     }
-    for (; index < max; index++) {
-      if (!isDecCode(data.charCodeAt(index))) return false;
+    for (; index2 < max; index2++) {
+      if (!isDecCode(data.charCodeAt(index2))) return false;
       hasDigits = true;
     }
     if (!hasDigits) return false;
@@ -145677,26 +145997,26 @@ var require_timestamp = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
   function constructYamlTimestamp(data) {
     let fraction = 0;
     let delta = null;
-    let match = YAML_DATE_REGEXP.exec(data);
-    if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data);
-    if (match === null) throw new Error("Date resolve error");
-    const year = +match[1];
-    const month = +match[2] - 1;
-    const day = +match[3];
-    if (!match[4]) return new Date(Date.UTC(year, month, day));
-    const hour = +match[4];
-    const minute = +match[5];
-    const second = +match[6];
-    if (match[7]) {
-      fraction = match[7].slice(0, 3);
+    let match2 = YAML_DATE_REGEXP.exec(data);
+    if (match2 === null) match2 = YAML_TIMESTAMP_REGEXP.exec(data);
+    if (match2 === null) throw new Error("Date resolve error");
+    const year = +match2[1];
+    const month = +match2[2] - 1;
+    const day = +match2[3];
+    if (!match2[4]) return new Date(Date.UTC(year, month, day));
+    const hour = +match2[4];
+    const minute = +match2[5];
+    const second = +match2[6];
+    if (match2[7]) {
+      fraction = match2[7].slice(0, 3);
       while (fraction.length < 3) fraction += "0";
       fraction = +fraction;
     }
-    if (match[9]) {
-      const tzHour = +match[10];
-      const tzMinute = +(match[11] || 0);
+    if (match2[9]) {
+      const tzHour = +match2[10];
+      const tzMinute = +(match2[11] || 0);
       delta = (tzHour * 60 + tzMinute) * 6e4;
-      if (match[9] === "-") delta = -delta;
+      if (match2[9] === "-") delta = -delta;
     }
     const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
     if (delta) date.setTime(date.getTime() - delta);
@@ -145816,8 +146136,8 @@ var require_omap = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     if (data === null) return true;
     const objectKeys = [];
     const object = data;
-    for (let index = 0, length = object.length; index < length; index += 1) {
-      const pair = object[index];
+    for (let index2 = 0, length = object.length; index2 < length; index2 += 1) {
+      const pair = object[index2];
       let pairHasKey = false;
       if (_toString.call(pair) !== "[object Object]") return false;
       let pairKey;
@@ -145845,12 +146165,12 @@ var require_pairs = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     if (data === null) return true;
     const object = data;
     const result = new Array(object.length);
-    for (let index = 0, length = object.length; index < length; index += 1) {
-      const pair = object[index];
+    for (let index2 = 0, length = object.length; index2 < length; index2 += 1) {
+      const pair = object[index2];
       if (_toString.call(pair) !== "[object Object]") return false;
       const keys = Object.keys(pair);
       if (keys.length !== 1) return false;
-      result[index] = [keys[0], pair[keys[0]]];
+      result[index2] = [keys[0], pair[keys[0]]];
     }
     return true;
   }
@@ -145858,10 +146178,10 @@ var require_pairs = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     if (data === null) return [];
     const object = data;
     const result = new Array(object.length);
-    for (let index = 0, length = object.length; index < length; index += 1) {
-      const pair = object[index];
+    for (let index2 = 0, length = object.length; index2 < length; index2 += 1) {
+      const pair = object[index2];
       const keys = Object.keys(pair);
-      result[index] = [keys[0], pair[keys[0]]];
+      result[index2] = [keys[0], pair[keys[0]]];
     }
     return result;
   }
@@ -146071,18 +146391,18 @@ var require_loader = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     if (transactions.length === 0) return;
     const parent = transactions[transactions.length - 1];
     const names = Object.keys(transaction);
-    for (let index = 0, length = names.length; index < length; index += 1) {
-      const name = names[index];
+    for (let index2 = 0, length = names.length; index2 < length; index2 += 1) {
+      const name = names[index2];
       if (!_hasOwnProperty.call(parent, name)) parent[name] = transaction[name];
     }
   }
   function rollbackAnchorTransaction(state) {
     const transaction = state.anchorMapTransactions.pop();
     const names = Object.keys(transaction);
-    for (let index = names.length - 1; index >= 0; index -= 1) {
-      const entry = transaction[names[index]];
-      if (entry.existed) state.anchorMap[names[index]] = entry.value;
-      else delete state.anchorMap[names[index]];
+    for (let index2 = names.length - 1; index2 >= 0; index2 -= 1) {
+      const entry = transaction[names[index2]];
+      if (entry.existed) state.anchorMap[names[index2]] = entry.value;
+      else delete state.anchorMap[names[index2]];
     }
   }
   function snapshotState(state) {
@@ -146113,10 +146433,10 @@ var require_loader = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     YAML: function handleYamlDirective(state, name, args) {
       if (state.version !== null) throwError(state, "duplication of %YAML directive");
       if (args.length !== 1) throwError(state, "YAML directive accepts exactly one argument");
-      const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
-      if (match === null) throwError(state, "ill-formed argument of the YAML directive");
-      const major = parseInt(match[1], 10);
-      const minor = parseInt(match[2], 10);
+      const match2 = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+      if (match2 === null) throwError(state, "ill-formed argument of the YAML directive");
+      const major = parseInt(match2[1], 10);
+      const minor = parseInt(match2[2], 10);
       if (major !== 1) throwError(state, "unacceptable YAML version of the document");
       state.version = args[0];
       state.checkLineBreaks = minor < 2;
@@ -146152,8 +146472,8 @@ var require_loader = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
   function mergeMappings(state, destination, source, overridableKeys) {
     if (!common.isObject(source)) throwError(state, "cannot merge mappings; the provided source object is unacceptable");
     const sourceKeys = Object.keys(source);
-    for (let index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
-      const key = sourceKeys[index];
+    for (let index2 = 0, quantity = sourceKeys.length; index2 < quantity; index2 += 1) {
+      const key = sourceKeys[index2];
       if (!_hasOwnProperty.call(destination, key)) {
         setProperty2(destination, key, source[key]);
         overridableKeys[key] = true;
@@ -146163,9 +146483,9 @@ var require_loader = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
   function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
     if (Array.isArray(keyNode)) {
       keyNode = Array.prototype.slice.call(keyNode);
-      for (let 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]";
+      for (let index2 = 0, quantity = keyNode.length; index2 < quantity; index2 += 1) {
+        if (Array.isArray(keyNode[index2])) throwError(state, "nested arrays are not supported inside keys");
+        if (typeof keyNode === "object" && _class(keyNode[index2]) === "[object Object]") keyNode[index2] = "[object Object]";
       }
     }
     if (typeof keyNode === "object" && _class(keyNode) === "[object Object]") keyNode = "[object Object]";
@@ -146174,8 +146494,8 @@ var require_loader = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     if (keyTag === "tag:yaml.org,2002:merge") if (Array.isArray(valueNode)) {
       if (valueNode.length > state.maxMergeSeqLength) throwError(state, "merge sequence length exceeded maxMergeSeqLength (" + state.maxMergeSeqLength + ")");
       const seen = /* @__PURE__ */ new Set();
-      for (let index = 0, quantity = valueNode.length; index < quantity; index += 1) {
-        const src = valueNode[index];
+      for (let index2 = 0, quantity = valueNode.length; index2 < quantity; index2 += 1) {
+        const src = valueNode[index2];
         if (seen.has(src)) continue;
         seen.add(src);
         mergeMappings(state, _result, src, overridableKeys);
@@ -146933,7 +147253,7 @@ var require_loader = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     }
     const documents = loadDocuments(input, options);
     if (typeof iterator2 !== "function") return documents;
-    for (let index = 0, length = documents.length; index < length; index += 1) iterator2(documents[index]);
+    for (let index2 = 0, length = documents.length; index2 < length; index2 += 1) iterator2(documents[index2]);
   }
   function load2(input, options) {
     const documents = loadDocuments(input, options);
@@ -147014,8 +147334,8 @@ var require_dumper = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     if (map === null) return {};
     const result = {};
     const keys = Object.keys(map);
-    for (let index = 0, length = keys.length; index < length; index += 1) {
-      let tag = keys[index];
+    for (let index2 = 0, length = keys.length; index2 < length; index2 += 1) {
+      let tag = keys[index2];
       let style = String(map[tag]);
       if (tag.slice(0, 2) === "!!") tag = "tag:yaml.org,2002:" + tag.slice(2);
       const type = schema.compiledTypeMap["fallback"][tag];
@@ -147088,7 +147408,7 @@ var require_dumper = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     return "\n" + common.repeat(" ", state.indent * level);
   }
   function testImplicitResolving(state, str) {
-    for (let index = 0, length = state.implicitTypes.length; index < length; index += 1) if (state.implicitTypes[index].resolve(str)) return true;
+    for (let index2 = 0, length = state.implicitTypes.length; index2 < length; index2 += 1) if (state.implicitTypes[index2].resolve(str)) return true;
     return false;
   }
   function isWhitespace(c) {
@@ -147212,10 +147532,10 @@ var require_dumper = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     })();
     let prevMoreIndented = string2[0] === "\n" || string2[0] === " ";
     let moreIndented;
-    let match;
-    while (match = lineRe.exec(string2)) {
-      const prefix = match[1];
-      const line = match[2];
+    let match2;
+    while (match2 = lineRe.exec(string2)) {
+      const prefix = match2[1];
+      const line = match2[2];
       moreIndented = line[0] === " ";
       result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
       prevMoreIndented = moreIndented;
@@ -147225,14 +147545,14 @@ var require_dumper = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
   function foldLine(line, width) {
     if (line === "" || line[0] === " ") return line;
     const breakRe = / [^ ]/g;
-    let match;
+    let match2;
     let start = 0;
     let end;
     let curr = 0;
     let next = 0;
     let result = "";
-    while (match = breakRe.exec(line)) {
-      next = match.index;
+    while (match2 = breakRe.exec(line)) {
+      next = match2.index;
       if (next - start > width) {
         end = curr > start ? curr : next;
         result += "\n" + line.slice(start, end);
@@ -147261,9 +147581,9 @@ var require_dumper = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
   function writeFlowSequence(state, level, object) {
     let _result = "";
     const _tag = state.tag;
-    for (let index = 0, length = object.length; index < length; index += 1) {
-      let value = object[index];
-      if (state.replacer) value = state.replacer.call(object, String(index), value);
+    for (let index2 = 0, length = object.length; index2 < length; index2 += 1) {
+      let value = object[index2];
+      if (state.replacer) value = state.replacer.call(object, String(index2), value);
       if (writeNode(state, level, value, false, false) || typeof value === "undefined" && writeNode(state, level, null, false, false)) {
         if (_result !== "") _result += "," + (!state.condenseFlow ? " " : "");
         _result += state.dump;
@@ -147275,9 +147595,9 @@ var require_dumper = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
   function writeBlockSequence(state, level, object, compact) {
     let _result = "";
     const _tag = state.tag;
-    for (let index = 0, length = object.length; index < length; index += 1) {
-      let value = object[index];
-      if (state.replacer) value = state.replacer.call(object, String(index), value);
+    for (let index2 = 0, length = object.length; index2 < length; index2 += 1) {
+      let value = object[index2];
+      if (state.replacer) value = state.replacer.call(object, String(index2), value);
       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 += "-";
@@ -147292,11 +147612,11 @@ var require_dumper = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     let _result = "";
     const _tag = state.tag;
     const objectKeyList = Object.keys(object);
-    for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
+    for (let index2 = 0, length = objectKeyList.length; index2 < length; index2 += 1) {
       let pairBuffer = "";
       if (_result !== "") pairBuffer += ", ";
       if (state.condenseFlow) pairBuffer += '"';
-      const objectKey = objectKeyList[index];
+      const objectKey = objectKeyList[index2];
       let objectValue = object[objectKey];
       if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
       if (!writeNode(state, level, objectKey, false, false)) continue;
@@ -147316,10 +147636,10 @@ var require_dumper = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     if (state.sortKeys === true) objectKeyList.sort();
     else if (typeof state.sortKeys === "function") objectKeyList.sort(state.sortKeys);
     else if (state.sortKeys) throw new YAMLException2("sortKeys must be a boolean or a function");
-    for (let index = 0, length = objectKeyList.length; index < length; index += 1) {
+    for (let index2 = 0, length = objectKeyList.length; index2 < length; index2 += 1) {
       let pairBuffer = "";
       if (!compact || _result !== "") pairBuffer += generateNextLine(state, level);
-      const objectKey = objectKeyList[index];
+      const objectKey = objectKeyList[index2];
       let objectValue = object[objectKey];
       if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
       if (!writeNode(state, level + 1, objectKey, true, true, true)) continue;
@@ -147339,8 +147659,8 @@ var require_dumper = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
   }
   function detectType(state, object, explicit) {
     const typeList = explicit ? state.explicitTypes : state.implicitTypes;
-    for (let index = 0, length = typeList.length; index < length; index += 1) {
-      const type = typeList[index];
+    for (let index2 = 0, length = typeList.length; index2 < length; index2 += 1) {
+      const type = typeList[index2];
       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;
@@ -147413,14 +147733,14 @@ var require_dumper = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
     const duplicatesIndexes = [];
     inspectNode(object, objects, duplicatesIndexes);
     const length = duplicatesIndexes.length;
-    for (let index = 0; index < length; index += 1) state.duplicates.push(objects[duplicatesIndexes[index]]);
+    for (let index2 = 0; index2 < length; index2 += 1) state.duplicates.push(objects[duplicatesIndexes[index2]]);
     state.usedDuplicates = new Array(length);
   }
   function inspectNode(object, objects, duplicatesIndexes) {
     if (object !== null && typeof object === "object") {
-      const index = objects.indexOf(object);
-      if (index !== -1) {
-        if (duplicatesIndexes.indexOf(index) === -1) duplicatesIndexes.push(index);
+      const index2 = objects.indexOf(object);
+      if (index2 !== -1) {
+        if (duplicatesIndexes.indexOf(index2) === -1) duplicatesIndexes.push(index2);
       } else {
         objects.push(object);
         if (Array.isArray(object)) for (let i = 0, length = object.length; i < length; i += 1) inspectNode(object[i], objects, duplicatesIndexes);
@@ -147936,8 +148256,8 @@ async function bundleDb(config, language, codeql, dbName, { includeDiagnostics }
 }
 async function delay(milliseconds, opts) {
   const { allowProcessExit } = opts || {};
-  return new Promise((resolve13) => {
-    const timer = setTimeout(resolve13, milliseconds);
+  return new Promise((resolve14) => {
+    const timer = setTimeout(resolve14, milliseconds);
     if (allowProcessExit) {
       timer.unref();
     }
@@ -148086,13 +148406,13 @@ function checkActionVersion(version, githubVersion) {
     }
   }
 }
-function satisfiesGHESVersion(ghesVersion, range, defaultIfInvalid) {
+function satisfiesGHESVersion(ghesVersion, range2, defaultIfInvalid) {
   const semverVersion = semver.coerce(ghesVersion);
   if (semverVersion === null) {
     return defaultIfInvalid;
   }
   semverVersion.prerelease = [];
-  return semver.satisfies(semverVersion, range);
+  return semver.satisfies(semverVersion, range2);
 }
 var BuildMode = /* @__PURE__ */ ((BuildMode3) => {
   BuildMode3["None"] = "none";
@@ -148126,7 +148446,7 @@ async function isBinaryAccessible(binary, logger) {
 }
 async function asyncFilter(array, predicate) {
   const results = await Promise.all(array.map(predicate));
-  return array.filter((_2, index) => results[index]);
+  return array.filter((_2, index2) => results[index2]);
 }
 async function asyncSome(array, predicate) {
   const results = await Promise.all(array.map(predicate));
@@ -148799,9 +149119,9 @@ async function getGitVersionOrThrow() {
     ["--version"],
     "Failed to get git version."
   );
-  const match = stdout.trim().match(/^git version ((\d+\.\d+\.\d+).*)$/);
-  if (match?.[1] && match?.[2]) {
-    return new GitVersionInfo(match[2], match[1]);
+  const match2 = stdout.trim().match(/^git version ((\d+\.\d+\.\d+).*)$/);
+  if (match2?.[1] && match2?.[2]) {
+    return new GitVersionInfo(match2[2], match2[1]);
   }
   throw new Error(`Could not parse Git version from output: ${stdout.trim()}`);
 }
@@ -148940,10 +149260,10 @@ var getFileOidsUnderPath = async function(basePath) {
   const regex = /^[0-9]+ ([0-9a-f]{40}|[0-9a-f]{64}) [0-9]+\t(.+)$/;
   for (const line of stdout.split("\n")) {
     if (line) {
-      const match = line.match(regex);
-      if (match) {
-        const oid = match[1];
-        const filePath = decodeGitFilePath(match[2]);
+      const match2 = line.match(regex);
+      if (match2) {
+        const oid = match2[1];
+        const filePath = decodeGitFilePath(match2[2]);
         fileOidMap[filePath] = oid;
       } else {
         throw new Error(`Unexpected "git ls-files" output: ${line}`);
@@ -149035,9 +149355,9 @@ async function getGeneratedFiles(workingDirectory) {
   const generatedFiles = [];
   const regex = /^([^:]+): linguist-generated: true$/;
   for (const result of stdout.split(os2.EOL)) {
-    const match = result.match(regex);
-    if (match && match[1].trim().length > 0) {
-      generatedFiles.push(match[1].trim());
+    const match2 = result.match(regex);
+    if (match2 && match2[1].trim().length > 0) {
+      generatedFiles.push(match2[1].trim());
     }
   }
   return generatedFiles;
@@ -149924,12 +150244,12 @@ function extractFatalErrors(error3) {
   const fatalErrorRegex = /.*fatal (internal )?error occurr?ed(. Details)?:/gi;
   let fatalErrors = [];
   let lastFatalErrorIndex;
-  let match;
-  while ((match = fatalErrorRegex.exec(error3)) !== null) {
+  let match2;
+  while ((match2 = fatalErrorRegex.exec(error3)) !== null) {
     if (lastFatalErrorIndex !== void 0) {
-      fatalErrors.push(error3.slice(lastFatalErrorIndex, match.index).trim());
+      fatalErrors.push(error3.slice(lastFatalErrorIndex, match2.index).trim());
     }
-    lastFatalErrorIndex = match.index;
+    lastFatalErrorIndex = match2.index;
   }
   if (lastFatalErrorIndex !== void 0) {
     const lastError = error3.slice(lastFatalErrorIndex).trim();
@@ -149950,7 +150270,7 @@ function extractFatalErrors(error3) {
 }
 function extractAutobuildErrors(error3) {
   const pattern = /.*\[autobuild\] \[ERROR\] (.*)/gi;
-  let errorLines = [...error3.matchAll(pattern)].map((match) => match[1]);
+  let errorLines = [...error3.matchAll(pattern)].map((match2) => match2[1]);
   if (errorLines.length > 10) {
     errorLines = errorLines.slice(0, 10);
     errorLines.push("(truncated)");
@@ -150912,14 +151232,14 @@ function getDiffRanges(fileDiff, logger) {
       additionRangeStartLine = void 0;
     }
     if (diffLine.startsWith("@@ ")) {
-      const match = diffLine.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
-      if (match === null) {
+      const match2 = diffLine.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,\d+)? @@/);
+      if (match2 === null) {
         logger.warning(
           `Cannot parse diff hunk header for ${fileDiff.filename}: ${diffLine}`
         );
         return void 0;
       }
-      currentLine = parseInt(match[1], 10);
+      currentLine = parseInt(match2[1], 10);
       continue;
     }
     if (diffLine.startsWith(" ")) {
@@ -152587,9 +152907,9 @@ async function getCodeQlVersionsForOverlayBaseDatabases(rawLanguages, logger) {
   for (const cache of caches) {
     if (!cache.key) continue;
     const suffix = cache.key.substring(cacheKeyPrefix.length);
-    const match = suffix.match(versionRegex);
-    if (match && semver6.valid(match[1])) {
-      versionSet.add(match[1]);
+    const match2 = suffix.match(versionRegex);
+    if (match2 && semver6.valid(match2[1])) {
+      versionSet.add(match2[1]);
     }
   }
   if (versionSet.size === 0) {
@@ -152629,17 +152949,17 @@ async function getTarVersion() {
     throw new Error("Failed to call tar --version");
   }
   if (stdout.includes("GNU tar")) {
-    const match = stdout.match(/tar \(GNU tar\) ([0-9.]+)/);
-    if (!match?.[1]) {
+    const match2 = stdout.match(/tar \(GNU tar\) ([0-9.]+)/);
+    if (!match2?.[1]) {
       throw new Error("Failed to parse output of tar --version.");
     }
-    return { type: "gnu", version: match[1] };
+    return { type: "gnu", version: match2[1] };
   } else if (stdout.includes("bsdtar")) {
-    const match = stdout.match(/bsdtar ([0-9.]+)/);
-    if (!match?.[1]) {
+    const match2 = stdout.match(/bsdtar ([0-9.]+)/);
+    if (!match2?.[1]) {
       throw new Error("Failed to parse output of tar --version.");
     }
-    return { type: "bsd", version: match[1] };
+    return { type: "bsd", version: match2[1] };
   } else {
     throw new Error("Unknown tar version");
   }
@@ -152708,7 +153028,7 @@ async function extractTarZst(tar, dest, tarVersion, logger) {
     args.push("-f", tar instanceof stream.Readable ? "-" : tar, "-C", dest);
     process.stdout.write(`[command]tar ${args.join(" ")}
 `);
-    await new Promise((resolve13, reject) => {
+    await new Promise((resolve14, reject) => {
       const tarProcess = (0, import_child_process.spawn)("tar", args, { stdio: "pipe" });
       let stdout = "";
       tarProcess.stdout?.on("data", (data) => {
@@ -152742,7 +153062,7 @@ async function extractTarZst(tar, dest, tarVersion, logger) {
             )
           );
         }
-        resolve13();
+        resolve14();
       });
     });
   } catch (e) {
@@ -152755,8 +153075,8 @@ var KNOWN_EXTENSIONS = {
   "tar.zst": "zstd"
 };
 function inferCompressionMethod(tarPath) {
-  for (const [ext, method] of Object.entries(KNOWN_EXTENSIONS)) {
-    if (tarPath.endsWith(`.${ext}`)) {
+  for (const [ext2, method] of Object.entries(KNOWN_EXTENSIONS)) {
+    if (tarPath.endsWith(`.${ext2}`)) {
       return method;
     }
   }
@@ -152879,7 +153199,7 @@ async function downloadAndExtractZstdWithStreaming(codeqlURL, dest, authorizatio
     headers
   );
   const response = await new Promise(
-    (resolve13) => import_follow_redirects.https.get(
+    (resolve14) => import_follow_redirects.https.get(
       codeqlURL,
       {
         headers,
@@ -152888,7 +153208,7 @@ async function downloadAndExtractZstdWithStreaming(codeqlURL, dest, authorizatio
         // Use the agent to respect proxy settings.
         agent
       },
-      (r) => resolve13(r)
+      (r) => resolve14(r)
     )
   );
   if (response.statusCode !== 200) {
@@ -152968,8 +153288,8 @@ async function getCodeQLBundleDownloadURL(tagName, apiDetails, compressionMethod
     [GITHUB_DOTCOM_URL, CODEQL_DEFAULT_ACTION_REPOSITORY]
   ];
   const uniqueDownloadSources = potentialDownloadSources.filter(
-    (source, index, self2) => {
-      return !self2.slice(0, index).some((other) => (0, import_fast_deep_equal.default)(source, other));
+    (source, index2, self2) => {
+      return !self2.slice(0, index2).some((other) => (0, import_fast_deep_equal.default)(source, other));
     }
   );
   const codeQLBundleName = getCodeQLBundleName(compressionMethod);
@@ -153002,12 +153322,12 @@ async function getCodeQLBundleDownloadURL(tagName, apiDetails, compressionMethod
   return `https://github.com/${CODEQL_DEFAULT_ACTION_REPOSITORY}/releases/download/${tagName}/${codeQLBundleName}`;
 }
 function tryGetBundleVersionFromTagName(tagName, logger) {
-  const match = tagName.match(/^codeql-bundle-(.*)$/);
-  if (match === null || match.length < 2) {
+  const match2 = tagName.match(/^codeql-bundle-(.*)$/);
+  if (match2 === null || match2.length < 2) {
     logger.debug(`Could not determine bundle version from tag ${tagName}.`);
     return void 0;
   }
-  return match[1];
+  return match2[1];
 }
 function tryGetTagNameFromUrl(url2, logger) {
   const matches = [...url2.matchAll(/\/(codeql-bundle-[^/]*)\//g)];
@@ -153015,16 +153335,16 @@ function tryGetTagNameFromUrl(url2, logger) {
     logger.debug(`Could not determine tag name for URL ${url2}.`);
     return void 0;
   }
-  const match = matches[matches.length - 1];
-  if (match?.length !== 2) {
+  const match2 = matches[matches.length - 1];
+  if (match2?.length !== 2) {
     logger.debug(
       `Could not determine tag name for URL ${url2}. Matched ${JSON.stringify(
-        match
+        match2
       )}.`
     );
     return void 0;
   }
-  return match[1];
+  return match2[1];
 }
 function convertToSemVer(version, logger) {
   if (!semver9.valid(version)) {
@@ -154012,9 +154332,9 @@ ${output}`
       ];
       if (await this.supportsFeature("bundleSupportsIncludeOption" /* BundleSupportsIncludeOption */)) {
         args.push(
-          ...alsoIncludeRelativePaths.flatMap((relativePath) => [
+          ...alsoIncludeRelativePaths.flatMap((relativePath2) => [
             "--include",
-            relativePath
+            relativePath2
           ])
         );
       }
@@ -154737,9 +155057,9 @@ extensions:
       checkPresence: false
     data:
 `;
-  let data = ranges.map((range) => {
-    const filename = path15.join(checkoutPath, range.path).replaceAll(path15.sep, "/");
-    return `      - [${dump(filename, { forceQuotes: true }).trim()}, ${range.startLine}, ${range.endLine}]
+  let data = ranges.map((range2) => {
+    const filename = path15.join(checkoutPath, range2.path).replaceAll(path15.sep, "/");
+    return `      - [${dump(filename, { forceQuotes: true }).trim()}, ${range2.startLine}, ${range2.endLine}]
 `;
   }).join("");
   if (!data) {
@@ -155058,7 +155378,7 @@ async function cleanupAndUploadDatabases(repositoryNwo, codeql, config, apiDetai
           logger.debug(
             `Database upload attempt ${attempt} of ${maxAttempts} failed for ${language}: ${getErrorMessage(e)}. Retrying in ${backoffMs / 1e3}s...`
           );
-          await new Promise((resolve13) => setTimeout(resolve13, backoffMs));
+          await new Promise((resolve14) => setTimeout(resolve14, backoffMs));
         }
       }
       reports.push({
@@ -156370,7 +156690,7 @@ async function hash(callback, filepath) {
   const lineNumbers = Array(BLOCK_SIZE).fill(-1);
   let hashRaw = long_default.ZERO;
   const firstMod = computeFirstMod();
-  let index = 0;
+  let index2 = 0;
   let lineNumber = 0;
   let lineStart = true;
   let prevCR = false;
@@ -156381,14 +156701,14 @@ async function hash(callback, filepath) {
       hashCounts[hashValue] = 0;
     }
     hashCounts[hashValue]++;
-    callback(lineNumbers[index], `${hashValue}:${hashCounts[hashValue]}`);
-    lineNumbers[index] = -1;
+    callback(lineNumbers[index2], `${hashValue}:${hashCounts[hashValue]}`);
+    lineNumbers[index2] = -1;
   };
   const updateHash = function(current) {
-    const begin = window2[index];
-    window2[index] = current;
+    const begin = window2[index2];
+    window2[index2] = current;
     hashRaw = MOD.multiply(hashRaw).add(long_default.fromInt(current)).subtract(firstMod.multiply(long_default.fromInt(begin)));
-    index = (index + 1) % BLOCK_SIZE;
+    index2 = (index2 + 1) % BLOCK_SIZE;
   };
   const processCharacter = function(current) {
     if (current === space || current === tab || prevCR && current === lf) {
@@ -156401,13 +156721,13 @@ async function hash(callback, filepath) {
     } else {
       prevCR = false;
     }
-    if (lineNumbers[index] !== -1) {
+    if (lineNumbers[index2] !== -1) {
       outputHash();
     }
     if (lineStart) {
       lineStart = false;
       lineNumber++;
-      lineNumbers[index] = lineNumber;
+      lineNumbers[index2] = lineNumber;
     }
     if (current === lf) {
       lineStart = true;
@@ -156422,7 +156742,7 @@ async function hash(callback, filepath) {
   }
   processCharacter(EOF);
   for (let i = 0; i < BLOCK_SIZE; i++) {
-    if (lineNumbers[index] !== -1) {
+    if (lineNumbers[index2] !== -1) {
       outputHash();
     }
     updateHash(0);
@@ -157467,7 +157787,7 @@ function filterAlertsByDiffRange(logger, sarifLog) {
             return false;
           }
           return diffRanges.some(
-            (range) => range.path === locationUri && (range.startLine <= locationStartLine && range.endLine >= locationStartLine || range.startLine === 0 && range.endLine === 0)
+            (range2) => range2.path === locationUri && (range2.startLine <= locationStartLine && range2.endLine >= locationStartLine || range2.startLine === 0 && range2.endLine === 0)
           );
         });
       });
@@ -157570,7 +157890,7 @@ function doesGoExtractionOutputExist(config) {
       ".trap.tar.gz",
       ".trap.tar.br",
       ".trap.tar"
-    ].some((ext) => fileName.endsWith(ext))
+    ].some((ext2) => fileName.endsWith(ext2))
   );
 }
 async function runAutobuildIfLegacyGoWorkflow(config, logger) {
@@ -157867,21 +158187,4330 @@ async function runWrapper() {
 }
 
 // src/analyze-action-post.ts
-var fs25 = __toESM(require("fs"));
+var fs26 = __toESM(require("fs"));
 var core17 = __toESM(require_core());
 
 // src/debug-artifacts.ts
-var fs24 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var fs25 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
 var artifact = __toESM(require_artifact2());
 var artifactLegacy = __toESM(require_artifact_client2());
 var core16 = __toESM(require_core());
-var import_archiver = __toESM(require_archiver());
+
+// node_modules/archiver/lib/core.js
+var import_fs2 = require("fs");
+
+// node_modules/is-stream/index.js
+function isStream(stream2, { checkOpen = true } = {}) {
+  return stream2 !== null && typeof stream2 === "object" && (stream2.writable || stream2.readable || !checkOpen || stream2.writable === void 0 && stream2.readable === void 0) && typeof stream2.pipe === "function";
+}
+
+// node_modules/readdir-glob/dist/index.mjs
+var fs23 = __toESM(require("fs"), 1);
+var import_events = require("events");
+
+// node_modules/readdir-glob/node_modules/balanced-match/dist/esm/index.js
+var balanced = (a, b, str) => {
+  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+  const r = ma !== null && mb != null && range(ma, mb, str);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + ma.length, r[1]),
+    post: str.slice(r[1] + mb.length)
+  };
+};
+var maybeMatch = (reg, str) => {
+  const m = str.match(reg);
+  return m ? m[0] : null;
+};
+var range = (a, b, str) => {
+  let begs, beg, left, right = void 0, result;
+  let ai = str.indexOf(a);
+  let bi = str.indexOf(b, ai + 1);
+  let i = ai;
+  if (ai >= 0 && bi > 0) {
+    if (a === b) {
+      return [ai, bi];
+    }
+    begs = [];
+    left = str.length;
+    while (i >= 0 && !result) {
+      if (i === ai) {
+        begs.push(i);
+        ai = str.indexOf(a, i + 1);
+      } else if (begs.length === 1) {
+        const r = begs.pop();
+        if (r !== void 0)
+          result = [r, bi];
+      } else {
+        beg = begs.pop();
+        if (beg !== void 0 && beg < left) {
+          left = beg;
+          right = bi;
+        }
+        bi = str.indexOf(b, i + 1);
+      }
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
+    if (begs.length && right !== void 0) {
+      result = [left, right];
+    }
+  }
+  return result;
+};
+
+// node_modules/readdir-glob/node_modules/brace-expansion/dist/esm/index.js
+var escSlash = "\0SLASH" + Math.random() + "\0";
+var escOpen = "\0OPEN" + Math.random() + "\0";
+var escClose = "\0CLOSE" + Math.random() + "\0";
+var escComma = "\0COMMA" + Math.random() + "\0";
+var escPeriod = "\0PERIOD" + Math.random() + "\0";
+var escSlashPattern = new RegExp(escSlash, "g");
+var escOpenPattern = new RegExp(escOpen, "g");
+var escClosePattern = new RegExp(escClose, "g");
+var escCommaPattern = new RegExp(escComma, "g");
+var escPeriodPattern = new RegExp(escPeriod, "g");
+var slashPattern = /\\\\/g;
+var openPattern = /\\{/g;
+var closePattern = /\\}/g;
+var commaPattern = /\\,/g;
+var periodPattern = /\\\./g;
+var EXPANSION_MAX = 1e5;
+function numeric(str) {
+  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+function parseCommaParts(str) {
+  if (!str) {
+    return [""];
+  }
+  const parts = [];
+  const m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
+  }
+  const { pre, body, post } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    ;
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+  parts.push.apply(parts, p);
+  return parts;
+}
+function expand2(str, options = {}) {
+  if (!str) {
+    return [];
+  }
+  const { max = EXPANSION_MAX } = options;
+  if (str.slice(0, 2) === "{}") {
+    str = "\\{\\}" + str.slice(2);
+  }
+  return expand_(escapeBraces(str), max, true).map(unescapeBraces);
+}
+function embrace(str) {
+  return "{" + str + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+  return i <= y;
+}
+function gte6(i, y) {
+  return i >= y;
+}
+function expand_(str, max, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str);
+  if (!m)
+    return [str];
+  const pre = m.pre;
+  const post = m.post.length ? expand_(m.post, max, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0; k < post.length && k < max; k++) {
+      const expansion = pre + "{" + m.body + "}" + post[k];
+      expansions.push(expansion);
+    }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str, max, true);
+      }
+      return [str];
+    }
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
+    } else {
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== void 0) {
+        n = expand_(n[0], max, false).map(embrace);
+        if (n.length === 1) {
+          return post.map((p) => m.pre + n[0] + p);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte6;
+      }
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i = x; test(i, y) && N.length < max; i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
+          }
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
+              }
+            }
+          }
+        }
+        N.push(c);
+      }
+    } else {
+      N = [];
+      for (let j = 0; j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], max, false));
+      }
+    }
+    for (let j = 0; j < N.length; j++) {
+      for (let k = 0; k < post.length && expansions.length < max; k++) {
+        const expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
+        }
+      }
+    }
+  }
+  return expansions;
+}
+
+// node_modules/readdir-glob/node_modules/minimatch/dist/esm/assert-valid-pattern.js
+var MAX_PATTERN_LENGTH = 1024 * 64;
+var assertValidPattern = (pattern) => {
+  if (typeof pattern !== "string") {
+    throw new TypeError("invalid pattern");
+  }
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    throw new TypeError("pattern is too long");
+  }
+};
+
+// node_modules/readdir-glob/node_modules/minimatch/dist/esm/brace-expressions.js
+var posixClasses = {
+  "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
+  "[:alpha:]": ["\\p{L}\\p{Nl}", true],
+  "[:ascii:]": ["\\x00-\\x7f", false],
+  "[:blank:]": ["\\p{Zs}\\t", true],
+  "[:cntrl:]": ["\\p{Cc}", true],
+  "[:digit:]": ["\\p{Nd}", true],
+  "[:graph:]": ["\\p{Z}\\p{C}", true, true],
+  "[:lower:]": ["\\p{Ll}", true],
+  "[:print:]": ["\\p{C}", true],
+  "[:punct:]": ["\\p{P}", true],
+  "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
+  "[:upper:]": ["\\p{Lu}", true],
+  "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
+  "[:xdigit:]": ["A-Fa-f0-9", false]
+};
+var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
+var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var rangesToString = (ranges) => ranges.join("");
+var parseClass = (glob2, position) => {
+  const pos = position;
+  if (glob2.charAt(pos) !== "[") {
+    throw new Error("not in a brace expression");
+  }
+  const ranges = [];
+  const negs = [];
+  let i = pos + 1;
+  let sawStart = false;
+  let uflag = false;
+  let escaping = false;
+  let negate2 = false;
+  let endPos = pos;
+  let rangeStart = "";
+  WHILE: while (i < glob2.length) {
+    const c = glob2.charAt(i);
+    if ((c === "!" || c === "^") && i === pos + 1) {
+      negate2 = true;
+      i++;
+      continue;
+    }
+    if (c === "]" && sawStart && !escaping) {
+      endPos = i + 1;
+      break;
+    }
+    sawStart = true;
+    if (c === "\\") {
+      if (!escaping) {
+        escaping = true;
+        i++;
+        continue;
+      }
+    }
+    if (c === "[" && !escaping) {
+      for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
+        if (glob2.startsWith(cls, i)) {
+          if (rangeStart) {
+            return ["$.", false, glob2.length - pos, true];
+          }
+          i += cls.length;
+          if (neg)
+            negs.push(unip);
+          else
+            ranges.push(unip);
+          uflag = uflag || u;
+          continue WHILE;
+        }
+      }
+    }
+    escaping = false;
+    if (rangeStart) {
+      if (c > rangeStart) {
+        ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
+      } else if (c === rangeStart) {
+        ranges.push(braceEscape(c));
+      }
+      rangeStart = "";
+      i++;
+      continue;
+    }
+    if (glob2.startsWith("-]", i + 1)) {
+      ranges.push(braceEscape(c + "-"));
+      i += 2;
+      continue;
+    }
+    if (glob2.startsWith("-", i + 1)) {
+      rangeStart = c;
+      i += 2;
+      continue;
+    }
+    ranges.push(braceEscape(c));
+    i++;
+  }
+  if (endPos < i) {
+    return ["", false, 0, false];
+  }
+  if (!ranges.length && !negs.length) {
+    return ["$.", false, glob2.length - pos, true];
+  }
+  if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate2) {
+    const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
+    return [regexpEscape(r), false, endPos - pos, false];
+  }
+  const sranges = "[" + (negate2 ? "^" : "") + rangesToString(ranges) + "]";
+  const snegs = "[" + (negate2 ? "" : "^") + rangesToString(negs) + "]";
+  const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
+  return [comb, uflag, endPos - pos, true];
+};
+
+// node_modules/readdir-glob/node_modules/minimatch/dist/esm/unescape.js
+var unescape2 = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
+  if (magicalBraces) {
+    return windowsPathsNoEscape ? s.replace(/\[([^/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^/\\])\]/g, "$1$2").replace(/\\([^/])/g, "$1");
+  }
+  return windowsPathsNoEscape ? s.replace(/\[([^/\\{}])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^/\\{}])\]/g, "$1$2").replace(/\\([^/{}])/g, "$1");
+};
+
+// node_modules/readdir-glob/node_modules/minimatch/dist/esm/ast.js
+var _a;
+var types2 = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
+var isExtglobType = (c) => types2.has(c);
+var isExtglobAST = (c) => isExtglobType(c.type);
+var adoptionMap = /* @__PURE__ */ new Map([
+  ["!", ["@"]],
+  ["?", ["?", "@"]],
+  ["@", ["@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@"]]
+]);
+var adoptionWithSpaceMap = /* @__PURE__ */ new Map([
+  ["!", ["?"]],
+  ["@", ["?"]],
+  ["+", ["?", "*"]]
+]);
+var adoptionAnyMap = /* @__PURE__ */ new Map([
+  ["!", ["?", "@"]],
+  ["?", ["?", "@"]],
+  ["@", ["?", "@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@", "?", "*"]]
+]);
+var usurpMap = /* @__PURE__ */ new Map([
+  ["!", /* @__PURE__ */ new Map([["!", "@"]])],
+  [
+    "?",
+    /* @__PURE__ */ new Map([
+      ["*", "*"],
+      ["+", "*"]
+    ])
+  ],
+  [
+    "@",
+    /* @__PURE__ */ new Map([
+      ["!", "!"],
+      ["?", "?"],
+      ["@", "@"],
+      ["*", "*"],
+      ["+", "+"]
+    ])
+  ],
+  [
+    "+",
+    /* @__PURE__ */ new Map([
+      ["?", "*"],
+      ["*", "*"]
+    ])
+  ]
+]);
+var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
+var startNoDot = "(?!\\.)";
+var addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
+var justDots = /* @__PURE__ */ new Set(["..", "."]);
+var reSpecials = new Set("().*{}+?[]^$\\!");
+var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var qmark = "[^/]";
+var star = qmark + "*?";
+var starNoEmpty = qmark + "+?";
+var ID = 0;
+var AST = class {
+  type;
+  #root;
+  #hasMagic;
+  #uflag = false;
+  #parts = [];
+  #parent;
+  #parentIndex;
+  #negs;
+  #filledNegs = false;
+  #options;
+  #toString;
+  // set to true if it's an extglob with no children
+  // (which really means one child of '')
+  #emptyExt = false;
+  id = ++ID;
+  get depth() {
+    return (this.#parent?.depth ?? -1) + 1;
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return {
+      "@@type": "AST",
+      id: this.id,
+      type: this.type,
+      root: this.#root.id,
+      parent: this.#parent?.id,
+      depth: this.depth,
+      partsLength: this.#parts.length,
+      parts: this.#parts
+    };
+  }
+  constructor(type, parent, options = {}) {
+    this.type = type;
+    if (type)
+      this.#hasMagic = true;
+    this.#parent = parent;
+    this.#root = this.#parent ? this.#parent.#root : this;
+    this.#options = this.#root === this ? options : this.#root.#options;
+    this.#negs = this.#root === this ? [] : this.#root.#negs;
+    if (type === "!" && !this.#root.#filledNegs)
+      this.#negs.push(this);
+    this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
+  }
+  get hasMagic() {
+    if (this.#hasMagic !== void 0)
+      return this.#hasMagic;
+    for (const p of this.#parts) {
+      if (typeof p === "string")
+        continue;
+      if (p.type || p.hasMagic)
+        return this.#hasMagic = true;
+    }
+    return this.#hasMagic;
+  }
+  // reconstructs the pattern
+  toString() {
+    return this.#toString !== void 0 ? this.#toString : !this.type ? this.#toString = this.#parts.map((p) => String(p)).join("") : this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
+  }
+  #fillNegs() {
+    if (this !== this.#root)
+      throw new Error("should only call on root");
+    if (this.#filledNegs)
+      return this;
+    this.toString();
+    this.#filledNegs = true;
+    let n;
+    while (n = this.#negs.pop()) {
+      if (n.type !== "!")
+        continue;
+      let p = n;
+      let pp = p.#parent;
+      while (pp) {
+        for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
+          for (const part of n.#parts) {
+            if (typeof part === "string") {
+              throw new Error("string part in extglob AST??");
+            }
+            part.copyIn(pp.#parts[i]);
+          }
+        }
+        p = pp;
+        pp = p.#parent;
+      }
+    }
+    return this;
+  }
+  push(...parts) {
+    for (const p of parts) {
+      if (p === "")
+        continue;
+      if (typeof p !== "string" && !(p instanceof _a && p.#parent === this)) {
+        throw new Error("invalid part: " + p);
+      }
+      this.#parts.push(p);
+    }
+  }
+  toJSON() {
+    const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
+    if (this.isStart() && !this.type)
+      ret.unshift([]);
+    if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === "!")) {
+      ret.push({});
+    }
+    return ret;
+  }
+  isStart() {
+    if (this.#root === this)
+      return true;
+    if (!this.#parent?.isStart())
+      return false;
+    if (this.#parentIndex === 0)
+      return true;
+    const p = this.#parent;
+    for (let i = 0; i < this.#parentIndex; i++) {
+      const pp = p.#parts[i];
+      if (!(pp instanceof _a && pp.type === "!")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isEnd() {
+    if (this.#root === this)
+      return true;
+    if (this.#parent?.type === "!")
+      return true;
+    if (!this.#parent?.isEnd())
+      return false;
+    if (!this.type)
+      return this.#parent?.isEnd();
+    const pl = this.#parent ? this.#parent.#parts.length : 0;
+    return this.#parentIndex === pl - 1;
+  }
+  copyIn(part) {
+    if (typeof part === "string")
+      this.push(part);
+    else
+      this.push(part.clone(this));
+  }
+  clone(parent) {
+    const c = new _a(this.type, parent);
+    for (const p of this.#parts) {
+      c.copyIn(p);
+    }
+    return c;
+  }
+  static #parseAST(str, ast, pos, opt, extDepth) {
+    const maxDepth = opt.maxExtglobRecursion ?? 2;
+    let escaping = false;
+    let inBrace = false;
+    let braceStart = -1;
+    let braceNeg = false;
+    if (ast.type === null) {
+      let i2 = pos;
+      let acc2 = "";
+      while (i2 < str.length) {
+        const c = str.charAt(i2++);
+        if (escaping || c === "\\") {
+          escaping = !escaping;
+          acc2 += c;
+          continue;
+        }
+        if (inBrace) {
+          if (i2 === braceStart + 1) {
+            if (c === "^" || c === "!") {
+              braceNeg = true;
+            }
+          } else if (c === "]" && !(i2 === braceStart + 2 && braceNeg)) {
+            inBrace = false;
+          }
+          acc2 += c;
+          continue;
+        } else if (c === "[") {
+          inBrace = true;
+          braceStart = i2;
+          braceNeg = false;
+          acc2 += c;
+          continue;
+        }
+        const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i2) === "(" && extDepth <= maxDepth;
+        if (doRecurse) {
+          ast.push(acc2);
+          acc2 = "";
+          const ext2 = new _a(c, ast);
+          i2 = _a.#parseAST(str, ext2, i2, opt, extDepth + 1);
+          ast.push(ext2);
+          continue;
+        }
+        acc2 += c;
+      }
+      ast.push(acc2);
+      return i2;
+    }
+    let i = pos + 1;
+    let part = new _a(null, ast);
+    const parts = [];
+    let acc = "";
+    while (i < str.length) {
+      const c = str.charAt(i++);
+      if (escaping || c === "\\") {
+        escaping = !escaping;
+        acc += c;
+        continue;
+      }
+      if (inBrace) {
+        if (i === braceStart + 1) {
+          if (c === "^" || c === "!") {
+            braceNeg = true;
+          }
+        } else if (c === "]" && !(i === braceStart + 2 && braceNeg)) {
+          inBrace = false;
+        }
+        acc += c;
+        continue;
+      } else if (c === "[") {
+        inBrace = true;
+        braceStart = i;
+        braceNeg = false;
+        acc += c;
+        continue;
+      }
+      const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
+      (extDepth <= maxDepth || ast && ast.#canAdoptType(c));
+      if (doRecurse) {
+        const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
+        part.push(acc);
+        acc = "";
+        const ext2 = new _a(c, part);
+        part.push(ext2);
+        i = _a.#parseAST(str, ext2, i, opt, extDepth + depthAdd);
+        continue;
+      }
+      if (c === "|") {
+        part.push(acc);
+        acc = "";
+        parts.push(part);
+        part = new _a(null, ast);
+        continue;
+      }
+      if (c === ")") {
+        if (acc === "" && ast.#parts.length === 0) {
+          ast.#emptyExt = true;
+        }
+        part.push(acc);
+        acc = "";
+        ast.push(...parts, part);
+        return i;
+      }
+      acc += c;
+    }
+    ast.type = null;
+    ast.#hasMagic = void 0;
+    ast.#parts = [str.substring(pos - 1)];
+    return i;
+  }
+  #canAdoptWithSpace(child) {
+    return this.#canAdopt(child, adoptionWithSpaceMap);
+  }
+  #canAdopt(child, map = adoptionMap) {
+    if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null) {
+      return false;
+    }
+    const gc = child.#parts[0];
+    if (!gc || typeof gc !== "object" || gc.type === null) {
+      return false;
+    }
+    return this.#canAdoptType(gc.type, map);
+  }
+  #canAdoptType(c, map = adoptionAnyMap) {
+    return !!map.get(this.type)?.includes(c);
+  }
+  #adoptWithSpace(child, index2) {
+    const gc = child.#parts[0];
+    const blank = new _a(null, gc, this.options);
+    blank.#parts.push("");
+    gc.push(blank);
+    this.#adopt(child, index2);
+  }
+  #adopt(child, index2) {
+    const gc = child.#parts[0];
+    this.#parts.splice(index2, 1, ...gc.#parts);
+    for (const p of gc.#parts) {
+      if (typeof p === "object")
+        p.#parent = this;
+    }
+    this.#toString = void 0;
+  }
+  #canUsurpType(c) {
+    const m = usurpMap.get(this.type);
+    return !!m?.has(c);
+  }
+  #canUsurp(child) {
+    if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null || this.#parts.length !== 1) {
+      return false;
+    }
+    const gc = child.#parts[0];
+    if (!gc || typeof gc !== "object" || gc.type === null) {
+      return false;
+    }
+    return this.#canUsurpType(gc.type);
+  }
+  #usurp(child) {
+    const m = usurpMap.get(this.type);
+    const gc = child.#parts[0];
+    const nt = m?.get(gc.type);
+    if (!nt)
+      return false;
+    this.#parts = gc.#parts;
+    for (const p of this.#parts) {
+      if (typeof p === "object") {
+        p.#parent = this;
+      }
+    }
+    this.type = nt;
+    this.#toString = void 0;
+    this.#emptyExt = false;
+  }
+  static fromGlob(pattern, options = {}) {
+    const ast = new _a(null, void 0, options);
+    _a.#parseAST(pattern, ast, 0, options, 0);
+    return ast;
+  }
+  // returns the regular expression if there's magic, or the unescaped
+  // string if not.
+  toMMPattern() {
+    if (this !== this.#root)
+      return this.#root.toMMPattern();
+    const glob2 = this.toString();
+    const [re, body, hasMagic, uflag] = this.toRegExpSource();
+    const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob2.toUpperCase() !== glob2.toLowerCase();
+    if (!anyMagic) {
+      return body;
+    }
+    const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
+    return Object.assign(new RegExp(`^${re}$`, flags), {
+      _src: re,
+      _glob: glob2
+    });
+  }
+  get options() {
+    return this.#options;
+  }
+  // returns the string match, the regexp source, whether there's magic
+  // in the regexp (so a regular expression is required) and whether or
+  // not the uflag is needed for the regular expression (for posix classes)
+  // TODO: instead of injecting the start/end at this point, just return
+  // the BODY of the regexp, along with the start/end portions suitable
+  // for binding the start/end in either a joined full-path makeRe context
+  // (where we bind to (^|/), or a standalone matchPart context (where
+  // we bind to ^, and not /).  Otherwise slashes get duped!
+  //
+  // In part-matching mode, the start is:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: ^(?!\.\.?$)
+  // - if dots allowed or not possible: ^
+  // - if dots possible and not allowed: ^(?!\.)
+  // end is:
+  // - if not isEnd(): nothing
+  // - else: $
+  //
+  // In full-path matching mode, we put the slash at the START of the
+  // pattern, so start is:
+  // - if first pattern: same as part-matching mode
+  // - if not isStart(): nothing
+  // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
+  // - if dots allowed or not possible: /
+  // - if dots possible and not allowed: /(?!\.)
+  // end is:
+  // - if last pattern, same as part-matching mode
+  // - else nothing
+  //
+  // Always put the (?:$|/) on negated tails, though, because that has to be
+  // there to bind the end of the negated pattern portion, and it's easier to
+  // just stick it in now rather than try to inject it later in the middle of
+  // the pattern.
+  //
+  // We can just always return the same end, and leave it up to the caller
+  // to know whether it's going to be used joined or in parts.
+  // And, if the start is adjusted slightly, can do the same there:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
+  // - if dots allowed or not possible: (?:/|^)
+  // - if dots possible and not allowed: (?:/|^)(?!\.)
+  //
+  // But it's better to have a simpler binding without a conditional, for
+  // performance, so probably better to return both start options.
+  //
+  // Then the caller just ignores the end if it's not the first pattern,
+  // and the start always gets applied.
+  //
+  // But that's always going to be $ if it's the ending pattern, or nothing,
+  // so the caller can just attach $ at the end of the pattern when building.
+  //
+  // So the todo is:
+  // - better detect what kind of start is needed
+  // - return both flavors of starting pattern
+  // - attach $ at the end of the pattern when creating the actual RegExp
+  //
+  // Ah, but wait, no, that all only applies to the root when the first pattern
+  // is not an extglob. If the first pattern IS an extglob, then we need all
+  // that dot prevention biz to live in the extglob portions, because eg
+  // +(*|.x*) can match .xy but not .yx.
+  //
+  // So, return the two flavors if it's #root and the first child is not an
+  // AST, otherwise leave it to the child AST to handle it, and there,
+  // use the (?:^|/) style of start binding.
+  //
+  // Even simplified further:
+  // - Since the start for a join is eg /(?!\.) and the start for a part
+  // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
+  // or start or whatever) and prepend ^ or / at the Regexp construction.
+  toRegExpSource(allowDot) {
+    const dot = allowDot ?? !!this.#options.dot;
+    if (this.#root === this) {
+      this.#flatten();
+      this.#fillNegs();
+    }
+    if (!isExtglobAST(this)) {
+      const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s) => typeof s !== "string");
+      const src = this.#parts.map((p) => {
+        const [re, _2, hasMagic, uflag] = typeof p === "string" ? _a.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+        this.#hasMagic = this.#hasMagic || hasMagic;
+        this.#uflag = this.#uflag || uflag;
+        return re;
+      }).join("");
+      let start2 = "";
+      if (this.isStart()) {
+        if (typeof this.#parts[0] === "string") {
+          const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
+          if (!dotTravAllowed) {
+            const aps = addPatternStart;
+            const needNoTrav = (
+              // dots are allowed, and the pattern starts with [ or .
+              dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
+              src.startsWith("\\.") && aps.has(src.charAt(2)) || // the pattern starts with \.\., and then [ or .
+              src.startsWith("\\.\\.") && aps.has(src.charAt(4))
+            );
+            const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
+            start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
+          }
+        }
+      }
+      let end = "";
+      if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") {
+        end = "(?:$|\\/)";
+      }
+      const final2 = start2 + src + end;
+      return [
+        final2,
+        unescape2(src),
+        this.#hasMagic = !!this.#hasMagic,
+        this.#uflag
+      ];
+    }
+    const repeated = this.type === "*" || this.type === "+";
+    const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
+    let body = this.#partsToRegExp(dot);
+    if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
+      const s = this.toString();
+      const me = this;
+      me.#parts = [s];
+      me.type = null;
+      me.#hasMagic = void 0;
+      return [s, unescape2(this.toString()), false, false];
+    }
+    let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
+    if (bodyDotAllowed === body) {
+      bodyDotAllowed = "";
+    }
+    if (bodyDotAllowed) {
+      body = `(?:${body})(?:${bodyDotAllowed})*?`;
+    }
+    let final = "";
+    if (this.type === "!" && this.#emptyExt) {
+      final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
+    } else {
+      const close = this.type === "!" ? (
+        // !() must match something,but !(x) can match ''
+        "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")"
+      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
+      final = start + body + close;
+    }
+    return [
+      final,
+      unescape2(body),
+      this.#hasMagic = !!this.#hasMagic,
+      this.#uflag
+    ];
+  }
+  #flatten() {
+    if (!isExtglobAST(this)) {
+      for (const p of this.#parts) {
+        if (typeof p === "object") {
+          p.#flatten();
+        }
+      }
+    } else {
+      let iterations = 0;
+      let done = false;
+      do {
+        done = true;
+        for (let i = 0; i < this.#parts.length; i++) {
+          const c = this.#parts[i];
+          if (typeof c === "object") {
+            c.#flatten();
+            if (this.#canAdopt(c)) {
+              done = false;
+              this.#adopt(c, i);
+            } else if (this.#canAdoptWithSpace(c)) {
+              done = false;
+              this.#adoptWithSpace(c, i);
+            } else if (this.#canUsurp(c)) {
+              done = false;
+              this.#usurp(c);
+            }
+          }
+        }
+      } while (!done && ++iterations < 10);
+    }
+    this.#toString = void 0;
+  }
+  #partsToRegExp(dot) {
+    return this.#parts.map((p) => {
+      if (typeof p === "string") {
+        throw new Error("string type in extglob ast??");
+      }
+      const [re, _2, _hasMagic, uflag] = p.toRegExpSource(dot);
+      this.#uflag = this.#uflag || uflag;
+      return re;
+    }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
+  }
+  static #parseGlob(glob2, hasMagic, noEmpty = false) {
+    let escaping = false;
+    let re = "";
+    let uflag = false;
+    let inStar = false;
+    for (let i = 0; i < glob2.length; i++) {
+      const c = glob2.charAt(i);
+      if (escaping) {
+        escaping = false;
+        re += (reSpecials.has(c) ? "\\" : "") + c;
+        continue;
+      }
+      if (c === "*") {
+        if (inStar)
+          continue;
+        inStar = true;
+        re += noEmpty && /^[*]+$/.test(glob2) ? starNoEmpty : star;
+        hasMagic = true;
+        continue;
+      } else {
+        inStar = false;
+      }
+      if (c === "\\") {
+        if (i === glob2.length - 1) {
+          re += "\\\\";
+        } else {
+          escaping = true;
+        }
+        continue;
+      }
+      if (c === "[") {
+        const [src, needUflag, consumed, magic] = parseClass(glob2, i);
+        if (consumed) {
+          re += src;
+          uflag = uflag || needUflag;
+          i += consumed - 1;
+          hasMagic = hasMagic || magic;
+          continue;
+        }
+      }
+      if (c === "?") {
+        re += qmark;
+        hasMagic = true;
+        continue;
+      }
+      re += regExpEscape(c);
+    }
+    return [re, unescape2(glob2), !!hasMagic, uflag];
+  }
+};
+_a = AST;
+
+// node_modules/readdir-glob/node_modules/minimatch/dist/esm/escape.js
+var escape2 = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
+  if (magicalBraces) {
+    return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
+  }
+  return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
+};
+
+// node_modules/readdir-glob/node_modules/minimatch/dist/esm/index.js
+var minimatch = (p, pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (!options.nocomment && pattern.charAt(0) === "#") {
+    return false;
+  }
+  return new Minimatch(pattern, options).match(p);
+};
+var starDotExtRE = /^\*+([^+@!?*[(]*)$/;
+var starDotExtTest = (ext2) => (f) => !f.startsWith(".") && f.endsWith(ext2);
+var starDotExtTestDot = (ext2) => (f) => f.endsWith(ext2);
+var starDotExtTestNocase = (ext2) => {
+  ext2 = ext2.toLowerCase();
+  return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext2);
+};
+var starDotExtTestNocaseDot = (ext2) => {
+  ext2 = ext2.toLowerCase();
+  return (f) => f.toLowerCase().endsWith(ext2);
+};
+var starDotStarRE = /^\*+\.\*+$/;
+var starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
+var starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
+var dotStarRE = /^\.\*+$/;
+var dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
+var starRE = /^\*+$/;
+var starTest = (f) => f.length !== 0 && !f.startsWith(".");
+var starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
+var qmarksRE = /^\?+([^+@!?*[(]*)?$/;
+var qmarksTestNocase = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  if (!ext2)
+    return noext;
+  ext2 = ext2.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+};
+var qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  if (!ext2)
+    return noext;
+  ext2 = ext2.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+};
+var qmarksTestDot = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+};
+var qmarksTest = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+};
+var qmarksTestNoExt = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && !f.startsWith(".");
+};
+var qmarksTestNoExtDot = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && f !== "." && f !== "..";
+};
+var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+var path20 = {
+  win32: { sep: "\\" },
+  posix: { sep: "/" }
+};
+var sep6 = defaultPlatform === "win32" ? path20.win32.sep : path20.posix.sep;
+minimatch.sep = sep6;
+var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
+minimatch.GLOBSTAR = GLOBSTAR;
+var qmark2 = "[^/]";
+var star2 = qmark2 + "*?";
+var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+var filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
+minimatch.filter = filter;
+var ext = (a, b = {}) => Object.assign({}, a, b);
+var defaults = (def) => {
+  if (!def || typeof def !== "object" || !Object.keys(def).length) {
+    return minimatch;
+  }
+  const orig = minimatch;
+  const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
+  return Object.assign(m, {
+    Minimatch: class Minimatch extends orig.Minimatch {
+      constructor(pattern, options = {}) {
+        super(pattern, ext(def, options));
+      }
+      static defaults(options) {
+        return orig.defaults(ext(def, options)).Minimatch;
+      }
+    },
+    AST: class AST extends orig.AST {
+      /* c8 ignore start */
+      constructor(type, parent, options = {}) {
+        super(type, parent, ext(def, options));
+      }
+      /* c8 ignore stop */
+      static fromGlob(pattern, options = {}) {
+        return orig.AST.fromGlob(pattern, ext(def, options));
+      }
+    },
+    unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
+    escape: (s, options = {}) => orig.escape(s, ext(def, options)),
+    filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
+    defaults: (options) => orig.defaults(ext(def, options)),
+    makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
+    braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
+    match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
+    sep: orig.sep,
+    GLOBSTAR
+  });
+};
+minimatch.defaults = defaults;
+var braceExpand = (pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+    return [pattern];
+  }
+  return expand2(pattern, { max: options.braceExpandMax });
+};
+minimatch.braceExpand = braceExpand;
+var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
+minimatch.makeRe = makeRe;
+var match = (list, pattern, options = {}) => {
+  const mm = new Minimatch(pattern, options);
+  list = list.filter((f) => mm.match(f));
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern);
+  }
+  return list;
+};
+minimatch.match = match;
+var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
+var regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var Minimatch = class {
+  options;
+  set;
+  pattern;
+  windowsPathsNoEscape;
+  nonegate;
+  negate;
+  comment;
+  empty;
+  preserveMultipleSlashes;
+  partial;
+  globSet;
+  globParts;
+  nocase;
+  isWindows;
+  platform;
+  windowsNoMagicRoot;
+  maxGlobstarRecursion;
+  regexp;
+  constructor(pattern, options = {}) {
+    assertValidPattern(pattern);
+    options = options || {};
+    this.options = options;
+    this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;
+    this.pattern = pattern;
+    this.platform = options.platform || defaultPlatform;
+    this.isWindows = this.platform === "win32";
+    const awe = "allowWindowsEscape";
+    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options[awe] === false;
+    if (this.windowsPathsNoEscape) {
+      this.pattern = this.pattern.replace(/\\/g, "/");
+    }
+    this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
+    this.regexp = null;
+    this.negate = false;
+    this.nonegate = !!options.nonegate;
+    this.comment = false;
+    this.empty = false;
+    this.partial = !!options.partial;
+    this.nocase = !!this.options.nocase;
+    this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
+    this.globSet = [];
+    this.globParts = [];
+    this.set = [];
+    this.make();
+  }
+  hasMagic() {
+    if (this.options.magicalBraces && this.set.length > 1) {
+      return true;
+    }
+    for (const pattern of this.set) {
+      for (const part of pattern) {
+        if (typeof part !== "string")
+          return true;
+      }
+    }
+    return false;
+  }
+  debug(..._2) {
+  }
+  make() {
+    const pattern = this.pattern;
+    const options = this.options;
+    if (!options.nocomment && pattern.charAt(0) === "#") {
+      this.comment = true;
+      return;
+    }
+    if (!pattern) {
+      this.empty = true;
+      return;
+    }
+    this.parseNegate();
+    this.globSet = [...new Set(this.braceExpand())];
+    if (options.debug) {
+      this.debug = (...args) => console.error(...args);
+    }
+    this.debug(this.pattern, this.globSet);
+    const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
+    this.globParts = this.preprocess(rawGlobParts);
+    this.debug(this.pattern, this.globParts);
+    let set = this.globParts.map((s, _2, __) => {
+      if (this.isWindows && this.windowsNoMagicRoot) {
+        const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
+        const isDrive = /^[a-z]:/i.test(s[0]);
+        if (isUNC) {
+          return [
+            ...s.slice(0, 4),
+            ...s.slice(4).map((ss) => this.parse(ss))
+          ];
+        } else if (isDrive) {
+          return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
+        }
+      }
+      return s.map((ss) => this.parse(ss));
+    });
+    this.debug(this.pattern, set);
+    this.set = set.filter((s) => s.indexOf(false) === -1);
+    if (this.isWindows) {
+      for (let i = 0; i < this.set.length; i++) {
+        const p = this.set[i];
+        if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) {
+          p[2] = "?";
+        }
+      }
+    }
+    this.debug(this.pattern, this.set);
+  }
+  // various transforms to equivalent pattern sets that are
+  // faster to process in a filesystem walk.  The goal is to
+  // eliminate what we can, and push all ** patterns as far
+  // to the right as possible, even if it increases the number
+  // of patterns that we have to process.
+  preprocess(globParts) {
+    if (this.options.noglobstar) {
+      for (const partset of globParts) {
+        for (let j = 0; j < partset.length; j++) {
+          if (partset[j] === "**") {
+            partset[j] = "*";
+          }
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      globParts = this.firstPhasePreProcess(globParts);
+      globParts = this.secondPhasePreProcess(globParts);
+    } else if (optimizationLevel >= 1) {
+      globParts = this.levelOneOptimize(globParts);
+    } else {
+      globParts = this.adjascentGlobstarOptimize(globParts);
+    }
+    return globParts;
+  }
+  // just get rid of adjascent ** portions
+  adjascentGlobstarOptimize(globParts) {
+    return globParts.map((parts) => {
+      let gs = -1;
+      while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+        let i = gs;
+        while (parts[i + 1] === "**") {
+          i++;
+        }
+        if (i !== gs) {
+          parts.splice(gs, i - gs);
+        }
+      }
+      return parts;
+    });
+  }
+  // get rid of adjascent ** and resolve .. portions
+  levelOneOptimize(globParts) {
+    return globParts.map((parts) => {
+      parts = parts.reduce((set, part) => {
+        const prev = set[set.length - 1];
+        if (part === "**" && prev === "**") {
+          return set;
+        }
+        if (part === "..") {
+          if (prev && prev !== ".." && prev !== "." && prev !== "**") {
+            set.pop();
+            return set;
+          }
+        }
+        set.push(part);
+        return set;
+      }, []);
+      return parts.length === 0 ? [""] : parts;
+    });
+  }
+  levelTwoFileOptimize(parts) {
+    if (!Array.isArray(parts)) {
+      parts = this.slashSplit(parts);
+    }
+    let didSomething = false;
+    do {
+      didSomething = false;
+      if (!this.preserveMultipleSlashes) {
+        for (let i = 1; i < parts.length - 1; i++) {
+          const p = parts[i];
+          if (i === 1 && p === "" && parts[0] === "")
+            continue;
+          if (p === "." || p === "") {
+            didSomething = true;
+            parts.splice(i, 1);
+            i--;
+          }
+        }
+        if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+          didSomething = true;
+          parts.pop();
+        }
+      }
+      let dd = 0;
+      while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+        const p = parts[dd - 1];
+        if (p && p !== "." && p !== ".." && p !== "**" && !(this.isWindows && /^[a-z]:$/i.test(p))) {
+          didSomething = true;
+          parts.splice(dd - 1, 2);
+          dd -= 2;
+        }
+      }
+    } while (didSomething);
+    return parts.length === 0 ? [""] : parts;
+  }
+  // First phase: single-pattern processing
+  // <pre> is 1 or more portions
+  // <rest> is 1 or more portions
+  // <p> is any portion other than ., .., '', or **
+  // <e> is . or ''
+  //
+  // **/.. is *brutal* for filesystem walking performance, because
+  // it effectively resets the recursive walk each time it occurs,
+  // and ** cannot be reduced out by a .. pattern part like a regexp
+  // or most strings (other than .., ., and '') can be.
+  //
+  // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
+  // <pre>/<e>/<rest> -> <pre>/<rest>
+  // <pre>/<p>/../<rest> -> <pre>/<rest>
+  // **/**/<rest> -> **/<rest>
+  //
+  // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
+  // this WOULD be allowed if ** did follow symlinks, or * didn't
+  firstPhasePreProcess(globParts) {
+    let didSomething = false;
+    do {
+      didSomething = false;
+      for (let parts of globParts) {
+        let gs = -1;
+        while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+          let gss = gs;
+          while (parts[gss + 1] === "**") {
+            gss++;
+          }
+          if (gss > gs) {
+            parts.splice(gs + 1, gss - gs);
+          }
+          let next = parts[gs + 1];
+          const p = parts[gs + 2];
+          const p2 = parts[gs + 3];
+          if (next !== "..")
+            continue;
+          if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") {
+            continue;
+          }
+          didSomething = true;
+          parts.splice(gs, 1);
+          const other = parts.slice(0);
+          other[gs] = "**";
+          globParts.push(other);
+          gs--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let i = 1; i < parts.length - 1; i++) {
+            const p = parts[i];
+            if (i === 1 && p === "" && parts[0] === "")
+              continue;
+            if (p === "." || p === "") {
+              didSomething = true;
+              parts.splice(i, 1);
+              i--;
+            }
+          }
+          if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+            didSomething = true;
+            parts.pop();
+          }
+        }
+        let dd = 0;
+        while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+          const p = parts[dd - 1];
+          if (p && p !== "." && p !== ".." && p !== "**") {
+            didSomething = true;
+            const needDot = dd === 1 && parts[dd + 1] === "**";
+            const splin = needDot ? ["."] : [];
+            parts.splice(dd - 1, 2, ...splin);
+            if (parts.length === 0)
+              parts.push("");
+            dd -= 2;
+          }
+        }
+      }
+    } while (didSomething);
+    return globParts;
+  }
+  // second phase: multi-pattern dedupes
+  // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
+  // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
+  // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
+  //
+  // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
+  // ^-- not valid because ** doens't follow symlinks
+  secondPhasePreProcess(globParts) {
+    for (let i = 0; i < globParts.length - 1; i++) {
+      for (let j = i + 1; j < globParts.length; j++) {
+        const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
+        if (matched) {
+          globParts[i] = [];
+          globParts[j] = matched;
+          break;
+        }
+      }
+    }
+    return globParts.filter((gs) => gs.length);
+  }
+  partsMatch(a, b, emptyGSMatch = false) {
+    let ai = 0;
+    let bi = 0;
+    let result = [];
+    let which9 = "";
+    while (ai < a.length && bi < b.length) {
+      if (a[ai] === b[bi]) {
+        result.push(which9 === "b" ? b[bi] : a[ai]);
+        ai++;
+        bi++;
+      } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
+        result.push(a[ai]);
+        ai++;
+      } else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
+        result.push(b[bi]);
+        bi++;
+      } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
+        if (which9 === "b")
+          return false;
+        which9 = "a";
+        result.push(a[ai]);
+        ai++;
+        bi++;
+      } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
+        if (which9 === "a")
+          return false;
+        which9 = "b";
+        result.push(b[bi]);
+        ai++;
+        bi++;
+      } else {
+        return false;
+      }
+    }
+    return a.length === b.length && result;
+  }
+  parseNegate() {
+    if (this.nonegate)
+      return;
+    const pattern = this.pattern;
+    let negate2 = false;
+    let negateOffset = 0;
+    for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
+      negate2 = !negate2;
+      negateOffset++;
+    }
+    if (negateOffset)
+      this.pattern = pattern.slice(negateOffset);
+    this.negate = negate2;
+  }
+  // set partial to true to test if, for example,
+  // "/a/b" matches the start of "/*/b/*/d"
+  // Partial means, if you run out of file before you run
+  // out of pattern, then that's fine, as long as all
+  // the parts match.
+  matchOne(file, pattern, partial = false) {
+    let fileStartIndex = 0;
+    let patternStartIndex = 0;
+    if (this.isWindows) {
+      const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
+      const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
+      const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
+      const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
+      const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
+      const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
+      if (typeof fdi === "number" && typeof pdi === "number") {
+        const [fd, pd] = [
+          file[fdi],
+          pattern[pdi]
+        ];
+        if (fd.toLowerCase() === pd.toLowerCase()) {
+          pattern[pdi] = fd;
+          patternStartIndex = pdi;
+          fileStartIndex = fdi;
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      file = this.levelTwoFileOptimize(file);
+    }
+    if (pattern.includes(GLOBSTAR)) {
+      return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
+    }
+    return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
+  }
+  #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
+    const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
+    const lastgs = pattern.lastIndexOf(GLOBSTAR);
+    const [head, body, tail] = partial ? [
+      pattern.slice(patternIndex, firstgs),
+      pattern.slice(firstgs + 1),
+      []
+    ] : [
+      pattern.slice(patternIndex, firstgs),
+      pattern.slice(firstgs + 1, lastgs),
+      pattern.slice(lastgs + 1)
+    ];
+    if (head.length) {
+      const fileHead = file.slice(fileIndex, fileIndex + head.length);
+      if (!this.#matchOne(fileHead, head, partial, 0, 0)) {
+        return false;
+      }
+      fileIndex += head.length;
+      patternIndex += head.length;
+    }
+    let fileTailMatch = 0;
+    if (tail.length) {
+      if (tail.length + fileIndex > file.length)
+        return false;
+      let tailStart = file.length - tail.length;
+      if (this.#matchOne(file, tail, partial, tailStart, 0)) {
+        fileTailMatch = tail.length;
+      } else {
+        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.length) {
+      let sawSome = !!fileTailMatch;
+      for (let i2 = fileIndex; i2 < file.length - fileTailMatch; i2++) {
+        const f = String(file[i2]);
+        sawSome = true;
+        if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+          return false;
+        }
+      }
+      return partial || sawSome;
+    }
+    const bodySegments = [[[], 0]];
+    let currentBody = bodySegments[0];
+    let nonGsParts = 0;
+    const nonGsPartsSums = [0];
+    for (const b of body) {
+      if (b === GLOBSTAR) {
+        nonGsPartsSums.push(nonGsParts);
+        currentBody = [[], 0];
+        bodySegments.push(currentBody);
+      } else {
+        currentBody[0].push(b);
+        nonGsParts++;
+      }
+    }
+    let i = bodySegments.length - 1;
+    const fileLength = file.length - fileTailMatch;
+    for (const b of bodySegments) {
+      b[1] = fileLength - (nonGsPartsSums[i--] + b[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"
+  #matchGlobStarBodySections(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+    const bs = bodySegments[bodyIndex];
+    if (!bs) {
+      for (let i = fileIndex; i < file.length; i++) {
+        sawTail = true;
+        const f = file[i];
+        if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+          return false;
+        }
+      }
+      return sawTail;
+    }
+    const [body, after] = bs;
+    while (fileIndex <= after) {
+      const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
+      if (m && globStarDepth < this.maxGlobstarRecursion) {
+        const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
+        if (sub !== false) {
+          return sub;
+        }
+      }
+      const f = file[fileIndex];
+      if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+        return false;
+      }
+      fileIndex++;
+    }
+    return partial || null;
+  }
+  #matchOne(file, pattern, partial, fileIndex, patternIndex) {
+    let fi;
+    let pi;
+    let pl;
+    let fl;
+    for (fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+      this.debug("matchOne loop");
+      let p = pattern[pi];
+      let f = file[fi];
+      this.debug(pattern, p, f);
+      if (p === false || p === GLOBSTAR) {
+        return false;
+      }
+      let hit;
+      if (typeof p === "string") {
+        hit = f === p;
+        this.debug("string match", p, f, hit);
+      } else {
+        hit = p.test(f);
+        this.debug("pattern match", p, f, hit);
+      }
+      if (!hit)
+        return false;
+    }
+    if (fi === fl && pi === pl) {
+      return true;
+    } else if (fi === fl) {
+      return partial;
+    } else if (pi === pl) {
+      return fi === fl - 1 && file[fi] === "";
+    } else {
+      throw new Error("wtf?");
+    }
+  }
+  braceExpand() {
+    return braceExpand(this.pattern, this.options);
+  }
+  parse(pattern) {
+    assertValidPattern(pattern);
+    const options = this.options;
+    if (pattern === "**")
+      return GLOBSTAR;
+    if (pattern === "")
+      return "";
+    let m;
+    let fastTest = null;
+    if (m = pattern.match(starRE)) {
+      fastTest = options.dot ? starTestDot : starTest;
+    } else if (m = pattern.match(starDotExtRE)) {
+      fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
+    } else if (m = pattern.match(qmarksRE)) {
+      fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
+    } else if (m = pattern.match(starDotStarRE)) {
+      fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
+    } else if (m = pattern.match(dotStarRE)) {
+      fastTest = dotStarTest;
+    }
+    const re = AST.fromGlob(pattern, this.options).toMMPattern();
+    if (fastTest && typeof re === "object") {
+      Reflect.defineProperty(re, "test", { value: fastTest });
+    }
+    return re;
+  }
+  makeRe() {
+    if (this.regexp || this.regexp === false)
+      return this.regexp;
+    const set = this.set;
+    if (!set.length) {
+      this.regexp = false;
+      return this.regexp;
+    }
+    const options = this.options;
+    const twoStar = options.noglobstar ? star2 : options.dot ? twoStarDot : twoStarNoDot;
+    const flags = new Set(options.nocase ? ["i"] : []);
+    let re = set.map((pattern) => {
+      const pp = pattern.map((p) => {
+        if (p instanceof RegExp) {
+          for (const f of p.flags.split(""))
+            flags.add(f);
+        }
+        return typeof p === "string" ? regExpEscape2(p) : p === GLOBSTAR ? GLOBSTAR : p._src;
+      });
+      pp.forEach((p, i) => {
+        const next = pp[i + 1];
+        const prev = pp[i - 1];
+        if (p !== GLOBSTAR || prev === GLOBSTAR) {
+          return;
+        }
+        if (prev === void 0) {
+          if (next !== void 0 && next !== GLOBSTAR) {
+            pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
+          } else {
+            pp[i] = twoStar;
+          }
+        } else if (next === void 0) {
+          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
+        } else if (next !== GLOBSTAR) {
+          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
+          pp[i + 1] = GLOBSTAR;
+        }
+      });
+      const filtered = pp.filter((p) => p !== GLOBSTAR);
+      if (this.partial && filtered.length >= 1) {
+        const prefixes = [];
+        for (let i = 1; i <= filtered.length; i++) {
+          prefixes.push(filtered.slice(0, i).join("/"));
+        }
+        return "(?:" + prefixes.join("|") + ")";
+      }
+      return filtered.join("/");
+    }).join("|");
+    const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
+    re = "^" + open + re + close + "$";
+    if (this.partial) {
+      re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
+    }
+    if (this.negate)
+      re = "^(?!" + re + ").+$";
+    try {
+      this.regexp = new RegExp(re, [...flags].join(""));
+    } catch {
+      this.regexp = false;
+    }
+    return this.regexp;
+  }
+  slashSplit(p) {
+    if (this.preserveMultipleSlashes) {
+      return p.split("/");
+    } else if (this.isWindows && /^\/\/[^/]+/.test(p)) {
+      return ["", ...p.split(/\/+/)];
+    } else {
+      return p.split(/\/+/);
+    }
+  }
+  match(f, partial = this.partial) {
+    this.debug("match", f, this.pattern);
+    if (this.comment) {
+      return false;
+    }
+    if (this.empty) {
+      return f === "";
+    }
+    if (f === "/" && partial) {
+      return true;
+    }
+    const options = this.options;
+    if (this.isWindows) {
+      f = f.split("\\").join("/");
+    }
+    const ff = this.slashSplit(f);
+    this.debug(this.pattern, "split", ff);
+    const set = this.set;
+    this.debug(this.pattern, "set", set);
+    let filename = ff[ff.length - 1];
+    if (!filename) {
+      for (let i = ff.length - 2; !filename && i >= 0; i--) {
+        filename = ff[i];
+      }
+    }
+    for (const pattern of set) {
+      let file = ff;
+      if (options.matchBase && pattern.length === 1) {
+        file = [filename];
+      }
+      const hit = this.matchOne(file, pattern, partial);
+      if (hit) {
+        if (options.flipNegate) {
+          return true;
+        }
+        return !this.negate;
+      }
+    }
+    if (options.flipNegate) {
+      return false;
+    }
+    return this.negate;
+  }
+  static defaults(def) {
+    return minimatch.defaults(def).Minimatch;
+  }
+};
+minimatch.AST = AST;
+minimatch.Minimatch = Minimatch;
+minimatch.escape = escape2;
+minimatch.unescape = unescape2;
+
+// node_modules/readdir-glob/dist/index.mjs
+var import_path5 = require("path");
+function readdir2(dir, strict) {
+  return new Promise((resolve$1, reject) => {
+    fs23.readdir(dir, { withFileTypes: true }, (err, files) => {
+      if (err) switch (err.code) {
+        case "ENOTDIR":
+          if (strict) reject(err);
+          else resolve$1([]);
+          break;
+        case "ENOTSUP":
+        case "ENOENT":
+        case "ENAMETOOLONG":
+        case "UNKNOWN":
+          resolve$1([]);
+          break;
+        case "ELOOP":
+        default:
+          reject(err);
+          break;
+      }
+      else resolve$1(files);
+    });
+  });
+}
+function getStat(file, followSymlinks) {
+  return new Promise((resolve$1) => {
+    const statFunc = followSymlinks ? fs23.stat : fs23.lstat;
+    statFunc(file, (err, stats) => {
+      if (err) switch (err.code) {
+        case "ENOENT":
+          if (followSymlinks) resolve$1(getStat(file, false));
+          else resolve$1(null);
+          break;
+        default:
+          resolve$1(null);
+          break;
+      }
+      else resolve$1(stats);
+    });
+  });
+}
+async function* exploreWalkAsync(dir, path29, followSymlinks, useStat, shouldSkip, strict) {
+  let files = await readdir2(path29 + dir, strict);
+  for (const file of files) {
+    let name = file.name;
+    const filename = dir + "/" + name;
+    const relative3 = filename.slice(1);
+    const absolute = path29 + "/" + relative3;
+    let stat2 = file;
+    if (useStat || followSymlinks) stat2 = await getStat(absolute, followSymlinks) ?? stat2;
+    if (stat2.isDirectory()) {
+      if (!shouldSkip(relative3)) {
+        yield {
+          relative: relative3,
+          absolute,
+          stat: stat2
+        };
+        yield* exploreWalkAsync(filename, path29, followSymlinks, useStat, shouldSkip, false);
+      }
+    } else yield {
+      relative: relative3,
+      absolute,
+      stat: stat2
+    };
+  }
+}
+async function* explore(path29, followSymlinks, useStat, shouldSkip) {
+  yield* exploreWalkAsync("", path29, followSymlinks, useStat, shouldSkip, true);
+}
+function readOptions(options) {
+  return {
+    pattern: options.pattern,
+    dot: !!options.dot,
+    noglobstar: !!options.noglobstar,
+    matchBase: !!options.matchBase,
+    nocase: !!options.nocase,
+    ignore: options.ignore,
+    skip: options.skip,
+    follow: !!options.follow,
+    stat: !!options.stat,
+    nodir: !!options.nodir,
+    mark: !!options.mark,
+    silent: !!options.silent,
+    absolute: !!options.absolute
+  };
+}
+var ReaddirGlob = class extends import_events.EventEmitter {
+  options;
+  matchers;
+  ignoreMatchers;
+  skipMatchers;
+  paused;
+  aborted;
+  inactive;
+  iterator;
+  constructor(cwd, options, cb) {
+    super();
+    if (typeof options === "function") {
+      cb = options;
+      options = void 0;
+    }
+    this.options = readOptions(options || {});
+    this.matchers = [];
+    if (this.options.pattern) {
+      const matchers = Array.isArray(this.options.pattern) ? this.options.pattern : [this.options.pattern];
+      this.matchers = matchers.map((m) => new Minimatch(m, {
+        dot: this.options.dot,
+        noglobstar: this.options.noglobstar,
+        matchBase: this.options.matchBase,
+        nocase: this.options.nocase
+      }));
+    }
+    this.ignoreMatchers = [];
+    if (this.options.ignore) {
+      const ignorePatterns = Array.isArray(this.options.ignore) ? this.options.ignore : [this.options.ignore];
+      this.ignoreMatchers = ignorePatterns.map((ignore) => new Minimatch(ignore, { dot: true }));
+    }
+    this.skipMatchers = [];
+    if (this.options.skip) {
+      const skipPatterns = Array.isArray(this.options.skip) ? this.options.skip : [this.options.skip];
+      this.skipMatchers = skipPatterns.map((skip) => new Minimatch(skip, { dot: true }));
+    }
+    this.iterator = explore((0, import_path5.resolve)(cwd || "."), this.options.follow, this.options.stat, this._shouldSkipDirectory.bind(this));
+    this.paused = false;
+    this.inactive = false;
+    this.aborted = false;
+    if (cb) {
+      const nonNullCb = cb;
+      const matches = [];
+      this.on("match", (match2) => matches.push(this.options.absolute ? match2.absolute : match2.relative));
+      this.on("error", (err) => nonNullCb(err));
+      this.on("end", () => nonNullCb(null, matches));
+    }
+    setTimeout(() => this._next());
+  }
+  _shouldSkipDirectory(relative3) {
+    return this.skipMatchers.some((m) => m.match(relative3));
+  }
+  _fileMatches(relative3, isDirectory) {
+    const file = relative3 + (isDirectory ? "/" : "");
+    return (this.matchers.length === 0 || this.matchers.some((m) => m.match(file))) && !this.ignoreMatchers.some((m) => m.match(file)) && (!this.options.nodir || !isDirectory);
+  }
+  _next() {
+    if (!this.paused && !this.aborted) this.iterator.next().then((obj) => {
+      if (!obj.done) {
+        const isDirectory = obj.value.stat.isDirectory();
+        if (this._fileMatches(obj.value.relative, isDirectory)) {
+          let relative3 = obj.value.relative;
+          let absolute = obj.value.absolute;
+          if (this.options.mark && isDirectory) {
+            relative3 += "/";
+            absolute += "/";
+          }
+          if (this.options.stat) this.emit("match", {
+            relative: relative3,
+            absolute,
+            stat: obj.value.stat
+          });
+          else this.emit("match", {
+            relative: relative3,
+            absolute
+          });
+        }
+        this._next();
+      } else this.emit("end");
+    }).catch((err) => {
+      this.abort();
+      this.emit("error", err);
+      if (!err.code && !this.options.silent) console.error(err);
+    });
+    else this.inactive = true;
+  }
+  abort() {
+    this.aborted = true;
+  }
+  pause() {
+    this.paused = true;
+  }
+  resume() {
+    this.paused = false;
+    if (this.inactive) {
+      this.inactive = false;
+      this._next();
+    }
+  }
+};
+var readdirGlob = (pattern, options, cb) => new ReaddirGlob(pattern, options, cb);
+readdirGlob.ReaddirGlob = ReaddirGlob;
+var src_default = readdirGlob;
+
+// node_modules/archiver/lib/core.js
+var import_lazystream = __toESM(require_lazystream(), 1);
+var import_async = __toESM(require_async(), 1);
+var import_path6 = require("path");
+
+// node_modules/archiver/lib/error.js
+var import_util28 = __toESM(require("util"), 1);
+var ERROR_CODES = {
+  ABORTED: "archive was aborted",
+  DIRECTORYDIRPATHREQUIRED: "diretory dirpath argument must be a non-empty string value",
+  DIRECTORYFUNCTIONINVALIDDATA: "invalid data returned by directory custom data function",
+  ENTRYNAMEREQUIRED: "entry name must be a non-empty string value",
+  FILEFILEPATHREQUIRED: "file filepath argument must be a non-empty string value",
+  FINALIZING: "archive already finalizing",
+  QUEUECLOSED: "queue closed",
+  NOENDMETHOD: "no suitable finalize/end method defined by module",
+  DIRECTORYNOTSUPPORTED: "support for directory entries not defined by module",
+  FORMATSET: "archive format already set",
+  INPUTSTEAMBUFFERREQUIRED: "input source must be valid Stream or Buffer instance",
+  MODULESET: "module already set",
+  SYMLINKNOTSUPPORTED: "support for symlink entries not defined by module",
+  SYMLINKFILEPATHREQUIRED: "symlink filepath argument must be a non-empty string value",
+  SYMLINKTARGETREQUIRED: "symlink target argument must be a non-empty string value",
+  ENTRYNOTSUPPORTED: "entry not supported"
+};
+function ArchiverError(code, data) {
+  Error.captureStackTrace(this, this.constructor);
+  this.message = ERROR_CODES[code] || code;
+  this.code = code;
+  this.data = data;
+}
+import_util28.default.inherits(ArchiverError, Error);
+
+// node_modules/archiver/lib/core.js
+var import_readable_stream2 = __toESM(require_ours(), 1);
+
+// node_modules/archiver/lib/utils.js
+var import_normalize_path = __toESM(require_normalize_path(), 1);
+var import_readable_stream = __toESM(require_ours(), 1);
+function dateify(dateish) {
+  dateish = dateish || /* @__PURE__ */ new Date();
+  if (dateish instanceof Date) {
+    dateish = dateish;
+  } else if (typeof dateish === "string") {
+    dateish = new Date(dateish);
+  } else {
+    dateish = /* @__PURE__ */ new Date();
+  }
+  return dateish;
+}
+function normalizeInputSource(source) {
+  if (source === null) {
+    return Buffer.alloc(0);
+  } else if (typeof source === "string") {
+    return Buffer.from(source);
+  } else if (isStream(source)) {
+    return source.pipe(new import_readable_stream.PassThrough());
+  }
+  return source;
+}
+function sanitizePath(filepath) {
+  return (0, import_normalize_path.default)(filepath, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
+}
+function trailingSlashIt(str) {
+  return str.slice(-1) !== "/" ? str + "/" : str;
+}
+
+// node_modules/archiver/lib/core.js
+var { ReaddirGlob: ReaddirGlob2 } = src_default;
+var win32 = process.platform === "win32";
+var Archiver = class extends import_readable_stream2.Transform {
+  _supportsDirectory = false;
+  _supportsSymlink = false;
+  /**
+   * @constructor
+   * @param {String} format The archive format to use.
+   * @param {(CoreOptions|TransformOptions)} options See also {@link ZipOptions} and {@link TarOptions}.
+   */
+  constructor(options) {
+    options = {
+      highWaterMark: 1024 * 1024,
+      statConcurrency: 4,
+      ...options
+    };
+    super(options);
+    this.options = options;
+    this._format = false;
+    this._module = false;
+    this._pending = 0;
+    this._pointer = 0;
+    this._entriesCount = 0;
+    this._entriesProcessedCount = 0;
+    this._fsEntriesTotalBytes = 0;
+    this._fsEntriesProcessedBytes = 0;
+    this._queue = (0, import_async.queue)(this._onQueueTask.bind(this), 1);
+    this._queue.drain(this._onQueueDrain.bind(this));
+    this._statQueue = (0, import_async.queue)(
+      this._onStatQueueTask.bind(this),
+      options.statConcurrency
+    );
+    this._statQueue.drain(this._onQueueDrain.bind(this));
+    this._state = {
+      aborted: false,
+      finalize: false,
+      finalizing: false,
+      finalized: false,
+      modulePiped: false
+    };
+    this._streams = [];
+  }
+  /**
+   * Internal logic for `abort`.
+   *
+   * @private
+   * @return void
+   */
+  _abort() {
+    this._state.aborted = true;
+    this._queue.kill();
+    this._statQueue.kill();
+    if (this._queue.idle()) {
+      this._shutdown();
+    }
+  }
+  /**
+   * Internal helper for appending files.
+   *
+   * @private
+   * @param  {String} filepath The source filepath.
+   * @param  {EntryData} data The entry data.
+   * @return void
+   */
+  _append(filepath, data) {
+    data = data || {};
+    let task = {
+      source: null,
+      filepath
+    };
+    if (!data.name) {
+      data.name = filepath;
+    }
+    data.sourcePath = filepath;
+    task.data = data;
+    this._entriesCount++;
+    if (data.stats && data.stats instanceof import_fs2.Stats) {
+      task = this._updateQueueTaskWithStats(task, data.stats);
+      if (task) {
+        if (data.stats.size) {
+          this._fsEntriesTotalBytes += data.stats.size;
+        }
+        this._queue.push(task);
+      }
+    } else {
+      this._statQueue.push(task);
+    }
+  }
+  /**
+   * Internal logic for `finalize`.
+   *
+   * @private
+   * @return void
+   */
+  _finalize() {
+    if (this._state.finalizing || this._state.finalized || this._state.aborted) {
+      return;
+    }
+    this._state.finalizing = true;
+    this._moduleFinalize();
+    this._state.finalizing = false;
+    this._state.finalized = true;
+  }
+  /**
+   * Checks the various state variables to determine if we can `finalize`.
+   *
+   * @private
+   * @return {Boolean}
+   */
+  _maybeFinalize() {
+    if (this._state.finalizing || this._state.finalized || this._state.aborted) {
+      return false;
+    }
+    if (this._state.finalize && this._pending === 0 && this._queue.idle() && this._statQueue.idle()) {
+      this._finalize();
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Appends an entry to the module.
+   *
+   * @private
+   * @fires  Archiver#entry
+   * @param  {(Buffer|Stream)} source
+   * @param  {EntryData} data
+   * @param  {Function} callback
+   * @return void
+   */
+  _moduleAppend(source, data, callback) {
+    if (this._state.aborted) {
+      callback();
+      return;
+    }
+    this._module.append(
+      source,
+      data,
+      function(err) {
+        this._task = null;
+        if (this._state.aborted) {
+          this._shutdown();
+          return;
+        }
+        if (err) {
+          this.emit("error", err);
+          setImmediate(callback);
+          return;
+        }
+        this.emit("entry", data);
+        this._entriesProcessedCount++;
+        if (data.stats && data.stats.size) {
+          this._fsEntriesProcessedBytes += data.stats.size;
+        }
+        this.emit("progress", {
+          entries: {
+            total: this._entriesCount,
+            processed: this._entriesProcessedCount
+          },
+          fs: {
+            totalBytes: this._fsEntriesTotalBytes,
+            processedBytes: this._fsEntriesProcessedBytes
+          }
+        });
+        setImmediate(callback);
+      }.bind(this)
+    );
+  }
+  /**
+   * Finalizes the module.
+   *
+   * @private
+   * @return void
+   */
+  _moduleFinalize() {
+    if (typeof this._module.finalize === "function") {
+      this._module.finalize();
+    } else if (typeof this._module.end === "function") {
+      this._module.end();
+    } else {
+      this.emit("error", new ArchiverError("NOENDMETHOD"));
+    }
+  }
+  /**
+   * Pipes the module to our internal stream with error bubbling.
+   *
+   * @private
+   * @return void
+   */
+  _modulePipe() {
+    this._module.on("error", this._onModuleError.bind(this));
+    this._module.pipe(this);
+    this._state.modulePiped = true;
+  }
+  /**
+   * Unpipes the module from our internal stream.
+   *
+   * @private
+   * @return void
+   */
+  _moduleUnpipe() {
+    this._module.unpipe(this);
+    this._state.modulePiped = false;
+  }
+  /**
+   * Normalizes entry data with fallbacks for key properties.
+   *
+   * @private
+   * @param  {Object} data
+   * @param  {fs.Stats} stats
+   * @return {Object}
+   */
+  _normalizeEntryData(data, stats) {
+    data = {
+      type: "file",
+      name: null,
+      date: null,
+      mode: null,
+      prefix: null,
+      sourcePath: null,
+      stats: false,
+      ...data
+    };
+    if (stats && data.stats === false) {
+      data.stats = stats;
+    }
+    let isDir = data.type === "directory";
+    if (data.name) {
+      if (typeof data.prefix === "string" && "" !== data.prefix) {
+        data.name = data.prefix + "/" + data.name;
+        data.prefix = null;
+      }
+      data.name = sanitizePath(data.name);
+      if (data.type !== "symlink" && data.name.slice(-1) === "/") {
+        isDir = true;
+        data.type = "directory";
+      } else if (isDir) {
+        data.name += "/";
+      }
+    }
+    if (typeof data.mode === "number") {
+      if (win32) {
+        data.mode &= 511;
+      } else {
+        data.mode &= 4095;
+      }
+    } else if (data.stats && data.mode === null) {
+      if (win32) {
+        data.mode = data.stats.mode & 511;
+      } else {
+        data.mode = data.stats.mode & 4095;
+      }
+      if (win32 && isDir) {
+        data.mode = 493;
+      }
+    } else if (data.mode === null) {
+      data.mode = isDir ? 493 : 420;
+    }
+    if (data.stats && data.date === null) {
+      data.date = data.stats.mtime;
+    } else {
+      data.date = dateify(data.date);
+    }
+    return data;
+  }
+  /**
+   * Error listener that re-emits error on to our internal stream.
+   *
+   * @private
+   * @param  {Error} err
+   * @return void
+   */
+  _onModuleError(err) {
+    this.emit("error", err);
+  }
+  /**
+   * Checks the various state variables after queue has drained to determine if
+   * we need to `finalize`.
+   *
+   * @private
+   * @return void
+   */
+  _onQueueDrain() {
+    if (this._state.finalizing || this._state.finalized || this._state.aborted) {
+      return;
+    }
+    if (this._state.finalize && this._pending === 0 && this._queue.idle() && this._statQueue.idle()) {
+      this._finalize();
+    }
+  }
+  /**
+   * Appends each queue task to the module.
+   *
+   * @private
+   * @param  {Object} task
+   * @param  {Function} callback
+   * @return void
+   */
+  _onQueueTask(task, callback) {
+    const fullCallback = () => {
+      if (task.data.callback) {
+        task.data.callback();
+      }
+      callback();
+    };
+    if (this._state.finalizing || this._state.finalized || this._state.aborted) {
+      fullCallback();
+      return;
+    }
+    this._task = task;
+    this._moduleAppend(task.source, task.data, fullCallback);
+  }
+  /**
+   * Performs a file stat and reinjects the task back into the queue.
+   *
+   * @private
+   * @param  {Object} task
+   * @param  {Function} callback
+   * @return void
+   */
+  _onStatQueueTask(task, callback) {
+    if (this._state.finalizing || this._state.finalized || this._state.aborted) {
+      callback();
+      return;
+    }
+    (0, import_fs2.lstat)(
+      task.filepath,
+      function(err, stats) {
+        if (this._state.aborted) {
+          setImmediate(callback);
+          return;
+        }
+        if (err) {
+          this._entriesCount--;
+          this.emit("warning", err);
+          setImmediate(callback);
+          return;
+        }
+        task = this._updateQueueTaskWithStats(task, stats);
+        if (task) {
+          if (stats.size) {
+            this._fsEntriesTotalBytes += stats.size;
+          }
+          this._queue.push(task);
+        }
+        setImmediate(callback);
+      }.bind(this)
+    );
+  }
+  /**
+   * Unpipes the module and ends our internal stream.
+   *
+   * @private
+   * @return void
+   */
+  _shutdown() {
+    this._moduleUnpipe();
+    this.end();
+  }
+  /**
+   * Tracks the bytes emitted by our internal stream.
+   *
+   * @private
+   * @param  {Buffer} chunk
+   * @param  {String} encoding
+   * @param  {Function} callback
+   * @return void
+   */
+  _transform(chunk, encoding, callback) {
+    if (chunk) {
+      this._pointer += chunk.length;
+    }
+    callback(null, chunk);
+  }
+  /**
+   * Updates and normalizes a queue task using stats data.
+   *
+   * @private
+   * @param  {Object} task
+   * @param  {Stats} stats
+   * @return {Object}
+   */
+  _updateQueueTaskWithStats(task, stats) {
+    if (stats.isFile()) {
+      task.data.type = "file";
+      task.data.sourceType = "stream";
+      task.source = new import_lazystream.Readable(function() {
+        return (0, import_fs2.createReadStream)(task.filepath);
+      });
+    } else if (stats.isDirectory() && this._supportsDirectory) {
+      task.data.name = trailingSlashIt(task.data.name);
+      task.data.type = "directory";
+      task.data.sourcePath = trailingSlashIt(task.filepath);
+      task.data.sourceType = "buffer";
+      task.source = Buffer.concat([]);
+    } else if (stats.isSymbolicLink() && this._supportsSymlink) {
+      const linkPath = (0, import_fs2.readlinkSync)(task.filepath);
+      const dirName = (0, import_path6.dirname)(task.filepath);
+      task.data.type = "symlink";
+      task.data.linkname = (0, import_path6.relative)(
+        dirName,
+        (0, import_path6.resolve)(dirName, linkPath)
+      );
+      task.data.sourceType = "buffer";
+      task.source = Buffer.concat([]);
+    } else {
+      if (stats.isDirectory()) {
+        this.emit(
+          "warning",
+          new ArchiverError("DIRECTORYNOTSUPPORTED", task.data)
+        );
+      } else if (stats.isSymbolicLink()) {
+        this.emit(
+          "warning",
+          new ArchiverError("SYMLINKNOTSUPPORTED", task.data)
+        );
+      } else {
+        this.emit("warning", new ArchiverError("ENTRYNOTSUPPORTED", task.data));
+      }
+      return null;
+    }
+    task.data = this._normalizeEntryData(task.data, stats);
+    return task;
+  }
+  /**
+   * Aborts the archiving process, taking a best-effort approach, by:
+   *
+   * - removing any pending queue tasks
+   * - allowing any active queue workers to finish
+   * - detaching internal module pipes
+   * - ending both sides of the Transform stream
+   *
+   * It will NOT drain any remaining sources.
+   *
+   * @return {this}
+   */
+  abort() {
+    if (this._state.aborted || this._state.finalized) {
+      return this;
+    }
+    this._abort();
+    return this;
+  }
+  /**
+   * Appends an input source (text string, buffer, or stream) to the instance.
+   *
+   * When the instance has received, processed, and emitted the input, the `entry`
+   * event is fired.
+   *
+   * @fires  Archiver#entry
+   * @param  {(Buffer|Stream|String)} source The input source.
+   * @param  {EntryData} data See also {@link ZipEntryData} and {@link TarEntryData}.
+   * @return {this}
+   */
+  append(source, data) {
+    if (this._state.finalize || this._state.aborted) {
+      this.emit("error", new ArchiverError("QUEUECLOSED"));
+      return this;
+    }
+    data = this._normalizeEntryData(data);
+    if (typeof data.name !== "string" || data.name.length === 0) {
+      this.emit("error", new ArchiverError("ENTRYNAMEREQUIRED"));
+      return this;
+    }
+    if (data.type === "directory" && !this._supportsDirectory) {
+      this.emit(
+        "error",
+        new ArchiverError("DIRECTORYNOTSUPPORTED", { name: data.name })
+      );
+      return this;
+    }
+    source = normalizeInputSource(source);
+    if (Buffer.isBuffer(source)) {
+      data.sourceType = "buffer";
+    } else if (isStream(source)) {
+      data.sourceType = "stream";
+    } else {
+      this.emit(
+        "error",
+        new ArchiverError("INPUTSTEAMBUFFERREQUIRED", { name: data.name })
+      );
+      return this;
+    }
+    this._entriesCount++;
+    this._queue.push({
+      data,
+      source
+    });
+    return this;
+  }
+  /**
+   * Appends a directory and its files, recursively, given its dirpath.
+   *
+   * @param  {String} dirpath The source directory path.
+   * @param  {String} destpath The destination path within the archive.
+   * @param  {(EntryData|Function)} data See also [ZipEntryData]{@link ZipEntryData} and
+   * [TarEntryData]{@link TarEntryData}.
+   * @return {this}
+   */
+  directory(dirpath, destpath, data) {
+    if (this._state.finalize || this._state.aborted) {
+      this.emit("error", new ArchiverError("QUEUECLOSED"));
+      return this;
+    }
+    if (typeof dirpath !== "string" || dirpath.length === 0) {
+      this.emit("error", new ArchiverError("DIRECTORYDIRPATHREQUIRED"));
+      return this;
+    }
+    this._pending++;
+    if (destpath === false) {
+      destpath = "";
+    } else if (typeof destpath !== "string") {
+      destpath = dirpath;
+    }
+    var dataFunction = false;
+    if (typeof data === "function") {
+      dataFunction = data;
+      data = {};
+    } else if (typeof data !== "object") {
+      data = {};
+    }
+    var globOptions = {
+      stat: true,
+      dot: true
+    };
+    function onGlobEnd() {
+      this._pending--;
+      this._maybeFinalize();
+    }
+    function onGlobError(err) {
+      this.emit("error", err);
+    }
+    function onGlobMatch(match2) {
+      globber.pause();
+      let ignoreMatch = false;
+      let entryData = Object.assign({}, data);
+      entryData.name = match2.relative;
+      entryData.prefix = destpath;
+      entryData.stats = match2.stat;
+      entryData.callback = globber.resume.bind(globber);
+      try {
+        if (dataFunction) {
+          entryData = dataFunction(entryData);
+          if (entryData === false) {
+            ignoreMatch = true;
+          } else if (typeof entryData !== "object") {
+            throw new ArchiverError("DIRECTORYFUNCTIONINVALIDDATA", {
+              dirpath
+            });
+          }
+        }
+      } catch (e) {
+        this.emit("error", e);
+        return;
+      }
+      if (ignoreMatch) {
+        globber.resume();
+        return;
+      }
+      this._append(match2.absolute, entryData);
+    }
+    const globber = src_default(dirpath, globOptions);
+    globber.on("error", onGlobError.bind(this));
+    globber.on("match", onGlobMatch.bind(this));
+    globber.on("end", onGlobEnd.bind(this));
+    return this;
+  }
+  /**
+   * Appends a file given its filepath using a
+   * [lazystream]{@link https://github.com/jpommerening/node-lazystream} wrapper to
+   * prevent issues with open file limits.
+   *
+   * When the instance has received, processed, and emitted the file, the `entry`
+   * event is fired.
+   *
+   * @param  {String} filepath The source filepath.
+   * @param  {EntryData} data See also [ZipEntryData]{@link ZipEntryData} and
+   * [TarEntryData]{@link TarEntryData}.
+   * @return {this}
+   */
+  file(filepath, data) {
+    if (this._state.finalize || this._state.aborted) {
+      this.emit("error", new ArchiverError("QUEUECLOSED"));
+      return this;
+    }
+    if (typeof filepath !== "string" || filepath.length === 0) {
+      this.emit("error", new ArchiverError("FILEFILEPATHREQUIRED"));
+      return this;
+    }
+    this._append(filepath, data);
+    return this;
+  }
+  /**
+   * Appends multiple files that match a glob pattern.
+   *
+   * @param  {String} pattern The [glob pattern]{@link https://github.com/isaacs/minimatch} to match.
+   * @param  {Object} options See [node-readdir-glob]{@link https://github.com/yqnn/node-readdir-glob#options}.
+   * @param  {EntryData} data See also [ZipEntryData]{@link ZipEntryData} and
+   * [TarEntryData]{@link TarEntryData}.
+   * @return {this}
+   */
+  glob(pattern, options, data) {
+    this._pending++;
+    options = {
+      stat: true,
+      pattern,
+      ...options
+    };
+    function onGlobEnd() {
+      this._pending--;
+      this._maybeFinalize();
+    }
+    function onGlobError(err) {
+      this.emit("error", err);
+    }
+    function onGlobMatch(match2) {
+      globber.pause();
+      const entryData = Object.assign({}, data);
+      entryData.callback = globber.resume.bind(globber);
+      entryData.stats = match2.stat;
+      entryData.name = match2.relative;
+      this._append(match2.absolute, entryData);
+    }
+    const globber = new ReaddirGlob2(options.cwd || ".", options);
+    globber.on("error", onGlobError.bind(this));
+    globber.on("match", onGlobMatch.bind(this));
+    globber.on("end", onGlobEnd.bind(this));
+    return this;
+  }
+  /**
+   * Finalizes the instance and prevents further appending to the archive
+   * structure (queue will continue til drained).
+   *
+   * The `end`, `close` or `finish` events on the destination stream may fire
+   * right after calling this method so you should set listeners beforehand to
+   * properly detect stream completion.
+   *
+   * @return {Promise}
+   */
+  finalize() {
+    if (this._state.aborted) {
+      var abortedError = new ArchiverError("ABORTED");
+      this.emit("error", abortedError);
+      return Promise.reject(abortedError);
+    }
+    if (this._state.finalize) {
+      var finalizingError = new ArchiverError("FINALIZING");
+      this.emit("error", finalizingError);
+      return Promise.reject(finalizingError);
+    }
+    this._state.finalize = true;
+    if (this._pending === 0 && this._queue.idle() && this._statQueue.idle()) {
+      this._finalize();
+    }
+    var self2 = this;
+    return new Promise(function(resolve14, reject) {
+      var errored;
+      self2._module.on("end", function() {
+        if (!errored) {
+          resolve14();
+        }
+      });
+      self2._module.on("error", function(err) {
+        errored = true;
+        reject(err);
+      });
+    });
+  }
+  /**
+   * Appends a symlink to the instance.
+   *
+   * This does NOT interact with filesystem and is used for programmatically creating symlinks.
+   *
+   * @param  {String} filepath The symlink path (within archive).
+   * @param  {String} target The target path (within archive).
+   * @param  {Number} mode Sets the entry permissions.
+   * @return {this}
+   */
+  symlink(filepath, target, mode) {
+    if (this._state.finalize || this._state.aborted) {
+      this.emit("error", new ArchiverError("QUEUECLOSED"));
+      return this;
+    }
+    if (typeof filepath !== "string" || filepath.length === 0) {
+      this.emit("error", new ArchiverError("SYMLINKFILEPATHREQUIRED"));
+      return this;
+    }
+    if (typeof target !== "string" || target.length === 0) {
+      this.emit(
+        "error",
+        new ArchiverError("SYMLINKTARGETREQUIRED", { filepath })
+      );
+      return this;
+    }
+    if (!this._supportsSymlink) {
+      this.emit(
+        "error",
+        new ArchiverError("SYMLINKNOTSUPPORTED", { filepath })
+      );
+      return this;
+    }
+    var data = {};
+    data.type = "symlink";
+    data.name = filepath.replace(/\\/g, "/");
+    data.linkname = target.replace(/\\/g, "/");
+    data.sourceType = "buffer";
+    if (typeof mode === "number") {
+      data.mode = mode;
+    }
+    this._entriesCount++;
+    this._queue.push({
+      data,
+      source: Buffer.concat([])
+    });
+    return this;
+  }
+  /**
+   * Returns the current length (in bytes) that has been emitted.
+   *
+   * @return {Number}
+   */
+  pointer() {
+    return this._pointer;
+  }
+};
+
+// node_modules/compress-commons/lib/archivers/archive-entry.js
+var ArchiveEntry = class {
+  getName() {
+  }
+  getSize() {
+  }
+  getLastModifiedDate() {
+  }
+  isDirectory() {
+  }
+};
+
+// node_modules/compress-commons/lib/archivers/zip/zip-archive-entry.js
+var import_normalize_path2 = __toESM(require_normalize_path(), 1);
+
+// node_modules/compress-commons/lib/archivers/zip/util.js
+function dateToDos(d, forceLocalTime) {
+  forceLocalTime = forceLocalTime || false;
+  var year = forceLocalTime ? d.getFullYear() : d.getUTCFullYear();
+  if (year < 1980) {
+    return 2162688;
+  } else if (year >= 2044) {
+    return 2141175677;
+  }
+  var val = {
+    year,
+    month: forceLocalTime ? d.getMonth() : d.getUTCMonth(),
+    date: forceLocalTime ? d.getDate() : d.getUTCDate(),
+    hours: forceLocalTime ? d.getHours() : d.getUTCHours(),
+    minutes: forceLocalTime ? d.getMinutes() : d.getUTCMinutes(),
+    seconds: forceLocalTime ? d.getSeconds() : d.getUTCSeconds()
+  };
+  return val.year - 1980 << 25 | val.month + 1 << 21 | val.date << 16 | val.hours << 11 | val.minutes << 5 | val.seconds / 2;
+}
+function dosToDate(dos) {
+  return new Date(
+    (dos >> 25 & 127) + 1980,
+    (dos >> 21 & 15) - 1,
+    dos >> 16 & 31,
+    dos >> 11 & 31,
+    dos >> 5 & 63,
+    (dos & 31) << 1
+  );
+}
+function getEightBytes(v) {
+  var buf = Buffer.alloc(8);
+  buf.writeUInt32LE(v % 4294967296, 0);
+  buf.writeUInt32LE(v / 4294967296 | 0, 4);
+  return buf;
+}
+function getShortBytes(v) {
+  var buf = Buffer.alloc(2);
+  buf.writeUInt16LE((v & 65535) >>> 0, 0);
+  return buf;
+}
+function getShortBytesValue(buf, offset) {
+  return buf.readUInt16LE(offset);
+}
+function getLongBytes(v) {
+  var buf = Buffer.alloc(4);
+  buf.writeUInt32LE((v & 4294967295) >>> 0, 0);
+  return buf;
+}
+
+// node_modules/compress-commons/lib/archivers/zip/general-purpose-bit.js
+var DATA_DESCRIPTOR_FLAG = 1 << 3;
+var ENCRYPTION_FLAG = 1 << 0;
+var NUMBER_OF_SHANNON_FANO_TREES_FLAG = 1 << 2;
+var SLIDING_DICTIONARY_SIZE_FLAG = 1 << 1;
+var STRONG_ENCRYPTION_FLAG = 1 << 6;
+var UFT8_NAMES_FLAG = 1 << 11;
+var GeneralPurposeBit = class _GeneralPurposeBit {
+  constructor() {
+    this.descriptor = false;
+    this.encryption = false;
+    this.utf8 = false;
+    this.numberOfShannonFanoTrees = 0;
+    this.strongEncryption = false;
+    this.slidingDictionarySize = 0;
+    return this;
+  }
+  encode() {
+    return getShortBytes(
+      (this.descriptor ? DATA_DESCRIPTOR_FLAG : 0) | (this.utf8 ? UFT8_NAMES_FLAG : 0) | (this.encryption ? ENCRYPTION_FLAG : 0) | (this.strongEncryption ? STRONG_ENCRYPTION_FLAG : 0)
+    );
+  }
+  static parse(buf, offset) {
+    var flag = getShortBytesValue(buf, offset);
+    var gbp = new _GeneralPurposeBit();
+    gbp.useDataDescriptor((flag & DATA_DESCRIPTOR_FLAG) !== 0);
+    gbp.useUTF8ForNames((flag & UFT8_NAMES_FLAG) !== 0);
+    gbp.useStrongEncryption((flag & STRONG_ENCRYPTION_FLAG) !== 0);
+    gbp.useEncryption((flag & ENCRYPTION_FLAG) !== 0);
+    gbp.setSlidingDictionarySize(
+      (flag & SLIDING_DICTIONARY_SIZE_FLAG) !== 0 ? 8192 : 4096
+    );
+    gbp.setNumberOfShannonFanoTrees(
+      (flag & NUMBER_OF_SHANNON_FANO_TREES_FLAG) !== 0 ? 3 : 2
+    );
+    return gbp;
+  }
+  setNumberOfShannonFanoTrees(n) {
+    this.numberOfShannonFanoTrees = n;
+  }
+  getNumberOfShannonFanoTrees() {
+    return this.numberOfShannonFanoTrees;
+  }
+  setSlidingDictionarySize(n) {
+    this.slidingDictionarySize = n;
+  }
+  getSlidingDictionarySize() {
+    return this.slidingDictionarySize;
+  }
+  useDataDescriptor(b) {
+    this.descriptor = b;
+  }
+  usesDataDescriptor() {
+    return this.descriptor;
+  }
+  useEncryption(b) {
+    this.encryption = b;
+  }
+  usesEncryption() {
+    return this.encryption;
+  }
+  useStrongEncryption(b) {
+    this.strongEncryption = b;
+  }
+  usesStrongEncryption() {
+    return this.strongEncryption;
+  }
+  useUTF8ForNames(b) {
+    this.utf8 = b;
+  }
+  usesUTF8ForNames() {
+    return this.utf8;
+  }
+};
+
+// node_modules/compress-commons/lib/archivers/zip/unix-stat.js
+var PERM_MASK = 4095;
+var FILE_TYPE_FLAG = 61440;
+var LINK_FLAG = 40960;
+var FILE_FLAG = 32768;
+var DIR_FLAG = 16384;
+var DEFAULT_LINK_PERM = 511;
+var DEFAULT_DIR_PERM = 493;
+var DEFAULT_FILE_PERM = 420;
+var unix_stat_default = {
+  PERM_MASK,
+  FILE_TYPE_FLAG,
+  LINK_FLAG,
+  FILE_FLAG,
+  DIR_FLAG,
+  DEFAULT_LINK_PERM,
+  DEFAULT_DIR_PERM,
+  DEFAULT_FILE_PERM
+};
+
+// node_modules/compress-commons/lib/archivers/zip/constants.js
+var EMPTY = Buffer.alloc(0);
+var SHORT_MASK = 65535;
+var SHORT_SHIFT = 16;
+var SHORT_ZERO = Buffer.from(Array(2));
+var LONG_ZERO = Buffer.from(Array(4));
+var MIN_VERSION_INITIAL = 10;
+var MIN_VERSION_DATA_DESCRIPTOR = 20;
+var MIN_VERSION_ZIP64 = 45;
+var VERSION_MADEBY = 45;
+var METHOD_STORED = 0;
+var METHOD_DEFLATED = 8;
+var PLATFORM_UNIX = 3;
+var PLATFORM_FAT = 0;
+var SIG_LFH = 67324752;
+var SIG_DD = 134695760;
+var SIG_CFH = 33639248;
+var SIG_EOCD = 101010256;
+var SIG_ZIP64_EOCD = 101075792;
+var SIG_ZIP64_EOCD_LOC = 117853008;
+var ZIP64_MAGIC_SHORT = 65535;
+var ZIP64_MAGIC = 4294967295;
+var ZIP64_EXTRA_ID = 1;
+var ZLIB_BEST_SPEED = 1;
+var MODE_MASK = 4095;
+var S_IFDIR = 16384;
+var S_IFREG = 32768;
+var S_DOS_A = 32;
+var S_DOS_D = 16;
+
+// node_modules/compress-commons/lib/archivers/zip/zip-archive-entry.js
+var ZipArchiveEntry = class extends ArchiveEntry {
+  constructor(name) {
+    super();
+    this.platform = PLATFORM_FAT;
+    this.method = -1;
+    this.name = null;
+    this.size = 0;
+    this.csize = 0;
+    this.gpb = new GeneralPurposeBit();
+    this.crc = 0;
+    this.time = -1;
+    this.minver = MIN_VERSION_INITIAL;
+    this.mode = -1;
+    this.extra = null;
+    this.exattr = 0;
+    this.inattr = 0;
+    this.comment = null;
+    if (name) {
+      this.setName(name);
+    }
+  }
+  /**
+   * Returns the extra fields related to the entry.
+   *
+   * @returns {Buffer}
+   */
+  getCentralDirectoryExtra() {
+    return this.getExtra();
+  }
+  /**
+   * Returns the comment set for the entry.
+   *
+   * @returns {string}
+   */
+  getComment() {
+    return this.comment !== null ? this.comment : "";
+  }
+  /**
+   * Returns the compressed size of the entry.
+   *
+   * @returns {number}
+   */
+  getCompressedSize() {
+    return this.csize;
+  }
+  /**
+   * Returns the CRC32 digest for the entry.
+   *
+   * @returns {number}
+   */
+  getCrc() {
+    return this.crc;
+  }
+  /**
+   * Returns the external file attributes for the entry.
+   *
+   * @returns {number}
+   */
+  getExternalAttributes = function() {
+    return this.exattr;
+  };
+  /**
+   * Returns the extra fields related to the entry.
+   *
+   * @returns {Buffer}
+   */
+  getExtra() {
+    return this.extra !== null ? this.extra : EMPTY;
+  }
+  /**
+   * Returns the general purpose bits related to the entry.
+   *
+   * @returns {GeneralPurposeBit}
+   */
+  getGeneralPurposeBit() {
+    return this.gpb;
+  }
+  /**
+   * Returns the internal file attributes for the entry.
+   *
+   * @returns {number}
+   */
+  getInternalAttributes() {
+    return this.inattr;
+  }
+  /**
+   * Returns the last modified date of the entry.
+   *
+   * @returns {number}
+   */
+  getLastModifiedDate() {
+    return this.getTime();
+  }
+  /**
+   * Returns the extra fields related to the entry.
+   *
+   * @returns {Buffer}
+   */
+  getLocalFileDataExtra() {
+    return this.getExtra();
+  }
+  /**
+   * Returns the compression method used on the entry.
+   *
+   * @returns {number}
+   */
+  getMethod() {
+    return this.method;
+  }
+  /**
+   * Returns the filename of the entry.
+   *
+   * @returns {string}
+   */
+  getName() {
+    return this.name;
+  }
+  /**
+   * Returns the platform on which the entry was made.
+   *
+   * @returns {number}
+   */
+  getPlatform() {
+    return this.platform;
+  }
+  /**
+   * Returns the size of the entry.
+   *
+   * @returns {number}
+   */
+  getSize() {
+    return this.size;
+  }
+  /**
+   * Returns a date object representing the last modified date of the entry.
+   *
+   * @returns {number|Date}
+   */
+  getTime() {
+    return this.time !== -1 ? dosToDate(this.time) : -1;
+  }
+  /**
+   * Returns the DOS timestamp for the entry.
+   *
+   * @returns {number}
+   */
+  getTimeDos() {
+    return this.time !== -1 ? this.time : 0;
+  }
+  /**
+   * Returns the UNIX file permissions for the entry.
+   *
+   * @returns {number}
+   */
+  getUnixMode() {
+    return this.platform !== PLATFORM_UNIX ? 0 : this.getExternalAttributes() >> SHORT_SHIFT & SHORT_MASK;
+  }
+  /**
+   * Returns the version of ZIP needed to extract the entry.
+   *
+   * @returns {number}
+   */
+  getVersionNeededToExtract() {
+    return this.minver;
+  }
+  /**
+   * Sets the comment of the entry.
+   *
+   * @param comment
+   */
+  setComment(comment) {
+    if (Buffer.byteLength(comment) !== comment.length) {
+      this.getGeneralPurposeBit().useUTF8ForNames(true);
+    }
+    this.comment = comment;
+  }
+  /**
+   * Sets the compressed size of the entry.
+   *
+   * @param size
+   */
+  setCompressedSize(size) {
+    if (size < 0) {
+      throw new Error("invalid entry compressed size");
+    }
+    this.csize = size;
+  }
+  /**
+   * Sets the checksum of the entry.
+   *
+   * @param crc
+   */
+  setCrc(crc) {
+    if (crc < 0) {
+      throw new Error("invalid entry crc32");
+    }
+    this.crc = crc;
+  }
+  /**
+   * Sets the external file attributes of the entry.
+   *
+   * @param attr
+   */
+  setExternalAttributes(attr) {
+    this.exattr = attr >>> 0;
+  }
+  /**
+   * Sets the extra fields related to the entry.
+   *
+   * @param extra
+   */
+  setExtra(extra) {
+    this.extra = extra;
+  }
+  /**
+   * Sets the general purpose bits related to the entry.
+   *
+   * @param gpb
+   */
+  setGeneralPurposeBit(gpb) {
+    if (!(gpb instanceof GeneralPurposeBit)) {
+      throw new Error("invalid entry GeneralPurposeBit");
+    }
+    this.gpb = gpb;
+  }
+  /**
+   * Sets the internal file attributes of the entry.
+   *
+   * @param attr
+   */
+  setInternalAttributes(attr) {
+    this.inattr = attr;
+  }
+  /**
+   * Sets the compression method of the entry.
+   *
+   * @param method
+   */
+  setMethod(method) {
+    if (method < 0) {
+      throw new Error("invalid entry compression method");
+    }
+    this.method = method;
+  }
+  /**
+   * Sets the name of the entry.
+   *
+   * @param name
+   * @param prependSlash
+   */
+  setName(name, prependSlash = false) {
+    name = (0, import_normalize_path2.default)(name, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
+    if (prependSlash) {
+      name = `/${name}`;
+    }
+    if (Buffer.byteLength(name) !== name.length) {
+      this.getGeneralPurposeBit().useUTF8ForNames(true);
+    }
+    this.name = name;
+  }
+  /**
+   * Sets the platform on which the entry was made.
+   *
+   * @param platform
+   */
+  setPlatform(platform2) {
+    this.platform = platform2;
+  }
+  /**
+   * Sets the size of the entry.
+   *
+   * @param size
+   */
+  setSize(size) {
+    if (size < 0) {
+      throw new Error("invalid entry size");
+    }
+    this.size = size;
+  }
+  /**
+   * Sets the time of the entry.
+   *
+   * @param time
+   * @param forceLocalTime
+   */
+  setTime(time, forceLocalTime) {
+    if (!(time instanceof Date)) {
+      throw new Error("invalid entry time");
+    }
+    this.time = dateToDos(time, forceLocalTime);
+  }
+  /**
+   * Sets the UNIX file permissions for the entry.
+   *
+   * @param mode
+   */
+  setUnixMode(mode) {
+    mode |= this.isDirectory() ? S_IFDIR : S_IFREG;
+    var extattr = 0;
+    extattr |= mode << SHORT_SHIFT | (this.isDirectory() ? S_DOS_D : S_DOS_A);
+    this.setExternalAttributes(extattr);
+    this.mode = mode & MODE_MASK;
+    this.platform = PLATFORM_UNIX;
+  }
+  /**
+   * Sets the version of ZIP needed to extract this entry.
+   *
+   * @param minver
+   */
+  setVersionNeededToExtract(minver) {
+    this.minver = minver;
+  }
+  /**
+   * Returns true if this entry represents a directory.
+   *
+   * @returns {boolean}
+   */
+  isDirectory() {
+    return this.getName().slice(-1) === "/";
+  }
+  /**
+   * Returns true if this entry represents a unix symlink,
+   * in which case the entry's content contains the target path
+   * for the symlink.
+   *
+   * @returns {boolean}
+   */
+  isUnixSymlink() {
+    return (this.getUnixMode() & unix_stat_default.FILE_TYPE_FLAG) === unix_stat_default.LINK_FLAG;
+  }
+  /**
+   * Returns true if this entry is using the ZIP64 extension of ZIP.
+   *
+   * @returns {boolean}
+   */
+  isZip64() {
+    return this.csize > ZIP64_MAGIC || this.size > ZIP64_MAGIC;
+  }
+};
+
+// node_modules/compress-commons/lib/archivers/archive-output-stream.js
+var import_readable_stream4 = __toESM(require_ours(), 1);
+
+// node_modules/compress-commons/lib/util/index.js
+var import_readable_stream3 = __toESM(require_ours(), 1);
+function normalizeInputSource2(source) {
+  if (source === null) {
+    return Buffer.alloc(0);
+  } else if (typeof source === "string") {
+    return Buffer.from(source);
+  } else if (isStream(source) && !source._readableState) {
+    var normalized = new import_readable_stream3.PassThrough();
+    source.pipe(normalized);
+    return normalized;
+  }
+  return source;
+}
+
+// node_modules/compress-commons/lib/archivers/archive-output-stream.js
+var ArchiveOutputStream = class extends import_readable_stream4.Transform {
+  constructor(options) {
+    super(options);
+    this.offset = 0;
+    this._archive = {
+      finish: false,
+      finished: false,
+      processing: false
+    };
+  }
+  _appendBuffer(zae, source, callback) {
+  }
+  _appendStream(zae, source, callback) {
+  }
+  _emitErrorCallback = function(err) {
+    if (err) {
+      this.emit("error", err);
+    }
+  };
+  _finish(ae) {
+  }
+  _normalizeEntry(ae) {
+  }
+  _transform(chunk, encoding, callback) {
+    callback(null, chunk);
+  }
+  entry(ae, source, callback) {
+    source = source || null;
+    if (typeof callback !== "function") {
+      callback = this._emitErrorCallback.bind(this);
+    }
+    if (!(ae instanceof ArchiveEntry)) {
+      callback(new Error("not a valid instance of ArchiveEntry"));
+      return;
+    }
+    if (this._archive.finish || this._archive.finished) {
+      callback(new Error("unacceptable entry after finish"));
+      return;
+    }
+    if (this._archive.processing) {
+      callback(new Error("already processing an entry"));
+      return;
+    }
+    this._archive.processing = true;
+    this._normalizeEntry(ae);
+    this._entry = ae;
+    source = normalizeInputSource2(source);
+    if (Buffer.isBuffer(source)) {
+      this._appendBuffer(ae, source, callback);
+    } else if (isStream(source)) {
+      this._appendStream(ae, source, callback);
+    } else {
+      this._archive.processing = false;
+      callback(
+        new Error("input source must be valid Stream or Buffer instance")
+      );
+      return;
+    }
+    return this;
+  }
+  finish() {
+    if (this._archive.processing) {
+      this._archive.finish = true;
+      return;
+    }
+    this._finish();
+  }
+  getBytesWritten() {
+    return this.offset;
+  }
+  write(chunk, cb) {
+    if (chunk) {
+      this.offset += chunk.length;
+    }
+    return super.write(chunk, cb);
+  }
+};
+
+// node_modules/compress-commons/lib/archivers/zip/zip-archive-output-stream.js
+var import_crc_323 = __toESM(require_crc32(), 1);
+
+// node_modules/crc32-stream/lib/crc32-stream.js
+var import_readable_stream5 = __toESM(require_ours(), 1);
+var import_crc_32 = __toESM(require_crc32(), 1);
+var CRC32Stream = class extends import_readable_stream5.Transform {
+  constructor(options) {
+    super(options);
+    this.checksum = Buffer.allocUnsafe(4);
+    this.checksum.writeInt32BE(0, 0);
+    this.rawSize = 0;
+  }
+  _transform(chunk, encoding, callback) {
+    if (chunk) {
+      this.checksum = import_crc_32.default.buf(chunk, this.checksum) >>> 0;
+      this.rawSize += chunk.length;
+    }
+    callback(null, chunk);
+  }
+  digest(encoding) {
+    const checksum = Buffer.allocUnsafe(4);
+    checksum.writeUInt32BE(this.checksum >>> 0, 0);
+    return encoding ? checksum.toString(encoding) : checksum;
+  }
+  hex() {
+    return this.digest("hex").toUpperCase();
+  }
+  size() {
+    return this.rawSize;
+  }
+};
+
+// node_modules/crc32-stream/lib/deflate-crc32-stream.js
+var import_zlib2 = require("zlib");
+var import_crc_322 = __toESM(require_crc32(), 1);
+var DeflateCRC32Stream = class extends import_zlib2.DeflateRaw {
+  constructor(options) {
+    super(options);
+    this.checksum = Buffer.allocUnsafe(4);
+    this.checksum.writeInt32BE(0, 0);
+    this.rawSize = 0;
+    this.compressedSize = 0;
+  }
+  push(chunk, encoding) {
+    if (chunk) {
+      this.compressedSize += chunk.length;
+    }
+    return super.push(chunk, encoding);
+  }
+  _transform(chunk, encoding, callback) {
+    if (chunk) {
+      this.checksum = import_crc_322.default.buf(chunk, this.checksum) >>> 0;
+      this.rawSize += chunk.length;
+    }
+    super._transform(chunk, encoding, callback);
+  }
+  digest(encoding) {
+    const checksum = Buffer.allocUnsafe(4);
+    checksum.writeUInt32BE(this.checksum >>> 0, 0);
+    return encoding ? checksum.toString(encoding) : checksum;
+  }
+  hex() {
+    return this.digest("hex").toUpperCase();
+  }
+  size(compressed = false) {
+    if (compressed) {
+      return this.compressedSize;
+    } else {
+      return this.rawSize;
+    }
+  }
+};
+
+// node_modules/compress-commons/lib/archivers/zip/zip-archive-output-stream.js
+function _defaults(o) {
+  if (typeof o !== "object") {
+    o = {};
+  }
+  if (typeof o.zlib !== "object") {
+    o.zlib = {};
+  }
+  if (typeof o.zlib.level !== "number") {
+    o.zlib.level = ZLIB_BEST_SPEED;
+  }
+  o.forceZip64 = !!o.forceZip64;
+  o.forceLocalTime = !!o.forceLocalTime;
+  return o;
+}
+var ZipArchiveOutputStream = class extends ArchiveOutputStream {
+  constructor(options) {
+    const _options = _defaults(options);
+    super(_options);
+    this.options = _options;
+    this._entry = null;
+    this._entries = [];
+    this._archive = {
+      centralLength: 0,
+      centralOffset: 0,
+      comment: "",
+      finish: false,
+      finished: false,
+      processing: false,
+      forceZip64: _options.forceZip64,
+      forceLocalTime: _options.forceLocalTime
+    };
+  }
+  _afterAppend(ae) {
+    this._entries.push(ae);
+    if (ae.getGeneralPurposeBit().usesDataDescriptor()) {
+      this._writeDataDescriptor(ae);
+    }
+    this._archive.processing = false;
+    this._entry = null;
+    if (this._archive.finish && !this._archive.finished) {
+      this._finish();
+    }
+  }
+  _appendBuffer(ae, source, callback) {
+    if (source.length === 0) {
+      ae.setMethod(METHOD_STORED);
+    }
+    var method = ae.getMethod();
+    if (method === METHOD_STORED) {
+      ae.setSize(source.length);
+      ae.setCompressedSize(source.length);
+      ae.setCrc(import_crc_323.default.buf(source) >>> 0);
+    }
+    this._writeLocalFileHeader(ae);
+    if (method === METHOD_STORED) {
+      this.write(source);
+      this._afterAppend(ae);
+      callback(null, ae);
+      return;
+    } else if (method === METHOD_DEFLATED) {
+      this._smartStream(ae, callback).end(source);
+      return;
+    } else {
+      callback(new Error("compression method " + method + " not implemented"));
+      return;
+    }
+  }
+  _appendStream(ae, source, callback) {
+    ae.getGeneralPurposeBit().useDataDescriptor(true);
+    ae.setVersionNeededToExtract(MIN_VERSION_DATA_DESCRIPTOR);
+    this._writeLocalFileHeader(ae);
+    var smart = this._smartStream(ae, callback);
+    source.once("error", function(err) {
+      smart.emit("error", err);
+      smart.end();
+    });
+    source.pipe(smart);
+  }
+  _finish() {
+    this._archive.centralOffset = this.offset;
+    this._entries.forEach(
+      function(ae) {
+        this._writeCentralFileHeader(ae);
+      }.bind(this)
+    );
+    this._archive.centralLength = this.offset - this._archive.centralOffset;
+    if (this.isZip64()) {
+      this._writeCentralDirectoryZip64();
+    }
+    this._writeCentralDirectoryEnd();
+    this._archive.processing = false;
+    this._archive.finish = true;
+    this._archive.finished = true;
+    this.end();
+  }
+  _normalizeEntry(ae) {
+    if (ae.getMethod() === -1) {
+      ae.setMethod(METHOD_DEFLATED);
+    }
+    if (ae.getMethod() === METHOD_DEFLATED) {
+      ae.getGeneralPurposeBit().useDataDescriptor(true);
+      ae.setVersionNeededToExtract(MIN_VERSION_DATA_DESCRIPTOR);
+    }
+    if (ae.getTime() === -1) {
+      ae.setTime(/* @__PURE__ */ new Date(), this._archive.forceLocalTime);
+    }
+    ae._offsets = {
+      file: 0,
+      data: 0,
+      contents: 0
+    };
+  }
+  _smartStream(ae, callback) {
+    var deflate = ae.getMethod() === METHOD_DEFLATED;
+    var process2 = deflate ? new DeflateCRC32Stream(this.options.zlib) : new CRC32Stream();
+    var error3 = null;
+    function handleStuff() {
+      var digest = process2.digest().readUInt32BE(0);
+      ae.setCrc(digest);
+      ae.setSize(process2.size());
+      ae.setCompressedSize(process2.size(true));
+      this._afterAppend(ae);
+      callback(error3, ae);
+    }
+    process2.once("end", handleStuff.bind(this));
+    process2.once("error", function(err) {
+      error3 = err;
+    });
+    process2.pipe(this, { end: false });
+    return process2;
+  }
+  _writeCentralDirectoryEnd() {
+    var records = this._entries.length;
+    var size = this._archive.centralLength;
+    var offset = this._archive.centralOffset;
+    if (this.isZip64()) {
+      records = ZIP64_MAGIC_SHORT;
+      size = ZIP64_MAGIC;
+      offset = ZIP64_MAGIC;
+    }
+    this.write(getLongBytes(SIG_EOCD));
+    this.write(SHORT_ZERO);
+    this.write(SHORT_ZERO);
+    this.write(getShortBytes(records));
+    this.write(getShortBytes(records));
+    this.write(getLongBytes(size));
+    this.write(getLongBytes(offset));
+    var comment = this.getComment();
+    var commentLength = Buffer.byteLength(comment);
+    this.write(getShortBytes(commentLength));
+    this.write(comment);
+  }
+  _writeCentralDirectoryZip64() {
+    this.write(getLongBytes(SIG_ZIP64_EOCD));
+    this.write(getEightBytes(44));
+    this.write(getShortBytes(MIN_VERSION_ZIP64));
+    this.write(getShortBytes(MIN_VERSION_ZIP64));
+    this.write(LONG_ZERO);
+    this.write(LONG_ZERO);
+    this.write(getEightBytes(this._entries.length));
+    this.write(getEightBytes(this._entries.length));
+    this.write(getEightBytes(this._archive.centralLength));
+    this.write(getEightBytes(this._archive.centralOffset));
+    this.write(getLongBytes(SIG_ZIP64_EOCD_LOC));
+    this.write(LONG_ZERO);
+    this.write(
+      getEightBytes(this._archive.centralOffset + this._archive.centralLength)
+    );
+    this.write(getLongBytes(1));
+  }
+  _writeCentralFileHeader(ae) {
+    var gpb = ae.getGeneralPurposeBit();
+    var method = ae.getMethod();
+    var fileOffset = ae._offsets.file;
+    var size = ae.getSize();
+    var compressedSize = ae.getCompressedSize();
+    if (ae.isZip64() || fileOffset > ZIP64_MAGIC) {
+      size = ZIP64_MAGIC;
+      compressedSize = ZIP64_MAGIC;
+      fileOffset = ZIP64_MAGIC;
+      ae.setVersionNeededToExtract(MIN_VERSION_ZIP64);
+      var extraBuf = Buffer.concat(
+        [
+          getShortBytes(ZIP64_EXTRA_ID),
+          getShortBytes(24),
+          getEightBytes(ae.getSize()),
+          getEightBytes(ae.getCompressedSize()),
+          getEightBytes(ae._offsets.file)
+        ],
+        28
+      );
+      ae.setExtra(extraBuf);
+    }
+    this.write(getLongBytes(SIG_CFH));
+    this.write(getShortBytes(ae.getPlatform() << 8 | VERSION_MADEBY));
+    this.write(getShortBytes(ae.getVersionNeededToExtract()));
+    this.write(gpb.encode());
+    this.write(getShortBytes(method));
+    this.write(getLongBytes(ae.getTimeDos()));
+    this.write(getLongBytes(ae.getCrc()));
+    this.write(getLongBytes(compressedSize));
+    this.write(getLongBytes(size));
+    var name = ae.getName();
+    var comment = ae.getComment();
+    var extra = ae.getCentralDirectoryExtra();
+    if (gpb.usesUTF8ForNames()) {
+      name = Buffer.from(name);
+      comment = Buffer.from(comment);
+    }
+    this.write(getShortBytes(name.length));
+    this.write(getShortBytes(extra.length));
+    this.write(getShortBytes(comment.length));
+    this.write(SHORT_ZERO);
+    this.write(getShortBytes(ae.getInternalAttributes()));
+    this.write(getLongBytes(ae.getExternalAttributes()));
+    this.write(getLongBytes(fileOffset));
+    this.write(name);
+    this.write(extra);
+    this.write(comment);
+  }
+  _writeDataDescriptor(ae) {
+    this.write(getLongBytes(SIG_DD));
+    this.write(getLongBytes(ae.getCrc()));
+    if (ae.isZip64()) {
+      this.write(getEightBytes(ae.getCompressedSize()));
+      this.write(getEightBytes(ae.getSize()));
+    } else {
+      this.write(getLongBytes(ae.getCompressedSize()));
+      this.write(getLongBytes(ae.getSize()));
+    }
+  }
+  _writeLocalFileHeader(ae) {
+    var gpb = ae.getGeneralPurposeBit();
+    var method = ae.getMethod();
+    var name = ae.getName();
+    var extra = ae.getLocalFileDataExtra();
+    if (ae.isZip64()) {
+      gpb.useDataDescriptor(true);
+      ae.setVersionNeededToExtract(MIN_VERSION_ZIP64);
+    }
+    if (gpb.usesUTF8ForNames()) {
+      name = Buffer.from(name);
+    }
+    ae._offsets.file = this.offset;
+    this.write(getLongBytes(SIG_LFH));
+    this.write(getShortBytes(ae.getVersionNeededToExtract()));
+    this.write(gpb.encode());
+    this.write(getShortBytes(method));
+    this.write(getLongBytes(ae.getTimeDos()));
+    ae._offsets.data = this.offset;
+    if (gpb.usesDataDescriptor()) {
+      this.write(LONG_ZERO);
+      this.write(LONG_ZERO);
+      this.write(LONG_ZERO);
+    } else {
+      this.write(getLongBytes(ae.getCrc()));
+      this.write(getLongBytes(ae.getCompressedSize()));
+      this.write(getLongBytes(ae.getSize()));
+    }
+    this.write(getShortBytes(name.length));
+    this.write(getShortBytes(extra.length));
+    this.write(name);
+    this.write(extra);
+    ae._offsets.contents = this.offset;
+  }
+  getComment(comment) {
+    return this._archive.comment !== null ? this._archive.comment : "";
+  }
+  isZip64() {
+    return this._archive.forceZip64 || this._entries.length > ZIP64_MAGIC_SHORT || this._archive.centralLength > ZIP64_MAGIC || this._archive.centralOffset > ZIP64_MAGIC;
+  }
+  setComment(comment) {
+    this._archive.comment = comment;
+  }
+};
+
+// node_modules/zip-stream/utils.js
+var import_normalize_path3 = __toESM(require_normalize_path(), 1);
+function dateify2(dateish) {
+  dateish = dateish || /* @__PURE__ */ new Date();
+  if (dateish instanceof Date) {
+    dateish = dateish;
+  } else if (typeof dateish === "string") {
+    dateish = new Date(dateish);
+  } else {
+    dateish = /* @__PURE__ */ new Date();
+  }
+  return dateish;
+}
+function sanitizePath2(filepath) {
+  return (0, import_normalize_path3.default)(filepath, false).replace(/^\w+:/, "").replace(/^(\.\.\/|\/)+/, "");
+}
+
+// node_modules/zip-stream/index.js
+var ZipStream = class extends ZipArchiveOutputStream {
+  /**
+   * @constructor
+   * @extends external:ZipArchiveOutputStream
+   * @param {Object} [options]
+   * @param {String} [options.comment] Sets the zip archive comment.
+   * @param {Boolean} [options.forceLocalTime=false] Forces the archive to contain local file times instead of UTC.
+   * @param {Boolean} [options.forceZip64=false] Forces the archive to contain ZIP64 headers.
+   * @param {Boolean} [options.store=false] Sets the compression method to STORE.
+   * @param {Object} [options.zlib] Passed to [zlib]{@link https://nodejs.org/api/zlib.html#zlib_class_options}
+   * to control compression.
+   */
+  constructor(options) {
+    options = options || {};
+    options.zlib = options.zlib || {};
+    if (typeof options.level === "number" && options.level >= 0) {
+      options.zlib.level = options.level;
+      delete options.level;
+    }
+    if (!options.forceZip64 && typeof options.zlib.level === "number" && options.zlib.level === 0) {
+      options.store = true;
+    }
+    options.namePrependSlash = options.namePrependSlash || false;
+    super(options);
+    if (options.comment && options.comment.length > 0) {
+      this.setComment(options.comment);
+    }
+  }
+  /**
+   * Normalizes entry data with fallbacks for key properties.
+   *
+   * @private
+   * @param  {Object} data
+   * @return {Object}
+   */
+  _normalizeFileData(data) {
+    data = {
+      type: "file",
+      name: null,
+      namePrependSlash: this.options.namePrependSlash,
+      linkname: null,
+      date: null,
+      mode: null,
+      store: this.options.store,
+      comment: "",
+      ...data
+    };
+    let isDir = data.type === "directory";
+    const isSymlink = data.type === "symlink";
+    if (data.name) {
+      data.name = sanitizePath2(data.name);
+      if (!isSymlink && data.name.slice(-1) === "/") {
+        isDir = true;
+        data.type = "directory";
+      } else if (isDir) {
+        data.name += "/";
+      }
+    }
+    if (isDir || isSymlink) {
+      data.store = true;
+    }
+    data.date = dateify2(data.date);
+    return data;
+  }
+  /**
+   * Appends an entry given an input source (text string, buffer, or stream).
+   *
+   * @param  {(Buffer|Stream|String)} source The input source.
+   * @param  {Object} data
+   * @param  {String} data.name Sets the entry name including internal path.
+   * @param  {String} [data.comment] Sets the entry comment.
+   * @param  {(String|Date)} [data.date=NOW()] Sets the entry date.
+   * @param  {Number} [data.mode=D:0755/F:0644] Sets the entry permissions.
+   * @param  {Boolean} [data.store=options.store] Sets the compression method to STORE.
+   * @param  {String} [data.type=file] Sets the entry type. Defaults to `directory`
+   * if name ends with trailing slash.
+   * @param  {Function} callback
+   * @return this
+   */
+  entry(source, data, callback) {
+    if (typeof callback !== "function") {
+      callback = this._emitErrorCallback.bind(this);
+    }
+    data = this._normalizeFileData(data);
+    if (data.type !== "file" && data.type !== "directory" && data.type !== "symlink") {
+      callback(new Error(data.type + " entries not currently supported"));
+      return;
+    }
+    if (typeof data.name !== "string" || data.name.length === 0) {
+      callback(new Error("entry name must be a non-empty string value"));
+      return;
+    }
+    if (data.type === "symlink" && typeof data.linkname !== "string") {
+      callback(
+        new Error(
+          "entry linkname must be a non-empty string value when type equals symlink"
+        )
+      );
+      return;
+    }
+    const entry = new ZipArchiveEntry(data.name);
+    entry.setTime(data.date, this.options.forceLocalTime);
+    if (data.namePrependSlash) {
+      entry.setName(data.name, true);
+    }
+    if (data.store) {
+      entry.setMethod(0);
+    }
+    if (data.comment.length > 0) {
+      entry.setComment(data.comment);
+    }
+    if (data.type === "symlink" && typeof data.mode !== "number") {
+      data.mode = 40960;
+    }
+    if (typeof data.mode === "number") {
+      if (data.type === "symlink") {
+        data.mode |= 40960;
+      }
+      entry.setUnixMode(data.mode);
+    }
+    if (data.type === "symlink" && typeof data.linkname === "string") {
+      source = Buffer.from(data.linkname);
+    }
+    return super.entry(entry, source, callback);
+  }
+  /**
+   * Finalizes the instance and prevents further appending to the archive
+   * structure (queue will continue til drained).
+   *
+   * @return void
+   */
+  finalize() {
+    this.finish();
+  }
+};
+
+// node_modules/archiver/lib/plugins/zip.js
+var Zip = class {
+  /**
+   * @constructor
+   * @param {ZipOptions} [options]
+   * @param {String} [options.comment] Sets the zip archive comment.
+   * @param {Boolean} [options.forceLocalTime=false] Forces the archive to contain local file times instead of UTC.
+   * @param {Boolean} [options.forceZip64=false] Forces the archive to contain ZIP64 headers.
+   * @param {Boolean} [options.namePrependSlash=false] Prepends a forward slash to archive file paths.
+   * @param {Boolean} [options.store=false] Sets the compression method to STORE.
+   * @param {Object} [options.zlib] Passed to [zlib]{@link https://nodejs.org/api/zlib.html#zlib_class_options}
+   */
+  constructor(options) {
+    options = this.options = {
+      comment: "",
+      forceUTC: false,
+      namePrependSlash: false,
+      store: false,
+      ...options
+    };
+    this.engine = new ZipStream(options);
+  }
+  /**
+   * @param  {(Buffer|Stream)} source
+   * @param  {ZipEntryData} data
+   * @param  {String} data.name Sets the entry name including internal path.
+   * @param  {(String|Date)} [data.date=NOW()] Sets the entry date.
+   * @param  {Number} [data.mode=D:0755/F:0644] Sets the entry permissions.
+   * @param  {String} [data.prefix] Sets a path prefix for the entry name. Useful
+   * when working with methods like `directory` or `glob`.
+   * @param  {fs.Stats} [data.stats] Sets the fs stat data for this entry allowing
+   * for reduction of fs stat calls when stat data is already known.
+   * @param  {Boolean} [data.store=ZipOptions.store] Sets the compression method to STORE.
+   * @param  {Function} callback
+   * @return void
+   */
+  append(source, data, callback) {
+    this.engine.entry(source, data, callback);
+  }
+  /**
+   * @return void
+   */
+  finalize() {
+    this.engine.finalize();
+  }
+  /**
+   * @return this.engine
+   */
+  on() {
+    return this.engine.on.apply(this.engine, arguments);
+  }
+  /**
+   * @return this.engine
+   */
+  pipe() {
+    return this.engine.pipe.apply(this.engine, arguments);
+  }
+  /**
+   * @return this.engine
+   */
+  unpipe() {
+    return this.engine.unpipe.apply(this.engine, arguments);
+  }
+};
+
+// node_modules/archiver/lib/plugins/tar.js
+var import_tar_stream = __toESM(require_tar_stream(), 1);
+
+// node_modules/archiver/lib/plugins/json.js
+var import_readable_stream6 = __toESM(require_ours(), 1);
+
+// node_modules/buffer-crc32/dist/index.mjs
+var CRC_TABLE = new Int32Array([
+  0,
+  1996959894,
+  3993919788,
+  2567524794,
+  124634137,
+  1886057615,
+  3915621685,
+  2657392035,
+  249268274,
+  2044508324,
+  3772115230,
+  2547177864,
+  162941995,
+  2125561021,
+  3887607047,
+  2428444049,
+  498536548,
+  1789927666,
+  4089016648,
+  2227061214,
+  450548861,
+  1843258603,
+  4107580753,
+  2211677639,
+  325883990,
+  1684777152,
+  4251122042,
+  2321926636,
+  335633487,
+  1661365465,
+  4195302755,
+  2366115317,
+  997073096,
+  1281953886,
+  3579855332,
+  2724688242,
+  1006888145,
+  1258607687,
+  3524101629,
+  2768942443,
+  901097722,
+  1119000684,
+  3686517206,
+  2898065728,
+  853044451,
+  1172266101,
+  3705015759,
+  2882616665,
+  651767980,
+  1373503546,
+  3369554304,
+  3218104598,
+  565507253,
+  1454621731,
+  3485111705,
+  3099436303,
+  671266974,
+  1594198024,
+  3322730930,
+  2970347812,
+  795835527,
+  1483230225,
+  3244367275,
+  3060149565,
+  1994146192,
+  31158534,
+  2563907772,
+  4023717930,
+  1907459465,
+  112637215,
+  2680153253,
+  3904427059,
+  2013776290,
+  251722036,
+  2517215374,
+  3775830040,
+  2137656763,
+  141376813,
+  2439277719,
+  3865271297,
+  1802195444,
+  476864866,
+  2238001368,
+  4066508878,
+  1812370925,
+  453092731,
+  2181625025,
+  4111451223,
+  1706088902,
+  314042704,
+  2344532202,
+  4240017532,
+  1658658271,
+  366619977,
+  2362670323,
+  4224994405,
+  1303535960,
+  984961486,
+  2747007092,
+  3569037538,
+  1256170817,
+  1037604311,
+  2765210733,
+  3554079995,
+  1131014506,
+  879679996,
+  2909243462,
+  3663771856,
+  1141124467,
+  855842277,
+  2852801631,
+  3708648649,
+  1342533948,
+  654459306,
+  3188396048,
+  3373015174,
+  1466479909,
+  544179635,
+  3110523913,
+  3462522015,
+  1591671054,
+  702138776,
+  2966460450,
+  3352799412,
+  1504918807,
+  783551873,
+  3082640443,
+  3233442989,
+  3988292384,
+  2596254646,
+  62317068,
+  1957810842,
+  3939845945,
+  2647816111,
+  81470997,
+  1943803523,
+  3814918930,
+  2489596804,
+  225274430,
+  2053790376,
+  3826175755,
+  2466906013,
+  167816743,
+  2097651377,
+  4027552580,
+  2265490386,
+  503444072,
+  1762050814,
+  4150417245,
+  2154129355,
+  426522225,
+  1852507879,
+  4275313526,
+  2312317920,
+  282753626,
+  1742555852,
+  4189708143,
+  2394877945,
+  397917763,
+  1622183637,
+  3604390888,
+  2714866558,
+  953729732,
+  1340076626,
+  3518719985,
+  2797360999,
+  1068828381,
+  1219638859,
+  3624741850,
+  2936675148,
+  906185462,
+  1090812512,
+  3747672003,
+  2825379669,
+  829329135,
+  1181335161,
+  3412177804,
+  3160834842,
+  628085408,
+  1382605366,
+  3423369109,
+  3138078467,
+  570562233,
+  1426400815,
+  3317316542,
+  2998733608,
+  733239954,
+  1555261956,
+  3268935591,
+  3050360625,
+  752459403,
+  1541320221,
+  2607071920,
+  3965973030,
+  1969922972,
+  40735498,
+  2617837225,
+  3943577151,
+  1913087877,
+  83908371,
+  2512341634,
+  3803740692,
+  2075208622,
+  213261112,
+  2463272603,
+  3855990285,
+  2094854071,
+  198958881,
+  2262029012,
+  4057260610,
+  1759359992,
+  534414190,
+  2176718541,
+  4139329115,
+  1873836001,
+  414664567,
+  2282248934,
+  4279200368,
+  1711684554,
+  285281116,
+  2405801727,
+  4167216745,
+  1634467795,
+  376229701,
+  2685067896,
+  3608007406,
+  1308918612,
+  956543938,
+  2808555105,
+  3495958263,
+  1231636301,
+  1047427035,
+  2932959818,
+  3654703836,
+  1088359270,
+  936918e3,
+  2847714899,
+  3736837829,
+  1202900863,
+  817233897,
+  3183342108,
+  3401237130,
+  1404277552,
+  615818150,
+  3134207493,
+  3453421203,
+  1423857449,
+  601450431,
+  3009837614,
+  3294710456,
+  1567103746,
+  711928724,
+  3020668471,
+  3272380065,
+  1510334235,
+  755167117
+]);
+function ensureBuffer(input) {
+  if (Buffer.isBuffer(input)) {
+    return input;
+  }
+  if (typeof input === "number") {
+    return Buffer.alloc(input);
+  } else if (typeof input === "string") {
+    return Buffer.from(input);
+  } else {
+    throw new Error("input must be buffer, number, or string, received " + typeof input);
+  }
+}
+function bufferizeInt(num) {
+  const tmp = ensureBuffer(4);
+  tmp.writeInt32BE(num, 0);
+  return tmp;
+}
+function _crc32(buf, previous) {
+  buf = ensureBuffer(buf);
+  if (Buffer.isBuffer(previous)) {
+    previous = previous.readUInt32BE(0);
+  }
+  let crc = ~~previous ^ -1;
+  for (var n = 0; n < buf.length; n++) {
+    crc = CRC_TABLE[(crc ^ buf[n]) & 255] ^ crc >>> 8;
+  }
+  return crc ^ -1;
+}
+function crc324() {
+  return bufferizeInt(_crc32.apply(null, arguments));
+}
+crc324.signed = function() {
+  return _crc32.apply(null, arguments);
+};
+crc324.unsigned = function() {
+  return _crc32.apply(null, arguments) >>> 0;
+};
+
+// node_modules/archiver/index.js
+var ZipArchive = class extends Archiver {
+  constructor(options) {
+    super(options);
+    this._format = "zip";
+    this._module = new Zip(options);
+    this._supportsDirectory = true;
+    this._supportsSymlink = true;
+    this._modulePipe();
+  }
+};
 
 // src/artifact-scanner.ts
-var fs23 = __toESM(require("fs"));
+var fs24 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
-var path20 = __toESM(require("path"));
+var path21 = __toESM(require("path"));
 var exec = __toESM(require_exec());
 var GITHUB_PAT_CLASSIC_PATTERN = {
   type: "Personal Access Token (Classic)" /* PersonalAccessClassic */,
@@ -157923,17 +162552,17 @@ function isAuthToken(value, patterns = GITHUB_TOKEN_PATTERNS) {
   }
   return void 0;
 }
-function scanFileForTokens(filePath, relativePath, logger) {
+function scanFileForTokens(filePath, relativePath2, logger) {
   const findings = [];
   try {
-    const content = fs23.readFileSync(filePath, "utf8");
+    const content = fs24.readFileSync(filePath, "utf8");
     for (const { type, pattern } of GITHUB_TOKEN_PATTERNS) {
       const matches = content.match(pattern);
       if (matches) {
         for (let i = 0; i < matches.length; i++) {
-          findings.push({ tokenType: type, filePath: relativePath });
+          findings.push({ tokenType: type, filePath: relativePath2 });
         }
-        logger.debug(`Found ${matches.length} ${type}(s) in ${relativePath}`);
+        logger.debug(`Found ${matches.length} ${type}(s) in ${relativePath2}`);
       }
     }
     return findings;
@@ -157959,10 +162588,10 @@ async function scanArchiveFile(archivePath, relativeArchivePath, extractDir, log
     findings: []
   };
   try {
-    const tempExtractDir = fs23.mkdtempSync(
-      path20.join(extractDir, `extract-${depth}-`)
+    const tempExtractDir = fs24.mkdtempSync(
+      path21.join(extractDir, `extract-${depth}-`)
     );
-    const fileName = path20.basename(archivePath).toLowerCase();
+    const fileName = path21.basename(archivePath).toLowerCase();
     if (fileName.endsWith(".tar.gz") || fileName.endsWith(".tgz")) {
       logger.debug(`Extracting tar.gz file: ${archivePath}`);
       await exec.exec("tar", ["-xzf", archivePath, "-C", tempExtractDir], {
@@ -157979,21 +162608,21 @@ async function scanArchiveFile(archivePath, relativeArchivePath, extractDir, log
       );
     } else if (fileName.endsWith(".zst")) {
       logger.debug(`Extracting zst file: ${archivePath}`);
-      const outputFile = path20.join(
+      const outputFile = path21.join(
         tempExtractDir,
-        path20.basename(archivePath, ".zst")
+        path21.basename(archivePath, ".zst")
       );
       await exec.exec("zstd", ["-d", archivePath, "-o", outputFile], {
         silent: true
       });
     } else if (fileName.endsWith(".gz")) {
       logger.debug(`Extracting gz file: ${archivePath}`);
-      const outputFile = path20.join(
+      const outputFile = path21.join(
         tempExtractDir,
-        path20.basename(archivePath, ".gz")
+        path21.basename(archivePath, ".gz")
       );
       await exec.exec("gunzip", ["-c", archivePath], {
-        outStream: fs23.createWriteStream(outputFile),
+        outStream: fs24.createWriteStream(outputFile),
         silent: true
       });
     } else if (fileName.endsWith(".zip")) {
@@ -158014,7 +162643,7 @@ async function scanArchiveFile(archivePath, relativeArchivePath, extractDir, log
     );
     result.scannedFiles += scanResult.scannedFiles;
     result.findings.push(...scanResult.findings);
-    fs23.rmSync(tempExtractDir, { recursive: true, force: true });
+    fs24.rmSync(tempExtractDir, { recursive: true, force: true });
   } catch (e) {
     logger.debug(
       `Could not extract or scan archive file ${archivePath}: ${getErrorMessage(e)}`
@@ -158022,17 +162651,17 @@ async function scanArchiveFile(archivePath, relativeArchivePath, extractDir, log
   }
   return result;
 }
-async function scanFile(fullPath, relativePath, extractDir, logger, depth = 0) {
+async function scanFile(fullPath, relativePath2, extractDir, logger, depth = 0) {
   const result = {
     scannedFiles: 1,
     findings: []
   };
-  const fileName = path20.basename(fullPath).toLowerCase();
+  const fileName = path21.basename(fullPath).toLowerCase();
   const isArchive = fileName.endsWith(".zip") || fileName.endsWith(".tar.gz") || fileName.endsWith(".tgz") || fileName.endsWith(".tar.zst") || fileName.endsWith(".zst") || fileName.endsWith(".gz");
   if (isArchive) {
     const archiveResult = await scanArchiveFile(
       fullPath,
-      relativePath,
+      relativePath2,
       extractDir,
       logger,
       depth
@@ -158040,7 +162669,7 @@ async function scanFile(fullPath, relativePath, extractDir, logger, depth = 0) {
     result.scannedFiles += archiveResult.scannedFiles;
     result.findings.push(...archiveResult.findings);
   }
-  const fileFindings = scanFileForTokens(fullPath, relativePath, logger);
+  const fileFindings = scanFileForTokens(fullPath, relativePath2, logger);
   result.findings.push(...fileFindings);
   return result;
 }
@@ -158049,14 +162678,14 @@ async function scanDirectory(dirPath, baseRelativePath, logger, depth = 0) {
     scannedFiles: 0,
     findings: []
   };
-  const entries = fs23.readdirSync(dirPath, { withFileTypes: true });
+  const entries = fs24.readdirSync(dirPath, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path20.join(dirPath, entry.name);
-    const relativePath = path20.join(baseRelativePath, entry.name);
+    const fullPath = path21.join(dirPath, entry.name);
+    const relativePath2 = path21.join(baseRelativePath, entry.name);
     if (entry.isDirectory()) {
       const subResult = await scanDirectory(
         fullPath,
-        relativePath,
+        relativePath2,
         logger,
         depth
       );
@@ -158065,8 +162694,8 @@ async function scanDirectory(dirPath, baseRelativePath, logger, depth = 0) {
     } else if (entry.isFile()) {
       const fileResult = await scanFile(
         fullPath,
-        relativePath,
-        path20.dirname(fullPath),
+        relativePath2,
+        path21.dirname(fullPath),
         logger,
         depth
       );
@@ -158084,11 +162713,11 @@ async function scanArtifactsForTokens(filesToScan, logger) {
     scannedFiles: 0,
     findings: []
   };
-  const tempScanDir = fs23.mkdtempSync(path20.join(os6.tmpdir(), "artifact-scan-"));
+  const tempScanDir = fs24.mkdtempSync(path21.join(os6.tmpdir(), "artifact-scan-"));
   try {
     for (const filePath of filesToScan) {
-      const stats = fs23.statSync(filePath);
-      const fileName = path20.basename(filePath);
+      const stats = fs24.statSync(filePath);
+      const fileName = path21.basename(filePath);
       if (stats.isDirectory()) {
         const dirResult = await scanDirectory(filePath, fileName, logger);
         result.scannedFiles += dirResult.scannedFiles;
@@ -158125,7 +162754,7 @@ async function scanArtifactsForTokens(filesToScan, logger) {
     }
   } finally {
     try {
-      fs23.rmSync(tempScanDir, { recursive: true, force: true });
+      fs24.rmSync(tempScanDir, { recursive: true, force: true });
     } catch (e) {
       logger.debug(
         `Could not clean up temporary scan directory: ${getErrorMessage(e)}`
@@ -158145,14 +162774,14 @@ async function uploadCombinedSarifArtifacts(logger, gitHubVariant, codeQlVersion
       logger.info(
         "Uploading available combined SARIF files as Actions debugging artifact..."
       );
-      const baseTempDir = path21.resolve(tempDir, "combined-sarif");
+      const baseTempDir = path22.resolve(tempDir, "combined-sarif");
       const toUpload = [];
-      if (fs24.existsSync(baseTempDir)) {
-        const outputDirs = fs24.readdirSync(baseTempDir);
+      if (fs25.existsSync(baseTempDir)) {
+        const outputDirs = fs25.readdirSync(baseTempDir);
         for (const outputDir of outputDirs) {
-          const sarifFiles = fs24.readdirSync(path21.resolve(baseTempDir, outputDir)).filter((f) => path21.extname(f) === ".sarif");
+          const sarifFiles = fs25.readdirSync(path22.resolve(baseTempDir, outputDir)).filter((f) => path22.extname(f) === ".sarif");
           for (const sarifFile of sarifFiles) {
-            toUpload.push(path21.resolve(baseTempDir, outputDir, sarifFile));
+            toUpload.push(path22.resolve(baseTempDir, outputDir, sarifFile));
           }
         }
       }
@@ -158178,17 +162807,17 @@ async function uploadCombinedSarifArtifacts(logger, gitHubVariant, codeQlVersion
 function tryPrepareSarifDebugArtifact(config, language, logger) {
   try {
     const analyzeActionOutputDir = process.env["CODEQL_ACTION_SARIF_RESULTS_OUTPUT_DIR" /* SARIF_RESULTS_OUTPUT_DIR */];
-    if (analyzeActionOutputDir !== void 0 && fs24.existsSync(analyzeActionOutputDir) && fs24.lstatSync(analyzeActionOutputDir).isDirectory()) {
-      const sarifFile = path21.resolve(
+    if (analyzeActionOutputDir !== void 0 && fs25.existsSync(analyzeActionOutputDir) && fs25.lstatSync(analyzeActionOutputDir).isDirectory()) {
+      const sarifFile = path22.resolve(
         analyzeActionOutputDir,
         `${language}.sarif`
       );
-      if (fs24.existsSync(sarifFile)) {
-        const sarifInDbLocation = path21.resolve(
+      if (fs25.existsSync(sarifFile)) {
+        const sarifInDbLocation = path22.resolve(
           config.dbLocation,
           `${language}.sarif`
         );
-        fs24.copyFileSync(sarifFile, sarifInDbLocation);
+        fs25.copyFileSync(sarifFile, sarifInDbLocation);
         return sarifInDbLocation;
       }
     }
@@ -158239,13 +162868,13 @@ async function tryUploadAllAvailableDebugArtifacts(codeql, config, logger, codeQ
         }
         logger.info("Preparing database logs debug artifact...");
         const databaseDirectory = getCodeQLDatabasePath(config, language);
-        const logsDirectory = path21.resolve(databaseDirectory, "log");
+        const logsDirectory = path22.resolve(databaseDirectory, "log");
         if (doesDirectoryExist(logsDirectory)) {
           filesToUpload.push(...listFolder(logsDirectory));
           logger.info("Database logs debug artifact ready for upload.");
         }
         logger.info("Preparing database cluster logs debug artifact...");
-        const multiLanguageTracingLogsDirectory = path21.resolve(
+        const multiLanguageTracingLogsDirectory = path22.resolve(
           config.dbLocation,
           "log"
         );
@@ -158332,8 +162961,8 @@ async function uploadArtifacts(logger, toUpload, rootDir, artifactName, ghVarian
   try {
     await artifactUploader.uploadArtifact(
       sanitizeArtifactName(`${artifactName}${suffix}`),
-      toUpload.map((file) => path21.normalize(file)),
-      path21.normalize(rootDir),
+      toUpload.map((file) => path22.normalize(file)),
+      path22.normalize(rootDir),
       {
         // ensure we don't keep the debug artifacts around for too long since they can be large.
         retentionDays: 7
@@ -158360,18 +162989,18 @@ async function getArtifactUploaderClient(logger, ghVariant) {
 }
 async function createPartialDatabaseBundle(config, language) {
   const databasePath = getCodeQLDatabasePath(config, language);
-  const databaseBundlePath = path21.resolve(
+  const databaseBundlePath = path22.resolve(
     config.dbLocation,
     `${config.debugDatabaseName}-${language}-partial.zip`
   );
   core16.info(
     `${config.debugDatabaseName}-${language} is not finalized. Uploading partial database bundle at ${databaseBundlePath}...`
   );
-  if (fs24.existsSync(databaseBundlePath)) {
-    await fs24.promises.rm(databaseBundlePath, { force: true });
+  if (fs25.existsSync(databaseBundlePath)) {
+    await fs25.promises.rm(databaseBundlePath, { force: true });
   }
-  const output = fs24.createWriteStream(databaseBundlePath);
-  const zip = (0, import_archiver.default)("zip");
+  const output = fs25.createWriteStream(databaseBundlePath);
+  const zip = new ZipArchive();
   zip.on("error", (err) => {
     throw err;
   });
@@ -158423,9 +163052,9 @@ async function runWrapper2() {
       getCsharpTempDependencyDir()
     ];
     for (const tempDependencyDir of tempDependencyDirs) {
-      if (fs25.existsSync(tempDependencyDir)) {
+      if (fs26.existsSync(tempDependencyDir)) {
         try {
-          fs25.rmSync(tempDependencyDir, { recursive: true });
+          fs26.rmSync(tempDependencyDir, { recursive: true });
         } catch (error3) {
           logger.info(
             `Failed to remove temporary dependencies directory: ${getErrorMessage(error3)}`
@@ -158541,8 +163170,8 @@ async function runWrapper3() {
 }
 
 // src/init-action.ts
-var fs27 = __toESM(require("fs"));
-var path23 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path24 = __toESM(require("path"));
 var core20 = __toESM(require_core());
 var github3 = __toESM(require_github());
 var io7 = __toESM(require_io());
@@ -158566,9 +163195,9 @@ function getConfigFileInput(logger, actions, repositoryProperties) {
 }
 
 // src/workflow.ts
-var fs26 = __toESM(require("fs"));
-var path22 = __toESM(require("path"));
-var import_zlib2 = __toESM(require("zlib"));
+var fs27 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
+var import_zlib3 = __toESM(require("zlib"));
 var core19 = __toESM(require_core());
 function toCodedErrors(errors) {
   return Object.entries(errors).reduce(
@@ -158714,19 +163343,19 @@ async function getWorkflow(logger) {
       "Using the workflow specified by the CODE_SCANNING_WORKFLOW_FILE environment variable."
     );
     return load(
-      import_zlib2.default.gunzipSync(Buffer.from(maybeWorkflow, "base64")).toString()
+      import_zlib3.default.gunzipSync(Buffer.from(maybeWorkflow, "base64")).toString()
     );
   }
   const workflowPath = await getWorkflowAbsolutePath(logger);
-  return load(fs26.readFileSync(workflowPath, "utf-8"));
+  return load(fs27.readFileSync(workflowPath, "utf-8"));
 }
 async function getWorkflowAbsolutePath(logger) {
-  const relativePath = await getWorkflowRelativePath();
-  const absolutePath = path22.join(
+  const relativePath2 = await getWorkflowRelativePath();
+  const absolutePath = path23.join(
     getRequiredEnvParam("GITHUB_WORKSPACE"),
-    relativePath
+    relativePath2
   );
-  if (fs26.existsSync(absolutePath)) {
+  if (fs27.existsSync(absolutePath)) {
     logger.debug(
       `Derived the following absolute path for the currently executing workflow: ${absolutePath}.`
     );
@@ -158946,7 +163575,7 @@ async function run3(startedAt) {
     core20.exportVariable("JOB_RUN_UUID" /* JOB_RUN_UUID */, jobRunUuid);
     core20.exportVariable("CODEQL_ACTION_INIT_HAS_RUN" /* INIT_ACTION_HAS_RUN */, "true");
     configFile = getConfigFileInput(logger, actionsEnv, repositoryProperties);
-    sourceRoot = path23.resolve(
+    sourceRoot = path24.resolve(
       getRequiredEnvParam("GITHUB_WORKSPACE"),
       getOptionalInput("source-root") || ""
     );
@@ -159145,21 +163774,21 @@ async function run3(startedAt) {
         )) {
           try {
             logger.debug(`Applying static binary workaround for Go`);
-            const tempBinPath = path23.resolve(
+            const tempBinPath = path24.resolve(
               getTemporaryDirectory(),
               "codeql-action-go-tracing",
               "bin"
             );
-            fs27.mkdirSync(tempBinPath, { recursive: true });
+            fs28.mkdirSync(tempBinPath, { recursive: true });
             core20.addPath(tempBinPath);
-            const goWrapperPath = path23.resolve(tempBinPath, "go");
-            fs27.writeFileSync(
+            const goWrapperPath = path24.resolve(tempBinPath, "go");
+            fs28.writeFileSync(
               goWrapperPath,
               `#!/bin/bash
 
 exec ${goBinaryPath} "$@"`
             );
-            fs27.chmodSync(goWrapperPath, "755");
+            fs28.chmodSync(goWrapperPath, "755");
             core20.exportVariable("CODEQL_ACTION_GO_BINARY" /* GO_BINARY_LOCATION */, goWrapperPath);
           } catch (e) {
             logger.warning(
@@ -159380,8 +164009,8 @@ async function runWrapper4() {
 var core21 = __toESM(require_core());
 
 // src/init-action-post-helper.ts
-var fs28 = __toESM(require("fs"));
-var import_path5 = __toESM(require("path"));
+var fs29 = __toESM(require("fs"));
+var import_path7 = __toESM(require("path"));
 var github4 = __toESM(require_github());
 function createFailedUploadFailedSarifResult(error3) {
   const wrappedError = wrapError(error3);
@@ -159492,8 +164121,8 @@ async function maybeUploadFailedSarifArtifact(config, features, logger) {
   const name = sanitizeArtifactName(`sarif-artifact-${suffix}`);
   await client.uploadArtifact(
     name,
-    [import_path5.default.normalize(failedSarif.sarifFile)],
-    import_path5.default.normalize("..")
+    [import_path7.default.normalize(failedSarif.sarifFile)],
+    import_path7.default.normalize("..")
   );
   return { sarifID: name };
 }
@@ -159568,7 +164197,7 @@ async function uploadFailureInfo(uploadAllAvailableDebugArtifacts, printDebugLog
   }
   if (isSelfHostedRunner()) {
     try {
-      fs28.rmSync(config.dbLocation, {
+      fs29.rmSync(config.dbLocation, {
         recursive: true,
         force: true,
         maxRetries: 3
@@ -160056,11 +164685,11 @@ async function runWrapper7() {
 
 // src/start-proxy-action.ts
 var import_child_process2 = require("child_process");
-var path27 = __toESM(require("path"));
+var path28 = __toESM(require("path"));
 var core26 = __toESM(require_core());
 
 // src/start-proxy.ts
-var path25 = __toESM(require("path"));
+var path26 = __toESM(require("path"));
 var core25 = __toESM(require_core());
 var toolcache4 = __toESM(require_tool_cache());
 
@@ -160540,7 +165169,7 @@ async function getProxyBinaryPath(logger, features) {
       proxyInfo.version
     );
   }
-  return path25.join(proxyBin, proxyFileName);
+  return path26.join(proxyBin, proxyFileName);
 }
 
 // src/start-proxy/ca.ts
@@ -160605,8 +165234,8 @@ function generateCertificateAuthority() {
 }
 
 // src/start-proxy/environment.ts
-var fs29 = __toESM(require("fs"));
-var path26 = __toESM(require("path"));
+var fs30 = __toESM(require("fs"));
+var path27 = __toESM(require("path"));
 var toolrunner5 = __toESM(require_toolrunner());
 var io8 = __toESM(require_io());
 function checkEnvVar(logger, name) {
@@ -160671,16 +165300,16 @@ function discoverActionsJdks() {
 function checkJdkSettings(logger, jdkHome) {
   const filesToCheck = [
     // JDK 9+
-    path26.join("conf", "net.properties"),
+    path27.join("conf", "net.properties"),
     // JDK 8 and below
-    path26.join("lib", "net.properties")
+    path27.join("lib", "net.properties")
   ];
   for (const fileToCheck of filesToCheck) {
-    const file = path26.join(jdkHome, fileToCheck);
+    const file = path27.join(jdkHome, fileToCheck);
     try {
-      if (fs29.existsSync(file)) {
+      if (fs30.existsSync(file)) {
         logger.debug(`Found '${file}'.`);
-        const lines = String(fs29.readFileSync(file)).split("\n");
+        const lines = String(fs30.readFileSync(file)).split("\n");
         for (const line of lines) {
           for (const property of javaProperties) {
             if (line.startsWith(`${property}=`)) {
@@ -160776,7 +165405,7 @@ var NetworkReachabilityBackend = class {
   proxy;
   agent;
   async checkConnection(url2) {
-    return new Promise((resolve13, reject) => {
+    return new Promise((resolve14, reject) => {
       const req = https2.request(
         url2,
         {
@@ -160789,7 +165418,7 @@ var NetworkReachabilityBackend = class {
         (res) => {
           res.destroy();
           if (res.statusCode !== void 0 && res.statusCode < 400) {
-            resolve13(res.statusCode);
+            resolve14(res.statusCode);
           } else {
             reject(new ReachabilityError(res.statusCode));
           }
@@ -160861,7 +165490,7 @@ async function run7(startedAt) {
   try {
     persistInputs();
     const tempDir = getTemporaryDirectory();
-    const proxyLogFilePath = path27.resolve(tempDir, "proxy.log");
+    const proxyLogFilePath = path28.resolve(tempDir, "proxy.log");
     core26.saveState("proxy-log-file", proxyLogFilePath);
     const repositoryNwo = getRepositoryNwo();
     const gitHubVersion = await getGitHubVersion();
@@ -161256,6 +165885,9 @@ normalize-path/index.js:
    * Released under the MIT License.
    *)
 
+safe-buffer/index.js:
+  (*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
 archiver/lib/error.js:
 archiver/lib/core.js:
   (**
@@ -161269,6 +165901,7 @@ archiver/lib/core.js:
 crc-32/crc32.js:
   (*! crc32.js (C) 2014-present SheetJS -- http://sheetjs.com *)
 
+zip-stream/index.js:
 zip-stream/index.js:
   (**
    * ZipStream
@@ -161278,6 +165911,7 @@ zip-stream/index.js:
    * @copyright (c) 2014 Chris Talkington, contributors.
    *)
 
+archiver/lib/plugins/zip.js:
 archiver/lib/plugins/zip.js:
   (**
    * ZIP Format Plugin
@@ -161287,6 +165921,7 @@ archiver/lib/plugins/zip.js:
    * @copyright (c) 2012-2014 Chris Talkington, contributors.
    *)
 
+archiver/lib/plugins/tar.js:
 archiver/lib/plugins/tar.js:
   (**
    * TAR Format Plugin
@@ -161296,6 +165931,7 @@ archiver/lib/plugins/tar.js:
    * @copyright (c) 2012-2014 Chris Talkington, contributors.
    *)
 
+archiver/lib/plugins/json.js:
 archiver/lib/plugins/json.js:
   (**
    * JSON Format Plugin
diff --git a/src/debug-artifacts.ts b/src/debug-artifacts.ts
index 016fcdf7c4..9f5f1775d4 100644
--- a/src/debug-artifacts.ts
+++ b/src/debug-artifacts.ts
@@ -4,7 +4,7 @@ import * as path from "path";
 import * as artifact from "@actions/artifact";
 import * as artifactLegacy from "@actions/artifact-legacy";
 import * as core from "@actions/core";
-import archiver from "archiver";
+import { ZipArchive } from "archiver";
 
 import { getOptionalInput, getTemporaryDirectory } from "./actions-util";
 import { dbIsFinalized } from "./analyze";
@@ -397,7 +397,7 @@ async function createPartialDatabaseBundle(
     await fs.promises.rm(databaseBundlePath, { force: true });
   }
   const output = fs.createWriteStream(databaseBundlePath);
-  const zip = archiver("zip");
+  const zip = new ZipArchive();
 
   zip.on("error", (err) => {
     throw err;

From e3a04b74731b3690c40ec0d95b2197d1d9137d8f Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Mon, 22 Jun 2026 13:19:40 +0100
Subject: [PATCH 41/65] Remove `ready_for_review` triggers

---
 .github/workflows/__all-platform-bundle.yml                | 7 +------
 .github/workflows/__analysis-kinds.yml                     | 7 +------
 .github/workflows/__analyze-ref-input.yml                  | 7 +------
 .github/workflows/__autobuild-action.yml                   | 7 +------
 .../__autobuild-direct-tracing-with-working-dir.yml        | 7 +------
 .github/workflows/__autobuild-working-dir.yml              | 7 +------
 .github/workflows/__build-mode-autobuild.yml               | 7 +------
 .github/workflows/__build-mode-manual.yml                  | 7 +------
 .github/workflows/__build-mode-none.yml                    | 7 +------
 .github/workflows/__build-mode-rollback.yml                | 7 +------
 .github/workflows/__bundle-from-nightly.yml                | 7 +------
 .github/workflows/__bundle-from-toolcache.yml              | 7 +------
 .github/workflows/__bundle-toolcache.yml                   | 7 +------
 .github/workflows/__bundle-zstd.yml                        | 7 +------
 .github/workflows/__cleanup-db-cluster-dir.yml             | 7 +------
 .github/workflows/__config-export.yml                      | 7 +------
 .github/workflows/__config-input.yml                       | 7 +------
 .github/workflows/__cpp-deptrace-disabled.yml              | 7 +------
 .github/workflows/__cpp-deptrace-enabled-on-macos.yml      | 7 +------
 .github/workflows/__cpp-deptrace-enabled.yml               | 7 +------
 .github/workflows/__diagnostics-export.yml                 | 7 +------
 .github/workflows/__export-file-baseline-information.yml   | 7 +------
 .github/workflows/__extractor-ram-threads.yml              | 7 +------
 .github/workflows/__global-proxy.yml                       | 7 +------
 .github/workflows/__go-custom-queries.yml                  | 7 +------
 .../__go-indirect-tracing-workaround-diagnostic.yml        | 7 +------
 .../__go-indirect-tracing-workaround-no-file-program.yml   | 7 +------
 .github/workflows/__go-indirect-tracing-workaround.yml     | 7 +------
 .github/workflows/__go-tracing-autobuilder.yml             | 7 +------
 .github/workflows/__go-tracing-custom-build-steps.yml      | 7 +------
 .github/workflows/__go-tracing-legacy-workflow.yml         | 7 +------
 .github/workflows/__init-with-registries.yml               | 7 +------
 .github/workflows/__javascript-source-root.yml             | 7 +------
 .github/workflows/__job-run-uuid-sarif.yml                 | 7 +------
 .github/workflows/__language-aliases.yml                   | 7 +------
 .github/workflows/__local-bundle.yml                       | 7 +------
 .github/workflows/__multi-language-autodetect.yml          | 7 +------
 .github/workflows/__overlay-init-fallback.yml              | 7 +------
 .../__packaging-codescanning-config-inputs-js.yml          | 7 +------
 .github/workflows/__packaging-config-inputs-js.yml         | 7 +------
 .github/workflows/__packaging-config-js.yml                | 7 +------
 .github/workflows/__packaging-inputs-js.yml                | 7 +------
 .github/workflows/__remote-config.yml                      | 7 +------
 .github/workflows/__resolve-environment-action.yml         | 7 +------
 .github/workflows/__rubocop-multi-language.yml             | 7 +------
 .github/workflows/__ruby.yml                               | 7 +------
 .github/workflows/__rust.yml                               | 7 +------
 .github/workflows/__split-workflow.yml                     | 7 +------
 .github/workflows/__start-proxy.yml                        | 7 +------
 .github/workflows/__submit-sarif-failure.yml               | 7 +------
 .github/workflows/__swift-autobuild.yml                    | 7 +------
 .github/workflows/__swift-custom-build.yml                 | 7 +------
 .github/workflows/__unset-environment.yml                  | 7 +------
 .github/workflows/__upload-ref-sha-input.yml               | 7 +------
 .github/workflows/__upload-sarif.yml                       | 7 +------
 .github/workflows/__with-checkout-path.yml                 | 7 +------
 .github/workflows/check-expected-release-files.yml         | 3 ---
 .github/workflows/codeql.yml                               | 3 ---
 .github/workflows/codescanning-config-cli.yml              | 5 -----
 .github/workflows/debug-artifacts-failure-safe.yml         | 5 -----
 .github/workflows/debug-artifacts-safe.yml                 | 5 -----
 .github/workflows/label-pr-size.yml                        | 6 ------
 .github/workflows/pr-checks.yml                            | 3 ---
 .github/workflows/python312-windows.yml                    | 3 ---
 .github/workflows/query-filters.yml                        | 5 -----
 .github/workflows/test-codeql-bundle-all.yml               | 5 -----
 pr-checks/sync.ts                                          | 4 +---
 67 files changed, 57 insertions(+), 382 deletions(-)

diff --git a/.github/workflows/__all-platform-bundle.yml b/.github/workflows/__all-platform-bundle.yml
index 648679b7bf..91843a5523 100644
--- a/.github/workflows/__all-platform-bundle.yml
+++ b/.github/workflows/__all-platform-bundle.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__analysis-kinds.yml b/.github/workflows/__analysis-kinds.yml
index 504c1fcc6e..66443d6382 100644
--- a/.github/workflows/__analysis-kinds.yml
+++ b/.github/workflows/__analysis-kinds.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__analyze-ref-input.yml b/.github/workflows/__analyze-ref-input.yml
index 5f4bb4d04a..1c2ace8a66 100644
--- a/.github/workflows/__analyze-ref-input.yml
+++ b/.github/workflows/__analyze-ref-input.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__autobuild-action.yml b/.github/workflows/__autobuild-action.yml
index f8cd1275d7..2eb8d5be8a 100644
--- a/.github/workflows/__autobuild-action.yml
+++ b/.github/workflows/__autobuild-action.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__autobuild-direct-tracing-with-working-dir.yml b/.github/workflows/__autobuild-direct-tracing-with-working-dir.yml
index 01016165b3..2e2658297c 100644
--- a/.github/workflows/__autobuild-direct-tracing-with-working-dir.yml
+++ b/.github/workflows/__autobuild-direct-tracing-with-working-dir.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__autobuild-working-dir.yml b/.github/workflows/__autobuild-working-dir.yml
index f9718baf7b..d82f24de51 100644
--- a/.github/workflows/__autobuild-working-dir.yml
+++ b/.github/workflows/__autobuild-working-dir.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__build-mode-autobuild.yml b/.github/workflows/__build-mode-autobuild.yml
index d2f129e848..8e1789135c 100644
--- a/.github/workflows/__build-mode-autobuild.yml
+++ b/.github/workflows/__build-mode-autobuild.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__build-mode-manual.yml b/.github/workflows/__build-mode-manual.yml
index 515e28223c..6eedc2e3f7 100644
--- a/.github/workflows/__build-mode-manual.yml
+++ b/.github/workflows/__build-mode-manual.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__build-mode-none.yml b/.github/workflows/__build-mode-none.yml
index 4aff835887..8af5952fb5 100644
--- a/.github/workflows/__build-mode-none.yml
+++ b/.github/workflows/__build-mode-none.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__build-mode-rollback.yml b/.github/workflows/__build-mode-rollback.yml
index f7c4d090e6..c2ceee4da5 100644
--- a/.github/workflows/__build-mode-rollback.yml
+++ b/.github/workflows/__build-mode-rollback.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__bundle-from-nightly.yml b/.github/workflows/__bundle-from-nightly.yml
index 5499696453..5f220e6c40 100644
--- a/.github/workflows/__bundle-from-nightly.yml
+++ b/.github/workflows/__bundle-from-nightly.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__bundle-from-toolcache.yml b/.github/workflows/__bundle-from-toolcache.yml
index 389981985c..63612d1dbe 100644
--- a/.github/workflows/__bundle-from-toolcache.yml
+++ b/.github/workflows/__bundle-from-toolcache.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__bundle-toolcache.yml b/.github/workflows/__bundle-toolcache.yml
index 7e83829d6a..017640730b 100644
--- a/.github/workflows/__bundle-toolcache.yml
+++ b/.github/workflows/__bundle-toolcache.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__bundle-zstd.yml b/.github/workflows/__bundle-zstd.yml
index 45cf73a0ed..adae450548 100644
--- a/.github/workflows/__bundle-zstd.yml
+++ b/.github/workflows/__bundle-zstd.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__cleanup-db-cluster-dir.yml b/.github/workflows/__cleanup-db-cluster-dir.yml
index 249a1f81b6..22bd3563fe 100644
--- a/.github/workflows/__cleanup-db-cluster-dir.yml
+++ b/.github/workflows/__cleanup-db-cluster-dir.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__config-export.yml b/.github/workflows/__config-export.yml
index e359764bdd..408a871f34 100644
--- a/.github/workflows/__config-export.yml
+++ b/.github/workflows/__config-export.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__config-input.yml b/.github/workflows/__config-input.yml
index 2a82e9aa5c..bc5d782b53 100644
--- a/.github/workflows/__config-input.yml
+++ b/.github/workflows/__config-input.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__cpp-deptrace-disabled.yml b/.github/workflows/__cpp-deptrace-disabled.yml
index 9e44285198..a6117be2ce 100644
--- a/.github/workflows/__cpp-deptrace-disabled.yml
+++ b/.github/workflows/__cpp-deptrace-disabled.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__cpp-deptrace-enabled-on-macos.yml b/.github/workflows/__cpp-deptrace-enabled-on-macos.yml
index 825d4acd99..c4a5e5df92 100644
--- a/.github/workflows/__cpp-deptrace-enabled-on-macos.yml
+++ b/.github/workflows/__cpp-deptrace-enabled-on-macos.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__cpp-deptrace-enabled.yml b/.github/workflows/__cpp-deptrace-enabled.yml
index c4ac54f3db..a4775d8ad5 100644
--- a/.github/workflows/__cpp-deptrace-enabled.yml
+++ b/.github/workflows/__cpp-deptrace-enabled.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__diagnostics-export.yml b/.github/workflows/__diagnostics-export.yml
index 418517a159..fbc3d189b6 100644
--- a/.github/workflows/__diagnostics-export.yml
+++ b/.github/workflows/__diagnostics-export.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__export-file-baseline-information.yml b/.github/workflows/__export-file-baseline-information.yml
index 18fcfafe08..2297597df0 100644
--- a/.github/workflows/__export-file-baseline-information.yml
+++ b/.github/workflows/__export-file-baseline-information.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__extractor-ram-threads.yml b/.github/workflows/__extractor-ram-threads.yml
index a647124bcc..4783be96c7 100644
--- a/.github/workflows/__extractor-ram-threads.yml
+++ b/.github/workflows/__extractor-ram-threads.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__global-proxy.yml b/.github/workflows/__global-proxy.yml
index df544fb68a..3f09901dba 100644
--- a/.github/workflows/__global-proxy.yml
+++ b/.github/workflows/__global-proxy.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__go-custom-queries.yml b/.github/workflows/__go-custom-queries.yml
index a595300652..9f24b27202 100644
--- a/.github/workflows/__go-custom-queries.yml
+++ b/.github/workflows/__go-custom-queries.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__go-indirect-tracing-workaround-diagnostic.yml b/.github/workflows/__go-indirect-tracing-workaround-diagnostic.yml
index 2415c7ff8e..d20710d4b4 100644
--- a/.github/workflows/__go-indirect-tracing-workaround-diagnostic.yml
+++ b/.github/workflows/__go-indirect-tracing-workaround-diagnostic.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__go-indirect-tracing-workaround-no-file-program.yml b/.github/workflows/__go-indirect-tracing-workaround-no-file-program.yml
index 38718fba2c..c533573bf0 100644
--- a/.github/workflows/__go-indirect-tracing-workaround-no-file-program.yml
+++ b/.github/workflows/__go-indirect-tracing-workaround-no-file-program.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__go-indirect-tracing-workaround.yml b/.github/workflows/__go-indirect-tracing-workaround.yml
index 754299d3ed..2ba520441f 100644
--- a/.github/workflows/__go-indirect-tracing-workaround.yml
+++ b/.github/workflows/__go-indirect-tracing-workaround.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__go-tracing-autobuilder.yml b/.github/workflows/__go-tracing-autobuilder.yml
index 5c96e28f11..10ecce6932 100644
--- a/.github/workflows/__go-tracing-autobuilder.yml
+++ b/.github/workflows/__go-tracing-autobuilder.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__go-tracing-custom-build-steps.yml b/.github/workflows/__go-tracing-custom-build-steps.yml
index 7d3ea3aea0..fa8b04e5e3 100644
--- a/.github/workflows/__go-tracing-custom-build-steps.yml
+++ b/.github/workflows/__go-tracing-custom-build-steps.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__go-tracing-legacy-workflow.yml b/.github/workflows/__go-tracing-legacy-workflow.yml
index 68012f0d4d..ce6a78678c 100644
--- a/.github/workflows/__go-tracing-legacy-workflow.yml
+++ b/.github/workflows/__go-tracing-legacy-workflow.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__init-with-registries.yml b/.github/workflows/__init-with-registries.yml
index 2c55e14e4a..bec944b568 100644
--- a/.github/workflows/__init-with-registries.yml
+++ b/.github/workflows/__init-with-registries.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__javascript-source-root.yml b/.github/workflows/__javascript-source-root.yml
index 31662fc166..c27f3633a2 100644
--- a/.github/workflows/__javascript-source-root.yml
+++ b/.github/workflows/__javascript-source-root.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__job-run-uuid-sarif.yml b/.github/workflows/__job-run-uuid-sarif.yml
index c0fa820e52..4f503b9a42 100644
--- a/.github/workflows/__job-run-uuid-sarif.yml
+++ b/.github/workflows/__job-run-uuid-sarif.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__language-aliases.yml b/.github/workflows/__language-aliases.yml
index fe9ebef9c3..91da90b496 100644
--- a/.github/workflows/__language-aliases.yml
+++ b/.github/workflows/__language-aliases.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__local-bundle.yml b/.github/workflows/__local-bundle.yml
index a6ab9f523f..9de7f39aee 100644
--- a/.github/workflows/__local-bundle.yml
+++ b/.github/workflows/__local-bundle.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__multi-language-autodetect.yml b/.github/workflows/__multi-language-autodetect.yml
index f4849b9903..34f38bb2ef 100644
--- a/.github/workflows/__multi-language-autodetect.yml
+++ b/.github/workflows/__multi-language-autodetect.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__overlay-init-fallback.yml b/.github/workflows/__overlay-init-fallback.yml
index 554e9defcc..ec0856ccf9 100644
--- a/.github/workflows/__overlay-init-fallback.yml
+++ b/.github/workflows/__overlay-init-fallback.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__packaging-codescanning-config-inputs-js.yml b/.github/workflows/__packaging-codescanning-config-inputs-js.yml
index 9c7d842293..9193791f8f 100644
--- a/.github/workflows/__packaging-codescanning-config-inputs-js.yml
+++ b/.github/workflows/__packaging-codescanning-config-inputs-js.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__packaging-config-inputs-js.yml b/.github/workflows/__packaging-config-inputs-js.yml
index c446c7ff36..4ca70d90e3 100644
--- a/.github/workflows/__packaging-config-inputs-js.yml
+++ b/.github/workflows/__packaging-config-inputs-js.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__packaging-config-js.yml b/.github/workflows/__packaging-config-js.yml
index e550e493d5..32d59ff8af 100644
--- a/.github/workflows/__packaging-config-js.yml
+++ b/.github/workflows/__packaging-config-js.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__packaging-inputs-js.yml b/.github/workflows/__packaging-inputs-js.yml
index 7d3450d04b..06356f0f63 100644
--- a/.github/workflows/__packaging-inputs-js.yml
+++ b/.github/workflows/__packaging-inputs-js.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__remote-config.yml b/.github/workflows/__remote-config.yml
index 277f9293e9..4c93775b1d 100644
--- a/.github/workflows/__remote-config.yml
+++ b/.github/workflows/__remote-config.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__resolve-environment-action.yml b/.github/workflows/__resolve-environment-action.yml
index 05125ca107..923b670622 100644
--- a/.github/workflows/__resolve-environment-action.yml
+++ b/.github/workflows/__resolve-environment-action.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__rubocop-multi-language.yml b/.github/workflows/__rubocop-multi-language.yml
index 9bee982be6..1752e511e3 100644
--- a/.github/workflows/__rubocop-multi-language.yml
+++ b/.github/workflows/__rubocop-multi-language.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__ruby.yml b/.github/workflows/__ruby.yml
index b8d556e534..adeb014fa7 100644
--- a/.github/workflows/__ruby.yml
+++ b/.github/workflows/__ruby.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__rust.yml b/.github/workflows/__rust.yml
index 91c3d6618e..8f89acb6b0 100644
--- a/.github/workflows/__rust.yml
+++ b/.github/workflows/__rust.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__split-workflow.yml b/.github/workflows/__split-workflow.yml
index 64efae65f2..c7dbc1b522 100644
--- a/.github/workflows/__split-workflow.yml
+++ b/.github/workflows/__split-workflow.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__start-proxy.yml b/.github/workflows/__start-proxy.yml
index 7a318b0233..3330c5ecff 100644
--- a/.github/workflows/__start-proxy.yml
+++ b/.github/workflows/__start-proxy.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__submit-sarif-failure.yml b/.github/workflows/__submit-sarif-failure.yml
index 03ea2de232..136c8a5313 100644
--- a/.github/workflows/__submit-sarif-failure.yml
+++ b/.github/workflows/__submit-sarif-failure.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__swift-autobuild.yml b/.github/workflows/__swift-autobuild.yml
index 4962547032..7c9ae25b06 100644
--- a/.github/workflows/__swift-autobuild.yml
+++ b/.github/workflows/__swift-autobuild.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__swift-custom-build.yml b/.github/workflows/__swift-custom-build.yml
index 83c06ffd09..c20a6c8c37 100644
--- a/.github/workflows/__swift-custom-build.yml
+++ b/.github/workflows/__swift-custom-build.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__unset-environment.yml b/.github/workflows/__unset-environment.yml
index b519e01dd6..0c39c82227 100644
--- a/.github/workflows/__unset-environment.yml
+++ b/.github/workflows/__unset-environment.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__upload-ref-sha-input.yml b/.github/workflows/__upload-ref-sha-input.yml
index 9a1c91dea9..8ccca4f405 100644
--- a/.github/workflows/__upload-ref-sha-input.yml
+++ b/.github/workflows/__upload-ref-sha-input.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__upload-sarif.yml b/.github/workflows/__upload-sarif.yml
index 182adbfdea..c6e877562d 100644
--- a/.github/workflows/__upload-sarif.yml
+++ b/.github/workflows/__upload-sarif.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/__with-checkout-path.yml b/.github/workflows/__with-checkout-path.yml
index 3d6380462b..c075883426 100644
--- a/.github/workflows/__with-checkout-path.yml
+++ b/.github/workflows/__with-checkout-path.yml
@@ -12,12 +12,7 @@ on:
     branches:
       - main
       - releases/v*
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - ready_for_review
+  pull_request: {}
   merge_group:
     types:
       - checks_requested
diff --git a/.github/workflows/check-expected-release-files.yml b/.github/workflows/check-expected-release-files.yml
index ee6ad120bc..9459e879ab 100644
--- a/.github/workflows/check-expected-release-files.yml
+++ b/.github/workflows/check-expected-release-files.yml
@@ -5,9 +5,6 @@ on:
     paths:
       - .github/workflows/check-expected-release-files.yml
       - src/defaults.json
-    # Run checks on reopened draft PRs to support triggering PR checks on draft PRs that were opened
-    # by other workflows.
-    types: [opened, synchronize, reopened, ready_for_review]
 
 concurrency:
   cancel-in-progress: ${{ github.event_name == 'pull_request' || false }}
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index d604bbd80e..7a5b81d9fa 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -4,9 +4,6 @@ on:
   push:
     branches: [main, releases/v*]
   pull_request:
-    # Run checks on reopened draft PRs to support triggering PR checks on draft PRs that were opened
-    # by other workflows.
-    types: [opened, synchronize, reopened, ready_for_review]
   merge_group:
     types: [checks_requested]
   schedule:
diff --git a/.github/workflows/codescanning-config-cli.yml b/.github/workflows/codescanning-config-cli.yml
index 3a62bd78d3..eeb4eefa3f 100644
--- a/.github/workflows/codescanning-config-cli.yml
+++ b/.github/workflows/codescanning-config-cli.yml
@@ -13,11 +13,6 @@ on:
     - main
     - releases/v*
   pull_request:
-    types:
-    - opened
-    - synchronize
-    - reopened
-    - ready_for_review
   merge_group:
     types: [checks_requested]
   schedule:
diff --git a/.github/workflows/debug-artifacts-failure-safe.yml b/.github/workflows/debug-artifacts-failure-safe.yml
index d044d8420a..fbddc54608 100644
--- a/.github/workflows/debug-artifacts-failure-safe.yml
+++ b/.github/workflows/debug-artifacts-failure-safe.yml
@@ -9,11 +9,6 @@ on:
     - main
     - releases/v*
   pull_request:
-    types:
-    - opened
-    - synchronize
-    - reopened
-    - ready_for_review
   merge_group:
     types: [checks_requested]
   schedule:
diff --git a/.github/workflows/debug-artifacts-safe.yml b/.github/workflows/debug-artifacts-safe.yml
index 4699436a11..15cb0b9890 100644
--- a/.github/workflows/debug-artifacts-safe.yml
+++ b/.github/workflows/debug-artifacts-safe.yml
@@ -8,11 +8,6 @@ on:
     - main
     - releases/v*
   pull_request:
-    types:
-    - opened
-    - synchronize
-    - reopened
-    - ready_for_review
   merge_group:
     types: [checks_requested]
   schedule:
diff --git a/.github/workflows/label-pr-size.yml b/.github/workflows/label-pr-size.yml
index f688122b2f..29f0052c13 100644
--- a/.github/workflows/label-pr-size.yml
+++ b/.github/workflows/label-pr-size.yml
@@ -2,12 +2,6 @@ name: Label PR with size
 
 on:
   pull_request:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      - edited
-      - ready_for_review
 
 permissions:
   contents: read
diff --git a/.github/workflows/pr-checks.yml b/.github/workflows/pr-checks.yml
index e0c37dbe24..b971cae363 100644
--- a/.github/workflows/pr-checks.yml
+++ b/.github/workflows/pr-checks.yml
@@ -3,9 +3,6 @@ name: PR Checks
 on:
   push:
   pull_request:
-    # Run checks on reopened draft PRs to support triggering PR checks on draft PRs that were opened
-    # by other workflows.
-    types: [opened, synchronize, reopened, ready_for_review]
   merge_group:
     types: [checks_requested]
   workflow_dispatch:
diff --git a/.github/workflows/python312-windows.yml b/.github/workflows/python312-windows.yml
index 76a9c4ff26..2e2f3a6f81 100644
--- a/.github/workflows/python312-windows.yml
+++ b/.github/workflows/python312-windows.yml
@@ -4,9 +4,6 @@ on:
   push:
     branches: [main, releases/v*]
   pull_request:
-    # Run checks on reopened draft PRs to support triggering PR checks on draft PRs that were opened
-    # by other workflows.
-    types: [opened, synchronize, reopened, ready_for_review]
   merge_group:
     types: [checks_requested]
   schedule:
diff --git a/.github/workflows/query-filters.yml b/.github/workflows/query-filters.yml
index 3d1f4275cf..1b1054627d 100644
--- a/.github/workflows/query-filters.yml
+++ b/.github/workflows/query-filters.yml
@@ -6,11 +6,6 @@ on:
     - main
     - releases/v*
   pull_request:
-    types:
-    - opened
-    - synchronize
-    - reopened
-    - ready_for_review
   merge_group:
     types: [checks_requested]
   schedule:
diff --git a/.github/workflows/test-codeql-bundle-all.yml b/.github/workflows/test-codeql-bundle-all.yml
index c44dafc590..6462973588 100644
--- a/.github/workflows/test-codeql-bundle-all.yml
+++ b/.github/workflows/test-codeql-bundle-all.yml
@@ -8,11 +8,6 @@ on:
     - main
     - releases/v*
   pull_request:
-    types:
-    - opened
-    - synchronize
-    - reopened
-    - ready_for_review
   merge_group:
     types: [checks_requested]
   schedule:
diff --git a/pr-checks/sync.ts b/pr-checks/sync.ts
index b969fcb937..4325bbc3ef 100755
--- a/pr-checks/sync.ts
+++ b/pr-checks/sync.ts
@@ -724,9 +724,7 @@ function main(): void {
         push: {
           branches: ["main", "releases/v*"],
         },
-        pull_request: {
-          types: ["opened", "synchronize", "reopened", "ready_for_review"],
-        },
+        pull_request: {},
         merge_group: {
           types: ["checks_requested"],
         },

From aa12ef06b4cbafe1cce4024d8dc15a9c51c5d89f Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Mon, 22 Jun 2026 13:27:47 +0100
Subject: [PATCH 42/65] Do not create draft PRs where we did so to trigger
 workflows with `ready_for_review` before

---
 .github/actions/prepare-mergeback-branch/action.yml | 7 ++-----
 .github/update-release-branch.py                    | 6 ++----
 .github/workflows/rebuild.yml                       | 3 +--
 .github/workflows/update-bundle.yml                 | 1 -
 4 files changed, 5 insertions(+), 12 deletions(-)

diff --git a/.github/actions/prepare-mergeback-branch/action.yml b/.github/actions/prepare-mergeback-branch/action.yml
index d4dee99bcb..2c57dfc012 100644
--- a/.github/actions/prepare-mergeback-branch/action.yml
+++ b/.github/actions/prepare-mergeback-branch/action.yml
@@ -91,18 +91,15 @@ runs:
 
           Please do the following:
 
-          - [ ] Mark the PR as ready for review to trigger the full set of PR checks.
+          - [ ] Approve running the full set of PR checks.
           - [ ] Approve and merge the PR. When merging the PR, make sure "Create a merge commit" is
                 selected rather than "Squash and merge" or "Rebase and merge".
         EOF
         )
 
-        # PR checks won't be triggered on PRs created by Actions. Therefore mark the PR as draft
-        # so that a maintainer can take the PR out of draft, thereby triggering the PR checks.
         gh pr create \
           --head "${NEW_BRANCH}" \
           --base "${BASE_BRANCH}" \
           --title "${pr_title}" \
           --body "${pr_body}" \
-          --assignee "${GITHUB_ACTOR}" \
-          --draft
+          --assignee "${GITHUB_ACTOR}"
diff --git a/.github/update-release-branch.py b/.github/update-release-branch.py
index 784a450ef0..2635126827 100644
--- a/.github/update-release-branch.py
+++ b/.github/update-release-branch.py
@@ -136,7 +136,7 @@ def open_pr(
   body.append(f' - [ ] Check that there are not any unexpected commits being merged into the `{target_branch}` branch.')
   body.append(' - [ ] Ensure the docs team is aware of any documentation changes that need to be released.')
 
-  body.append(' - [ ] Mark the PR as ready for review to trigger the full set of PR checks.')
+  body.append(' - [ ] Approve running the full set of PR checks if you have not pushed any changes.')
   body.append(' - [ ] Approve and merge this PR. Make sure `Create a merge commit` is selected rather than `Squash and merge` or `Rebase and merge`.')
 
   if is_primary_release:
@@ -146,9 +146,7 @@ def open_pr(
   title = f'Merge {source_branch} into {target_branch}'
 
   # Create the pull request
-  # PR checks won't be triggered on PRs created by Actions. Therefore mark the PR as draft so that
-  # a maintainer can take the PR out of draft, thereby triggering the PR checks.
-  pr = repo.create_pull(title=title, body='\n'.join(body), head=new_branch_name, base=target_branch, draft=True)
+  pr = repo.create_pull(title=title, body='\n'.join(body), head=new_branch_name, base=target_branch)
   print(f'Created PR #{str(pr.number)}')
 
   # Assign the conductor
diff --git a/.github/workflows/rebuild.yml b/.github/workflows/rebuild.yml
index f1d74dc8f4..26acd867fb 100644
--- a/.github/workflows/rebuild.yml
+++ b/.github/workflows/rebuild.yml
@@ -143,6 +143,5 @@ jobs:
           PR_NUMBER: ${{ github.event.pull_request.number }}
         run: |
           echo "Pushed a commit to rebuild the Action." \
-            "Please mark the PR as ready for review to trigger PR checks." |
+            "Please approve running the PR checks." |
             gh pr comment --body-file - --repo github/codeql-action "$PR_NUMBER"
-          gh pr ready --undo --repo github/codeql-action "$PR_NUMBER"
diff --git a/.github/workflows/update-bundle.yml b/.github/workflows/update-bundle.yml
index 94c79bc56e..6b15d1932d 100644
--- a/.github/workflows/update-bundle.yml
+++ b/.github/workflows/update-bundle.yml
@@ -114,7 +114,6 @@ jobs:
             --title "Update default bundle to $cli_version" \
             --body "$pr_body" \
             --assignee "$GITHUB_ACTOR" \
-            --draft \
           )
           echo "CLI_VERSION=$cli_version" | tee -a "$GITHUB_ENV"
           echo "PR_URL=$pr_url" | tee -a "$GITHUB_ENV"

From 31d88dd791de031d4001359db9efdf1ece32e0a3 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 22 Jun 2026 12:31:01 +0000
Subject: [PATCH 43/65] Bump js-yaml from 4.2.0 to 5.0.0

Bumps [js-yaml](https://github.com/nodeca/js-yaml) from 4.2.0 to 5.0.0.
- [Changelog](https://github.com/nodeca/js-yaml/blob/master/CHANGELOG.md)
- [Commits](https://github.com/nodeca/js-yaml/compare/4.2.0...5.0.0)

---
updated-dependencies:
- dependency-name: js-yaml
  dependency-version: 5.0.0
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 package-lock.json | 56 ++++++++++++++++++++++++++++++++++++++++++-----
 package.json      |  2 +-
 2 files changed, 52 insertions(+), 6 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 40cb630e24..95ac61f15c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -28,7 +28,7 @@
         "follow-redirects": "^1.16.0",
         "get-folder-size": "^5.0.0",
         "https-proxy-agent": "^7.0.6",
-        "js-yaml": "^4.2.0",
+        "js-yaml": "^5.0.0",
         "jsonschema": "1.5.0",
         "long": "^5.3.2",
         "node-forge": "^1.4.0",
@@ -1529,6 +1529,29 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/@eslint/eslintrc/node_modules/js-yaml": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.2.0.tgz",
+      "integrity": "sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/puzrin"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodeca"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
     "node_modules/@eslint/js": {
       "version": "9.39.4",
       "resolved": "https://registry.npmjs.org/@eslint/js/-/js-9.39.4.tgz",
@@ -2035,6 +2058,29 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/@microsoft/eslint-formatter-sarif/node_modules/js-yaml": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.2.0.tgz",
+      "integrity": "sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/puzrin"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodeca"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "argparse": "^2.0.1"
+      },
+      "bin": {
+        "js-yaml": "bin/js-yaml.js"
+      }
+    },
     "node_modules/@mswjs/interceptors": {
       "version": "0.41.3",
       "resolved": "https://registry.npmjs.org/@mswjs/interceptors/-/interceptors-0.41.3.tgz",
@@ -7059,9 +7105,9 @@
       }
     },
     "node_modules/js-yaml": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.2.0.tgz",
-      "integrity": "sha512-ePWsvanv0DWuDRsW8dnt+R4jQ31SCRCQ7hhNcPXZPsoBZiemuZNYGf7adZdqX2D86j6rvKp3RpCxVTSb8WQlOw==",
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-5.0.0.tgz",
+      "integrity": "sha512-GSvaPUbk1U+FMZ7rJzF+F8e5YVtu7KnD40et/5rBXXRBv2jCO9L3qCewvIDDdudC0QycTFlf6EAA+h3kxBsuUw==",
       "funding": [
         {
           "type": "github",
@@ -7077,7 +7123,7 @@
         "argparse": "^2.0.1"
       },
       "bin": {
-        "js-yaml": "bin/js-yaml.js"
+        "js-yaml": "bin/js-yaml.mjs"
       }
     },
     "node_modules/jschardet": {
diff --git a/package.json b/package.json
index 5a0a1b0bf1..1f0dd37a26 100644
--- a/package.json
+++ b/package.json
@@ -36,7 +36,7 @@
     "follow-redirects": "^1.16.0",
     "get-folder-size": "^5.0.0",
     "https-proxy-agent": "^7.0.6",
-    "js-yaml": "^4.2.0",
+    "js-yaml": "^5.0.0",
     "jsonschema": "1.5.0",
     "long": "^5.3.2",
     "node-forge": "^1.4.0",

From ba61470b11afbc92a6a6cb7cac5736ae8e273c4a Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Mon, 22 Jun 2026 14:23:48 +0100
Subject: [PATCH 44/65] Use `quoteStyle`

---
 lib/entry-points.js | 5406 +++++++++++++++++++++++--------------------
 src/analyze.ts      |    4 +-
 2 files changed, 2960 insertions(+), 2450 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 28b29d0f16..11a8c4c291 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -3866,7 +3866,7 @@ var require_data_url = __commonJS({
 var require_webidl = __commonJS({
   "node_modules/undici/lib/web/fetch/webidl.js"(exports2, module2) {
     "use strict";
-    var { types: types3, inspect } = require("node:util");
+    var { types: types2, inspect } = require("node:util");
     var { markAsUncloneable } = require("node:worker_threads");
     var { toUSVString } = require_util();
     var webidl = {};
@@ -4056,7 +4056,7 @@ var require_webidl = __commonJS({
           });
         }
         const result = {};
-        if (!types3.isProxy(O)) {
+        if (!types2.isProxy(O)) {
           const keys2 = [...Object.getOwnPropertyNames(O), ...Object.getOwnPropertySymbols(O)];
           for (const key of keys2) {
             const typedKey = keyConverter(key, prefix, argument);
@@ -4185,14 +4185,14 @@ var require_webidl = __commonJS({
       return x;
     };
     webidl.converters.ArrayBuffer = function(V, prefix, argument, opts) {
-      if (webidl.util.Type(V) !== "Object" || !types3.isAnyArrayBuffer(V)) {
+      if (webidl.util.Type(V) !== "Object" || !types2.isAnyArrayBuffer(V)) {
         throw webidl.errors.conversionFailed({
           prefix,
           argument: `${argument} ("${webidl.util.Stringify(V)}")`,
           types: ["ArrayBuffer"]
         });
       }
-      if (opts?.allowShared === false && types3.isSharedArrayBuffer(V)) {
+      if (opts?.allowShared === false && types2.isSharedArrayBuffer(V)) {
         throw webidl.errors.exception({
           header: "ArrayBuffer",
           message: "SharedArrayBuffer is not allowed."
@@ -4207,14 +4207,14 @@ var require_webidl = __commonJS({
       return V;
     };
     webidl.converters.TypedArray = function(V, T, prefix, name, opts) {
-      if (webidl.util.Type(V) !== "Object" || !types3.isTypedArray(V) || V.constructor.name !== T.name) {
+      if (webidl.util.Type(V) !== "Object" || !types2.isTypedArray(V) || V.constructor.name !== T.name) {
         throw webidl.errors.conversionFailed({
           prefix,
           argument: `${name} ("${webidl.util.Stringify(V)}")`,
           types: [T.name]
         });
       }
-      if (opts?.allowShared === false && types3.isSharedArrayBuffer(V.buffer)) {
+      if (opts?.allowShared === false && types2.isSharedArrayBuffer(V.buffer)) {
         throw webidl.errors.exception({
           header: "ArrayBuffer",
           message: "SharedArrayBuffer is not allowed."
@@ -4229,13 +4229,13 @@ var require_webidl = __commonJS({
       return V;
     };
     webidl.converters.DataView = function(V, prefix, name, opts) {
-      if (webidl.util.Type(V) !== "Object" || !types3.isDataView(V)) {
+      if (webidl.util.Type(V) !== "Object" || !types2.isDataView(V)) {
         throw webidl.errors.exception({
           header: prefix,
           message: `${name} is not a DataView.`
         });
       }
-      if (opts?.allowShared === false && types3.isSharedArrayBuffer(V.buffer)) {
+      if (opts?.allowShared === false && types2.isSharedArrayBuffer(V.buffer)) {
         throw webidl.errors.exception({
           header: "ArrayBuffer",
           message: "SharedArrayBuffer is not allowed."
@@ -4250,13 +4250,13 @@ var require_webidl = __commonJS({
       return V;
     };
     webidl.converters.BufferSource = function(V, prefix, name, opts) {
-      if (types3.isAnyArrayBuffer(V)) {
+      if (types2.isAnyArrayBuffer(V)) {
         return webidl.converters.ArrayBuffer(V, prefix, name, { ...opts, allowShared: false });
       }
-      if (types3.isTypedArray(V)) {
+      if (types2.isTypedArray(V)) {
         return webidl.converters.TypedArray(V, V.constructor, prefix, name, { ...opts, allowShared: false });
       }
-      if (types3.isDataView(V)) {
+      if (types2.isDataView(V)) {
         return webidl.converters.DataView(V, prefix, name, { ...opts, allowShared: false });
       }
       throw webidl.errors.conversionFailed({
@@ -12408,7 +12408,7 @@ var require_response = __commonJS({
     var { URLSerializer } = require_data_url();
     var { kConstruct } = require_symbols();
     var assert = require("node:assert");
-    var { types: types3 } = require("node:util");
+    var { types: types2 } = require("node:util");
     var textEncoder = new TextEncoder("utf-8");
     var Response = class _Response {
       // Creates network error Response.
@@ -12729,7 +12729,7 @@ var require_response = __commonJS({
       if (isBlobLike(V)) {
         return webidl.converters.Blob(V, prefix, name, { strict: false });
       }
-      if (ArrayBuffer.isView(V) || types3.isArrayBuffer(V)) {
+      if (ArrayBuffer.isView(V) || types2.isArrayBuffer(V)) {
         return webidl.converters.BufferSource(V, prefix, name);
       }
       if (util3.isFormDataLike(V)) {
@@ -14965,7 +14965,7 @@ var require_util4 = __commonJS({
     var { ProgressEvent } = require_progressevent();
     var { getEncoding } = require_encoding();
     var { serializeAMimeType, parseMIMEType } = require_data_url();
-    var { types: types3 } = require("node:util");
+    var { types: types2 } = require("node:util");
     var { StringDecoder } = require("string_decoder");
     var { btoa: btoa2 } = require("node:buffer");
     var staticPropertyDescriptors = {
@@ -14995,7 +14995,7 @@ var require_util4 = __commonJS({
               });
             }
             isFirstChunk = false;
-            if (!done && types3.isUint8Array(value)) {
+            if (!done && types2.isUint8Array(value)) {
               bytes.push(value);
               if ((fr[kLastProgressEventFired] === void 0 || Date.now() - fr[kLastProgressEventFired] >= 50) && !fr[kAborted]) {
                 fr[kLastProgressEventFired] = Date.now();
@@ -17829,7 +17829,7 @@ var require_websocket = __commonJS({
     var { ByteParser } = require_receiver();
     var { kEnumerableProperty, isBlobLike } = require_util();
     var { getGlobalDispatcher } = require_global2();
-    var { types: types3 } = require("node:util");
+    var { types: types2 } = require("node:util");
     var { ErrorEvent, CloseEvent } = require_events();
     var { SendQueue } = require_sender();
     var WebSocket = class _WebSocket extends EventTarget {
@@ -17952,7 +17952,7 @@ var require_websocket = __commonJS({
           this.#sendQueue.add(data, () => {
             this.#bufferedAmount -= length;
           }, sendHints.string);
-        } else if (types3.isArrayBuffer(data)) {
+        } else if (types2.isArrayBuffer(data)) {
           this.#bufferedAmount += data.byteLength;
           this.#sendQueue.add(data, () => {
             this.#bufferedAmount -= data.byteLength;
@@ -18158,7 +18158,7 @@ var require_websocket = __commonJS({
         if (isBlobLike(V)) {
           return webidl.converters.Blob(V, { strict: false });
         }
-        if (ArrayBuffer.isView(V) || types3.isArrayBuffer(V)) {
+        if (ArrayBuffer.isView(V) || types2.isArrayBuffer(V)) {
           return webidl.converters.BufferSource(V);
         }
       }
@@ -26719,8 +26719,8 @@ var require_coerce = __commonJS({
       const minor = match2[3] || "0";
       const patch = match2[4] || "0";
       const prerelease = options.includePrerelease && match2[5] ? `-${match2[5]}` : "";
-      const build = options.includePrerelease && match2[6] ? `+${match2[6]}` : "";
-      return parse2(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+      const build2 = options.includePrerelease && match2[6] ? `+${match2[6]}` : "";
+      return parse2(`${major}.${minor}.${patch}${prerelease}${build2}`, options);
     };
     module2.exports = coerce3;
   }
@@ -29551,9 +29551,9 @@ var require_attribute = __commonJS({
         return null;
       }
       var result = new ValidatorResult(instance, schema, options, ctx);
-      var types3 = Array.isArray(schema.type) ? schema.type : [schema.type];
-      if (!types3.some(this.testType.bind(this, instance, schema, options, ctx))) {
-        var list = types3.map(function(v) {
+      var types2 = Array.isArray(schema.type) ? schema.type : [schema.type];
+      if (!types2.some(this.testType.bind(this, instance, schema, options, ctx))) {
+        var list = types2.map(function(v) {
           if (!v) return;
           var id = v.$id || v.id;
           return id ? "<" + id + ">" : v + "";
@@ -29567,12 +29567,12 @@ var require_attribute = __commonJS({
       return result;
     };
     function testSchemaNoThrow(instance, options, ctx, callback, schema) {
-      var throwError = options.throwError;
+      var throwError2 = options.throwError;
       var throwAll = options.throwAll;
       options.throwError = false;
       options.throwAll = false;
       var res = this.validateSchema(instance, schema, options, ctx);
-      options.throwError = throwError;
+      options.throwError = throwError2;
       options.throwAll = throwAll;
       if (!res.valid && callback instanceof Function) {
         callback(res);
@@ -30274,7 +30274,7 @@ var require_validator = __commonJS({
       this.customFormats = Object.create(Validator4.prototype.customFormats);
       this.schemas = {};
       this.unresolvedRefs = [];
-      this.types = Object.create(types3);
+      this.types = Object.create(types2);
       this.attributes = Object.create(attribute.validators);
     };
     Validator3.prototype.customFormats = {};
@@ -30448,32 +30448,32 @@ var require_validator = __commonJS({
       }
       return true;
     };
-    var types3 = Validator3.prototype.types = {};
-    types3.string = function testString(instance) {
+    var types2 = Validator3.prototype.types = {};
+    types2.string = function testString(instance) {
       return typeof instance == "string";
     };
-    types3.number = function testNumber(instance) {
+    types2.number = function testNumber(instance) {
       return typeof instance == "number" && isFinite(instance);
     };
-    types3.integer = function testInteger(instance) {
+    types2.integer = function testInteger(instance) {
       return typeof instance == "number" && instance % 1 === 0;
     };
-    types3.boolean = function testBoolean(instance) {
+    types2.boolean = function testBoolean(instance) {
       return typeof instance == "boolean";
     };
-    types3.array = function testArray(instance) {
+    types2.array = function testArray(instance) {
       return Array.isArray(instance);
     };
-    types3["null"] = function testNull(instance) {
+    types2["null"] = function testNull(instance) {
       return instance === null;
     };
-    types3.date = function testDate(instance) {
+    types2.date = function testDate(instance) {
       return instance instanceof Date;
     };
-    types3.any = function testAny(instance) {
+    types2.any = function testAny(instance) {
       return true;
     };
-    types3.object = function testObject(instance) {
+    types2.object = function testObject(instance) {
       return instance && typeof instance === "object" && !Array.isArray(instance) && !(instance instanceof Date);
     };
     module2.exports = Validator3;
@@ -36664,7 +36664,7 @@ var require_ms = __commonJS({
 });
 
 // node_modules/debug/src/common.js
-var require_common2 = __commonJS({
+var require_common = __commonJS({
   "node_modules/debug/src/common.js"(exports2, module2) {
     function setup(env) {
       createDebug.debug = createDebug;
@@ -36998,7 +36998,7 @@ var require_browser = __commonJS({
       } catch (error3) {
       }
     }
-    module2.exports = require_common2()(exports2);
+    module2.exports = require_common()(exports2);
     var { formatters } = module2.exports;
     formatters.j = function(v) {
       try {
@@ -37286,7 +37286,7 @@ var require_node = __commonJS({
         debug6.inspectOpts[keys[i]] = exports2.inspectOpts[keys[i]];
       }
     }
-    module2.exports = require_common2()(exports2);
+    module2.exports = require_common()(exports2);
     var { formatters } = module2.exports;
     formatters.o = function(v) {
       this.inspectOpts.colors = this.useColors;
@@ -45814,7 +45814,7 @@ var require_utils_common = __commonJS({
     exports2.base64decode = base64decode;
     exports2.generateBlockID = generateBlockID;
     exports2.delay = delay2;
-    exports2.padStart = padStart;
+    exports2.padStart = padStart2;
     exports2.sanitizeURL = sanitizeURL;
     exports2.sanitizeHeaders = sanitizeHeaders;
     exports2.iEqual = iEqual;
@@ -46039,7 +46039,7 @@ var require_utils_common = __commonJS({
       if (blockIDPrefix.length > maxAllowedBlockIDPrefixLength) {
         blockIDPrefix = blockIDPrefix.slice(0, maxAllowedBlockIDPrefixLength);
       }
-      const res = blockIDPrefix + padStart(blockIndex.toString(), maxSourceStringLength - blockIDPrefix.length, "0");
+      const res = blockIDPrefix + padStart2(blockIndex.toString(), maxSourceStringLength - blockIDPrefix.length, "0");
       return base64encode(res);
     }
     async function delay2(timeInMs, aborter, abortError) {
@@ -46063,7 +46063,7 @@ var require_utils_common = __commonJS({
         }
       });
     }
-    function padStart(currentString, targetLength, padString = " ") {
+    function padStart2(currentString, targetLength, padString = " ") {
       if (String.prototype.padStart) {
         return currentString.padStart(targetLength, padString);
       }
@@ -47881,7 +47881,7 @@ var require_utils_common2 = __commonJS({
     exports2.base64decode = base64decode;
     exports2.generateBlockID = generateBlockID;
     exports2.delay = delay2;
-    exports2.padStart = padStart;
+    exports2.padStart = padStart2;
     exports2.sanitizeURL = sanitizeURL;
     exports2.sanitizeHeaders = sanitizeHeaders;
     exports2.iEqual = iEqual;
@@ -48097,7 +48097,7 @@ var require_utils_common2 = __commonJS({
       if (blockIDPrefix.length > maxAllowedBlockIDPrefixLength) {
         blockIDPrefix = blockIDPrefix.slice(0, maxAllowedBlockIDPrefixLength);
       }
-      const res = blockIDPrefix + padStart(blockIndex.toString(), maxSourceStringLength - blockIDPrefix.length, "0");
+      const res = blockIDPrefix + padStart2(blockIndex.toString(), maxSourceStringLength - blockIDPrefix.length, "0");
       return base64encode(res);
     }
     async function delay2(timeInMs, aborter, abortError) {
@@ -48121,7 +48121,7 @@ var require_utils_common2 = __commonJS({
         }
       });
     }
-    function padStart(currentString, targetLength, padString = " ") {
+    function padStart2(currentString, targetLength, padString = " ") {
       if (String.prototype.padStart) {
         return currentString.padStart(targetLength, padString);
       }
@@ -66074,9 +66074,9 @@ var require_AvroParser = __commonJS({
     };
     var AvroUnionType = class extends AvroType {
       _types;
-      constructor(types3) {
+      constructor(types2) {
         super();
-        this._types = types3;
+        this._types = types2;
       }
       async read(stream2, options = {}) {
         const typeIndex = await AvroParser.readInt(stream2, options);
@@ -85927,7 +85927,7 @@ var require_config2 = __commonJS({
 });
 
 // node_modules/@actions/artifact/lib/generated/google/protobuf/timestamp.js
-var require_timestamp2 = __commonJS({
+var require_timestamp = __commonJS({
   "node_modules/@actions/artifact/lib/generated/google/protobuf/timestamp.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -86681,7 +86681,7 @@ var require_artifact = __commonJS({
     var runtime_5 = require_commonjs16();
     var wrappers_1 = require_wrappers();
     var wrappers_2 = require_wrappers();
-    var timestamp_1 = require_timestamp2();
+    var timestamp_1 = require_timestamp();
     var MigrateArtifactRequest$Type = class extends runtime_5.MessageType {
       constructor() {
         super("github.actions.results.api.v1.MigrateArtifactRequest", [
@@ -87897,7 +87897,7 @@ var require_generated = __commonJS({
       for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding2(exports3, m, p);
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    __exportStar2(require_timestamp2(), exports2);
+    __exportStar2(require_timestamp(), exports2);
     __exportStar2(require_wrappers(), exports2);
     __exportStar2(require_artifact(), exports2);
     __exportStar2(require_artifact_twirp_client(), exports2);
@@ -95012,11 +95012,11 @@ var require_baseIsTypedArray = __commonJS({
     var dateTag = "[object Date]";
     var errorTag = "[object Error]";
     var funcTag = "[object Function]";
-    var mapTag = "[object Map]";
+    var mapTag2 = "[object Map]";
     var numberTag = "[object Number]";
     var objectTag = "[object Object]";
     var regexpTag = "[object RegExp]";
-    var setTag = "[object Set]";
+    var setTag2 = "[object Set]";
     var stringTag = "[object String]";
     var weakMapTag = "[object WeakMap]";
     var arrayBufferTag = "[object ArrayBuffer]";
@@ -95032,7 +95032,7 @@ var require_baseIsTypedArray = __commonJS({
     var uint32Tag = "[object Uint32Array]";
     var typedArrayTags = {};
     typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
-    typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
+    typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag2] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag2] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;
     function baseIsTypedArray(value) {
       return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
     }
@@ -95062,9 +95062,9 @@ var require_nodeUtil = __commonJS({
     var freeProcess = moduleExports && freeGlobal.process;
     var nodeUtil = (function() {
       try {
-        var types3 = freeModule && freeModule.require && freeModule.require("util").types;
-        if (types3) {
-          return types3;
+        var types2 = freeModule && freeModule.require && freeModule.require("util").types;
+        if (types2) {
+          return types2;
         }
         return freeProcess && freeProcess.binding && freeProcess.binding("util");
       } catch (e) {
@@ -95519,13 +95519,13 @@ var require_errors4 = __commonJS({
           msg += `"${name}" ${name.includes(".") ? "property" : "argument"} `;
         }
         msg += "must be ";
-        const types3 = [];
+        const types2 = [];
         const instances = [];
         const other = [];
         for (const value of expected) {
           assert(typeof value === "string", "All expected entries have to be of type string");
           if (kTypes.includes(value)) {
-            types3.push(value.toLowerCase());
+            types2.push(value.toLowerCase());
           } else if (classRegExp.test(value)) {
             instances.push(value);
           } else {
@@ -95534,23 +95534,23 @@ var require_errors4 = __commonJS({
           }
         }
         if (instances.length > 0) {
-          const pos = types3.indexOf("object");
+          const pos = types2.indexOf("object");
           if (pos !== -1) {
-            types3.splice(types3, pos, 1);
+            types2.splice(types2, pos, 1);
             instances.push("Object");
           }
         }
-        if (types3.length > 0) {
-          switch (types3.length) {
+        if (types2.length > 0) {
+          switch (types2.length) {
             case 1:
-              msg += `of type ${types3[0]}`;
+              msg += `of type ${types2[0]}`;
               break;
             case 2:
-              msg += `one of type ${types3[0]} or ${types3[1]}`;
+              msg += `one of type ${types2[0]} or ${types2[1]}`;
               break;
             default: {
-              const last = types3.pop();
-              msg += `one of type ${types3.join(", ")}, or ${last}`;
+              const last = types2.pop();
+              msg += `one of type ${types2.join(", ")}, or ${last}`;
             }
           }
           if (instances.length > 0 || other.length > 0) {
@@ -96125,11 +96125,11 @@ var require_event_target_shim = __commonJS({
         return defineCustomEventTarget(arguments[0]);
       }
       if (arguments.length > 0) {
-        const types3 = new Array(arguments.length);
+        const types2 = new Array(arguments.length);
         for (let i = 0; i < arguments.length; ++i) {
-          types3[i] = arguments[i];
+          types2[i] = arguments[i];
         }
-        return defineCustomEventTarget(types3);
+        return defineCustomEventTarget(types2);
       }
       throw new TypeError("Cannot call a class as a function");
     }
@@ -102435,7 +102435,7 @@ var require_isPlainObject = __commonJS({
     var funcToString = funcProto.toString;
     var hasOwnProperty = objectProto.hasOwnProperty;
     var objectCtorString = funcToString.call(Object);
-    function isPlainObject3(value) {
+    function isPlainObject4(value) {
       if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
         return false;
       }
@@ -102446,7 +102446,7 @@ var require_isPlainObject = __commonJS({
       var Ctor = hasOwnProperty.call(proto, "constructor") && proto.constructor;
       return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
     }
-    module2.exports = isPlainObject3;
+    module2.exports = isPlainObject4;
   }
 });
 
@@ -102842,8 +102842,8 @@ var require_ast = __commonJS({
     exports2.AST = void 0;
     var brace_expressions_js_1 = require_brace_expressions();
     var unescape_js_1 = require_unescape();
-    var types3 = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
-    var isExtglobType2 = (c) => types3.has(c);
+    var types2 = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
+    var isExtglobType2 = (c) => types2.has(c);
     var isExtglobAST2 = (c) => isExtglobType2(c.type);
     var adoptionMap2 = /* @__PURE__ */ new Map([
       ["!", ["@"]],
@@ -109580,7 +109580,7 @@ var require_file3 = __commonJS({
     var flatten = require_flatten();
     var difference = require_difference();
     var union = require_union();
-    var isPlainObject3 = require_isPlainObject();
+    var isPlainObject4 = require_isPlainObject();
     var glob2 = require_commonjs24();
     var file = module2.exports = {};
     var pathSeparatorRe = /[\/\\]/g;
@@ -109605,7 +109605,7 @@ var require_file3 = __commonJS({
       return fs31.existsSync(filepath);
     };
     file.expand = function(...args) {
-      var options = isPlainObject3(args[0]) ? args.shift() : {};
+      var options = isPlainObject4(args[0]) ? args.shift() : {};
       var patterns = Array.isArray(args[0]) ? args[0] : args;
       if (patterns.length === 0) {
         return [];
@@ -109878,7 +109878,7 @@ var require_error3 = __commonJS({
 });
 
 // node_modules/@actions/artifact/node_modules/archiver/lib/core.js
-var require_core3 = __commonJS({
+var require_core2 = __commonJS({
   "node_modules/@actions/artifact/node_modules/archiver/lib/core.js"(exports2, module2) {
     var fs31 = require("fs");
     var glob2 = require_readdir_glob();
@@ -114236,7 +114236,7 @@ var require_dist5 = __commonJS({
 });
 
 // node_modules/@actions/artifact/node_modules/archiver/lib/plugins/json.js
-var require_json2 = __commonJS({
+var require_json = __commonJS({
   "node_modules/@actions/artifact/node_modules/archiver/lib/plugins/json.js"(exports2, module2) {
     var inherits = require("util").inherits;
     var Transform5 = require_ours().Transform;
@@ -114292,7 +114292,7 @@ var require_json2 = __commonJS({
 // node_modules/@actions/artifact/node_modules/archiver/index.js
 var require_archiver = __commonJS({
   "node_modules/@actions/artifact/node_modules/archiver/index.js"(exports2, module2) {
-    var Archiver2 = require_core3();
+    var Archiver2 = require_core2();
     var formats = {};
     var vending = function(format, options) {
       return vending.create(format, options);
@@ -114327,7 +114327,7 @@ var require_archiver = __commonJS({
     };
     vending.registerFormat("zip", require_zip());
     vending.registerFormat("tar", require_tar2());
-    vending.registerFormat("json", require_json2());
+    vending.registerFormat("json", require_json());
     module2.exports = vending;
   }
 });
@@ -115613,23 +115613,23 @@ var require_before_after_hook = __commonJS({
 var require_dist_node2 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/endpoint/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp3 = Object.defineProperty;
-    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames3 = Object.getOwnPropertyNames;
-    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp3(target, name, { get: all[name], enumerable: true });
+        __defProp2(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps3 = (to, from, except, desc) => {
+    var __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames3(from))
-          if (!__hasOwnProp3.call(to, key) && key !== except)
-            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var dist_src_exports3 = {};
     __export2(dist_src_exports3, {
       endpoint: () => endpoint2
@@ -115658,7 +115658,7 @@ var require_dist_node2 = __commonJS({
         return newObj;
       }, {});
     }
-    function isPlainObject3(value) {
+    function isPlainObject4(value) {
       if (typeof value !== "object" || value === null)
         return false;
       if (Object.prototype.toString.call(value) !== "[object Object]")
@@ -115672,7 +115672,7 @@ var require_dist_node2 = __commonJS({
     function mergeDeep2(defaults2, options) {
       const result = Object.assign({}, defaults2);
       Object.keys(options).forEach((key) => {
-        if (isPlainObject3(options[key])) {
+        if (isPlainObject4(options[key])) {
           if (!(key in defaults2))
             Object.assign(result, { [key]: options[key] });
           else
@@ -116051,40 +116051,40 @@ var require_once = __commonJS({
 var require_dist_node4 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/request-error/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __create3 = Object.create;
-    var __defProp3 = Object.defineProperty;
-    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames3 = Object.getOwnPropertyNames;
-    var __getProtoOf3 = Object.getPrototypeOf;
-    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp3(target, name, { get: all[name], enumerable: true });
+        __defProp2(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps3 = (to, from, except, desc) => {
+    var __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames3(from))
-          if (!__hasOwnProp3.call(to, key) && key !== except)
-            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toESM3 = (mod, isNodeMode, target) => (target = mod != null ? __create3(__getProtoOf3(mod)) : {}, __copyProps3(
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
       // If the importer is in node compatibility mode or this is not an ESM
       // file that has been converted to a CommonJS file using a Babel-
       // compatible transform (i.e. "__esModule" has not been set), then set
       // "default" to the CommonJS "module.exports" for node compatibility.
-      isNodeMode || !mod || !mod.__esModule ? __defProp3(target, "default", { value: mod, enumerable: true }) : target,
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
       mod
     ));
-    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var dist_src_exports3 = {};
     __export2(dist_src_exports3, {
       RequestError: () => RequestError2
     });
     module2.exports = __toCommonJS2(dist_src_exports3);
     var import_deprecation = require_dist_node3();
-    var import_once = __toESM3(require_once());
+    var import_once = __toESM2(require_once());
     var logOnceCode = (0, import_once.default)((deprecation) => console.warn(deprecation));
     var logOnceHeaders = (0, import_once.default)((deprecation) => console.warn(deprecation));
     var RequestError2 = class extends Error {
@@ -116143,23 +116143,23 @@ var require_dist_node4 = __commonJS({
 var require_dist_node5 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/request/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp3 = Object.defineProperty;
-    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames3 = Object.getOwnPropertyNames;
-    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp3(target, name, { get: all[name], enumerable: true });
+        __defProp2(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps3 = (to, from, except, desc) => {
+    var __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames3(from))
-          if (!__hasOwnProp3.call(to, key) && key !== except)
-            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var dist_src_exports3 = {};
     __export2(dist_src_exports3, {
       request: () => request3
@@ -116168,7 +116168,7 @@ var require_dist_node5 = __commonJS({
     var import_endpoint2 = require_dist_node2();
     var import_universal_user_agent5 = require_dist_node();
     var VERSION8 = "8.4.1";
-    function isPlainObject3(value) {
+    function isPlainObject4(value) {
       if (typeof value !== "object" || value === null)
         return false;
       if (Object.prototype.toString.call(value) !== "[object Object]")
@@ -116187,7 +116187,7 @@ var require_dist_node5 = __commonJS({
       var _a2, _b, _c, _d;
       const log = requestOptions.request && requestOptions.request.log ? requestOptions.request.log : console;
       const parseSuccessResponseBody = ((_a2 = requestOptions.request) == null ? void 0 : _a2.parseSuccessResponseBody) !== false;
-      if (isPlainObject3(requestOptions.body) || Array.isArray(requestOptions.body)) {
+      if (isPlainObject4(requestOptions.body) || Array.isArray(requestOptions.body)) {
         requestOptions.body = JSON.stringify(requestOptions.body);
       }
       let headers = {};
@@ -116353,23 +116353,23 @@ var require_dist_node5 = __commonJS({
 var require_dist_node6 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/graphql/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp3 = Object.defineProperty;
-    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames3 = Object.getOwnPropertyNames;
-    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp3(target, name, { get: all[name], enumerable: true });
+        __defProp2(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps3 = (to, from, except, desc) => {
+    var __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames3(from))
-          if (!__hasOwnProp3.call(to, key) && key !== except)
-            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var index_exports = {};
     __export2(index_exports, {
       GraphqlResponseError: () => GraphqlResponseError2,
@@ -116490,23 +116490,23 @@ var require_dist_node6 = __commonJS({
 var require_dist_node7 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/auth-token/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp3 = Object.defineProperty;
-    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames3 = Object.getOwnPropertyNames;
-    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp3(target, name, { get: all[name], enumerable: true });
+        __defProp2(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps3 = (to, from, except, desc) => {
+    var __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames3(from))
-          if (!__hasOwnProp3.call(to, key) && key !== except)
-            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var dist_src_exports3 = {};
     __export2(dist_src_exports3, {
       createTokenAuth: () => createTokenAuth3
@@ -116561,23 +116561,23 @@ var require_dist_node7 = __commonJS({
 var require_dist_node8 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/core/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp3 = Object.defineProperty;
-    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames3 = Object.getOwnPropertyNames;
-    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp3(target, name, { get: all[name], enumerable: true });
+        __defProp2(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps3 = (to, from, except, desc) => {
+    var __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames3(from))
-          if (!__hasOwnProp3.call(to, key) && key !== except)
-            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var index_exports = {};
     __export2(index_exports, {
       Octokit: () => Octokit2
@@ -116727,23 +116727,23 @@ var require_dist_node8 = __commonJS({
 var require_dist_node9 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/plugin-rest-endpoint-methods/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp3 = Object.defineProperty;
-    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames3 = Object.getOwnPropertyNames;
-    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp3(target, name, { get: all[name], enumerable: true });
+        __defProp2(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps3 = (to, from, except, desc) => {
+    var __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames3(from))
-          if (!__hasOwnProp3.call(to, key) && key !== except)
-            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var dist_src_exports3 = {};
     __export2(dist_src_exports3, {
       legacyRestEndpointMethods: () => legacyRestEndpointMethods2,
@@ -118883,23 +118883,23 @@ var require_dist_node9 = __commonJS({
 var require_dist_node10 = __commonJS({
   "node_modules/@actions/artifact/node_modules/@octokit/plugin-paginate-rest/dist-node/index.js"(exports2, module2) {
     "use strict";
-    var __defProp3 = Object.defineProperty;
-    var __getOwnPropDesc3 = Object.getOwnPropertyDescriptor;
-    var __getOwnPropNames3 = Object.getOwnPropertyNames;
-    var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
     var __export2 = (target, all) => {
       for (var name in all)
-        __defProp3(target, name, { get: all[name], enumerable: true });
+        __defProp2(target, name, { get: all[name], enumerable: true });
     };
-    var __copyProps3 = (to, from, except, desc) => {
+    var __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames3(from))
-          if (!__hasOwnProp3.call(to, key) && key !== except)
-            __defProp3(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc3(from, key)) || desc.enumerable });
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
       }
       return to;
     };
-    var __toCommonJS2 = (mod) => __copyProps3(__defProp3({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var dist_src_exports3 = {};
     __export2(dist_src_exports3, {
       composePaginateRest: () => composePaginateRest2,
@@ -119986,7 +119986,7 @@ var require_vars = __commonJS({
 });
 
 // node_modules/binary/index.js
-var require_binary2 = __commonJS({
+var require_binary = __commonJS({
   "node_modules/binary/index.js"(exports2, module2) {
     var Chainsaw = require_chainsaw();
     var EventEmitter2 = require("events").EventEmitter;
@@ -120419,7 +120419,7 @@ var require_entry = __commonJS({
 var require_unzip_stream = __commonJS({
   "node_modules/unzip-stream/lib/unzip-stream.js"(exports2, module2) {
     "use strict";
-    var binary = require_binary2();
+    var binary = require_binary();
     var stream2 = require("stream");
     var util3 = require("util");
     var zlib3 = require("zlib");
@@ -123263,7 +123263,7 @@ var require_oidc_utils2 = __commonJS({
     exports2.OidcClient = void 0;
     var http_client_1 = require_lib5();
     var auth_1 = require_auth2();
-    var core_1 = require_core4();
+    var core_1 = require_core3();
     var OidcClient = class _OidcClient {
       static createHttpClient(allowRetry = true, maxRetry = 10) {
         const requestOptions = {
@@ -124801,7 +124801,7 @@ var require_platform2 = __commonJS({
 });
 
 // node_modules/@actions/artifact-legacy/node_modules/@actions/core/lib/core.js
-var require_core4 = __commonJS({
+var require_core3 = __commonJS({
   "node_modules/@actions/artifact-legacy/node_modules/@actions/core/lib/core.js"(exports2) {
     "use strict";
     var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
@@ -125035,7 +125035,7 @@ var require_path_and_artifact_name_validation2 = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.checkArtifactFilePath = exports2.checkArtifactName = void 0;
-    var core_1 = require_core4();
+    var core_1 = require_core3();
     var invalidArtifactFilePathCharacters = /* @__PURE__ */ new Map([
       ['"', ' Double quote "'],
       [":", " Colon :"],
@@ -125121,7 +125121,7 @@ var require_upload_specification = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getUploadSpecification = void 0;
     var fs31 = __importStar2(require("fs"));
-    var core_1 = require_core4();
+    var core_1 = require_core3();
     var path_1 = require("path");
     var path_and_artifact_name_validation_1 = require_path_and_artifact_name_validation2();
     function getUploadSpecification(artifactName, rootDirectory, artifactFiles) {
@@ -125988,7 +125988,7 @@ var require_utils11 = __commonJS({
     exports2.digestForStream = exports2.sleep = exports2.getProperRetention = exports2.rmFile = exports2.getFileSize = exports2.createEmptyFilesForArtifact = exports2.createDirectoriesForArtifact = exports2.displayHttpDiagnostics = exports2.getArtifactUrl = exports2.createHttpClient = exports2.getUploadHeaders = exports2.getDownloadHeaders = exports2.getContentRange = exports2.tryGetRetryAfterValueTimeInMilliseconds = exports2.isThrottledStatusCode = exports2.isRetryableStatusCode = exports2.isForbiddenStatusCode = exports2.isSuccessStatusCode = exports2.getApiVersion = exports2.parseEnvNumber = exports2.getExponentialRetryTimeInMilliseconds = void 0;
     var crypto_1 = __importDefault2(require("crypto"));
     var fs_1 = require("fs");
-    var core_1 = require_core4();
+    var core_1 = require_core3();
     var http_client_1 = require_lib5();
     var auth_1 = require_auth2();
     var config_variables_1 = require_config_variables();
@@ -126215,7 +126215,7 @@ var require_status_reporter = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.StatusReporter = void 0;
-    var core_1 = require_core4();
+    var core_1 = require_core3();
     var StatusReporter = class {
       constructor(displayFrequencyInMilliseconds) {
         this.totalNumberOfFilesToProcess = 0;
@@ -126517,7 +126517,7 @@ var require_requestUtils2 = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.retryHttpClientRequest = exports2.retry = void 0;
     var utils_1 = require_utils11();
-    var core30 = __importStar2(require_core4());
+    var core30 = __importStar2(require_core3());
     var config_variables_1 = require_config_variables();
     function retry2(name, operation, customErrorMessages, maxAttempts) {
       return __awaiter2(this, void 0, void 0, function* () {
@@ -126634,7 +126634,7 @@ var require_upload_http_client = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.UploadHttpClient = void 0;
     var fs31 = __importStar2(require("fs"));
-    var core30 = __importStar2(require_core4());
+    var core30 = __importStar2(require_core3());
     var tmp = __importStar2(require_tmp_promise());
     var stream2 = __importStar2(require("stream"));
     var utils_1 = require_utils11();
@@ -127026,7 +127026,7 @@ var require_download_http_client = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DownloadHttpClient = void 0;
     var fs31 = __importStar2(require("fs"));
-    var core30 = __importStar2(require_core4());
+    var core30 = __importStar2(require_core3());
     var zlib3 = __importStar2(require("zlib"));
     var utils_1 = require_utils11();
     var url_1 = require("url");
@@ -127368,7 +127368,7 @@ var require_artifact_client = __commonJS({
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.DefaultArtifactClient = void 0;
-    var core30 = __importStar2(require_core4());
+    var core30 = __importStar2(require_core3());
     var upload_specification_1 = require_upload_specification();
     var upload_http_client_1 = require_upload_http_client();
     var utils_1 = require_utils11();
@@ -145441,2366 +145441,2876 @@ async function core(rootItemPath, options = {}, returnType = {}) {
 }
 
 // node_modules/js-yaml/dist/js-yaml.mjs
-var __create2 = Object.create;
-var __defProp2 = Object.defineProperty;
-var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames2 = Object.getOwnPropertyNames;
-var __getProtoOf2 = Object.getPrototypeOf;
-var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __copyProps2 = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames2(from), i = 0, n = keys.length, key; i < n; i++) {
-    key = keys[i];
-    if (!__hasOwnProp2.call(to, key) && key !== except) __defProp2(to, key, {
-      get: ((k) => from[k]).bind(null, key),
-      enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable
+var NOT_RESOLVED = /* @__PURE__ */ Symbol("NOT_RESOLVED");
+var MERGE_KEY = /* @__PURE__ */ Symbol("MERGE_KEY");
+function defineScalarTag(tagName, options) {
+  return {
+    tagName,
+    nodeKind: "scalar",
+    implicit: options.implicit ?? false,
+    matchByTagPrefix: options.matchByTagPrefix ?? false,
+    implicitFirstChars: options.implicitFirstChars ?? null,
+    resolve: options.resolve,
+    identify: options.identify ?? null,
+    represent: options.represent ?? ((data) => String(data)),
+    representTagName: options.representTagName ?? null
+  };
+}
+function defineSequenceTag(tagName, options) {
+  return {
+    tagName,
+    nodeKind: "sequence",
+    implicit: false,
+    matchByTagPrefix: options.matchByTagPrefix ?? false,
+    create: options.create,
+    addItem: options.addItem,
+    identify: options.identify ?? null,
+    represent: options.represent ?? ((data) => data),
+    representTagName: options.representTagName ?? null
+  };
+}
+function defineMappingTag(tagName, options) {
+  return {
+    tagName,
+    nodeKind: "mapping",
+    implicit: false,
+    matchByTagPrefix: options.matchByTagPrefix ?? false,
+    create: options.create,
+    addPair: options.addPair,
+    has: options.has,
+    keys: options.keys,
+    get: options.get,
+    identify: options.identify ?? null,
+    represent: options.represent ?? ((data) => data),
+    representTagName: options.representTagName ?? null
+  };
+}
+var strTag = defineScalarTag("tag:yaml.org,2002:str", {
+  resolve: (source) => source,
+  identify: (data) => typeof data === "string"
+});
+var NULL_VALUES$1 = [
+  "",
+  "~",
+  "null",
+  "Null",
+  "NULL"
+];
+var nullCoreTag = defineScalarTag("tag:yaml.org,2002:null", {
+  implicit: true,
+  implicitFirstChars: [
+    "",
+    "~",
+    "n",
+    "N"
+  ],
+  resolve: (source) => {
+    if (NULL_VALUES$1.indexOf(source) !== -1) return null;
+    return NOT_RESOLVED;
+  },
+  identify: (object) => object === null,
+  represent: () => "null"
+});
+var nullJsonTag = defineScalarTag("tag:yaml.org,2002:null", {
+  implicit: true,
+  implicitFirstChars: ["n"],
+  resolve: (source, isExplicit) => {
+    if (source === "null" || isExplicit && source === "") return null;
+    return NOT_RESOLVED;
+  },
+  identify: (object) => object === null,
+  represent: () => "null"
+});
+var NULL_VALUES = [
+  "",
+  "~",
+  "null",
+  "Null",
+  "NULL"
+];
+var nullYaml11Tag = defineScalarTag("tag:yaml.org,2002:null", {
+  implicit: true,
+  implicitFirstChars: [
+    "",
+    "~",
+    "n",
+    "N"
+  ],
+  resolve: (source) => {
+    if (NULL_VALUES.indexOf(source) !== -1) return null;
+    return NOT_RESOLVED;
+  },
+  identify: (object) => object === null,
+  represent: () => "null"
+});
+var TRUE_VALUES$2 = [
+  "true",
+  "True",
+  "TRUE"
+];
+var FALSE_VALUES$2 = [
+  "false",
+  "False",
+  "FALSE"
+];
+var boolCoreTag = defineScalarTag("tag:yaml.org,2002:bool", {
+  implicit: true,
+  implicitFirstChars: [
+    "t",
+    "T",
+    "f",
+    "F"
+  ],
+  resolve: (source) => {
+    if (TRUE_VALUES$2.indexOf(source) !== -1) return true;
+    if (FALSE_VALUES$2.indexOf(source) !== -1) return false;
+    return NOT_RESOLVED;
+  },
+  identify: (object) => Object.prototype.toString.call(object) === "[object Boolean]",
+  represent: (object) => object ? "true" : "false"
+});
+var TRUE_VALUES$1 = ["true"];
+var FALSE_VALUES$1 = ["false"];
+var boolJsonTag = defineScalarTag("tag:yaml.org,2002:bool", {
+  implicit: true,
+  implicitFirstChars: ["t", "f"],
+  resolve: (source) => {
+    if (TRUE_VALUES$1.indexOf(source) !== -1) return true;
+    if (FALSE_VALUES$1.indexOf(source) !== -1) return false;
+    return NOT_RESOLVED;
+  },
+  identify: (object) => Object.prototype.toString.call(object) === "[object Boolean]",
+  represent: (object) => object ? "true" : "false"
+});
+var TRUE_VALUES = [
+  "true",
+  "True",
+  "TRUE",
+  "y",
+  "Y",
+  "yes",
+  "Yes",
+  "YES",
+  "on",
+  "On",
+  "ON"
+];
+var FALSE_VALUES = [
+  "false",
+  "False",
+  "FALSE",
+  "n",
+  "N",
+  "no",
+  "No",
+  "NO",
+  "off",
+  "Off",
+  "OFF"
+];
+var boolYaml11Tag = defineScalarTag("tag:yaml.org,2002:bool", {
+  implicit: true,
+  implicitFirstChars: [
+    "y",
+    "Y",
+    "n",
+    "N",
+    "t",
+    "T",
+    "f",
+    "F",
+    "o",
+    "O"
+  ],
+  resolve: (source) => {
+    if (TRUE_VALUES.indexOf(source) !== -1) return true;
+    if (FALSE_VALUES.indexOf(source) !== -1) return false;
+    return NOT_RESOLVED;
+  },
+  identify: (object) => Object.prototype.toString.call(object) === "[object Boolean]",
+  represent: (object) => object ? "true" : "false"
+});
+var YAML_INTEGER_IMPLICIT_PATTERN$1 = /* @__PURE__ */ new RegExp("^(?:0o[0-7]+|0x[0-9a-fA-F]+|[-+]?[0-9]+)$");
+var YAML_INTEGER_EXPLICIT_PATTERN$1 = /* @__PURE__ */ new RegExp("^(?:[-+]?0b[0-1]+|[-+]?0o[0-7]+|[-+]?0x[0-9a-fA-F]+|[-+]?[0-9]+)$");
+function parseYamlInteger$2(source) {
+  let value = source;
+  let sign = 1;
+  if (value[0] === "-" || value[0] === "+") {
+    if (value[0] === "-") sign = -1;
+    value = value.slice(1);
+  }
+  if (value.startsWith("0b")) return sign * parseInt(value.slice(2), 2);
+  if (value.startsWith("0o")) return sign * parseInt(value.slice(2), 8);
+  if (value.startsWith("0x")) return sign * parseInt(value.slice(2), 16);
+  return sign * parseInt(value, 10);
+}
+function resolveYamlInteger$2(source, isExplicit) {
+  if (isExplicit) {
+    if (!YAML_INTEGER_EXPLICIT_PATTERN$1.test(source)) return NOT_RESOLVED;
+  } else if (!YAML_INTEGER_IMPLICIT_PATTERN$1.test(source)) return NOT_RESOLVED;
+  const result = parseYamlInteger$2(source);
+  return Number.isFinite(result) ? result : NOT_RESOLVED;
+}
+var intCoreTag = defineScalarTag("tag:yaml.org,2002:int", {
+  implicit: true,
+  implicitFirstChars: [
+    "-",
+    "+",
+    ..."0123456789"
+  ],
+  resolve: resolveYamlInteger$2,
+  identify: (object) => Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !Object.is(object, -0),
+  represent: (object) => object.toString(10)
+});
+var YAML_INTEGER_IMPLICIT_PATTERN = /* @__PURE__ */ new RegExp("^-?(?:0|[1-9][0-9]*)$");
+var YAML_INTEGER_EXPLICIT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?0b[0-1]+|[-+]?0o[0-7]+|[-+]?0x[0-9a-fA-F]+|[-+]?[0-9]+)$");
+function parseYamlInteger$1(source) {
+  let value = source;
+  let sign = 1;
+  if (value[0] === "-" || value[0] === "+") {
+    if (value[0] === "-") sign = -1;
+    value = value.slice(1);
+  }
+  if (value.startsWith("0b")) return sign * parseInt(value.slice(2), 2);
+  if (value.startsWith("0o")) return sign * parseInt(value.slice(2), 8);
+  if (value.startsWith("0x")) return sign * parseInt(value.slice(2), 16);
+  return sign * parseInt(value, 10);
+}
+function resolveYamlInteger$1(source, isExplicit) {
+  if (isExplicit) {
+    if (!YAML_INTEGER_EXPLICIT_PATTERN.test(source)) return NOT_RESOLVED;
+  } else if (!YAML_INTEGER_IMPLICIT_PATTERN.test(source)) return NOT_RESOLVED;
+  const result = parseYamlInteger$1(source);
+  return Number.isFinite(result) ? result : NOT_RESOLVED;
+}
+var intJsonTag = defineScalarTag("tag:yaml.org,2002:int", {
+  implicit: true,
+  implicitFirstChars: ["-", ..."0123456789"],
+  resolve: resolveYamlInteger$1,
+  identify: (object) => Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !Object.is(object, -0),
+  represent: (object) => object.toString(10)
+});
+var YAML_INTEGER_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?0b[0-1_]+|[-+]?0[0-7_]+|[-+]?0x[0-9a-fA-F_]+|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+|[-+]?(?:0|[1-9][0-9_]*))$");
+function parseYamlInteger(source) {
+  let value = source.replace(/_/g, "");
+  let sign = 1;
+  if (value[0] === "-" || value[0] === "+") {
+    if (value[0] === "-") sign = -1;
+    value = value.slice(1);
+  }
+  if (value.startsWith("0b")) return sign * parseInt(value.slice(2), 2);
+  if (value.startsWith("0x")) return sign * parseInt(value.slice(2), 16);
+  if (value.includes(":")) {
+    let result = 0;
+    for (const part of value.split(":")) result = result * 60 + Number(part);
+    return sign * result;
+  }
+  if (value !== "0" && value[0] === "0") return sign * parseInt(value, 8);
+  return sign * parseInt(value, 10);
+}
+function resolveYamlInteger(source) {
+  if (!YAML_INTEGER_PATTERN.test(source)) return NOT_RESOLVED;
+  const result = parseYamlInteger(source);
+  return Number.isFinite(result) ? result : NOT_RESOLVED;
+}
+var intYaml11Tag = defineScalarTag("tag:yaml.org,2002:int", {
+  implicit: true,
+  implicitFirstChars: [
+    "-",
+    "+",
+    ..."0123456789"
+  ],
+  resolve: resolveYamlInteger,
+  identify: (object) => Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !Object.is(object, -0),
+  represent: (object) => object.toString(10)
+});
+var YAML_FLOAT_PATTERN$1 = /* @__PURE__ */ new RegExp("^(?:[-+]?[0-9]+(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|[-+]?\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+var YAML_FLOAT_SPECIAL_PATTERN$1 = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+function resolveYamlFloat$2(source) {
+  if (!YAML_FLOAT_PATTERN$1.test(source)) return NOT_RESOLVED;
+  let value = source.toLowerCase();
+  const sign = value[0] === "-" ? -1 : 1;
+  if ("+-".includes(value[0])) value = value.slice(1);
+  if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+  if (value === ".nan") return NaN;
+  const result = sign * parseFloat(value);
+  if (Number.isFinite(result) || YAML_FLOAT_SPECIAL_PATTERN$1.test(source)) return result;
+  return NOT_RESOLVED;
+}
+function representYamlFloat$2(object) {
+  if (isNaN(object)) return ".nan";
+  if (object === Number.POSITIVE_INFINITY) return ".inf";
+  if (object === Number.NEGATIVE_INFINITY) return "-.inf";
+  if (Object.is(object, -0)) return "-0.0";
+  const result = object.toString(10);
+  return /^[-+]?[0-9]+e/.test(result) ? result.replace("e", ".e") : result;
+}
+var floatCoreTag = defineScalarTag("tag:yaml.org,2002:float", {
+  implicit: true,
+  implicitFirstChars: [
+    "-",
+    "+",
+    ".",
+    ..."0123456789"
+  ],
+  resolve: resolveYamlFloat$2,
+  identify: (object) => Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || Object.is(object, -0)),
+  represent: representYamlFloat$2
+});
+var YAML_FLOAT_IMPLICIT_PATTERN = /* @__PURE__ */ new RegExp("^-?(?:0|[1-9][0-9]*)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$");
+var YAML_FLOAT_EXPLICIT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?[0-9]+(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|[-+]?\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+function resolveYamlFloat$1(source, isExplicit) {
+  if (isExplicit) {
+    if (!YAML_FLOAT_EXPLICIT_PATTERN.test(source)) return NOT_RESOLVED;
+    let value = source.toLowerCase();
+    const sign = value[0] === "-" ? -1 : 1;
+    if ("+-".includes(value[0])) value = value.slice(1);
+    if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+    if (value === ".nan") return NaN;
+    const result2 = sign * parseFloat(value);
+    return Number.isFinite(result2) ? result2 : NOT_RESOLVED;
+  }
+  if (!YAML_FLOAT_IMPLICIT_PATTERN.test(source)) return NOT_RESOLVED;
+  const result = Number(source);
+  if (Number.isFinite(result)) return result;
+  return NOT_RESOLVED;
+}
+function representYamlFloat$1(object) {
+  if (isNaN(object)) return ".nan";
+  if (object === Number.POSITIVE_INFINITY) return ".inf";
+  if (object === Number.NEGATIVE_INFINITY) return "-.inf";
+  if (Object.is(object, -0)) return "-0.0";
+  const result = object.toString(10);
+  return /^[-+]?[0-9]+e/.test(result) ? result.replace("e", ".e") : result;
+}
+var floatJsonTag = defineScalarTag("tag:yaml.org,2002:float", {
+  implicit: true,
+  implicitFirstChars: ["-", ..."0123456789"],
+  resolve: resolveYamlFloat$1,
+  identify: (object) => Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || Object.is(object, -0)),
+  represent: representYamlFloat$1
+});
+var YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:(?:[0-9][0-9_]*)?\\.[0-9_]*)(?:[eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+var YAML_FLOAT_SPECIAL_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
+function resolveYamlFloat(source) {
+  if (!YAML_FLOAT_PATTERN.test(source)) return NOT_RESOLVED;
+  let value = source.toLowerCase().replace(/_/g, "");
+  const sign = value[0] === "-" ? -1 : 1;
+  if ("+-".includes(value[0])) value = value.slice(1);
+  if (value === ".inf") return sign === 1 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY;
+  if (value === ".nan") return NaN;
+  let result = 0;
+  if (value.includes(":")) {
+    for (const part of value.split(":")) result = result * 60 + Number(part);
+    result *= sign;
+  } else result = sign * parseFloat(value);
+  if (Number.isFinite(result) || YAML_FLOAT_SPECIAL_PATTERN.test(source)) return result;
+  return NOT_RESOLVED;
+}
+function representYamlFloat(object) {
+  if (isNaN(object)) return ".nan";
+  if (object === Number.POSITIVE_INFINITY) return ".inf";
+  if (object === Number.NEGATIVE_INFINITY) return "-.inf";
+  if (Object.is(object, -0)) return "-0.0";
+  const result = object.toString(10);
+  return /^[-+]?[0-9]+e/.test(result) ? result.replace("e", ".e") : result;
+}
+var floatYaml11Tag = defineScalarTag("tag:yaml.org,2002:float", {
+  implicit: true,
+  implicitFirstChars: [
+    "-",
+    "+",
+    ".",
+    ..."0123456789"
+  ],
+  resolve: resolveYamlFloat,
+  identify: (object) => Object.prototype.toString.call(object) === "[object Number]" && (object % 1 !== 0 || Object.is(object, -0)),
+  represent: representYamlFloat
+});
+var mergeTag = defineScalarTag("tag:yaml.org,2002:merge", {
+  implicit: true,
+  implicitFirstChars: ["<"],
+  resolve: (source, isExplicit) => {
+    if (source === "<<" || isExplicit && source === "") return MERGE_KEY;
+    return NOT_RESOLVED;
+  }
+});
+var BASE64_PATTERN = /^[A-Za-z0-9+/]*={0,2}$/;
+function resolveYamlBinary(source) {
+  const input = source.replace(/\s/g, "");
+  if (input.length % 4 !== 0 || !BASE64_PATTERN.test(input)) return NOT_RESOLVED;
+  const binary = atob(input);
+  const result = new Uint8Array(binary.length);
+  for (let index2 = 0; index2 < binary.length; index2++) result[index2] = binary.charCodeAt(index2);
+  return result;
+}
+function representYamlBinary(object) {
+  let binary = "";
+  for (let index2 = 0; index2 < object.length; index2++) binary += String.fromCharCode(object[index2]);
+  return btoa(binary);
+}
+var binaryTag = defineScalarTag("tag:yaml.org,2002:binary", {
+  resolve: resolveYamlBinary,
+  identify: (object) => Object.prototype.toString.call(object) === "[object Uint8Array]",
+  represent: representYamlBinary
+});
+var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
+var YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
+function resolveYamlTimestamp(source) {
+  let match2 = YAML_DATE_REGEXP.exec(source);
+  if (match2 === null) match2 = YAML_TIMESTAMP_REGEXP.exec(source);
+  if (match2 === null) return NOT_RESOLVED;
+  const year = +match2[1];
+  const month = +match2[2] - 1;
+  const day = +match2[3];
+  if (!match2[4]) {
+    const date2 = new Date(Date.UTC(year, month, day));
+    if (date2.getUTCFullYear() !== year || date2.getUTCMonth() !== month || date2.getUTCDate() !== day) return NOT_RESOLVED;
+    return date2;
+  }
+  const hour = +match2[4];
+  const minute = +match2[5];
+  const second = +match2[6];
+  let fraction = 0;
+  if (hour > 23 || minute > 59 || second > 59) return NOT_RESOLVED;
+  if (match2[7]) {
+    let value = match2[7].slice(0, 3);
+    while (value.length < 3) value += "0";
+    fraction = +value;
+  }
+  const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
+  if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month || date.getUTCDate() !== day) return NOT_RESOLVED;
+  if (match2[9]) {
+    const offsetHour = +match2[10];
+    const offsetMinute = +(match2[11] || 0);
+    if (offsetHour > 23 || offsetMinute > 59) return NOT_RESOLVED;
+    const offset = (offsetHour * 60 + offsetMinute) * 6e4;
+    date.setTime(date.getTime() - (match2[9] === "-" ? -offset : offset));
+  }
+  return date;
+}
+var timestampTag = defineScalarTag("tag:yaml.org,2002:timestamp", {
+  implicit: true,
+  implicitFirstChars: [..."0123456789"],
+  resolve: resolveYamlTimestamp,
+  identify: (object) => object instanceof Date,
+  represent: (object) => object.toISOString()
+});
+var seqTag = defineSequenceTag("tag:yaml.org,2002:seq", {
+  create: () => [],
+  addItem: (container, item) => {
+    container.push(item);
+  },
+  identify: Array.isArray
+});
+var omapTag = defineSequenceTag("tag:yaml.org,2002:omap", {
+  create: () => [],
+  addItem: (container, item) => {
+    if (Object.prototype.toString.call(item) !== "[object Object]") return "cannot resolve an ordered map item";
+    const object = item;
+    const itemKeys = Object.keys(object);
+    if (itemKeys.length !== 1) return "cannot resolve an ordered map item";
+    for (const existing of container) if (Object.prototype.hasOwnProperty.call(existing, itemKeys[0])) return "cannot resolve an ordered map item";
+    container.push(object);
+    return "";
+  }
+});
+var pairsTag = defineSequenceTag("tag:yaml.org,2002:pairs", {
+  create: () => [],
+  addItem: (container, item) => {
+    if (item instanceof Map) {
+      if (item.size !== 1) return "cannot resolve a pairs item";
+      container.push(item.entries().next().value);
+      return "";
+    }
+    if (Object.prototype.toString.call(item) !== "[object Object]") return "cannot resolve a pairs item";
+    const object = item;
+    const keys = Object.keys(object);
+    if (keys.length !== 1) return "cannot resolve a pairs item";
+    container.push([keys[0], object[keys[0]]]);
+    return "";
+  }
+});
+function isPlainObject3(data) {
+  if (data === null || typeof data !== "object" || Array.isArray(data)) return false;
+  const prototype = Object.getPrototypeOf(data);
+  return prototype === null || prototype === Object.prototype;
+}
+function pick(object, keys) {
+  const result = {};
+  for (const key of keys) if (object[key] !== void 0) result[key] = object[key];
+  return result;
+}
+var mapTag = defineMappingTag("tag:yaml.org,2002:map", {
+  create: () => ({}),
+  identify: isPlainObject3,
+  represent: (o) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const key of Object.keys(o)) map.set(key, o[key]);
+    return map;
+  },
+  addPair: (container, key, value) => {
+    if (key !== null && typeof key === "object") return "object-based map does not support complex keys";
+    const normalizedKey = String(key);
+    if (normalizedKey === "__proto__") Object.defineProperty(container, normalizedKey, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
     });
+    else container[normalizedKey] = value;
+    return "";
+  },
+  has: (container, key) => {
+    if (key !== null && typeof key === "object") return false;
+    return Object.prototype.hasOwnProperty.call(container, String(key));
+  },
+  keys: (container) => Object.keys(container),
+  get: (container, key) => container[String(key)]
+});
+var setTag = defineMappingTag("tag:yaml.org,2002:set", {
+  create: () => /* @__PURE__ */ new Set(),
+  identify: (data) => data instanceof Set,
+  represent: (data) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const key of data) map.set(key, null);
+    return map;
+  },
+  addPair: (container, key, value) => {
+    if (value !== null) return "cannot resolve a set item";
+    container.add(key);
+    return "";
+  },
+  has: (container, key) => container.has(key),
+  keys: (container) => container.keys(),
+  get: () => null
+});
+function createTagDefinitionMap() {
+  return {
+    scalar: {},
+    sequence: {},
+    mapping: {}
+  };
+}
+function createTagDefinitionListMap() {
+  return {
+    scalar: [],
+    sequence: [],
+    mapping: []
+  };
+}
+function compileTags(tags) {
+  const result = [];
+  for (const tag of tags) {
+    let index2 = result.length;
+    for (let previousIndex = 0; previousIndex < result.length; previousIndex++) {
+      const previous = result[previousIndex];
+      if (previous.nodeKind === tag.nodeKind && previous.tagName === tag.tagName && previous.matchByTagPrefix === tag.matchByTagPrefix) {
+        index2 = previousIndex;
+        break;
+      }
+    }
+    result[index2] = tag;
+  }
+  return result;
+}
+var Schema = class Schema2 {
+  tags;
+  implicitScalarTags;
+  implicitScalarByFirstChar;
+  implicitScalarAnyFirstChar;
+  defaultScalarTag;
+  defaultSequenceTag;
+  defaultMappingTag;
+  exact;
+  prefix;
+  constructor(tags) {
+    const compiledTags = compileTags(tags);
+    const implicitScalarTags = [];
+    const exact = createTagDefinitionMap();
+    const prefix = createTagDefinitionListMap();
+    for (const tag of compiledTags) {
+      if (tag.nodeKind === "scalar" && tag.implicit) {
+        if (tag.matchByTagPrefix) throw new Error("Implicit scalar tags cannot match by tag prefix");
+        implicitScalarTags.push(tag);
+      }
+      switch (tag.nodeKind) {
+        case "scalar":
+          if (tag.matchByTagPrefix) prefix.scalar.push(tag);
+          else exact.scalar[tag.tagName] = tag;
+          break;
+        case "sequence":
+          if (tag.matchByTagPrefix) prefix.sequence.push(tag);
+          else exact.sequence[tag.tagName] = tag;
+          break;
+        case "mapping":
+          if (tag.matchByTagPrefix) prefix.mapping.push(tag);
+          else exact.mapping[tag.tagName] = tag;
+          break;
+      }
+    }
+    const implicitScalarAnyFirstChar = implicitScalarTags.filter((tag) => tag.implicitFirstChars === null);
+    const keys = /* @__PURE__ */ new Set();
+    for (const tag of implicitScalarTags) if (tag.implicitFirstChars !== null) for (const key of tag.implicitFirstChars) keys.add(key);
+    const implicitScalarByFirstChar = /* @__PURE__ */ new Map();
+    for (const key of keys) implicitScalarByFirstChar.set(key, implicitScalarTags.filter((tag) => tag.implicitFirstChars === null || tag.implicitFirstChars.indexOf(key) !== -1));
+    const defaultScalarTag = exact.scalar["tag:yaml.org,2002:str"];
+    if (!defaultScalarTag) throw new Error("schema does not define the default scalar tag (tag:yaml.org,2002:str)");
+    this.tags = compiledTags;
+    this.implicitScalarTags = implicitScalarTags;
+    this.implicitScalarByFirstChar = implicitScalarByFirstChar;
+    this.implicitScalarAnyFirstChar = implicitScalarAnyFirstChar;
+    this.defaultScalarTag = defaultScalarTag;
+    this.defaultSequenceTag = exact.sequence["tag:yaml.org,2002:seq"];
+    this.defaultMappingTag = exact.mapping["tag:yaml.org,2002:map"];
+    this.exact = exact;
+    this.prefix = prefix;
+  }
+  withTags(...tags) {
+    let flatTags = [];
+    for (const tag of tags) flatTags = flatTags.concat(tag);
+    return new Schema2([...this.tags, ...flatTags]);
   }
-  return to;
 };
-var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", {
-  value: mod,
-  enumerable: true
-}) : target, mod));
-var require_common = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  function isNothing(subject) {
-    return typeof subject === "undefined" || subject === null;
-  }
-  function isObject2(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) {
-    if (source) {
-      const sourceKeys = Object.keys(source);
-      for (let index2 = 0, length = sourceKeys.length; index2 < length; index2 += 1) {
-        const key = sourceKeys[index2];
-        target[key] = source[key];
-      }
-    }
-    return target;
-  }
-  function repeat(string2, count) {
-    let result = "";
-    for (let cycle = 0; cycle < count; cycle += 1) result += string2;
-    return result;
+var FAILSAFE_SCHEMA = new Schema([
+  strTag,
+  seqTag,
+  mapTag
+]);
+var JSON_SCHEMA = new Schema([
+  ...FAILSAFE_SCHEMA.tags,
+  nullJsonTag,
+  boolJsonTag,
+  intJsonTag,
+  floatJsonTag
+]);
+var CORE_SCHEMA = new Schema([
+  ...FAILSAFE_SCHEMA.tags,
+  nullCoreTag,
+  boolCoreTag,
+  intCoreTag,
+  floatCoreTag
+]);
+var YAML11_SCHEMA = new Schema([
+  ...FAILSAFE_SCHEMA.tags,
+  nullYaml11Tag,
+  boolYaml11Tag,
+  intYaml11Tag,
+  floatYaml11Tag,
+  timestampTag,
+  mergeTag,
+  binaryTag,
+  omapTag,
+  pairsTag,
+  setTag
+]);
+var realMapTag = defineMappingTag("tag:yaml.org,2002:map", {
+  create: () => /* @__PURE__ */ new Map(),
+  addPair: (container, key, value) => {
+    container.set(key, value);
+    return "";
+  },
+  has: (container, key) => container.has(key),
+  keys: (container) => container.keys(),
+  get: (container, key) => container.get(key),
+  identify: (data) => data instanceof Map || isPlainObject3(data),
+  represent: (data) => {
+    if (data instanceof Map) return data;
+    const map = /* @__PURE__ */ new Map();
+    const obj = data;
+    for (const key of Object.keys(obj)) map.set(key, obj[key]);
+    return map;
+  }
+});
+function normalizeKey(key) {
+  if (Array.isArray(key)) {
+    const array = Array.prototype.slice.call(key);
+    for (let index2 = 0; index2 < array.length; index2++) {
+      if (Array.isArray(array[index2])) return null;
+      if (typeof array[index2] === "object" && Object.prototype.toString.call(array[index2]) === "[object Object]") array[index2] = "[object Object]";
+    }
+    return String(array);
+  }
+  if (typeof key === "object" && Object.prototype.toString.call(key) === "[object Object]") return "[object Object]";
+  return String(key);
+}
+var legacyMapTag = defineMappingTag("tag:yaml.org,2002:map", {
+  create: () => ({}),
+  identify: isPlainObject3,
+  represent: (o) => {
+    const map = /* @__PURE__ */ new Map();
+    for (const key of Object.keys(o)) map.set(key, o[key]);
+    return map;
+  },
+  addPair: (container, key, value) => {
+    const normalizedKey = normalizeKey(key);
+    if (normalizedKey === null) return "nested arrays are not supported inside keys";
+    if (normalizedKey === "__proto__") Object.defineProperty(container, normalizedKey, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+    else container[normalizedKey] = value;
+    return "";
+  },
+  has: (container, key) => {
+    const normalizedKey = normalizeKey(key);
+    return normalizedKey !== null && Object.prototype.hasOwnProperty.call(container, normalizedKey);
+  },
+  keys: (container) => Object.keys(container),
+  get: (container, key) => container[String(key)]
+});
+var DEFAULT_SNIPPET_OPTIONS = {
+  maxLength: 79,
+  indent: 1,
+  linesBefore: 3,
+  linesAfter: 2
+};
+function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
+  let head = "";
+  let tail = "";
+  const 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;
   }
-  function isNegativeZero(number) {
-    return number === 0 && Number.NEGATIVE_INFINITY === 1 / number;
-  }
-  module2.exports.isNothing = isNothing;
-  module2.exports.isObject = isObject2;
-  module2.exports.toArray = toArray;
-  module2.exports.repeat = repeat;
-  module2.exports.isNegativeZero = isNegativeZero;
-  module2.exports.extend = extend;
-}));
-var require_exception = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  function formatError(exception, compact) {
-    let where = "";
-    const 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 YAMLException2(reason, mark) {
-    Error.call(this);
+  return {
+    str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, "\u2192") + tail,
+    pos: position - lineStart + head.length
+  };
+}
+function padStart(string2, max) {
+  return " ".repeat(Math.max(max - string2.length, 0)) + string2;
+}
+function makeSnippet(mark, options) {
+  if (!mark.buffer) return null;
+  const opts = {
+    ...DEFAULT_SNIPPET_OPTIONS,
+    ...options
+  };
+  const re = /\r?\n|\r|\0/g;
+  const lineStarts = [0];
+  const lineEnds = [];
+  let match2;
+  let foundLineNo = -1;
+  while (match2 = re.exec(mark.buffer)) {
+    lineEnds.push(match2.index);
+    lineStarts.push(match2.index + match2[0].length);
+    if (mark.position <= match2.index && foundLineNo < 0) foundLineNo = lineStarts.length - 2;
+  }
+  if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
+  let result = "";
+  const lineNoLength = Math.min(mark.line + opts.linesAfter, lineEnds.length).toString().length;
+  const maxLineLength = opts.maxLength - (opts.indent + lineNoLength + 3);
+  for (let i = 1; i <= opts.linesBefore; i++) {
+    if (foundLineNo - i < 0) break;
+    const line2 = getLine(mark.buffer, lineStarts[foundLineNo - i], lineEnds[foundLineNo - i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), maxLineLength);
+    result = `${" ".repeat(opts.indent)}${padStart((mark.line - i + 1).toString(), lineNoLength)} | ${line2.str}
+${result}`;
+  }
+  const line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength);
+  result += `${" ".repeat(opts.indent)}${padStart((mark.line + 1).toString(), lineNoLength)} | ${line.str}
+`;
+  result += `${"-".repeat(opts.indent + lineNoLength + 3 + line.pos)}^
+`;
+  for (let i = 1; i <= opts.linesAfter; i++) {
+    if (foundLineNo + i >= lineEnds.length) break;
+    const line2 = getLine(mark.buffer, lineStarts[foundLineNo + i], lineEnds[foundLineNo + i], mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), maxLineLength);
+    result += `${" ".repeat(opts.indent)}${padStart((mark.line + i + 1).toString(), lineNoLength)} | ${line2.str}
+`;
+  }
+  return result.replace(/\n$/, "");
+}
+function formatError(exception, compact) {
+  let where = "";
+  if (!exception.mark) return exception.reason;
+  if (exception.mark.name) where += `in "${exception.mark.name}" `;
+  where += `(${exception.mark.line + 1}:${exception.mark.column + 1})`;
+  if (!compact && exception.mark.snippet) where += `
+
+${exception.mark.snippet}`;
+  return `${exception.reason} ${where}`;
+}
+var YAMLException = class extends Error {
+  reason;
+  mark;
+  constructor(reason, mark) {
+    super();
     this.name = "YAMLException";
     this.reason = reason;
     this.mark = mark;
     this.message = formatError(this, false);
     if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-    else this.stack = (/* @__PURE__ */ new Error()).stack || "";
   }
-  YAMLException2.prototype = Object.create(Error.prototype);
-  YAMLException2.prototype.constructor = YAMLException2;
-  YAMLException2.prototype.toString = function toString2(compact) {
-    return this.name + ": " + formatError(this, compact);
-  };
-  module2.exports = YAMLException2;
-}));
-var require_snippet = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var common = require_common();
-  function getLine(buffer, lineStart, lineEnd, position, maxLineLength) {
-    let head = "";
-    let tail = "";
-    const 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, "\u2192") + tail,
-      pos: position - lineStart + head.length
-    };
-  }
-  function padStart(string2, max) {
-    return common.repeat(" ", max - string2.length) + string2;
-  }
-  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;
-    const re = /\r?\n|\r|\0/g;
-    const lineStarts = [0];
-    const lineEnds = [];
-    let match2;
-    let foundLineNo = -1;
-    while (match2 = re.exec(mark.buffer)) {
-      lineEnds.push(match2.index);
-      lineStarts.push(match2.index + match2[0].length);
-      if (mark.position <= match2.index && foundLineNo < 0) foundLineNo = lineStarts.length - 2;
-    }
-    if (foundLineNo < 0) foundLineNo = lineStarts.length - 1;
-    let result = "";
-    const lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length;
-    const maxLineLength = options.maxLength - (options.indent + lineNoLength + 3);
-    for (let i = 1; i <= options.linesBefore; i++) {
-      if (foundLineNo - i < 0) break;
-      const line2 = 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) + " | " + line2.str + "\n" + result;
-    }
-    const 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 (let i = 1; i <= options.linesAfter; i++) {
-      if (foundLineNo + i >= lineEnds.length) break;
-      const line2 = 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) + " | " + line2.str + "\n";
-    }
-    return result.replace(/\n$/, "");
-  }
-  module2.exports = makeSnippet;
-}));
-var require_type = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var YAMLException2 = require_exception();
-  var TYPE_CONSTRUCTOR_OPTIONS = [
-    "kind",
-    "multi",
-    "resolve",
-    "construct",
-    "instanceOf",
-    "predicate",
-    "represent",
-    "representName",
-    "defaultStyle",
-    "styleAliases"
-  ];
-  var YAML_NODE_KINDS = [
-    "scalar",
-    "sequence",
-    "mapping"
-  ];
-  function compileStyleAliases(map) {
-    const result = {};
-    if (map !== null) Object.keys(map).forEach(function(style) {
-      map[style].forEach(function(alias) {
-        result[String(alias)] = style;
-      });
-    });
-    return result;
+  toString(compact) {
+    return `${this.name}: ${formatError(this, compact)}`;
   }
-  function Type2(tag, options) {
-    options = options || {};
-    Object.keys(options).forEach(function(name) {
-      if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) throw new YAMLException2('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.');
-    });
-    this.options = options;
-    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 YAMLException2('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.');
-  }
-  module2.exports = Type2;
-}));
-var require_schema = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var YAMLException2 = require_exception();
-  var Type2 = require_type();
-  function compileList(schema, name) {
-    const result = [];
-    schema[name].forEach(function(currentType) {
-      let 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 throwErrorAt(source, position, message, filename = "") {
+  let line = 0;
+  let lineStart = 0;
+  for (let index2 = 0; index2 < position; index2++) {
+    const ch = source.charCodeAt(index2);
+    if (ch === 10) {
+      line++;
+      lineStart = index2 + 1;
+    } else if (ch === 13) {
+      line++;
+      if (source.charCodeAt(index2 + 1) === 10) index2++;
+      lineStart = index2 + 1;
+    }
+  }
+  const mark = {
+    name: filename,
+    buffer: source,
+    position,
+    line,
+    column: position - lineStart
+  };
+  mark.snippet = makeSnippet(mark);
+  throw new YAMLException(message, mark);
+}
+var NO_RANGE$3 = -1;
+function simpleEscapeSequence(c) {
+  switch (c) {
+    case 48:
+      return "\0";
+    case 97:
+      return "\x07";
+    case 98:
+      return "\b";
+    case 116:
+      return "	";
+    case 9:
+      return "	";
+    case 110:
+      return "\n";
+    case 118:
+      return "\v";
+    case 102:
+      return "\f";
+    case 114:
+      return "\r";
+    case 101:
+      return "\x1B";
+    case 32:
+      return " ";
+    case 34:
+      return '"';
+    case 47:
+      return "/";
+    case 92:
+      return "\\";
+    case 78:
+      return "\x85";
+    case 95:
+      return "\xA0";
+    case 76:
+      return "\u2028";
+    case 80:
+      return "\u2029";
+    default:
+      return "";
   }
-  function compileMap() {
-    const result = {
-      scalar: {},
-      sequence: {},
-      mapping: {},
-      fallback: {},
-      multi: {
-        scalar: [],
-        sequence: [],
-        mapping: [],
-        fallback: []
-      }
-    };
-    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 (let index2 = 0, length = arguments.length; index2 < length; index2 += 1) arguments[index2].forEach(collectType);
-    return result;
+}
+var simpleEscapeCheck = new Array(256);
+var simpleEscapeMap = new Array(256);
+for (let i = 0; i < 256; i++) {
+  simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0;
+  simpleEscapeMap[i] = simpleEscapeSequence(i);
+}
+function charFromCodepoint(c) {
+  if (c <= 65535) return String.fromCharCode(c);
+  return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
+}
+function fromHexCode$1(c) {
+  if (c >= 48 && c <= 57) return c - 48;
+  return (c | 32) - 97 + 10;
+}
+function escapedHexLen$1(c) {
+  if (c === 120) return 2;
+  if (c === 117) return 4;
+  return 8;
+}
+function skipFoldedBreaks(input, position, end) {
+  let breaks = 0;
+  while (position < end) {
+    const ch = input.charCodeAt(position);
+    if (ch === 10) {
+      breaks++;
+      position++;
+    } else if (ch === 13) {
+      breaks++;
+      position++;
+      if (input.charCodeAt(position) === 10) position++;
+    } else if (ch === 32 || ch === 9) position++;
+    else break;
   }
-  function Schema2(definition) {
-    return this.extend(definition);
-  }
-  Schema2.prototype.extend = function extend(definition) {
-    let implicit = [];
-    let explicit = [];
-    if (definition instanceof Type2) explicit.push(definition);
-    else if (Array.isArray(definition)) explicit = explicit.concat(definition);
-    else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) {
-      if (definition.implicit) implicit = implicit.concat(definition.implicit);
-      if (definition.explicit) explicit = explicit.concat(definition.explicit);
-    } else throw new YAMLException2("Schema.extend argument should be a Type, [ Type ], or a schema definition ({ implicit: [...], explicit: [...] })");
-    implicit.forEach(function(type) {
-      if (!(type instanceof Type2)) throw new YAMLException2("Specified list of YAML types (or a single Type object) contains a non-Type object.");
-      if (type.loadKind && type.loadKind !== "scalar") throw new YAMLException2("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 YAMLException2("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 Type2)) throw new YAMLException2("Specified list of YAML types (or a single Type object) contains a non-Type object.");
-    });
-    const result = Object.create(Schema2.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;
+  return {
+    position,
+    breaks
   };
-  module2.exports = Schema2;
-}));
-var require_str = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  module2.exports = new (require_type())("tag:yaml.org,2002:str", {
-    kind: "scalar",
-    construct: function(data) {
-      return data !== null ? data : "";
+}
+function foldedBreaks(count) {
+  if (count === 1) return " ";
+  return "\n".repeat(count - 1);
+}
+function getPlainValue(input, start, end) {
+  let result = "";
+  let position = start;
+  let captureStart = start;
+  let captureEnd = start;
+  while (position < end) {
+    const ch = input.charCodeAt(position);
+    if (ch === 10 || ch === 13) {
+      result += input.slice(captureStart, captureEnd);
+      const fold = skipFoldedBreaks(input, position, end);
+      result += foldedBreaks(fold.breaks);
+      position = captureStart = captureEnd = fold.position;
+    } else {
+      position++;
+      if (ch !== 32 && ch !== 9) captureEnd = position;
+    }
+  }
+  return result + input.slice(captureStart, captureEnd);
+}
+function getSingleQuotedValue(input, start, end) {
+  let result = "";
+  let position = start;
+  let captureStart = start;
+  let captureEnd = start;
+  while (position < end) {
+    const ch = input.charCodeAt(position);
+    if (ch === 39) {
+      result += input.slice(captureStart, position) + "'";
+      position += 2;
+      captureStart = captureEnd = position;
+    } else if (ch === 10 || ch === 13) {
+      result += input.slice(captureStart, captureEnd);
+      const fold = skipFoldedBreaks(input, position, end);
+      result += foldedBreaks(fold.breaks);
+      position = captureStart = captureEnd = fold.position;
+    } else {
+      position++;
+      if (ch !== 32 && ch !== 9) captureEnd = position;
+    }
+  }
+  return result + input.slice(captureStart, end);
+}
+function getDoubleQuotedValue(input, start, end) {
+  let result = "";
+  let position = start;
+  let captureStart = start;
+  let captureEnd = start;
+  while (position < end) {
+    const ch = input.charCodeAt(position);
+    if (ch === 92) {
+      result += input.slice(captureStart, position);
+      position++;
+      const escaped = input.charCodeAt(position);
+      if (escaped === 10 || escaped === 13) position = skipFoldedBreaks(input, position, end).position;
+      else if (escaped < 256 && simpleEscapeCheck[escaped]) {
+        result += simpleEscapeMap[escaped];
+        position++;
+      } else {
+        let hexLength = escapedHexLen$1(escaped);
+        let hexResult = 0;
+        for (; hexLength > 0; hexLength--) {
+          position++;
+          const digit = fromHexCode$1(input.charCodeAt(position));
+          hexResult = (hexResult << 4) + digit;
+        }
+        result += charFromCodepoint(hexResult);
+        position++;
+      }
+      captureStart = captureEnd = position;
+    } else if (ch === 10 || ch === 13) {
+      result += input.slice(captureStart, captureEnd);
+      const fold = skipFoldedBreaks(input, position, end);
+      result += foldedBreaks(fold.breaks);
+      position = captureStart = captureEnd = fold.position;
+    } else {
+      position++;
+      if (ch !== 32 && ch !== 9) captureEnd = position;
+    }
+  }
+  return result + input.slice(captureStart, end);
+}
+function getBlockValue(input, start, end, indent, chomping, folded) {
+  const textIndent = indent < 0 ? 0 : indent;
+  const region = input.slice(start, end).replace(/\r\n?/g, "\n");
+  const lines = region === "" ? [] : (region.endsWith("\n") ? region.slice(0, -1) : region).split("\n");
+  let result = "";
+  let didReadContent = false;
+  let emptyLines = 0;
+  let atMoreIndented = false;
+  for (const line of lines) {
+    let column = 0;
+    while (column < textIndent && line.charCodeAt(column) === 32) column++;
+    if (indent < 0 || column >= line.length) {
+      emptyLines++;
+      continue;
     }
-  });
-}));
-var require_seq = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  module2.exports = new (require_type())("tag:yaml.org,2002:seq", {
-    kind: "sequence",
-    construct: function(data) {
-      return data !== null ? data : [];
+    const content = line.slice(textIndent);
+    const first = content.charCodeAt(0);
+    if (folded) if (first === 32 || first === 9) {
+      atMoreIndented = true;
+      result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+    } else if (atMoreIndented) {
+      atMoreIndented = false;
+      result += "\n".repeat(emptyLines + 1);
+    } else if (emptyLines === 0) {
+      if (didReadContent) result += " ";
+    } else result += "\n".repeat(emptyLines);
+    else result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+    result += content;
+    didReadContent = true;
+    emptyLines = 0;
+  }
+  if (chomping === 3) result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+  else if (chomping !== 2) {
+    if (didReadContent) result += "\n";
+  }
+  return result;
+}
+function getScalarValue(input, scalar) {
+  if (scalar.valueStart === NO_RANGE$3) return "";
+  const { valueStart, valueEnd } = scalar;
+  if (scalar.fast) return input.slice(valueStart, valueEnd);
+  switch (scalar.style) {
+    case 2:
+      return getSingleQuotedValue(input, valueStart, valueEnd);
+    case 3:
+      return getDoubleQuotedValue(input, valueStart, valueEnd);
+    case 4:
+      return getBlockValue(input, valueStart, valueEnd, scalar.indent, scalar.chomping, false);
+    case 5:
+      return getBlockValue(input, valueStart, valueEnd, scalar.indent, scalar.chomping, true);
+    default:
+      return getPlainValue(input, valueStart, valueEnd);
+  }
+}
+var DEFAULT_TAG_HANDLERS = {
+  "!": "!",
+  "!!": "tag:yaml.org,2002:"
+};
+function tagPercentEncode(source) {
+  return encodeURI(source).replace(/!/g, "%21");
+}
+function tagNameFull(rawTag, tagHandlers) {
+  if (rawTag.startsWith("!<") && rawTag.endsWith(">")) return decodeURIComponent(rawTag.slice(2, -1));
+  const handleEnd = rawTag.indexOf("!", 1);
+  const handle = handleEnd === -1 ? "!" : rawTag.slice(0, handleEnd + 1);
+  const prefix = tagHandlers?.[handle] ?? DEFAULT_TAG_HANDLERS[handle] ?? handle;
+  return decodeURIComponent(prefix) + decodeURIComponent(rawTag.slice(handle.length));
+}
+function tagNameShort(fullTag) {
+  let tag = fullTag;
+  if (tag.charCodeAt(0) === 33) {
+    tag = tag.slice(1);
+    return `!${tagPercentEncode(tag)}`;
+  }
+  if (tag.slice(0, 18) === "tag:yaml.org,2002:") return `!!${tagPercentEncode(tag.slice(18))}`;
+  return `!<${tagPercentEncode(tag)}>`;
+}
+var NO_RANGE$2 = -1;
+var DEFAULT_CONSTRUCTOR_OPTIONS = {
+  filename: "",
+  schema: CORE_SCHEMA,
+  json: false,
+  maxMergeSeqLength: 20
+};
+function eventPosition$1(event) {
+  if ("tagStart" in event && event.tagStart !== NO_RANGE$2) return event.tagStart;
+  if ("anchorStart" in event && event.anchorStart !== NO_RANGE$2) return event.anchorStart;
+  if ("valueStart" in event && event.valueStart !== NO_RANGE$2) return event.valueStart;
+  if ("start" in event) return event.start;
+  return 0;
+}
+function throwError$1(state, message) {
+  throwErrorAt(state.source, state.position, message, state.filename);
+}
+function lookupTag(exact, prefix, tagName) {
+  const exactTag = exact[tagName];
+  if (exactTag) return exactTag;
+  for (const tag of prefix) if (tagName.startsWith(tag.tagName)) return tag;
+}
+function findExplicitTag(state, exact, prefix, tagName, nodeKind) {
+  const tag = lookupTag(exact, prefix, tagName);
+  if (tag) return tag;
+  throwError$1(state, `unknown ${nodeKind} tag !<${tagName}>`);
+}
+function constructScalar(state, event) {
+  const source = getScalarValue(state.source, event);
+  const rawTag = event.tagStart === NO_RANGE$2 ? "" : state.source.slice(event.tagStart, event.tagEnd);
+  const strTag2 = state.schema.defaultScalarTag;
+  if (rawTag !== "") {
+    if (rawTag === "!") return {
+      value: source,
+      tag: strTag2
+    };
+    const tagName = tagNameFull(rawTag, state.tagHandlers);
+    const scalarTag = lookupTag(state.schema.exact.scalar, state.schema.prefix.scalar, tagName);
+    if (scalarTag) {
+      const result = scalarTag.resolve(source, true, tagName);
+      if (result === NOT_RESOLVED) throwError$1(state, `cannot resolve a node with !<${tagName}> explicit tag`);
+      return {
+        value: result,
+        tag: scalarTag
+      };
     }
-  });
-}));
-var require_map = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  module2.exports = new (require_type())("tag:yaml.org,2002:map", {
-    kind: "mapping",
-    construct: function(data) {
-      return data !== null ? data : {};
+    const collectionTagDef = lookupTag(state.schema.exact.mapping, state.schema.prefix.mapping, tagName) ?? lookupTag(state.schema.exact.sequence, state.schema.prefix.sequence, tagName);
+    if (collectionTagDef) {
+      if (source !== "") throwError$1(state, `cannot resolve a node with !<${tagName}> explicit tag`);
+      return {
+        value: collectionTagDef.create(tagName),
+        tag: collectionTagDef
+      };
     }
+    throwError$1(state, `unknown scalar tag !<${tagName}>`);
+  }
+  if (event.style === 1) {
+    const candidates = state.schema.implicitScalarByFirstChar.get(source.charAt(0)) ?? state.schema.implicitScalarAnyFirstChar;
+    for (const tag of candidates) {
+      const result = tag.resolve(source, false, tag.tagName);
+      if (result !== NOT_RESOLVED) return {
+        value: result,
+        tag
+      };
+    }
+  }
+  return {
+    value: strTag2.resolve(source, false, strTag2.tagName),
+    tag: strTag2
+  };
+}
+function collectionTag(state, event, exact, prefix, defaultTagName, nodeKind) {
+  const rawTag = event.tagStart === NO_RANGE$2 ? "" : state.source.slice(event.tagStart, event.tagEnd);
+  const tagName = rawTag === "" || rawTag === "!" ? defaultTagName : tagNameFull(rawTag, state.tagHandlers);
+  return {
+    tagName,
+    tag: findExplicitTag(state, exact, prefix, tagName, nodeKind)
+  };
+}
+function isMappingTag(tag) {
+  return tag.nodeKind === "mapping";
+}
+function mergeKeys(state, frame, source, sourceTag) {
+  for (const sourceKey of sourceTag.keys(source)) {
+    if (frame.tag.has(frame.value, sourceKey)) continue;
+    const err = frame.tag.addPair(frame.value, sourceKey, sourceTag.get(source, sourceKey));
+    if (err) throwError$1(state, err);
+    (frame.overridable ??= /* @__PURE__ */ new Set()).add(sourceKey);
+  }
+}
+function mergeSource(state, frame, source, sourceTag) {
+  state.position = frame.keyPosition;
+  if (isMappingTag(sourceTag)) mergeKeys(state, frame, source, sourceTag);
+  else if (sourceTag.nodeKind === "sequence" && Array.isArray(source)) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const element of source) {
+      if (seen.has(element)) continue;
+      seen.add(element);
+      mergeKeys(state, frame, element, frame.tag);
+    }
+  } else throwError$1(state, "cannot merge mappings; the provided source object is unacceptable");
+}
+function addMappingValue(state, frame, key, value, tag) {
+  state.position = frame.keyPosition;
+  if (key === MERGE_KEY) {
+    mergeSource(state, frame, value, tag);
+    return;
+  }
+  if (!state.json && frame.tag.has(frame.value, key) && !frame.overridable?.has(key)) throwError$1(state, "duplicated mapping key");
+  const err = frame.tag.addPair(frame.value, key, value);
+  if (err) throwError$1(state, err);
+  frame.overridable?.delete(key);
+}
+function addValue(state, value, tag) {
+  const frame = state.frames[state.frames.length - 1];
+  if (frame.kind === "document") {
+    frame.value = value;
+    frame.hasValue = true;
+  } else if (frame.kind === "sequence") {
+    if (frame.merge) {
+      if (!isMappingTag(tag)) throwError$1(state, "cannot merge mappings; the provided source object is unacceptable");
+      if (frame.index >= state.maxMergeSeqLength) throwError$1(state, `merge sequence length exceeded maxMergeSeqLength (${state.maxMergeSeqLength})`);
+    }
+    const err = frame.tag.addItem(frame.value, value, frame.index++);
+    if (err) throwError$1(state, err);
+  } else if (frame.hasKey) {
+    const key = frame.key;
+    frame.key = void 0;
+    frame.hasKey = false;
+    addMappingValue(state, frame, key, value, tag);
+  } else {
+    frame.key = value;
+    frame.keyPosition = state.position;
+    frame.hasKey = true;
+  }
+}
+function storeAnchor(state, event, value, tag) {
+  if (event.anchorStart !== NO_RANGE$2) state.anchors.set(state.source.slice(event.anchorStart, event.anchorEnd), {
+    value,
+    tag
   });
-}));
-var require_failsafe = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  module2.exports = new (require_schema())({ explicit: [
-    require_str(),
-    require_seq(),
-    require_map()
-  ] });
-}));
-var require_null = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var Type2 = require_type();
-  function resolveYamlNull(data) {
-    if (data === null) return true;
-    const 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;
-  }
-  module2.exports = new Type2("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 "";
+}
+function constructFromEvents(events, options) {
+  const state = {
+    ...DEFAULT_CONSTRUCTOR_OPTIONS,
+    ...options,
+    events,
+    documents: [],
+    eventIndex: 0,
+    position: 0,
+    frames: [],
+    anchors: /* @__PURE__ */ new Map(),
+    tagHandlers: /* @__PURE__ */ Object.create(null)
+  };
+  while (state.eventIndex < state.events.length) {
+    const event = state.events[state.eventIndex++];
+    state.position = eventPosition$1(event);
+    switch (event.type) {
+      case 1:
+        state.anchors = /* @__PURE__ */ new Map();
+        state.tagHandlers = /* @__PURE__ */ Object.create(null);
+        for (const directive of event.directives) if (directive.kind === "tag") state.tagHandlers[directive.handle] = directive.prefix;
+        state.frames.push({
+          kind: "document",
+          position: state.position,
+          value: void 0,
+          hasValue: false
+        });
+        break;
+      case 4: {
+        const { value, tag } = constructScalar(state, event);
+        storeAnchor(state, event, value, tag);
+        addValue(state, value, tag);
+        break;
       }
-    },
-    defaultStyle: "lowercase"
-  });
-}));
-var require_bool = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var Type2 = require_type();
-  function resolveYamlBoolean(data) {
-    if (data === null) return false;
-    const 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]";
-  }
-  module2.exports = new Type2("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";
+      case 2: {
+        const definition = collectionTag(state, event, state.schema.exact.sequence, state.schema.prefix.sequence, "tag:yaml.org,2002:seq", "sequence");
+        const value = definition.tag.create(definition.tagName);
+        storeAnchor(state, event, value, definition.tag);
+        const parent = state.frames[state.frames.length - 1];
+        const merge2 = parent !== void 0 && parent.kind === "mapping" && parent.hasKey && parent.key === MERGE_KEY;
+        state.frames.push({
+          kind: "sequence",
+          position: state.position,
+          value,
+          tag: definition.tag,
+          index: 0,
+          merge: merge2
+        });
+        break;
       }
-    },
-    defaultStyle: "lowercase"
-  });
-}));
-var require_int = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var common = require_common();
-  var Type2 = require_type();
-  function isHexCode(c) {
-    return c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102;
-  }
-  function isOctCode(c) {
-    return c >= 48 && c <= 55;
-  }
-  function isDecCode(c) {
-    return c >= 48 && c <= 57;
-  }
-  function resolveYamlInteger(data) {
-    if (data === null) return false;
-    const max = data.length;
-    let index2 = 0;
-    let hasDigits = false;
-    if (!max) return false;
-    let ch = data[index2];
-    if (ch === "-" || ch === "+") ch = data[++index2];
-    if (ch === "0") {
-      if (index2 + 1 === max) return true;
-      ch = data[++index2];
-      if (ch === "b") {
-        index2++;
-        for (; index2 < max; index2++) {
-          ch = data[index2];
-          if (ch !== "0" && ch !== "1") return false;
-          hasDigits = true;
-        }
-        return hasDigits && Number.isFinite(parseYamlInteger(data));
+      case 3: {
+        const definition = collectionTag(state, event, state.schema.exact.mapping, state.schema.prefix.mapping, "tag:yaml.org,2002:map", "mapping");
+        const value = definition.tag.create(definition.tagName);
+        storeAnchor(state, event, value, definition.tag);
+        state.frames.push({
+          kind: "mapping",
+          position: state.position,
+          value,
+          tag: definition.tag,
+          key: void 0,
+          keyPosition: state.position,
+          hasKey: false,
+          overridable: null
+        });
+        break;
       }
-      if (ch === "x") {
-        index2++;
-        for (; index2 < max; index2++) {
-          if (!isHexCode(data.charCodeAt(index2))) return false;
-          hasDigits = true;
-        }
-        return hasDigits && Number.isFinite(parseYamlInteger(data));
+      case 5: {
+        const name = state.source.slice(event.anchorStart, event.anchorEnd);
+        const anchor = state.anchors.get(name);
+        if (!anchor) throwError$1(state, `unidentified alias "${name}"`);
+        addValue(state, anchor.value, anchor.tag);
+        break;
       }
-      if (ch === "o") {
-        index2++;
-        for (; index2 < max; index2++) {
-          if (!isOctCode(data.charCodeAt(index2))) return false;
-          hasDigits = true;
-        }
-        return hasDigits && Number.isFinite(parseYamlInteger(data));
-      }
-    }
-    for (; index2 < max; index2++) {
-      if (!isDecCode(data.charCodeAt(index2))) return false;
-      hasDigits = true;
-    }
-    if (!hasDigits) return false;
-    return Number.isFinite(parseYamlInteger(data));
-  }
-  function parseYamlInteger(data) {
-    let value = data;
-    let sign = 1;
-    let 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 constructYamlInteger(data) {
-    return parseYamlInteger(data);
-  }
-  function isInteger(object) {
-    return Object.prototype.toString.call(object) === "[object Number]" && object % 1 === 0 && !common.isNegativeZero(object);
-  }
-  module2.exports = new Type2("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);
-      },
-      hexadecimal: function(obj) {
-        return obj >= 0 ? "0x" + obj.toString(16).toUpperCase() : "-0x" + obj.toString(16).toUpperCase().slice(1);
+      case 6: {
+        const frame = state.frames.pop();
+        if (frame.kind === "document") state.documents.push(frame.value);
+        else addValue(state, frame.value, frame.tag);
+        break;
       }
-    },
-    defaultStyle: "decimal",
-    styleAliases: {
-      binary: [2, "bin"],
-      octal: [8, "oct"],
-      decimal: [10, "dec"],
-      hexadecimal: [16, "hex"]
     }
-  });
-}));
-var require_float = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var common = require_common();
-  var Type2 = require_type();
-  var YAML_FLOAT_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?(?:[0-9]+)(?:\\.[0-9]*)?(?:[eE][-+]?[0-9]+)?|\\.[0-9]+(?:[eE][-+]?[0-9]+)?|[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
-  var YAML_FLOAT_SPECIAL_PATTERN = /* @__PURE__ */ new RegExp("^(?:[-+]?\\.(?:inf|Inf|INF)|\\.(?:nan|NaN|NAN))$");
-  function resolveYamlFloat(data) {
-    if (data === null) return false;
-    if (!YAML_FLOAT_PATTERN.test(data)) return false;
-    if (Number.isFinite(parseFloat(data, 10))) return true;
-    return YAML_FLOAT_SPECIAL_PATTERN.test(data);
-  }
-  function constructYamlFloat(data) {
-    let value = data.toLowerCase();
-    const 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) {
-    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";
-    const res = object.toString(10);
-    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));
-  }
-  module2.exports = new Type2("tag:yaml.org,2002:float", {
-    kind: "scalar",
-    resolve: resolveYamlFloat,
-    construct: constructYamlFloat,
-    predicate: isFloat,
-    represent: representYamlFloat,
-    defaultStyle: "lowercase"
-  });
-}));
-var require_json = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  module2.exports = require_failsafe().extend({ implicit: [
-    require_null(),
-    require_bool(),
-    require_int(),
-    require_float()
-  ] });
-}));
-var require_core2 = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  module2.exports = require_json();
-}));
-var require_timestamp = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var Type2 = require_type();
-  var YAML_DATE_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9])-([0-9][0-9])$");
-  var YAML_TIMESTAMP_REGEXP = /* @__PURE__ */ new RegExp("^([0-9][0-9][0-9][0-9])-([0-9][0-9]?)-([0-9][0-9]?)(?:[Tt]|[ \\t]+)([0-9][0-9]?):([0-9][0-9]):([0-9][0-9])(?:\\.([0-9]*))?(?:[ \\t]*(Z|([-+])([0-9][0-9]?)(?::([0-9][0-9]))?))?$");
-  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) {
-    let fraction = 0;
-    let delta = null;
-    let match2 = YAML_DATE_REGEXP.exec(data);
-    if (match2 === null) match2 = YAML_TIMESTAMP_REGEXP.exec(data);
-    if (match2 === null) throw new Error("Date resolve error");
-    const year = +match2[1];
-    const month = +match2[2] - 1;
-    const day = +match2[3];
-    if (!match2[4]) return new Date(Date.UTC(year, month, day));
-    const hour = +match2[4];
-    const minute = +match2[5];
-    const second = +match2[6];
-    if (match2[7]) {
-      fraction = match2[7].slice(0, 3);
-      while (fraction.length < 3) fraction += "0";
-      fraction = +fraction;
-    }
-    if (match2[9]) {
-      const tzHour = +match2[10];
-      const tzMinute = +(match2[11] || 0);
-      delta = (tzHour * 60 + tzMinute) * 6e4;
-      if (match2[9] === "-") delta = -delta;
-    }
-    const date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction));
-    if (delta) date.setTime(date.getTime() - delta);
-    return date;
-  }
-  function representYamlTimestamp(object) {
-    return object.toISOString();
-  }
-  module2.exports = new Type2("tag:yaml.org,2002:timestamp", {
-    kind: "scalar",
-    resolve: resolveYamlTimestamp,
-    construct: constructYamlTimestamp,
-    instanceOf: Date,
-    represent: representYamlTimestamp
+  return state.documents;
+}
+var NO_RANGE$1 = -1;
+var HAS_OWN = Object.prototype.hasOwnProperty;
+var CONTEXT_FLOW_IN = 1;
+var CONTEXT_FLOW_OUT = 2;
+var CONTEXT_BLOCK_IN = 3;
+var CONTEXT_BLOCK_OUT = 4;
+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_FLOW_INDICATORS = /[,\[\]{}]/;
+var PATTERN_TAG_HANDLE = /^(?:!|!!|![0-9A-Za-z-]+!)$/;
+var NS_URI_CHAR = String.raw`(?:%[0-9A-Fa-f]{2}|[0-9A-Za-z\-#;/?:@&=+$,_.!~*'()\[\]])`;
+var NS_TAG_CHAR = String.raw`(?:%[0-9A-Fa-f]{2}|[0-9A-Za-z\-#;/?:@&=+$.~*'()_])`;
+var PATTERN_TAG_URI = new RegExp(`^(?:${NS_URI_CHAR})*$`);
+var PATTERN_TAG_SUFFIX = new RegExp(`^(?:${NS_TAG_CHAR})+$`);
+var PATTERN_TAG_PREFIX = new RegExp(`^(?:!(?:${NS_URI_CHAR})*|${NS_TAG_CHAR}(?:${NS_URI_CHAR})*)$`);
+var DEFAULT_PARSER_OPTIONS = {
+  filename: "",
+  maxDepth: 100
+};
+function addDocumentEvent(state, explicitStart, explicitEnd) {
+  state.events.push({
+    type: 1,
+    explicitStart,
+    explicitEnd,
+    directives: state.directives
   });
-}));
-var require_merge = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var Type2 = require_type();
-  function resolveYamlMerge(data) {
-    return data === "<<" || data === null;
-  }
-  module2.exports = new Type2("tag:yaml.org,2002:merge", {
-    kind: "scalar",
-    resolve: resolveYamlMerge
+}
+function addSequenceEvent(state, start, anchorStart, anchorEnd, tagStart, tagEnd, style) {
+  state.events.push({
+    type: 2,
+    start,
+    anchorStart,
+    anchorEnd,
+    tagStart,
+    tagEnd,
+    style
   });
-}));
-var require_binary = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var Type2 = require_type();
-  var BASE64_MAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r";
-  function resolveYamlBinary(data) {
-    if (data === null) return false;
-    let bitlen = 0;
-    const max = data.length;
-    const map = BASE64_MAP;
-    for (let idx = 0; idx < max; idx++) {
-      const code = map.indexOf(data.charAt(idx));
-      if (code > 64) continue;
-      if (code < 0) return false;
-      bitlen += 6;
-    }
-    return bitlen % 8 === 0;
-  }
-  function constructYamlBinary(data) {
-    const input = data.replace(/[\r\n=]/g, "");
-    const max = input.length;
-    const map = BASE64_MAP;
-    let bits = 0;
-    const result = [];
-    for (let idx = 0; idx < max; idx++) {
-      if (idx % 4 === 0 && idx) {
-        result.push(bits >> 16 & 255);
-        result.push(bits >> 8 & 255);
-        result.push(bits & 255);
-      }
-      bits = bits << 6 | map.indexOf(input.charAt(idx));
-    }
-    const tailbits = max % 4 * 6;
-    if (tailbits === 0) {
-      result.push(bits >> 16 & 255);
-      result.push(bits >> 8 & 255);
-      result.push(bits & 255);
-    } else if (tailbits === 18) {
-      result.push(bits >> 10 & 255);
-      result.push(bits >> 2 & 255);
-    } else if (tailbits === 12) result.push(bits >> 4 & 255);
-    return new Uint8Array(result);
-  }
-  function representYamlBinary(object) {
-    let result = "";
-    let bits = 0;
-    const max = object.length;
-    const map = BASE64_MAP;
-    for (let idx = 0; idx < max; idx++) {
-      if (idx % 3 === 0 && idx) {
-        result += map[bits >> 18 & 63];
-        result += map[bits >> 12 & 63];
-        result += map[bits >> 6 & 63];
-        result += map[bits & 63];
-      }
-      bits = (bits << 8) + object[idx];
-    }
-    const tail = max % 3;
-    if (tail === 0) {
-      result += map[bits >> 18 & 63];
-      result += map[bits >> 12 & 63];
-      result += map[bits >> 6 & 63];
-      result += map[bits & 63];
-    } else if (tail === 2) {
-      result += map[bits >> 10 & 63];
-      result += map[bits >> 4 & 63];
-      result += map[bits << 2 & 63];
-      result += map[64];
-    } else if (tail === 1) {
-      result += map[bits >> 2 & 63];
-      result += map[bits << 4 & 63];
-      result += map[64];
-      result += map[64];
-    }
-    return result;
-  }
-  function isBinary(obj) {
-    return Object.prototype.toString.call(obj) === "[object Uint8Array]";
-  }
-  module2.exports = new Type2("tag:yaml.org,2002:binary", {
-    kind: "scalar",
-    resolve: resolveYamlBinary,
-    construct: constructYamlBinary,
-    predicate: isBinary,
-    represent: representYamlBinary
+}
+function addMappingEvent(state, start, anchorStart, anchorEnd, tagStart, tagEnd, style) {
+  state.events.push({
+    type: 3,
+    start,
+    anchorStart,
+    anchorEnd,
+    tagStart,
+    tagEnd,
+    style
   });
-}));
-var require_omap = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var Type2 = require_type();
-  var _hasOwnProperty = Object.prototype.hasOwnProperty;
-  var _toString = Object.prototype.toString;
-  function resolveYamlOmap(data) {
-    if (data === null) return true;
-    const objectKeys = [];
-    const object = data;
-    for (let index2 = 0, length = object.length; index2 < length; index2 += 1) {
-      const pair = object[index2];
-      let pairHasKey = false;
-      if (_toString.call(pair) !== "[object Object]") return false;
-      let pairKey;
-      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 : [];
-  }
-  module2.exports = new Type2("tag:yaml.org,2002:omap", {
-    kind: "sequence",
-    resolve: resolveYamlOmap,
-    construct: constructYamlOmap
+}
+function addScalarEvent(state, valueStart, valueEnd, anchorStart, anchorEnd, tagStart, tagEnd, style, chomping = 1, indent = -1, fast = false) {
+  state.events.push({
+    type: 4,
+    valueStart,
+    valueEnd,
+    anchorStart,
+    anchorEnd,
+    tagStart,
+    tagEnd,
+    style,
+    chomping,
+    indent,
+    fast
   });
-}));
-var require_pairs = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var Type2 = require_type();
-  var _toString = Object.prototype.toString;
-  function resolveYamlPairs(data) {
-    if (data === null) return true;
-    const object = data;
-    const result = new Array(object.length);
-    for (let index2 = 0, length = object.length; index2 < length; index2 += 1) {
-      const pair = object[index2];
-      if (_toString.call(pair) !== "[object Object]") return false;
-      const keys = Object.keys(pair);
-      if (keys.length !== 1) return false;
-      result[index2] = [keys[0], pair[keys[0]]];
-    }
-    return true;
-  }
-  function constructYamlPairs(data) {
-    if (data === null) return [];
-    const object = data;
-    const result = new Array(object.length);
-    for (let index2 = 0, length = object.length; index2 < length; index2 += 1) {
-      const pair = object[index2];
-      const keys = Object.keys(pair);
-      result[index2] = [keys[0], pair[keys[0]]];
-    }
-    return result;
-  }
-  module2.exports = new Type2("tag:yaml.org,2002:pairs", {
-    kind: "sequence",
-    resolve: resolveYamlPairs,
-    construct: constructYamlPairs
+}
+function addAliasEvent(state, anchorStart, anchorEnd) {
+  state.events.push({
+    type: 5,
+    anchorStart,
+    anchorEnd
   });
-}));
-var require_set = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var Type2 = require_type();
-  var _hasOwnProperty = Object.prototype.hasOwnProperty;
-  function resolveYamlSet(data) {
-    if (data === null) return true;
-    const object = data;
-    for (const key in object) if (_hasOwnProperty.call(object, key)) {
-      if (object[key] !== null) return false;
+}
+function addPopEvent(state) {
+  state.events.push({ type: 6 });
+}
+function addEmptyScalarEvent(state) {
+  addScalarEvent(state, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, 1);
+}
+function emptyProperties() {
+  return {
+    anchorStart: NO_RANGE$1,
+    anchorEnd: NO_RANGE$1,
+    tagStart: NO_RANGE$1,
+    tagEnd: NO_RANGE$1
+  };
+}
+function snapshotState(state) {
+  return {
+    position: state.position,
+    line: state.line,
+    lineStart: state.lineStart,
+    lineIndent: state.lineIndent,
+    firstTabInLine: state.firstTabInLine,
+    eventsLength: state.events.length
+  };
+}
+function restoreState(state, snapshot) {
+  state.position = snapshot.position;
+  state.line = snapshot.line;
+  state.lineStart = snapshot.lineStart;
+  state.lineIndent = snapshot.lineIndent;
+  state.firstTabInLine = snapshot.firstTabInLine;
+  state.events.length = snapshot.eventsLength;
+}
+function throwError(state, message) {
+  throwErrorAt(state.input.slice(0, state.length), state.position, message, state.filename);
+}
+function isEol(c) {
+  return c === 10 || c === 13;
+}
+function isWhiteSpace(c) {
+  return c === 9 || c === 32;
+}
+function isWsOrEol(c) {
+  return isWhiteSpace(c) || isEol(c);
+}
+function isWsOrEolOrEnd(c) {
+  return c === 0 || isWsOrEol(c);
+}
+function isFlowIndicator(c) {
+  return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
+}
+function fromDecimalCode(c) {
+  return c >= 48 && c <= 57 ? c - 48 : -1;
+}
+function fromHexCode(c) {
+  if (c >= 48 && c <= 57) return c - 48;
+  const lc = c | 32;
+  if (lc >= 97 && lc <= 102) return lc - 97 + 10;
+  return -1;
+}
+function escapedHexLen(c) {
+  if (c === 120) return 2;
+  if (c === 117) return 4;
+  if (c === 85) return 8;
+  return 0;
+}
+function isSimpleEscape(c) {
+  return c === 48 || c === 97 || c === 98 || c === 116 || c === 9 || c === 110 || c === 118 || c === 102 || c === 114 || c === 101 || c === 32 || c === 34 || c === 47 || c === 92 || c === 78 || c === 95 || c === 76 || c === 80;
+}
+function consumeLineBreak(state) {
+  if (state.input.charCodeAt(state.position) === 10) state.position++;
+  else {
+    state.position++;
+    if (state.input.charCodeAt(state.position) === 10) state.position++;
+  }
+  state.line++;
+  state.lineStart = state.position;
+  state.lineIndent = 0;
+  state.firstTabInLine = -1;
+}
+function skipSeparationSpace(state, allowComments) {
+  let lineBreaks = 0;
+  let ch = state.input.charCodeAt(state.position);
+  let hasSeparation = state.position === state.lineStart || isWsOrEol(state.input.charCodeAt(state.position - 1));
+  while (ch !== 0) {
+    while (isWhiteSpace(ch)) {
+      hasSeparation = true;
+      if (ch === 9 && state.firstTabInLine === -1) state.firstTabInLine = state.position;
+      ch = state.input.charCodeAt(++state.position);
     }
-    return true;
-  }
-  function constructYamlSet(data) {
-    return data !== null ? data : {};
-  }
-  module2.exports = new Type2("tag:yaml.org,2002:set", {
-    kind: "mapping",
-    resolve: resolveYamlSet,
-    construct: constructYamlSet
-  });
-}));
-var require_default = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  module2.exports = require_core2().extend({
-    implicit: [require_timestamp(), require_merge()],
-    explicit: [
-      require_binary(),
-      require_omap(),
-      require_pairs(),
-      require_set()
-    ]
-  });
-}));
-var require_loader = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var common = require_common();
-  var YAMLException2 = require_exception();
-  var makeSnippet = require_snippet();
-  var DEFAULT_SCHEMA2 = require_default();
-  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 = /^(?:!|!!|![0-9A-Za-z-]+!)$/;
-  var PATTERN_TAG_URI = /^(?:!|[^,\[\]{}])(?:%[0-9a-f]{2}|[0-9a-z\-#;/?:@&=+$,_.!~*'()\[\]])*$/i;
-  function _class(obj) {
-    return Object.prototype.toString.call(obj);
-  }
-  function isEol(c) {
-    return c === 10 || c === 13;
-  }
-  function isWhiteSpace(c) {
-    return c === 9 || c === 32;
-  }
-  function isWsOrEol(c) {
-    return c === 9 || c === 32 || c === 10 || c === 13;
-  }
-  function isFlowIndicator(c) {
-    return c === 44 || c === 91 || c === 93 || c === 123 || c === 125;
-  }
-  function fromHexCode(c) {
-    if (c >= 48 && c <= 57) return c - 48;
-    const lc = c | 32;
-    if (lc >= 97 && lc <= 102) return lc - 97 + 10;
-    return -1;
-  }
-  function escapedHexLen(c) {
-    if (c === 120) return 2;
-    if (c === 117) return 4;
-    if (c === 85) return 8;
-    return 0;
-  }
-  function fromDecimalCode(c) {
-    if (c >= 48 && c <= 57) return c - 48;
-    return -1;
-  }
-  function simpleEscapeSequence(c) {
-    switch (c) {
-      case 48:
-        return "\0";
-      case 97:
-        return "\x07";
-      case 98:
-        return "\b";
-      case 116:
-        return "	";
-      case 9:
-        return "	";
-      case 110:
-        return "\n";
-      case 118:
-        return "\v";
-      case 102:
-        return "\f";
-      case 114:
-        return "\r";
-      case 101:
-        return "\x1B";
-      case 32:
-        return " ";
-      case 34:
-        return '"';
-      case 47:
-        return "/";
-      case 92:
-        return "\\";
-      case 78:
-        return "\x85";
-      case 95:
-        return "\xA0";
-      case 76:
-        return "\u2028";
-      case 80:
-        return "\u2029";
-      default:
-        return "";
+    if (allowComments && hasSeparation && ch === 35) do
+      ch = state.input.charCodeAt(++state.position);
+    while (!isEol(ch) && ch !== 0);
+    if (!isEol(ch)) break;
+    consumeLineBreak(state);
+    lineBreaks++;
+    hasSeparation = true;
+    ch = state.input.charCodeAt(state.position);
+    while (ch === 32) {
+      state.lineIndent++;
+      ch = state.input.charCodeAt(++state.position);
     }
   }
-  function charFromCodepoint(c) {
-    if (c <= 65535) return String.fromCharCode(c);
-    return String.fromCharCode((c - 65536 >> 10) + 55296, (c - 65536 & 1023) + 56320);
-  }
-  function setProperty2(object, key, value) {
-    if (key === "__proto__") Object.defineProperty(object, key, {
-      configurable: true,
-      enumerable: true,
-      writable: true,
-      value
-    });
-    else object[key] = value;
-  }
-  var simpleEscapeCheck = new Array(256);
-  var simpleEscapeMap = new Array(256);
-  for (let 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_SCHEMA2;
-    this.onWarning = options["onWarning"] || null;
-    this.legacy = options["legacy"] || false;
-    this.json = options["json"] || false;
-    this.listener = options["listener"] || null;
-    this.maxDepth = typeof options["maxDepth"] === "number" ? options["maxDepth"] : 100;
-    this.maxMergeSeqLength = typeof options["maxMergeSeqLength"] === "number" ? options["maxMergeSeqLength"] : 20;
-    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.depth = 0;
-    this.firstTabInLine = -1;
-    this.documents = [];
-    this.anchorMapTransactions = [];
-  }
-  function generateError(state, message) {
-    const mark = {
-      name: state.filename,
-      buffer: state.input.slice(0, -1),
-      position: state.position,
-      line: state.line,
-      column: state.position - state.lineStart
-    };
-    mark.snippet = makeSnippet(mark);
-    return new YAMLException2(message, mark);
-  }
-  function throwError(state, message) {
-    throw generateError(state, message);
-  }
-  function throwWarning(state, message) {
-    if (state.onWarning) state.onWarning.call(null, generateError(state, message));
-  }
-  function storeAnchor(state, name, value) {
-    const transactions = state.anchorMapTransactions;
-    if (transactions.length !== 0) {
-      const transaction = transactions[transactions.length - 1];
-      if (!_hasOwnProperty.call(transaction, name)) transaction[name] = {
-        existed: _hasOwnProperty.call(state.anchorMap, name),
-        value: state.anchorMap[name]
-      };
-    }
-    state.anchorMap[name] = value;
-  }
-  function beginAnchorTransaction(state) {
-    state.anchorMapTransactions.push(/* @__PURE__ */ Object.create(null));
-  }
-  function commitAnchorTransaction(state) {
-    const transaction = state.anchorMapTransactions.pop();
-    const transactions = state.anchorMapTransactions;
-    if (transactions.length === 0) return;
-    const parent = transactions[transactions.length - 1];
-    const names = Object.keys(transaction);
-    for (let index2 = 0, length = names.length; index2 < length; index2 += 1) {
-      const name = names[index2];
-      if (!_hasOwnProperty.call(parent, name)) parent[name] = transaction[name];
-    }
-  }
-  function rollbackAnchorTransaction(state) {
-    const transaction = state.anchorMapTransactions.pop();
-    const names = Object.keys(transaction);
-    for (let index2 = names.length - 1; index2 >= 0; index2 -= 1) {
-      const entry = transaction[names[index2]];
-      if (entry.existed) state.anchorMap[names[index2]] = entry.value;
-      else delete state.anchorMap[names[index2]];
-    }
-  }
-  function snapshotState(state) {
-    return {
-      position: state.position,
-      line: state.line,
-      lineStart: state.lineStart,
-      lineIndent: state.lineIndent,
-      firstTabInLine: state.firstTabInLine,
-      tag: state.tag,
-      anchor: state.anchor,
-      kind: state.kind,
-      result: state.result
-    };
-  }
-  function restoreState(state, snapshot) {
-    state.position = snapshot.position;
-    state.line = snapshot.line;
-    state.lineStart = snapshot.lineStart;
-    state.lineIndent = snapshot.lineIndent;
-    state.firstTabInLine = snapshot.firstTabInLine;
-    state.tag = snapshot.tag;
-    state.anchor = snapshot.anchor;
-    state.kind = snapshot.kind;
-    state.result = snapshot.result;
-  }
-  var directiveHandlers = {
-    YAML: function handleYamlDirective(state, name, args) {
-      if (state.version !== null) throwError(state, "duplication of %YAML directive");
-      if (args.length !== 1) throwError(state, "YAML directive accepts exactly one argument");
-      const match2 = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
-      if (match2 === null) throwError(state, "ill-formed argument of the YAML directive");
-      const major = parseInt(match2[1], 10);
-      const minor = parseInt(match2[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) {
-      let prefix;
-      if (args.length !== 2) throwError(state, "TAG directive accepts exactly two arguments");
-      const 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) {
-    if (start < end) {
-      const _result = state.input.slice(start, end);
-      if (checkJson) for (let _position = 0, _length = _result.length; _position < _length; _position += 1) {
-        const _character = _result.charCodeAt(_position);
-        if (!(_character === 9 || _character >= 32 && _character <= 1114111)) 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) {
-    if (!common.isObject(source)) throwError(state, "cannot merge mappings; the provided source object is unacceptable");
-    const sourceKeys = Object.keys(source);
-    for (let index2 = 0, quantity = sourceKeys.length; index2 < quantity; index2 += 1) {
-      const key = sourceKeys[index2];
-      if (!_hasOwnProperty.call(destination, key)) {
-        setProperty2(destination, key, source[key]);
-        overridableKeys[key] = true;
-      }
-    }
-  }
-  function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, startLine, startLineStart, startPos) {
-    if (Array.isArray(keyNode)) {
-      keyNode = Array.prototype.slice.call(keyNode);
-      for (let index2 = 0, quantity = keyNode.length; index2 < quantity; index2 += 1) {
-        if (Array.isArray(keyNode[index2])) throwError(state, "nested arrays are not supported inside keys");
-        if (typeof keyNode === "object" && _class(keyNode[index2]) === "[object Object]") keyNode[index2] = "[object Object]";
-      }
-    }
-    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)) {
-      if (valueNode.length > state.maxMergeSeqLength) throwError(state, "merge sequence length exceeded maxMergeSeqLength (" + state.maxMergeSeqLength + ")");
-      const seen = /* @__PURE__ */ new Set();
-      for (let index2 = 0, quantity = valueNode.length; index2 < quantity; index2 += 1) {
-        const src = valueNode[index2];
-        if (seen.has(src)) continue;
-        seen.add(src);
-        mergeMappings(state, _result, src, 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");
-      }
-      setProperty2(_result, keyNode, valueNode);
-      delete overridableKeys[keyNode];
-    }
-    return _result;
+  return lineBreaks;
+}
+function testDocumentSeparator(state, position = state.position) {
+  const ch = state.input.charCodeAt(position);
+  if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(position + 1) && ch === state.input.charCodeAt(position + 2)) {
+    const following = state.input.charCodeAt(position + 3);
+    return following === 0 || isWsOrEol(following);
   }
-  function readLineBreak(state) {
-    const ch = state.input.charCodeAt(state.position);
-    if (ch === 10) state.position++;
-    else if (ch === 13) {
-      state.position++;
-      if (state.input.charCodeAt(state.position) === 10) 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) {
-    let lineBreaks = 0;
-    let ch = state.input.charCodeAt(state.position);
-    while (ch !== 0) {
-      while (isWhiteSpace(ch)) {
-        if (ch === 9 && state.firstTabInLine === -1) state.firstTabInLine = state.position;
-        ch = state.input.charCodeAt(++state.position);
-      }
-      if (allowComments && ch === 35) do
-        ch = state.input.charCodeAt(++state.position);
-      while (ch !== 10 && ch !== 13 && ch !== 0);
-      if (isEol(ch)) {
-        readLineBreak(state);
-        ch = state.input.charCodeAt(state.position);
-        lineBreaks++;
-        state.lineIndent = 0;
-        while (ch === 32) {
-          state.lineIndent++;
-          ch = state.input.charCodeAt(++state.position);
-        }
-      } else break;
-    }
-    if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) throwWarning(state, "deficient indentation");
-    return lineBreaks;
+  return false;
+}
+function skipUntilLineEnd(state) {
+  let ch = state.input.charCodeAt(state.position);
+  while (ch !== 0 && !isEol(ch)) ch = state.input.charCodeAt(++state.position);
+}
+function checkPrintable(state, start, end) {
+  if (PATTERN_NON_PRINTABLE.test(state.input.slice(start, end))) throwError(state, "the stream contains non-printable characters");
+}
+function readTagProperty(state, props, inFlow) {
+  if (state.input.charCodeAt(state.position) !== 33) return false;
+  if (props.tagStart !== NO_RANGE$1) throwError(state, "duplication of a tag property");
+  const start = state.position;
+  let isVerbatim = false;
+  let isNamed = false;
+  let tagHandle = "!";
+  let ch = state.input.charCodeAt(++state.position);
+  if (ch === 60) {
+    isVerbatim = true;
+    ch = state.input.charCodeAt(++state.position);
+  } else if (ch === 33) {
+    isNamed = true;
+    tagHandle = "!!";
+    ch = state.input.charCodeAt(++state.position);
   }
-  function testDocumentSeparator(state) {
-    let _position = state.position;
-    let ch = state.input.charCodeAt(_position);
-    if ((ch === 45 || ch === 46) && ch === state.input.charCodeAt(_position + 1) && ch === state.input.charCodeAt(_position + 2)) {
-      _position += 3;
-      ch = state.input.charCodeAt(_position);
-      if (ch === 0 || isWsOrEol(ch)) return true;
+  let suffixStart = state.position;
+  let tagName;
+  if (isVerbatim) {
+    while (ch !== 0 && ch !== 62) ch = state.input.charCodeAt(++state.position);
+    if (ch !== 62) throwError(state, "unexpected end of the stream within a verbatim tag");
+    tagName = state.input.slice(suffixStart, state.position);
+    state.position++;
+  } else {
+    while (ch !== 0 && !isWsOrEol(ch) && !(inFlow && isFlowIndicator(ch))) {
+      if (ch === 33) if (!isNamed) {
+        tagHandle = state.input.slice(suffixStart - 1, state.position + 1);
+        if (!PATTERN_TAG_HANDLE.test(tagHandle)) throwError(state, "named tag handle cannot contain such characters");
+        isNamed = true;
+        suffixStart = state.position + 1;
+      } else throwError(state, "tag suffix cannot contain exclamation marks");
+      ch = state.input.charCodeAt(++state.position);
     }
-    return false;
+    tagName = state.input.slice(suffixStart, state.position);
+    if (PATTERN_FLOW_INDICATORS.test(tagName)) throwError(state, "tag suffix cannot contain flow indicator characters");
   }
-  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) {
-    let captureStart;
-    let captureEnd;
-    let hasPendingContent;
-    let _line;
-    let _lineStart;
-    let _lineIndent;
-    const _kind = state.kind;
-    const _result = state.result;
-    let ch = state.input.charCodeAt(state.position);
-    if (isWsOrEol(ch) || isFlowIndicator(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96) return false;
-    if (ch === 63 || ch === 45) {
-      const following = state.input.charCodeAt(state.position + 1);
-      if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) return false;
-    }
-    state.kind = "scalar";
-    state.result = "";
-    captureStart = captureEnd = state.position;
-    hasPendingContent = false;
-    while (ch !== 0) {
-      if (ch === 58) {
-        const following = state.input.charCodeAt(state.position + 1);
-        if (isWsOrEol(following) || withinFlowCollection && isFlowIndicator(following)) break;
-      } else if (ch === 35) {
-        if (isWsOrEol(state.input.charCodeAt(state.position - 1))) break;
-      } else if (state.position === state.lineStart && testDocumentSeparator(state) || withinFlowCollection && isFlowIndicator(ch)) break;
-      else if (isEol(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 (tagName && !(isVerbatim ? PATTERN_TAG_URI.test(tagName) : PATTERN_TAG_SUFFIX.test(tagName))) throwError(state, `tag name cannot contain such characters: ${tagName}`);
+  if (!isVerbatim && tagHandle !== "!" && tagHandle !== "!!" && !HAS_OWN.call(state.tagHandlers, tagHandle)) throwError(state, `undeclared tag handle "${tagHandle}"`);
+  props.tagStart = start;
+  props.tagEnd = state.position;
+  return true;
+}
+function readAnchorProperty(state, props) {
+  if (state.input.charCodeAt(state.position) !== 38) return false;
+  if (props.anchorStart !== NO_RANGE$1) throwError(state, "duplication of an anchor property");
+  state.position++;
+  const start = state.position;
+  while (state.input.charCodeAt(state.position) !== 0 && !isWsOrEol(state.input.charCodeAt(state.position)) && !isFlowIndicator(state.input.charCodeAt(state.position))) state.position++;
+  if (state.position === start) throwError(state, "name of an anchor node must contain at least one character");
+  props.anchorStart = start;
+  props.anchorEnd = state.position;
+  return true;
+}
+function readAlias(state, props) {
+  if (state.input.charCodeAt(state.position) !== 42) return false;
+  if (props.anchorStart !== NO_RANGE$1 || props.tagStart !== NO_RANGE$1) throwError(state, "alias node should not have any properties");
+  state.position++;
+  const start = state.position;
+  while (state.input.charCodeAt(state.position) !== 0 && !isWsOrEol(state.input.charCodeAt(state.position)) && !isFlowIndicator(state.input.charCodeAt(state.position))) state.position++;
+  if (state.position === start) throwError(state, "name of an alias node must contain at least one character");
+  addAliasEvent(state, start, state.position);
+  return true;
+}
+function readFlowScalarBreak(state, nodeIndent) {
+  skipSeparationSpace(state, false);
+  if (state.lineIndent < nodeIndent) throwError(state, "deficient indentation");
+}
+function readSingleQuotedScalar(state, nodeIndent, props) {
+  if (state.input.charCodeAt(state.position) !== 39) return false;
+  state.position++;
+  const start = state.position;
+  let simple = true;
+  while (state.input.charCodeAt(state.position) !== 0) {
+    const ch = state.input.charCodeAt(state.position);
+    if (ch === 39) {
+      if (state.input.charCodeAt(state.position + 1) === 39) {
+        simple = false;
+        state.position += 2;
+        continue;
       }
-      if (!isWhiteSpace(ch)) captureEnd = state.position + 1;
-      ch = state.input.charCodeAt(++state.position);
+      const end = state.position;
+      state.position++;
+      addScalarEvent(state, start, end, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 2, 1, -1, simple);
+      return true;
     }
-    captureSegment(state, captureStart, captureEnd, false);
-    if (state.result) return true;
-    state.kind = _kind;
-    state.result = _result;
-    return false;
-  }
-  function readSingleQuotedScalar(state, nodeIndent) {
-    let captureStart;
-    let captureEnd;
-    let ch = state.input.charCodeAt(state.position);
-    if (ch !== 39) return false;
-    state.kind = "scalar";
-    state.result = "";
-    state.position++;
-    captureStart = captureEnd = state.position;
-    while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 39) {
-      captureSegment(state, captureStart, state.position, true);
-      ch = state.input.charCodeAt(++state.position);
-      if (ch === 39) {
-        captureStart = state.position;
-        state.position++;
-        captureEnd = state.position;
-      } else return true;
-    } else if (isEol(ch)) {
-      captureSegment(state, captureStart, captureEnd, true);
-      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
-      captureStart = captureEnd = state.position;
+    if (isEol(ch)) {
+      simple = false;
+      readFlowScalarBreak(state, nodeIndent);
     } else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a single quoted scalar");
-    else {
-      state.position++;
-      if (!isWhiteSpace(ch)) captureEnd = state.position;
-    }
-    throwError(state, "unexpected end of the stream within a single quoted scalar");
-  }
-  function readDoubleQuotedScalar(state, nodeIndent) {
-    let captureStart;
-    let captureEnd;
-    let tmp;
-    let ch = state.input.charCodeAt(state.position);
-    if (ch !== 34) return false;
-    state.kind = "scalar";
-    state.result = "";
-    state.position++;
-    captureStart = captureEnd = state.position;
-    while ((ch = state.input.charCodeAt(state.position)) !== 0) if (ch === 34) {
-      captureSegment(state, captureStart, state.position, true);
+    else if (ch !== 9 && ch < 32) throwError(state, "expected valid JSON character");
+    else state.position++;
+  }
+  throwError(state, "unexpected end of the stream within a single quoted scalar");
+}
+function readDoubleQuotedScalar(state, nodeIndent, props) {
+  if (state.input.charCodeAt(state.position) !== 34) return false;
+  state.position++;
+  const start = state.position;
+  let simple = true;
+  while (state.input.charCodeAt(state.position) !== 0) {
+    const ch = state.input.charCodeAt(state.position);
+    if (ch === 34) {
+      const end = state.position;
       state.position++;
+      addScalarEvent(state, start, end, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 3, 1, -1, simple);
       return true;
-    } else if (ch === 92) {
-      captureSegment(state, captureStart, state.position, true);
-      ch = state.input.charCodeAt(++state.position);
-      if (isEol(ch)) skipSeparationSpace(state, false, nodeIndent);
-      else if (ch < 256 && simpleEscapeCheck[ch]) {
-        state.result += simpleEscapeMap[ch];
-        state.position++;
-      } else if ((tmp = escapedHexLen(ch)) > 0) {
-        let hexLength = tmp;
-        let 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");
+    }
+    if (ch === 92) {
+      simple = false;
+      const escaped = state.input.charCodeAt(++state.position);
+      if (isEol(escaped)) readFlowScalarBreak(state, nodeIndent);
+      else if (isSimpleEscape(escaped)) state.position++;
+      else {
+        let hexLength = escapedHexLen(escaped);
+        if (hexLength === 0) throwError(state, "unknown escape sequence");
+        while (hexLength-- > 0) {
+          state.position++;
+          if (fromHexCode(state.input.charCodeAt(state.position)) < 0) throwError(state, "expected hexadecimal character");
         }
-        state.result += charFromCodepoint(hexResult);
         state.position++;
-      } else throwError(state, "unknown escape sequence");
-      captureStart = captureEnd = state.position;
+      }
     } else if (isEol(ch)) {
-      captureSegment(state, captureStart, captureEnd, true);
-      writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent));
-      captureStart = captureEnd = state.position;
+      simple = false;
+      readFlowScalarBreak(state, nodeIndent);
     } else if (state.position === state.lineStart && testDocumentSeparator(state)) throwError(state, "unexpected end of the document within a double quoted scalar");
-    else {
+    else if (ch !== 9 && ch < 32) throwError(state, "expected valid JSON character");
+    else state.position++;
+  }
+  throwError(state, "unexpected end of the stream within a double quoted scalar");
+}
+function readBlockScalar(state, parentIndent, props) {
+  const ch = state.input.charCodeAt(state.position);
+  let chomping = 1;
+  let indent = -1;
+  let detectedIndent = false;
+  if (ch !== 124 && ch !== 62) return false;
+  const style = ch === 124 ? 4 : 5;
+  state.position++;
+  while (state.input.charCodeAt(state.position) !== 0) {
+    const current = state.input.charCodeAt(state.position);
+    const digit = fromDecimalCode(current);
+    if (current === 43 || current === 45) {
+      if (chomping !== 1) throwError(state, "repeat of a chomping mode identifier");
+      chomping = current === 43 ? 3 : 2;
       state.position++;
-      if (!isWhiteSpace(ch)) captureEnd = state.position;
-    }
-    throwError(state, "unexpected end of the stream within a double quoted scalar");
-  }
-  function readFlowCollection(state, nodeIndent) {
-    let readNext = true;
-    let _line;
-    let _lineStart;
-    let _pos;
-    const _tag = state.tag;
-    let _result;
-    const _anchor = state.anchor;
-    let terminator;
-    let isPair;
-    let isExplicitPair;
-    let isMapping;
-    const overridableKeys = /* @__PURE__ */ Object.create(null);
-    let keyNode;
-    let keyTag;
-    let valueNode;
-    let ch = state.input.charCodeAt(state.position);
-    if (ch === 91) {
-      terminator = 93;
-      isMapping = false;
-      _result = [];
-    } else if (ch === 123) {
-      terminator = 125;
-      isMapping = true;
-      _result = {};
-    } else return false;
-    if (state.anchor !== null) storeAnchor(state, 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 === 44) throwError(state, "expected the node content, but found ','");
-      keyTag = keyNode = valueNode = null;
-      isPair = isExplicitPair = false;
-      if (ch === 63) {
-        if (isWsOrEol(state.input.charCodeAt(state.position + 1))) {
-          isPair = isExplicitPair = true;
-          state.position++;
-          skipSeparationSpace(state, true, nodeIndent);
-        }
-      }
-      _line = state.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 === 58) {
-        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 === 44) {
-        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) {
-    let folding;
-    let chomping = CHOMPING_CLIP;
-    let didReadContent = false;
-    let detectedIndent = false;
-    let textIndent = nodeIndent;
-    let emptyLines = 0;
-    let atMoreIndented = false;
-    let tmp;
-    let ch = state.input.charCodeAt(state.position);
-    if (ch === 124) folding = false;
-    else if (ch === 62) folding = true;
-    else return false;
-    state.kind = "scalar";
-    state.result = "";
-    while (ch !== 0) {
-      ch = state.input.charCodeAt(++state.position);
-      if (ch === 43 || ch === 45) if (CHOMPING_CLIP === chomping) chomping = ch === 43 ? 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 (isWhiteSpace(ch)) {
-      do
-        ch = state.input.charCodeAt(++state.position);
-      while (isWhiteSpace(ch));
-      if (ch === 35) do
-        ch = state.input.charCodeAt(++state.position);
-      while (!isEol(ch) && ch !== 0);
-    }
-    while (ch !== 0) {
-      readLineBreak(state);
-      state.lineIndent = 0;
-      ch = state.input.charCodeAt(state.position);
-      while ((!detectedIndent || state.lineIndent < textIndent) && ch === 32) {
-        state.lineIndent++;
-        ch = state.input.charCodeAt(++state.position);
-      }
-      if (!detectedIndent && state.lineIndent > textIndent) textIndent = state.lineIndent;
-      if (isEol(ch)) {
-        emptyLines++;
-        continue;
-      }
-      if (!detectedIndent && textIndent === 0) throwError(state, "missing indentation for block scalar");
-      if (state.lineIndent < textIndent) {
-        if (chomping === CHOMPING_KEEP) state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
-        else if (chomping === CHOMPING_CLIP) {
-          if (didReadContent) state.result += "\n";
-        }
-        break;
-      }
-      if (folding) if (isWhiteSpace(ch)) {
-        atMoreIndented = true;
-        state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
-      } else if (atMoreIndented) {
-        atMoreIndented = false;
-        state.result += common.repeat("\n", emptyLines + 1);
-      } else if (emptyLines === 0) {
-        if (didReadContent) state.result += " ";
-      } else state.result += common.repeat("\n", emptyLines);
-      else state.result += common.repeat("\n", didReadContent ? 1 + emptyLines : emptyLines);
-      didReadContent = true;
+    } else if (digit >= 0) {
+      if (digit === 0) throwError(state, "bad explicit indentation width of a block scalar; it cannot be less than one");
+      if (detectedIndent) throwError(state, "repeat of an indentation width identifier");
+      indent = parentIndent + digit - 1;
       detectedIndent = true;
-      emptyLines = 0;
-      const captureStart = state.position;
-      while (!isEol(ch) && ch !== 0) ch = state.input.charCodeAt(++state.position);
-      captureSegment(state, captureStart, state.position, false);
-    }
-    return true;
+      state.position++;
+    } else break;
+  }
+  let hadWhitespace = false;
+  while (isWhiteSpace(state.input.charCodeAt(state.position))) {
+    hadWhitespace = true;
+    state.position++;
   }
-  function readBlockSequence(state, nodeIndent) {
-    const _tag = state.tag;
-    const _anchor = state.anchor;
-    const _result = [];
-    let detected = false;
-    if (state.firstTabInLine !== -1) return false;
-    if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
-    let ch = state.input.charCodeAt(state.position);
-    while (ch !== 0) {
-      if (state.firstTabInLine !== -1) {
-        state.position = state.firstTabInLine;
+  if (hadWhitespace && state.input.charCodeAt(state.position) === 35) skipUntilLineEnd(state);
+  if (isEol(state.input.charCodeAt(state.position))) consumeLineBreak(state);
+  else if (state.input.charCodeAt(state.position) !== 0) throwError(state, "a line break is expected");
+  let contentIndent = detectedIndent ? indent : -1;
+  let maxLeadingIndent = 0;
+  const valueStart = state.position;
+  let valueEnd = state.position;
+  while (state.input.charCodeAt(state.position) !== 0) {
+    const linePosition = state.position;
+    let column = 0;
+    while (state.input.charCodeAt(linePosition + column) === 32) column++;
+    const first = state.input.charCodeAt(linePosition + column);
+    if (first === 0) {
+      if (contentIndent >= 0) {
+        if (column > contentIndent) valueEnd = linePosition + column;
+      } else if (column > 0) valueEnd = linePosition + column;
+      break;
+    }
+    if (linePosition === state.lineStart && testDocumentSeparator(state, linePosition)) break;
+    if (!detectedIndent && contentIndent === -1 && isEol(first)) maxLeadingIndent = Math.max(maxLeadingIndent, column);
+    if (!detectedIndent && contentIndent === -1 && !isEol(first)) {
+      if (first === 9 && column < parentIndent) {
+        state.position = linePosition + column;
         throwError(state, "tab characters must not be used in indentation");
       }
-      if (ch !== 45) break;
-      if (!isWsOrEol(state.input.charCodeAt(state.position + 1))) break;
-      detected = true;
-      state.position++;
-      if (skipSeparationSpace(state, true, -1)) {
-        if (state.lineIndent <= nodeIndent) {
-          _result.push(null);
-          ch = state.input.charCodeAt(state.position);
-          continue;
-        }
+      if (column < maxLeadingIndent) {
+        state.position = linePosition + column;
+        throwError(state, "bad indentation of a mapping entry");
       }
-      const _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;
+    if (contentIndent === -1 && first !== 0 && !isEol(first) && column < parentIndent) {
+      state.lineIndent = column;
+      state.position = linePosition + column;
+      break;
+    }
+    if (!detectedIndent && first !== 0 && !isEol(first) && contentIndent === -1) contentIndent = column;
+    const requiredIndent = contentIndent === -1 ? parentIndent + 1 : contentIndent;
+    if (first !== 0 && !isEol(first) && column < requiredIndent) {
+      state.lineIndent = column;
+      state.position = linePosition + column;
+      break;
+    }
+    skipUntilLineEnd(state);
+    valueEnd = state.position;
+    if (isEol(state.input.charCodeAt(state.position))) {
+      consumeLineBreak(state);
+      valueEnd = state.position;
     }
-    return false;
   }
-  function readBlockMapping(state, nodeIndent, flowIndent) {
-    let allowCompact;
-    let _keyLine;
-    let _keyLineStart;
-    let _keyPos;
-    const _tag = state.tag;
-    const _anchor = state.anchor;
-    const _result = {};
-    const overridableKeys = /* @__PURE__ */ Object.create(null);
-    let keyTag = null;
-    let keyNode = null;
-    let valueNode = null;
-    let atExplicitKey = false;
-    let detected = false;
-    if (state.firstTabInLine !== -1) return false;
-    if (state.anchor !== null) storeAnchor(state, state.anchor, _result);
-    let 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");
-      }
+  checkPrintable(state, valueStart, valueEnd);
+  addScalarEvent(state, valueStart, valueEnd, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, style, chomping, contentIndent);
+  return true;
+}
+function canStartPlainScalar(state, nodeContext) {
+  const ch = state.input.charCodeAt(state.position);
+  const inFlow = nodeContext === CONTEXT_FLOW_IN;
+  if (ch === 0 || isWsOrEol(ch) || ch === 35 || ch === 38 || ch === 42 || ch === 33 || ch === 124 || ch === 62 || ch === 39 || ch === 34 || ch === 37 || ch === 64 || ch === 96 || inFlow && isFlowIndicator(ch)) return false;
+  if (ch === 63 || ch === 45) {
+    const following = state.input.charCodeAt(state.position + 1);
+    if (isWsOrEolOrEnd(following) || inFlow && isFlowIndicator(following)) return false;
+  }
+  return true;
+}
+function readPlainScalar(state, nodeIndent, nodeContext, props) {
+  if (!canStartPlainScalar(state, nodeContext)) return false;
+  const start = state.position;
+  let end = state.position;
+  let ch = state.input.charCodeAt(state.position);
+  const inFlow = nodeContext === CONTEXT_FLOW_IN;
+  let multiline = false;
+  while (ch !== 0) {
+    if (state.position === state.lineStart && testDocumentSeparator(state)) break;
+    if (ch === 58) {
       const following = state.input.charCodeAt(state.position + 1);
-      const _line = state.line;
-      if ((ch === 63 || ch === 58) && isWsOrEol(following)) {
-        if (ch === 63) {
-          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) {
-          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;
-      } else {
-        _keyLine = state.line;
-        _keyLineStart = state.lineStart;
-        _keyPos = state.position;
-        if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) break;
-        if (state.line === _line) {
-          ch = state.input.charCodeAt(state.position);
-          while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position);
-          if (ch === 58) {
-            ch = state.input.charCodeAt(++state.position);
-            if (!isWsOrEol(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;
-          }
-        } 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;
-        }
-      }
-      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);
+      if (isWsOrEolOrEnd(following) || inFlow && isFlowIndicator(following)) break;
+    } else if (ch === 35) {
+      if (isWsOrEol(state.input.charCodeAt(state.position - 1))) break;
+    } else if (inFlow && isFlowIndicator(ch)) break;
+    else if (isEol(ch)) {
+      const savedPosition = state.position;
+      const savedLine = state.line;
+      const savedLineStart = state.lineStart;
+      const savedLineIndent = state.lineIndent;
+      skipSeparationSpace(state, false);
+      if (state.lineIndent >= nodeIndent) {
+        multiline = true;
         ch = state.input.charCodeAt(state.position);
+        continue;
       }
-      if ((state.line === _line || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a mapping entry");
-      else if (state.lineIndent < nodeIndent) break;
-    }
-    if (atExplicitKey) storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos);
-    if (detected) {
-      state.tag = _tag;
-      state.anchor = _anchor;
-      state.kind = "mapping";
-      state.result = _result;
-    }
-    return detected;
-  }
-  function readTagProperty(state) {
-    let isVerbatim = false;
-    let isNamed = false;
-    let tagHandle;
-    let tagName;
-    let ch = state.input.charCodeAt(state.position);
-    if (ch !== 33) return false;
-    if (state.tag !== null) throwError(state, "duplication of a tag property");
-    ch = state.input.charCodeAt(++state.position);
-    if (ch === 60) {
-      isVerbatim = true;
-      ch = state.input.charCodeAt(++state.position);
-    } else if (ch === 33) {
-      isNamed = true;
-      tagHandle = "!!";
-      ch = state.input.charCodeAt(++state.position);
-    } else tagHandle = "!";
-    let _position = state.position;
-    if (isVerbatim) {
-      do
-        ch = state.input.charCodeAt(++state.position);
-      while (ch !== 0 && ch !== 62);
-      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 && !isWsOrEol(ch)) {
-        if (ch === 33) 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);
+      state.position = savedPosition;
+      state.line = savedLine;
+      state.lineStart = savedLineStart;
+      state.lineIndent = savedLineIndent;
+      break;
     }
-    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) {
-    let ch = state.input.charCodeAt(state.position);
-    if (ch !== 38) return false;
-    if (state.anchor !== null) throwError(state, "duplication of an anchor property");
-    ch = state.input.charCodeAt(++state.position);
-    const _position = state.position;
-    while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(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) {
-    let ch = state.input.charCodeAt(state.position);
-    if (ch !== 42) return false;
+    if (!isWhiteSpace(ch)) end = state.position + 1;
     ch = state.input.charCodeAt(++state.position);
-    const _position = state.position;
-    while (ch !== 0 && !isWsOrEol(ch) && !isFlowIndicator(ch)) ch = state.input.charCodeAt(++state.position);
-    if (state.position === _position) throwError(state, "name of an alias node must contain at least one character");
-    const 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 tryReadBlockMappingFromProperty(state, propertyStart, nodeIndent, flowIndent) {
-    const fallbackState = snapshotState(state);
-    beginAnchorTransaction(state);
-    restoreState(state, propertyStart);
-    state.tag = null;
-    state.anchor = null;
-    state.kind = null;
-    state.result = null;
-    if (readBlockMapping(state, nodeIndent, flowIndent) && state.kind === "mapping") {
-      commitAnchorTransaction(state);
+  if (end === start) return false;
+  checkPrintable(state, start, end);
+  addScalarEvent(state, start, end, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 1, 1, -1, !multiline);
+  return true;
+}
+function skipFlowSeparationSpace(state, nodeIndent) {
+  const startLine = state.line;
+  skipSeparationSpace(state, true);
+  if (state.line > startLine && state.lineIndent < nodeIndent || state.firstTabInLine !== -1 && state.lineIndent < nodeIndent) throwError(state, "deficient indentation");
+}
+function readFlowCollection(state, nodeIndent, props) {
+  const ch = state.input.charCodeAt(state.position);
+  const isMapping = ch === 123;
+  const start = state.position;
+  let readNext = true;
+  if (ch !== 91 && ch !== 123) return false;
+  const terminator = isMapping ? 125 : 93;
+  if (isMapping) addMappingEvent(state, start, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 2);
+  else addSequenceEvent(state, start, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 2);
+  state.position++;
+  while (state.input.charCodeAt(state.position) !== 0) {
+    skipFlowSeparationSpace(state, nodeIndent);
+    let ch2 = state.input.charCodeAt(state.position);
+    if (ch2 === terminator) {
+      state.position++;
+      addPopEvent(state);
       return true;
-    }
-    rollbackAnchorTransaction(state);
-    restoreState(state, fallbackState);
-    return false;
+    } else if (!readNext) throwError(state, "missed comma between flow collection entries");
+    else if (ch2 === 44) throwError(state, "expected the node content, but found ','");
+    let isPair = false;
+    let isExplicitPair = false;
+    if (ch2 === 63 && isWsOrEol(state.input.charCodeAt(state.position + 1))) {
+      isPair = isExplicitPair = true;
+      state.position += 1;
+      skipFlowSeparationSpace(state, nodeIndent);
+    }
+    const entryLine = state.line;
+    const entryStart = snapshotState(state);
+    const keyWasRead = parseNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+    skipFlowSeparationSpace(state, nodeIndent);
+    ch2 = state.input.charCodeAt(state.position);
+    if ((isMapping || isExplicitPair || state.line === entryLine) && ch2 === 58) {
+      isPair = true;
+      state.position++;
+      skipFlowSeparationSpace(state, nodeIndent);
+      if (!isMapping) {
+        restoreState(state, entryStart);
+        addMappingEvent(state, entryStart.position, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, 2);
+        if (!parseNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true)) addEmptyScalarEvent(state);
+        skipFlowSeparationSpace(state, nodeIndent);
+        state.position++;
+        skipFlowSeparationSpace(state, nodeIndent);
+      } else if (!keyWasRead) addEmptyScalarEvent(state);
+      if (!parseNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true)) addEmptyScalarEvent(state);
+      skipFlowSeparationSpace(state, nodeIndent);
+      if (!isMapping) addPopEvent(state);
+    } else if (isMapping && isPair) {
+      if (!keyWasRead) addEmptyScalarEvent(state);
+      addEmptyScalarEvent(state);
+    } else if (isMapping) addEmptyScalarEvent(state);
+    else if (isPair) {
+      restoreState(state, entryStart);
+      addMappingEvent(state, entryStart.position, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, NO_RANGE$1, 2);
+      parseNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true);
+      addEmptyScalarEvent(state);
+      addPopEvent(state);
+    }
+    ch2 = state.input.charCodeAt(state.position);
+    if (ch2 === 44) {
+      readNext = true;
+      state.position++;
+    } else readNext = false;
   }
-  function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) {
-    let allowBlockScalars;
-    let allowBlockCollections;
-    let indentStatus = 1;
-    let atNewLine = false;
-    let hasContent = false;
-    let propertyStart = null;
-    let type;
-    let flowIndent;
-    let blockIndent;
-    if (state.depth >= state.maxDepth) throwError(state, "nesting exceeded maxDepth (" + state.maxDepth + ")");
-    state.depth += 1;
-    if (state.listener !== null) state.listener("open", state);
-    state.tag = null;
-    state.anchor = null;
-    state.kind = null;
-    state.result = null;
-    const 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 (true) {
-      const ch = state.input.charCodeAt(state.position);
-      const propertyState = snapshotState(state);
-      if (atNewLine && (ch === 33 && state.tag !== null || ch === 38 && state.anchor !== null)) break;
-      if (!readTagProperty(state) && !readAnchorProperty(state)) break;
-      if (propertyStart === null) propertyStart = propertyState;
-      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 {
-        const ch = state.input.charCodeAt(state.position);
-        if (propertyStart !== null && allowBlockStyles && !allowBlockCollections && ch !== 124 && ch !== 62 && tryReadBlockMappingFromProperty(state, propertyStart, propertyStart.position - propertyStart.lineStart, 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) storeAnchor(state, state.anchor, state.result);
-      }
-      else if (indentStatus === 0) hasContent = allowBlockCollections && readBlockSequence(state, blockIndent);
-    }
-    if (state.tag === null) {
-      if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
-    } else if (state.tag === "?") {
-      if (state.result !== null && state.kind !== "scalar") throwError(state, 'unacceptable node kind for !<?> tag; it should be "scalar", not "' + state.kind + '"');
-      for (let typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) {
-        type = state.implicitTypes[typeIndex];
-        if (type.resolve(state.result)) {
-          state.result = type.construct(state.result);
-          state.tag = type.tag;
-          if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
-          break;
-        }
+  throwError(state, "unexpected end of the stream within a flow collection");
+}
+function readBlockSequence(state, nodeIndent, props) {
+  if (state.firstTabInLine !== -1 || state.input.charCodeAt(state.position) !== 45 || !isWsOrEolOrEnd(state.input.charCodeAt(state.position + 1))) return false;
+  addSequenceEvent(state, state.position, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 1);
+  while (state.input.charCodeAt(state.position) === 45 && isWsOrEolOrEnd(state.input.charCodeAt(state.position + 1))) {
+    if (state.firstTabInLine !== -1) {
+      state.position = state.firstTabInLine;
+      throwError(state, "tab characters must not be used in indentation");
+    }
+    const entryLine = state.line;
+    state.position++;
+    const hadBreak = skipSeparationSpace(state, true) > 0;
+    if (state.firstTabInLine !== -1 && state.input.charCodeAt(state.position) === 45 && isWsOrEolOrEnd(state.input.charCodeAt(state.position + 1))) throwError(state, "bad indentation of a sequence entry");
+    if (hadBreak && state.lineIndent <= nodeIndent) addEmptyScalarEvent(state);
+    else parseNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true);
+    skipSeparationSpace(state, true);
+    if (state.lineIndent < nodeIndent || state.position >= state.length) break;
+    if (state.lineIndent > nodeIndent) throwError(state, "bad indentation of a sequence entry");
+    if (state.line === entryLine && state.input.charCodeAt(state.position) === 45 && isWsOrEolOrEnd(state.input.charCodeAt(state.position + 1))) throwError(state, "bad indentation of a sequence entry");
+  }
+  addPopEvent(state);
+  return true;
+}
+function readBlockMapping(state, nodeIndent, flowIndent, props) {
+  let atExplicitKey = false;
+  let detected = false;
+  let mappingOpened = false;
+  let pendingExplicitKey = false;
+  if (state.firstTabInLine !== -1) return false;
+  let 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");
+    }
+    const following = state.input.charCodeAt(state.position + 1);
+    const entryLine = state.line;
+    if ((ch === 63 || ch === 58) && isWsOrEolOrEnd(following)) {
+      if (!mappingOpened) {
+        addMappingEvent(state, state.position, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 1);
+        mappingOpened = true;
       }
-    } else if (state.tag !== "!") {
-      if (_hasOwnProperty.call(state.typeMap[state.kind || "fallback"], state.tag)) type = state.typeMap[state.kind || "fallback"][state.tag];
+      if (ch === 63) {
+        if (atExplicitKey) addEmptyScalarEvent(state);
+        detected = true;
+        atExplicitKey = true;
+      } else if (atExplicitKey) atExplicitKey = false;
       else {
-        type = null;
-        const typeList = state.typeMap.multi[state.kind || "fallback"];
-        for (let 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;
-        }
+        addEmptyScalarEvent(state);
+        detected = true;
+        atExplicitKey = false;
       }
-      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)) throwError(state, "cannot resolve a node with !<" + state.tag + "> explicit tag");
-      else {
-        state.result = type.construct(state.result, state.tag);
-        if (state.anchor !== null) storeAnchor(state, state.anchor, state.result);
+      state.position += 1;
+      pendingExplicitKey = true;
+    } else {
+      if (atExplicitKey) {
+        addEmptyScalarEvent(state);
+        atExplicitKey = false;
       }
-    }
-    if (state.listener !== null) state.listener("close", state);
-    state.depth -= 1;
-    return state.tag !== null || state.anchor !== null || hasContent;
-  }
-  function readDocument(state) {
-    const documentStart = state.position;
-    let hasDirectives = false;
-    let ch;
-    state.version = null;
-    state.checkLineBreaks = state.legacy;
-    state.tagMap = /* @__PURE__ */ Object.create(null);
-    state.anchorMap = /* @__PURE__ */ 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 !== 37) break;
-      hasDirectives = true;
-      ch = state.input.charCodeAt(++state.position);
-      let _position = state.position;
-      while (ch !== 0 && !isWsOrEol(ch)) ch = state.input.charCodeAt(++state.position);
-      const directiveName = state.input.slice(_position, state.position);
-      const directiveArgs = [];
-      if (directiveName.length < 1) throwError(state, "directive name must not be less than one character in length");
-      while (ch !== 0) {
+      const beforeKey = snapshotState(state);
+      if (!parseNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) break;
+      if (state.line === entryLine) {
+        ch = state.input.charCodeAt(state.position);
         while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position);
-        if (ch === 35) {
-          do
-            ch = state.input.charCodeAt(++state.position);
-          while (ch !== 0 && !isEol(ch));
-          break;
+        if (ch === 58) {
+          ch = state.input.charCodeAt(++state.position);
+          if (!isWsOrEolOrEnd(ch)) throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
+          if (!mappingOpened) {
+            restoreState(state, beforeKey);
+            addMappingEvent(state, beforeKey.position, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 1);
+            mappingOpened = true;
+            parseNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true);
+            ch = state.input.charCodeAt(state.position);
+            while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position);
+            state.position++;
+          }
+          detected = true;
+          atExplicitKey = false;
+          pendingExplicitKey = false;
+        } else if (detected) throwError(state, "expected ':' after a mapping key");
+        else {
+          if (props.anchorStart !== NO_RANGE$1 || props.tagStart !== NO_RANGE$1) {
+            restoreState(state, beforeKey);
+            return false;
+          }
+          return true;
         }
-        if (isEol(ch)) break;
-        _position = state.position;
-        while (ch !== 0 && !isWsOrEol(ch)) ch = state.input.charCodeAt(++state.position);
-        directiveArgs.push(state.input.slice(_position, state.position));
+      } else if (detected) throwError(state, "can not read a block mapping entry; a multiline key may not be an implicit key");
+      else {
+        if (props.anchorStart !== NO_RANGE$1 || props.tagStart !== NO_RANGE$1) {
+          restoreState(state, beforeKey);
+          return false;
+        }
+        return true;
       }
-      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) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45) {
-      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) === 46) {
-        state.position += 3;
-        skipSeparationSpace(state, true, -1);
+    if (parseNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, pendingExplicitKey)) pendingExplicitKey = false;
+    if (!atExplicitKey) {
+      if (pendingExplicitKey) {
+        addEmptyScalarEvent(state);
+        pendingExplicitKey = false;
       }
-      return;
     }
-    if (state.position < state.length - 1) throwError(state, "end of the stream or a document separator is expected");
+    skipSeparationSpace(state, true);
+    ch = state.input.charCodeAt(state.position);
+    if ((state.line === entryLine || state.lineIndent > nodeIndent) && ch !== 0) throwError(state, "bad indentation of a mapping entry");
+    else if (state.lineIndent < nodeIndent) break;
   }
-  function loadDocuments(input, options) {
-    input = String(input);
-    options = options || {};
-    if (input.length !== 0) {
-      if (input.charCodeAt(input.length - 1) !== 10 && input.charCodeAt(input.length - 1) !== 13) input += "\n";
-      if (input.charCodeAt(0) === 65279) input = input.slice(1);
-    }
-    const state = new State(input, options);
-    const nullpos = input.indexOf("\0");
-    if (nullpos !== -1) {
-      state.position = nullpos;
-      throwError(state, "null byte is not allowed in input");
-    }
-    state.input += "\0";
-    while (state.input.charCodeAt(state.position) === 32) {
-      state.lineIndent += 1;
-      state.position += 1;
+  if (!detected) return false;
+  if (atExplicitKey) addEmptyScalarEvent(state);
+  if (mappingOpened) addPopEvent(state);
+  return true;
+}
+function parseNode(state, parentIndent, nodeContext, allowToSeek, allowCompact, allowPropertyMapping = true) {
+  if (state.depth >= state.maxDepth) throwError(state, `nesting exceeded maxDepth (${state.maxDepth})`);
+  state.depth++;
+  let indentStatus = 1;
+  let atNewLine = false;
+  let hasContent = false;
+  let propertyStart = null;
+  const props = emptyProperties();
+  let allowBlockScalars = nodeContext === CONTEXT_BLOCK_OUT || nodeContext === CONTEXT_BLOCK_IN;
+  let allowBlockCollections = allowBlockScalars;
+  const allowBlockStyles = allowBlockScalars;
+  if (allowToSeek && skipSeparationSpace(state, true)) {
+    atNewLine = true;
+    if (state.lineIndent > parentIndent) indentStatus = 1;
+    else if (state.lineIndent === parentIndent) indentStatus = 0;
+    else indentStatus = -1;
+  }
+  if (state.position === state.lineStart && testDocumentSeparator(state)) {
+    state.depth--;
+    return false;
+  }
+  if (indentStatus === 1) while (true) {
+    const ch = state.input.charCodeAt(state.position);
+    const propertyState = snapshotState(state);
+    if (atNewLine && indentStatus !== 1 && (ch === 33 || ch === 38)) break;
+    if (atNewLine && allowBlockStyles && (props.tagStart !== NO_RANGE$1 || props.anchorStart !== NO_RANGE$1) && (ch === 33 || ch === 38)) {
+      const fallbackState = snapshotState(state);
+      const flowIndent = parentIndent + 1;
+      if (readBlockMapping(state, state.position - state.lineStart, flowIndent, props) && state.events[fallbackState.eventsLength]?.type === 3) {
+        state.depth--;
+        return true;
+      }
+      restoreState(state, fallbackState);
+    }
+    if (atNewLine && (ch === 33 && props.tagStart !== NO_RANGE$1 || ch === 38 && props.anchorStart !== NO_RANGE$1)) break;
+    if (!readTagProperty(state, props, nodeContext === CONTEXT_FLOW_IN) && !readAnchorProperty(state, props)) break;
+    if (propertyStart === null) propertyStart = propertyState;
+    if (skipSeparationSpace(state, true)) {
+      atNewLine = true;
+      allowBlockCollections = allowBlockStyles;
+      if (state.lineIndent > parentIndent) indentStatus = 1;
+      else if (state.lineIndent === parentIndent) indentStatus = 0;
+      else indentStatus = -1;
+    } else allowBlockCollections = false;
+  }
+  if (allowBlockCollections) allowBlockCollections = atNewLine || allowCompact;
+  if (indentStatus === 1 || nodeContext === CONTEXT_BLOCK_OUT) {
+    const flowIndent = nodeContext === CONTEXT_FLOW_IN || nodeContext === CONTEXT_FLOW_OUT ? parentIndent : parentIndent + 1;
+    const blockIndent = state.position - state.lineStart;
+    if (indentStatus === 1) if (allowBlockCollections && (readBlockSequence(state, blockIndent, props) || readBlockMapping(state, blockIndent, flowIndent, props)) || readFlowCollection(state, flowIndent, props)) hasContent = true;
+    else {
+      const ch = state.input.charCodeAt(state.position);
+      if (propertyStart !== null && allowPropertyMapping && allowBlockStyles && !allowBlockCollections && ch !== 124 && ch !== 62) {
+        const fallbackState = snapshotState(state);
+        const propertyIndent = propertyStart.position - propertyStart.lineStart;
+        restoreState(state, propertyStart);
+        if (readBlockMapping(state, propertyIndent, flowIndent, emptyProperties()) && state.events[fallbackState.eventsLength]?.type === 3) hasContent = true;
+        else restoreState(state, fallbackState);
+      }
+      if (!hasContent && (allowBlockScalars && readBlockScalar(state, flowIndent, props) || readSingleQuotedScalar(state, flowIndent, props) || readDoubleQuotedScalar(state, flowIndent, props) || readAlias(state, props) || readPlainScalar(state, flowIndent, nodeContext, props))) hasContent = true;
+    }
+    else if (indentStatus === 0) hasContent = allowBlockCollections && readBlockSequence(state, blockIndent, props);
+  }
+  allowBlockScalars = allowBlockScalars && !hasContent;
+  if (!hasContent && (props.anchorStart !== NO_RANGE$1 || props.tagStart !== NO_RANGE$1 || allowBlockScalars)) {
+    addScalarEvent(state, NO_RANGE$1, NO_RANGE$1, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, 1);
+    hasContent = true;
+  }
+  state.depth--;
+  return hasContent || props.anchorStart !== NO_RANGE$1 || props.tagStart !== NO_RANGE$1;
+}
+function readDirective(state) {
+  if (state.lineIndent > 0 || state.input.charCodeAt(state.position) !== 37) return false;
+  state.position++;
+  const nameStart = state.position;
+  while (state.input.charCodeAt(state.position) !== 0 && !isWsOrEol(state.input.charCodeAt(state.position))) state.position++;
+  const name = state.input.slice(nameStart, state.position);
+  const args = [];
+  if (name.length === 0) throwError(state, "directive name must not be less than one character in length");
+  while (state.input.charCodeAt(state.position) !== 0 && !isEol(state.input.charCodeAt(state.position))) {
+    while (isWhiteSpace(state.input.charCodeAt(state.position))) state.position++;
+    if (state.input.charCodeAt(state.position) === 35 || isEol(state.input.charCodeAt(state.position)) || state.input.charCodeAt(state.position) === 0) break;
+    const start = state.position;
+    while (state.input.charCodeAt(state.position) !== 0 && !isWsOrEol(state.input.charCodeAt(state.position))) state.position++;
+    args.push(state.input.slice(start, state.position));
+  }
+  if (isEol(state.input.charCodeAt(state.position))) consumeLineBreak(state);
+  if (name === "YAML") {
+    if (state.directives.some((directive) => directive.kind === "yaml")) throwError(state, "duplication of %YAML directive");
+    if (args.length !== 1) throwError(state, "YAML directive accepts exactly one argument");
+    const match2 = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+    if (match2 === null) throwError(state, "ill-formed argument of the YAML directive");
+    if (parseInt(match2[1], 10) !== 1) throwError(state, "unacceptable YAML version of the document");
+    state.directives.push({
+      kind: "yaml",
+      version: args[0]
+    });
+  } else if (name === "TAG") {
+    if (args.length !== 2) throwError(state, "TAG directive accepts exactly two arguments");
+    const [handle, prefix] = args;
+    if (!PATTERN_TAG_HANDLE.test(handle)) throwError(state, "ill-formed tag handle (first argument) of the TAG directive");
+    if (HAS_OWN.call(state.tagHandlers, handle)) throwError(state, `there is a previously declared suffix for "${handle}" tag handle`);
+    if (!PATTERN_TAG_PREFIX.test(prefix)) throwError(state, "ill-formed tag prefix (second argument) of the TAG directive");
+    state.tagHandlers[handle] = prefix;
+    state.directives.push({
+      kind: "tag",
+      handle,
+      prefix
+    });
+  }
+  return true;
+}
+function readDocument(state) {
+  state.directives = [];
+  state.tagHandlers = /* @__PURE__ */ Object.create(null);
+  let hasDirectives = false;
+  skipSeparationSpace(state, true);
+  while (readDirective(state)) {
+    hasDirectives = true;
+    skipSeparationSpace(state, true);
+  }
+  let explicitStart = false;
+  let explicitEnd = false;
+  let allowCompact = true;
+  if (state.lineIndent === 0 && state.input.charCodeAt(state.position) === 45 && state.input.charCodeAt(state.position + 1) === 45 && state.input.charCodeAt(state.position + 2) === 45 && isWsOrEolOrEnd(state.input.charCodeAt(state.position + 3))) {
+    explicitStart = true;
+    const markerLine = state.line;
+    state.position += 3;
+    skipSeparationSpace(state, true);
+    allowCompact = state.line > markerLine;
+  } else if (hasDirectives) throwError(state, "directives end mark is expected");
+  const documentEventIndex = state.events.length;
+  if (!explicitStart && state.position === state.lineStart && state.input.charCodeAt(state.position) === 46 && testDocumentSeparator(state)) {
+    state.position += 3;
+    skipSeparationSpace(state, true);
+    return;
+  }
+  addDocumentEvent(state, explicitStart, false);
+  if (!parseNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, allowCompact, allowCompact)) addEmptyScalarEvent(state);
+  skipSeparationSpace(state, true);
+  if (state.position === state.lineStart && testDocumentSeparator(state)) {
+    explicitEnd = state.input.charCodeAt(state.position) === 46;
+    if (explicitEnd) {
+      const markerLine = state.line;
+      state.position += 3;
+      skipSeparationSpace(state, true);
+      if (state.line === markerLine && state.position < state.length) throwError(state, "end of the stream or a document separator is expected");
     }
-    while (state.position < state.length - 1) readDocument(state);
-    return state.documents;
-  }
-  function loadAll2(input, iterator2, options) {
-    if (iterator2 !== null && typeof iterator2 === "object" && typeof options === "undefined") {
-      options = iterator2;
-      iterator2 = null;
-    }
-    const documents = loadDocuments(input, options);
-    if (typeof iterator2 !== "function") return documents;
-    for (let index2 = 0, length = documents.length; index2 < length; index2 += 1) iterator2(documents[index2]);
-  }
-  function load2(input, options) {
-    const documents = loadDocuments(input, options);
-    if (documents.length === 0) return;
-    else if (documents.length === 1) return documents[0];
-    throw new YAMLException2("expected a single document in the stream, but found more");
-  }
-  module2.exports.loadAll = loadAll2;
-  module2.exports.load = load2;
-}));
-var require_dumper = /* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var common = require_common();
-  var YAMLException2 = require_exception();
-  var DEFAULT_SCHEMA2 = require_default();
-  var _toString = Object.prototype.toString;
-  var _hasOwnProperty = Object.prototype.hasOwnProperty;
-  var CHAR_BOM = 65279;
-  var CHAR_TAB = 9;
-  var CHAR_LINE_FEED = 10;
-  var CHAR_CARRIAGE_RETURN = 13;
-  var CHAR_SPACE = 32;
-  var CHAR_EXCLAMATION = 33;
-  var CHAR_DOUBLE_QUOTE = 34;
-  var CHAR_SHARP = 35;
-  var CHAR_PERCENT = 37;
-  var CHAR_AMPERSAND = 38;
-  var CHAR_SINGLE_QUOTE = 39;
-  var CHAR_ASTERISK = 42;
-  var CHAR_COMMA = 44;
-  var CHAR_MINUS = 45;
-  var CHAR_COLON = 58;
-  var CHAR_EQUALS = 61;
-  var CHAR_GREATER_THAN = 62;
-  var CHAR_QUESTION = 63;
-  var CHAR_COMMERCIAL_AT = 64;
-  var CHAR_LEFT_SQUARE_BRACKET = 91;
-  var CHAR_RIGHT_SQUARE_BRACKET = 93;
-  var CHAR_GRAVE_ACCENT = 96;
-  var CHAR_LEFT_CURLY_BRACKET = 123;
-  var CHAR_VERTICAL_LINE = 124;
-  var CHAR_RIGHT_CURLY_BRACKET = 125;
-  var ESCAPE_SEQUENCES = {};
-  ESCAPE_SEQUENCES[0] = "\\0";
-  ESCAPE_SEQUENCES[7] = "\\a";
-  ESCAPE_SEQUENCES[8] = "\\b";
-  ESCAPE_SEQUENCES[9] = "\\t";
-  ESCAPE_SEQUENCES[10] = "\\n";
-  ESCAPE_SEQUENCES[11] = "\\v";
-  ESCAPE_SEQUENCES[12] = "\\f";
-  ESCAPE_SEQUENCES[13] = "\\r";
-  ESCAPE_SEQUENCES[27] = "\\e";
-  ESCAPE_SEQUENCES[34] = '\\"';
-  ESCAPE_SEQUENCES[92] = "\\\\";
-  ESCAPE_SEQUENCES[133] = "\\N";
-  ESCAPE_SEQUENCES[160] = "\\_";
-  ESCAPE_SEQUENCES[8232] = "\\L";
-  ESCAPE_SEQUENCES[8233] = "\\P";
-  var DEPRECATED_BOOLEANS_SYNTAX = [
-    "y",
-    "Y",
-    "yes",
-    "Yes",
-    "YES",
-    "on",
-    "On",
-    "ON",
-    "n",
-    "N",
-    "no",
-    "No",
-    "NO",
-    "off",
-    "Off",
-    "OFF"
+  }
+  const documentEvent = state.events[documentEventIndex];
+  if (documentEvent?.type === 1) documentEvent.explicitEnd = explicitEnd;
+  addPopEvent(state);
+  if (!explicitEnd && state.position < state.length && !(state.position === state.lineStart && testDocumentSeparator(state))) throwError(state, "end of the stream or a document separator is expected");
+}
+function parseEvents(input, options) {
+  const length = input.length;
+  const state = {
+    ...DEFAULT_PARSER_OPTIONS,
+    ...options,
+    input: `${input}\0`,
+    length,
+    position: 0,
+    line: 0,
+    lineStart: 0,
+    lineIndent: 0,
+    firstTabInLine: -1,
+    depth: 0,
+    directives: [],
+    tagHandlers: /* @__PURE__ */ Object.create(null),
+    events: []
+  };
+  const nullpos = input.indexOf("\0");
+  if (nullpos !== -1) throwErrorAt(input, nullpos, "null byte is not allowed in input", state.filename);
+  if (state.input.charCodeAt(state.position) === 65279) state.position++;
+  while (state.position < state.length) {
+    skipSeparationSpace(state, true);
+    if (state.position >= state.length) break;
+    const documentStart = state.position;
+    readDocument(state);
+    if (state.position === documentStart)
+      throwError(state, "can not read a document");
+  }
+  return state.events;
+}
+var DEFAULT_LOAD_OPTIONS = {
+  ...DEFAULT_PARSER_OPTIONS,
+  ...DEFAULT_CONSTRUCTOR_OPTIONS
+};
+function loadDocuments(input, options = {}) {
+  const opts = {
+    ...DEFAULT_LOAD_OPTIONS,
+    ...options
+  };
+  const source = String(input);
+  const PARSER_OPT_KEYS = Object.keys(DEFAULT_PARSER_OPTIONS);
+  const CONSTRUCTOR_OPT_KEYS = Object.keys(DEFAULT_CONSTRUCTOR_OPTIONS);
+  return constructFromEvents(parseEvents(source, pick(opts, PARSER_OPT_KEYS)), {
+    ...pick(opts, CONSTRUCTOR_OPT_KEYS),
+    source
+  });
+}
+function load(input, options) {
+  const documents = loadDocuments(input, options);
+  if (documents.length === 0) throw new YAMLException("expected a document, but the input is empty");
+  if (documents.length === 1) return documents[0];
+  throw new YAMLException("expected a single document in the stream, but found more");
+}
+var Style = class {
+  tagged = false;
+  flow = false;
+  singleQuoted = false;
+  doubleQuoted = false;
+  literal = false;
+  folded = false;
+};
+var INVALID = /* @__PURE__ */ Symbol("INVALID");
+function buildRepresentTypes(schema) {
+  const defaultTags = new Set([
+    schema.defaultScalarTag,
+    schema.defaultSequenceTag,
+    schema.defaultMappingTag
+  ].filter((t) => t !== void 0));
+  const implicitScalars = schema.implicitScalarTags;
+  const explicitTags = schema.tags.filter((t) => !(t.nodeKind === "scalar" && t.implicit) && !defaultTags.has(t));
+  const defaultTagsLast = schema.tags.filter((t) => defaultTags.has(t));
+  return [
+    ...implicitScalars.map((tag) => ({
+      tag,
+      implicitTag: true
+    })),
+    ...explicitTags.map((tag) => ({
+      tag,
+      implicitTag: false
+    })),
+    ...defaultTagsLast.map((tag) => ({
+      tag,
+      implicitTag: true
+    }))
   ];
-  var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/;
-  function compileStyleMap(schema, map) {
-    if (map === null) return {};
-    const result = {};
-    const keys = Object.keys(map);
-    for (let index2 = 0, length = keys.length; index2 < length; index2 += 1) {
-      let tag = keys[index2];
-      let style = String(map[tag]);
-      if (tag.slice(0, 2) === "!!") tag = "tag:yaml.org,2002:" + tag.slice(2);
-      const type = schema.compiledTypeMap["fallback"][tag];
-      if (type && _hasOwnProperty.call(type.styleAliases, style)) style = type.styleAliases[style];
-      result[tag] = style;
+}
+function matchTag(state, object) {
+  for (let index2 = 0, length = state.representTypes.length; index2 < length; index2 += 1) {
+    const { tag, implicitTag } = state.representTypes[index2];
+    if (tag.identify && tag.identify(object)) {
+      let tagName;
+      if (tag.matchByTagPrefix && tag.representTagName) tagName = tag.representTagName(object);
+      else tagName = tag.tagName;
+      return {
+        tag,
+        tagName,
+        implicitTag
+      };
     }
-    return result;
   }
-  function encodeHex(character) {
-    let handle;
-    let length;
-    const string2 = character.toString(16).toUpperCase();
-    if (character <= 255) {
-      handle = "x";
-      length = 2;
-    } else if (character <= 65535) {
-      handle = "u";
-      length = 4;
-    } else if (character <= 4294967295) {
-      handle = "U";
-      length = 8;
-    } else throw new YAMLException2("code point within a string may not be greater than 0xFFFFFFFF");
-    return "\\" + handle + common.repeat("0", length - string2.length) + string2;
-  }
-  var QUOTING_TYPE_SINGLE = 1;
-  var QUOTING_TYPE_DOUBLE = 2;
-  function State(options) {
-    this.schema = options["schema"] || DEFAULT_SCHEMA2;
-    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;
-  }
-  function indentString(string2, spaces) {
-    const ind = common.repeat(" ", spaces);
-    let position = 0;
-    let result = "";
-    const length = string2.length;
-    while (position < length) {
-      let line;
-      const next = string2.indexOf("\n", position);
-      if (next === -1) {
-        line = string2.slice(position);
-        position = length;
-      } else {
-        line = string2.slice(position, next + 1);
-        position = next + 1;
+  return null;
+}
+function build(state, object) {
+  if (!state.noRefs && object !== null && typeof object === "object") {
+    const existing = state.refs.get(object);
+    if (existing) {
+      if (existing.anchor === void 0) existing.anchor = `ref_${state.refCounter++}`;
+      return {
+        kind: "alias",
+        tag: "",
+        style: new Style(),
+        anchor: existing.anchor
+      };
+    }
+  }
+  const matched = matchTag(state, object);
+  if (!matched) {
+    if (object === void 0) return INVALID;
+    if (state.skipInvalid) return INVALID;
+    throw new YAMLException(`unacceptable kind of an object to dump ${Object.prototype.toString.call(object)}`);
+  }
+  const { tag, tagName, implicitTag } = matched;
+  const nodeTagName = implicitTag ? tagName : tagNameShort(tagName);
+  if (tag.nodeKind === "scalar") {
+    const style2 = new Style();
+    style2.tagged = !implicitTag;
+    return {
+      kind: "scalar",
+      tag: nodeTagName,
+      style: style2,
+      value: tag.represent(object)
+    };
+  }
+  if (tag.nodeKind === "sequence") {
+    const container = tag.represent(object);
+    const style2 = new Style();
+    style2.tagged = !implicitTag;
+    const node2 = {
+      kind: "sequence",
+      tag: nodeTagName,
+      style: style2,
+      items: []
+    };
+    if (!state.noRefs) state.refs.set(object, node2);
+    for (let index2 = 0, length = container.length; index2 < length; index2 += 1) {
+      let item = build(state, container[index2]);
+      if (item === INVALID && container[index2] === void 0) item = build(state, null);
+      if (item === INVALID) continue;
+      node2.items.push(item);
+    }
+    return node2;
+  }
+  const map = tag.represent(object);
+  const style = new Style();
+  style.tagged = !implicitTag;
+  const node = {
+    kind: "mapping",
+    tag: nodeTagName,
+    style,
+    items: []
+  };
+  if (!state.noRefs) state.refs.set(object, node);
+  for (const [objectKey, objectValue] of map) {
+    const key = build(state, objectKey);
+    if (key === INVALID) continue;
+    const value = build(state, objectValue);
+    if (value === INVALID) continue;
+    node.items.push({
+      key,
+      value
+    });
+  }
+  return node;
+}
+function jsToAst(input, schema, options = {}) {
+  const root = build({
+    representTypes: buildRepresentTypes(schema),
+    noRefs: options.noRefs ?? false,
+    skipInvalid: options.skipInvalid ?? false,
+    refs: /* @__PURE__ */ new Map(),
+    refCounter: 0
+  }, input);
+  return [{
+    contents: root === INVALID ? null : root,
+    directives: []
+  }];
+}
+var VISIT_BREAK = /* @__PURE__ */ Symbol("visit:break");
+var VISIT_SKIP = /* @__PURE__ */ Symbol("visit:skip");
+function visitNode(node, visitor, ctx) {
+  const control = visitor(node, ctx);
+  if (control === VISIT_BREAK) return true;
+  if (control === VISIT_SKIP) return false;
+  const depth = ctx.depth + 1;
+  switch (node.kind) {
+    case "sequence":
+      for (const item of node.items) if (visitNode(item, visitor, {
+        depth,
+        parent: node,
+        isKey: false
+      })) return true;
+      break;
+    case "mapping":
+      for (const { key, value } of node.items) {
+        if (visitNode(key, visitor, {
+          depth,
+          parent: node,
+          isKey: true
+        })) return true;
+        if (visitNode(value, visitor, {
+          depth,
+          parent: node,
+          isKey: false
+        })) return true;
       }
-      if (line.length && line !== "\n") result += ind;
-      result += line;
+      break;
+  }
+  return false;
+}
+function visit(documents, visitor) {
+  for (const doc of documents) if (doc.contents && visitNode(doc.contents, visitor, {
+    depth: 0,
+    parent: null,
+    isKey: false
+  })) return;
+}
+var CHAR_BOM = 65279;
+var CHAR_TAB = 9;
+var CHAR_LINE_FEED = 10;
+var CHAR_CARRIAGE_RETURN = 13;
+var CHAR_SPACE = 32;
+var CHAR_EXCLAMATION = 33;
+var CHAR_DOUBLE_QUOTE = 34;
+var CHAR_SHARP = 35;
+var CHAR_PERCENT = 37;
+var CHAR_AMPERSAND = 38;
+var CHAR_SINGLE_QUOTE = 39;
+var CHAR_ASTERISK = 42;
+var CHAR_COMMA = 44;
+var CHAR_MINUS = 45;
+var CHAR_COLON = 58;
+var CHAR_EQUALS = 61;
+var CHAR_GREATER_THAN = 62;
+var CHAR_QUESTION = 63;
+var CHAR_COMMERCIAL_AT = 64;
+var CHAR_LEFT_SQUARE_BRACKET = 91;
+var CHAR_RIGHT_SQUARE_BRACKET = 93;
+var CHAR_GRAVE_ACCENT = 96;
+var CHAR_LEFT_CURLY_BRACKET = 123;
+var CHAR_VERTICAL_LINE = 124;
+var CHAR_RIGHT_CURLY_BRACKET = 125;
+var ESCAPE_SEQUENCES = {};
+ESCAPE_SEQUENCES[0] = "\\0";
+ESCAPE_SEQUENCES[7] = "\\a";
+ESCAPE_SEQUENCES[8] = "\\b";
+ESCAPE_SEQUENCES[9] = "\\t";
+ESCAPE_SEQUENCES[10] = "\\n";
+ESCAPE_SEQUENCES[11] = "\\v";
+ESCAPE_SEQUENCES[12] = "\\f";
+ESCAPE_SEQUENCES[13] = "\\r";
+ESCAPE_SEQUENCES[27] = "\\e";
+ESCAPE_SEQUENCES[34] = '\\"';
+ESCAPE_SEQUENCES[92] = "\\\\";
+ESCAPE_SEQUENCES[133] = "\\N";
+ESCAPE_SEQUENCES[160] = "\\_";
+ESCAPE_SEQUENCES[8232] = "\\L";
+ESCAPE_SEQUENCES[8233] = "\\P";
+var DEFAULT_PRESENTER_OPTIONS = {
+  indent: 2,
+  seqNoIndent: false,
+  seqInlineFirst: true,
+  sortKeys: false,
+  lineWidth: 80,
+  flowBracketPadding: false,
+  flowSkipCommaSpace: false,
+  flowSkipColonSpace: false,
+  quoteFlowKeys: false,
+  quoteStyle: "auto",
+  tagBeforeAnchor: false
+};
+function nodeTagShort(node) {
+  return node.style.tagged ? node.tag : tagNameShort(node.tag);
+}
+function createPresenterState(options) {
+  const opts = {
+    ...DEFAULT_PRESENTER_OPTIONS,
+    ...options
+  };
+  return {
+    ...opts,
+    defaultScalarTagName: opts.schema.defaultScalarTag.tagName,
+    implicitResolvers: opts.schema.implicitScalarTags
+  };
+}
+function encodeNonPrintable(character) {
+  const string2 = character.toString(16).toUpperCase();
+  const handle = character <= 255 ? "x" : "u";
+  const length = character <= 255 ? 2 : 4;
+  return `\\${handle}${"0".repeat(length - string2.length)}${string2}`;
+}
+function indentString(string2, spaces) {
+  const ind = " ".repeat(spaces);
+  let position = 0;
+  let result = "";
+  const length = string2.length;
+  while (position < length) {
+    let line;
+    const next = string2.indexOf("\n", position);
+    if (next === -1) {
+      line = string2.slice(position);
+      position = length;
+    } else {
+      line = string2.slice(position, next + 1);
+      position = next + 1;
     }
-    return result;
+    if (line.length && line !== "\n") result += ind;
+    result += line;
   }
-  function generateNextLine(state, level) {
-    return "\n" + common.repeat(" ", state.indent * level);
+  return result;
+}
+function generateNextLine(state, level) {
+  return `
+${" ".repeat(state.indent * level)}`;
+}
+function scalarLayout(state, level) {
+  const indent = state.indent * Math.max(1, level);
+  return {
+    indent,
+    blockIndent: level === 0 ? state.indent + 1 : state.indent,
+    lineWidth: state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent)
+  };
+}
+function resolveImplicitTag(state, str) {
+  for (let index2 = 0, length = state.implicitResolvers.length; index2 < length; index2 += 1) {
+    const tagDefinition = state.implicitResolvers[index2];
+    if (tagDefinition.resolve(str, false, tagDefinition.tagName) !== NOT_RESOLVED) return tagDefinition.tagName;
   }
-  function testImplicitResolving(state, str) {
-    for (let index2 = 0, length = state.implicitTypes.length; index2 < length; index2 += 1) if (state.implicitTypes[index2].resolve(str)) return true;
-    return false;
+  return state.defaultScalarTagName;
+}
+function isWhitespace(c) {
+  return c === CHAR_SPACE || c === CHAR_TAB;
+}
+function startsWithDocumentSeparator(string2) {
+  const marker = string2.charCodeAt(0);
+  if (marker !== CHAR_MINUS && marker !== 46 || string2.charCodeAt(1) !== marker || string2.charCodeAt(2) !== marker) return false;
+  if (string2.length === 3) return true;
+  const following = string2.charCodeAt(3);
+  return isWhitespace(following) || following === CHAR_CARRIAGE_RETURN || following === CHAR_LINE_FEED;
+}
+function isPrintable(c) {
+  return c >= 32 && c <= 126 || c >= 161 && c <= 55295 && c !== 8232 && c !== 8233 || c >= 57344 && c <= 65533 && c !== CHAR_BOM || c >= 65536 && c <= 1114111;
+}
+function isNsCharOrWhitespace(c) {
+  return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
+}
+function isPlainSafe(c, prev, inblock) {
+  const cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
+  const cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
+  return (inblock ? cIsNsCharOrWhitespace : cIsNsCharOrWhitespace && 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 && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar;
+}
+function isPlainSafeFirst(c) {
+  return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && 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;
+}
+function isPlainSafeAtStart(string2, inblock) {
+  const first = codePointAt(string2, 0);
+  if (isPlainSafeFirst(first)) return true;
+  if (string2.length > 1 && (first === CHAR_MINUS || first === CHAR_QUESTION || first === CHAR_COLON)) {
+    const second = codePointAt(string2, 1);
+    return !isWhitespace(second) && isPlainSafe(second, first, inblock);
   }
-  function isWhitespace(c) {
-    return c === CHAR_SPACE || c === CHAR_TAB;
-  }
-  function isPrintable(c) {
-    return c >= 32 && c <= 126 || c >= 161 && c <= 55295 && c !== 8232 && c !== 8233 || c >= 57344 && c <= 65533 && c !== CHAR_BOM || c >= 65536 && c <= 1114111;
-  }
-  function isNsCharOrWhitespace(c) {
-    return isPrintable(c) && c !== CHAR_BOM && c !== CHAR_CARRIAGE_RETURN && c !== CHAR_LINE_FEED;
-  }
-  function isPlainSafe(c, prev, inblock) {
-    const cIsNsCharOrWhitespace = isNsCharOrWhitespace(c);
-    const cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c);
-    return (inblock ? cIsNsCharOrWhitespace : cIsNsCharOrWhitespace && 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 && !(prev === CHAR_COLON && !cIsNsChar) || isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP || prev === CHAR_COLON && cIsNsChar;
-  }
-  function isPlainSafeFirst(c) {
-    return isPrintable(c) && c !== CHAR_BOM && !isWhitespace(c) && 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;
-  }
-  function isPlainSafeLast(c) {
-    return !isWhitespace(c) && c !== CHAR_COLON;
-  }
-  function codePointAt(string2, pos) {
-    const first = string2.charCodeAt(pos);
-    let second;
-    if (first >= 55296 && first <= 56319 && pos + 1 < string2.length) {
-      second = string2.charCodeAt(pos + 1);
-      if (second >= 56320 && second <= 57343) return (first - 55296) * 1024 + second - 56320 + 65536;
-    }
-    return first;
-  }
-  function needIndentIndicator(string2) {
-    return /^\n* /.test(string2);
-  }
-  var STYLE_PLAIN = 1;
-  var STYLE_SINGLE = 2;
-  var STYLE_LITERAL = 3;
-  var STYLE_FOLDED = 4;
-  var STYLE_DOUBLE = 5;
-  function chooseScalarStyle(string2, singleLineOnly, indentPerLevel, lineWidth, testAmbiguousType, quotingType, forceQuotes, inblock) {
-    let i;
-    let char = 0;
-    let prevChar = null;
-    let hasLineBreak = false;
-    let hasFoldableLine = false;
-    const shouldTrackWidth = lineWidth !== -1;
-    let previousLineBreak = -1;
-    let plain = isPlainSafeFirst(codePointAt(string2, 0)) && isPlainSafeLast(codePointAt(string2, string2.length - 1));
-    if (singleLineOnly || forceQuotes) for (i = 0; i < string2.length; char >= 65536 ? i += 2 : i++) {
+  return false;
+}
+function isPlainSafeLast(c) {
+  return !isWhitespace(c) && c !== CHAR_COLON;
+}
+function codePointAt(string2, pos) {
+  const first = string2.charCodeAt(pos);
+  let second;
+  if (first >= 55296 && first <= 56319 && pos + 1 < string2.length) {
+    second = string2.charCodeAt(pos + 1);
+    if (second >= 56320 && second <= 57343) return (first - 55296) * 1024 + second - 56320 + 65536;
+  }
+  return first;
+}
+function needIndentIndicator(string2) {
+  return /^\n* /.test(string2);
+}
+var STYLE_PLAIN = 1;
+var STYLE_SINGLE = 2;
+var STYLE_LITERAL = 3;
+var STYLE_FOLDED = 4;
+var STYLE_DOUBLE = 5;
+function chooseScalarStyle(state, string2, layout, singleLineOnly, inblock) {
+  const { blockIndent, lineWidth } = layout;
+  const forceQuote = state.quoteStyle !== "auto";
+  let i;
+  let char = 0;
+  let prevChar = -1;
+  let hasLineBreak = false;
+  let hasFoldableLine = false;
+  const shouldTrackWidth = lineWidth !== -1;
+  let previousLineBreak = -1;
+  let plain = !startsWithDocumentSeparator(string2) && isPlainSafeAtStart(string2, inblock) && isPlainSafeLast(codePointAt(string2, string2.length - 1));
+  if (singleLineOnly || forceQuote) for (i = 0; i < string2.length; char >= 65536 ? i += 2 : i++) {
+    char = codePointAt(string2, i);
+    if (!isPrintable(char)) return STYLE_DOUBLE;
+    plain = plain && isPlainSafe(char, prevChar, inblock);
+    prevChar = char;
+  }
+  else {
+    for (i = 0; i < string2.length; char >= 65536 ? i += 2 : i++) {
       char = codePointAt(string2, i);
-      if (!isPrintable(char)) return STYLE_DOUBLE;
+      if (char === CHAR_LINE_FEED) {
+        hasLineBreak = true;
+        if (shouldTrackWidth) {
+          hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string2[previousLineBreak + 1] !== " ";
+          previousLineBreak = i;
+        }
+      } else if (!isPrintable(char)) return STYLE_DOUBLE;
       plain = plain && isPlainSafe(char, prevChar, inblock);
       prevChar = char;
     }
-    else {
-      for (i = 0; i < string2.length; char >= 65536 ? i += 2 : i++) {
-        char = codePointAt(string2, i);
-        if (char === CHAR_LINE_FEED) {
-          hasLineBreak = true;
-          if (shouldTrackWidth) {
-            hasFoldableLine = hasFoldableLine || i - previousLineBreak - 1 > lineWidth && string2[previousLineBreak + 1] !== " ";
-            previousLineBreak = i;
-          }
-        } else if (!isPrintable(char)) return STYLE_DOUBLE;
-        plain = plain && isPlainSafe(char, prevChar, inblock);
-        prevChar = char;
-      }
-      hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string2[previousLineBreak + 1] !== " ";
-    }
-    if (!hasLineBreak && !hasFoldableLine) {
-      if (plain && !forceQuotes && !testAmbiguousType(string2)) return STYLE_PLAIN;
-      return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
-    }
-    if (indentPerLevel > 9 && needIndentIndicator(string2)) return STYLE_DOUBLE;
-    if (!forceQuotes) return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
-    return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE;
-  }
-  function writeScalar(state, string2, level, iskey, inblock) {
-    state.dump = (function() {
-      if (string2.length === 0) return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''";
-      if (!state.noCompatMode) {
-        if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string2) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string2)) return state.quotingType === QUOTING_TYPE_DOUBLE ? '"' + string2 + '"' : "'" + string2 + "'";
-      }
-      const indent = state.indent * Math.max(1, level);
-      const lineWidth = state.lineWidth === -1 ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent);
-      const singleLineOnly = iskey || state.flowLevel > -1 && level >= state.flowLevel;
-      function testAmbiguity(string3) {
-        return testImplicitResolving(state, string3);
-      }
-      switch (chooseScalarStyle(string2, singleLineOnly, state.indent, lineWidth, testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) {
-        case STYLE_PLAIN:
-          return string2;
-        case STYLE_SINGLE:
-          return "'" + string2.replace(/'/g, "''") + "'";
-        case STYLE_LITERAL:
-          return "|" + blockHeader(string2, state.indent) + dropEndingNewline(indentString(string2, indent));
-        case STYLE_FOLDED:
-          return ">" + blockHeader(string2, state.indent) + dropEndingNewline(indentString(foldString(string2, lineWidth), indent));
-        case STYLE_DOUBLE:
-          return '"' + escapeString(string2, lineWidth) + '"';
-        default:
-          throw new YAMLException2("impossible error: invalid scalar style");
-      }
-    })();
+    hasFoldableLine = hasFoldableLine || shouldTrackWidth && i - previousLineBreak - 1 > lineWidth && string2[previousLineBreak + 1] !== " ";
+  }
+  if (!hasLineBreak && !hasFoldableLine) {
+    if (plain && !forceQuote) return STYLE_PLAIN;
+    return state.quoteStyle === "double" ? STYLE_DOUBLE : STYLE_SINGLE;
+  }
+  if (blockIndent > 9 && needIndentIndicator(string2)) return STYLE_DOUBLE;
+  return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL;
+}
+function renderScalarStyle(string2, style, layout) {
+  const { indent, blockIndent, lineWidth } = layout;
+  switch (style) {
+    case STYLE_PLAIN:
+      return encodeFlowBreaks(string2, indent);
+    case STYLE_SINGLE:
+      return `'${encodeFlowBreaks(string2, indent).replace(/'/g, "''")}'`;
+    case STYLE_LITERAL:
+      return "|" + blockHeader(string2, blockIndent) + dropEndingNewline(indentString(string2, indent));
+    case STYLE_FOLDED:
+      return ">" + blockHeader(string2, blockIndent) + dropEndingNewline(indentString(foldBlockScalar(string2, lineWidth), indent));
+    case STYLE_DOUBLE:
+      return `"${escapeString(string2)}"`;
+  }
+}
+function resolveScalarStyle(state, node, layout, iskey, inblock) {
+  const singleLineOnly = iskey || !inblock;
+  if (node.style.singleQuoted) return STYLE_SINGLE;
+  if (node.style.doubleQuoted) return STYLE_DOUBLE;
+  if (!singleLineOnly) {
+    if (node.style.literal) return STYLE_LITERAL;
+    if (node.style.folded) return STYLE_FOLDED;
+  }
+  const string2 = node.value;
+  if (string2.length === 0) {
+    if (state.quoteStyle === "auto" && (node.style.tagged || resolveImplicitTag(state, string2) === node.tag)) return STYLE_PLAIN;
+    return state.quoteStyle === "double" ? STYLE_DOUBLE : STYLE_SINGLE;
+  }
+  const style = chooseScalarStyle(state, string2, layout, singleLineOnly, inblock);
+  if (style === STYLE_PLAIN && !node.style.tagged && resolveImplicitTag(state, string2) !== node.tag) return STYLE_SINGLE;
+  return style;
+}
+function blockHeader(string2, indentPerLevel) {
+  const indentIndicator = needIndentIndicator(string2) ? String(indentPerLevel) : "";
+  const clip = string2[string2.length - 1] === "\n";
+  return `${indentIndicator}${clip && (string2[string2.length - 2] === "\n" || string2 === "\n") ? "+" : clip ? "" : "-"}
+`;
+}
+function encodeFlowBreaks(string2, indent) {
+  let nextLF = string2.indexOf("\n");
+  if (nextLF === -1) return string2;
+  const pad = " ".repeat(indent);
+  let result = string2.slice(0, nextLF);
+  const lineRe = /(\n+)([^\n]*)/g;
+  lineRe.lastIndex = nextLF;
+  let match2;
+  while (match2 = lineRe.exec(string2)) {
+    const breaks = match2[1].length;
+    const line = match2[2];
+    result += "\n".repeat(breaks + 1) + pad + line;
   }
-  function blockHeader(string2, indentPerLevel) {
-    const indentIndicator = needIndentIndicator(string2) ? String(indentPerLevel) : "";
-    const clip = string2[string2.length - 1] === "\n";
-    return indentIndicator + (clip && (string2[string2.length - 2] === "\n" || string2 === "\n") ? "+" : clip ? "" : "-") + "\n";
-  }
-  function dropEndingNewline(string2) {
-    return string2[string2.length - 1] === "\n" ? string2.slice(0, -1) : string2;
-  }
-  function foldString(string2, width) {
-    const lineRe = /(\n+)([^\n]*)/g;
-    let result = (function() {
-      let nextLF = string2.indexOf("\n");
-      nextLF = nextLF !== -1 ? nextLF : string2.length;
-      lineRe.lastIndex = nextLF;
-      return foldLine(string2.slice(0, nextLF), width);
-    })();
-    let prevMoreIndented = string2[0] === "\n" || string2[0] === " ";
-    let moreIndented;
-    let match2;
-    while (match2 = lineRe.exec(string2)) {
-      const prefix = match2[1];
-      const line = match2[2];
-      moreIndented = line[0] === " ";
-      result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
-      prevMoreIndented = moreIndented;
-    }
-    return result;
+  return result;
+}
+function dropEndingNewline(string2) {
+  return string2[string2.length - 1] === "\n" ? string2.slice(0, -1) : string2;
+}
+function foldBlockScalar(string2, width) {
+  const lineRe = /(\n+)([^\n]*)/g;
+  let nextLF = string2.indexOf("\n");
+  if (nextLF === -1) nextLF = string2.length;
+  lineRe.lastIndex = nextLF;
+  let result = foldLine(string2.slice(0, nextLF), width);
+  let prevMoreIndented = string2[0] === "\n" || string2[0] === " ";
+  let moreIndented;
+  let match2;
+  while (match2 = lineRe.exec(string2)) {
+    const prefix = match2[1];
+    const line = match2[2];
+    moreIndented = line[0] === " ";
+    result += prefix + (!prevMoreIndented && !moreIndented && line !== "" ? "\n" : "") + foldLine(line, width);
+    prevMoreIndented = moreIndented;
   }
-  function foldLine(line, width) {
-    if (line === "" || line[0] === " ") return line;
-    const breakRe = / [^ ]/g;
-    let match2;
-    let start = 0;
-    let end;
-    let curr = 0;
-    let next = 0;
-    let result = "";
-    while (match2 = breakRe.exec(line)) {
-      next = match2.index;
-      if (next - start > width) {
-        end = curr > start ? curr : next;
-        result += "\n" + line.slice(start, end);
-        start = end + 1;
-      }
-      curr = next;
-    }
-    result += "\n";
-    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);
-  }
-  function escapeString(string2) {
-    let result = "";
-    let char = 0;
-    for (let i = 0; i < string2.length; char >= 65536 ? i += 2 : i++) {
-      char = codePointAt(string2, i);
-      const escapeSeq = ESCAPE_SEQUENCES[char];
-      if (!escapeSeq && isPrintable(char)) {
-        result += string2[i];
-        if (char >= 65536) result += string2[i + 1];
-      } else result += escapeSeq || encodeHex(char);
+  return result;
+}
+function foldLine(line, width) {
+  if (line === "" || line[0] === " ") return line;
+  const breakRe = / [^ ]/g;
+  let match2;
+  let start = 0;
+  let end;
+  let curr = 0;
+  let next = 0;
+  let result = "";
+  while (match2 = breakRe.exec(line)) {
+    next = match2.index;
+    if (next - start > width) {
+      end = curr > start ? curr : next;
+      result += `
+${line.slice(start, end)}`;
+      start = end + 1;
+    }
+    curr = next;
+  }
+  result += "\n";
+  if (line.length - start > width && curr > start) result += `${line.slice(start, curr)}
+${line.slice(curr + 1)}`;
+  else result += line.slice(start);
+  return result.slice(1);
+}
+function escapeString(string2) {
+  let result = "";
+  let char = 0;
+  for (let i = 0; i < string2.length; char >= 65536 ? i += 2 : i++) {
+    char = codePointAt(string2, i);
+    const escapeSeq = ESCAPE_SEQUENCES[char];
+    if (escapeSeq) {
+      result += escapeSeq;
+      continue;
     }
-    return result;
-  }
-  function writeFlowSequence(state, level, object) {
-    let _result = "";
-    const _tag = state.tag;
-    for (let index2 = 0, length = object.length; index2 < length; index2 += 1) {
-      let value = object[index2];
-      if (state.replacer) value = state.replacer.call(object, String(index2), value);
-      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) {
-    let _result = "";
-    const _tag = state.tag;
-    for (let index2 = 0, length = object.length; index2 < length; index2 += 1) {
-      let value = object[index2];
-      if (state.replacer) value = state.replacer.call(object, String(index2), value);
-      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 || "[]";
-  }
-  function writeFlowMapping(state, level, object) {
-    let _result = "";
-    const _tag = state.tag;
-    const objectKeyList = Object.keys(object);
-    for (let index2 = 0, length = objectKeyList.length; index2 < length; index2 += 1) {
-      let pairBuffer = "";
-      if (_result !== "") pairBuffer += ", ";
-      if (state.condenseFlow) pairBuffer += '"';
-      const objectKey = objectKeyList[index2];
-      let objectValue = object[objectKey];
-      if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
-      if (!writeNode(state, level, objectKey, false, false)) continue;
-      if (state.dump.length > 1024) pairBuffer += "? ";
-      pairBuffer += state.dump + (state.condenseFlow ? '"' : "") + ":" + (state.condenseFlow ? "" : " ");
-      if (!writeNode(state, level, objectValue, false, false)) continue;
-      pairBuffer += state.dump;
-      _result += pairBuffer;
-    }
-    state.tag = _tag;
-    state.dump = "{" + _result + "}";
-  }
-  function writeBlockMapping(state, level, object, compact) {
-    let _result = "";
-    const _tag = state.tag;
-    const objectKeyList = Object.keys(object);
-    if (state.sortKeys === true) objectKeyList.sort();
-    else if (typeof state.sortKeys === "function") objectKeyList.sort(state.sortKeys);
-    else if (state.sortKeys) throw new YAMLException2("sortKeys must be a boolean or a function");
-    for (let index2 = 0, length = objectKeyList.length; index2 < length; index2 += 1) {
-      let pairBuffer = "";
-      if (!compact || _result !== "") pairBuffer += generateNextLine(state, level);
-      const objectKey = objectKeyList[index2];
-      let objectValue = object[objectKey];
-      if (state.replacer) objectValue = state.replacer.call(object, objectKey, objectValue);
-      if (!writeNode(state, level + 1, objectKey, true, true, true)) continue;
-      const 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;
-      if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) pairBuffer += ":";
-      else pairBuffer += ": ";
-      pairBuffer += state.dump;
-      _result += pairBuffer;
-    }
-    state.tag = _tag;
-    state.dump = _result || "{}";
-  }
-  function detectType(state, object, explicit) {
-    const typeList = explicit ? state.explicitTypes : state.implicitTypes;
-    for (let index2 = 0, length = typeList.length; index2 < length; index2 += 1) {
-      const type = typeList[index2];
-      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) {
-          const style = state.styleMap[type.tag] || type.defaultStyle;
-          let _result;
-          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 YAMLException2("!<" + type.tag + '> tag resolver accepts not "' + style + '" style');
-          state.dump = _result;
-        }
-        return true;
-      }
+    if (isPrintable(char)) {
+      result += string2[i];
+      if (char >= 65536) result += string2[i + 1];
+      continue;
     }
-    return false;
+    result += encodeNonPrintable(char);
   }
-  function writeNode(state, level, object, block, compact, iskey, isblockseq) {
-    state.tag = null;
-    state.dump = object;
-    if (!detectType(state, object, false)) detectType(state, object, true);
-    const type = _toString.call(state.dump);
-    const inblock = block;
-    if (block) block = state.flowLevel < 0 || state.flowLevel > level;
-    const objectOrArray = type === "[object Object]" || type === "[object Array]";
-    let duplicateIndex;
-    let 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 YAMLException2("unacceptable kind of an object to dump " + type);
-      }
-      if (state.tag !== null && state.tag !== "?") {
-        let 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 result;
+}
+function writeFlowSequence(state, level, node) {
+  let result = "";
+  for (let index2 = 0, length = node.items.length; index2 < length; index2 += 1) {
+    const item = writeNode(state, level, node.items[index2], {});
+    if (result !== "") result += `,${!state.flowSkipCommaSpace ? " " : ""}`;
+    result += item;
+  }
+  const pad = state.flowBracketPadding && result !== "" ? " " : "";
+  return `[${pad}${result}${pad}]`;
+}
+function writeBlockSequence(state, level, node, compact) {
+  let result = "";
+  for (let index2 = 0, length = node.items.length; index2 < length; index2 += 1) {
+    const item = writeNode(state, level + 1, node.items[index2], {
+      block: true,
+      compact: state.seqInlineFirst,
+      isblockseq: true
+    });
+    if (!compact || result !== "") result += generateNextLine(state, level);
+    if (item === "" || CHAR_LINE_FEED === item.charCodeAt(0)) result += "-";
+    else result += "- ";
+    result += item;
+  }
+  return result;
+}
+function writeFlowMapping(state, level, node) {
+  let result = "";
+  const items = sortMappingItems(state, node.items);
+  for (const { key, value } of items) {
+    let pairBuffer = "";
+    if (result !== "") pairBuffer += `,${!state.flowSkipCommaSpace ? " " : ""}`;
+    const keyText = writeNode(state, level, key, {});
+    const explicitPair = keyText.length > 1024;
+    if (explicitPair) pairBuffer += "? ";
+    else if (state.quoteFlowKeys) pairBuffer += '"';
+    const valueText = writeNode(state, level, value, {});
+    const sep7 = state.flowSkipColonSpace || valueText === "" ? "" : " ";
+    pairBuffer += `${keyText}${state.quoteFlowKeys && !explicitPair ? '"' : ""}:${sep7}${valueText}`;
+    result += pairBuffer;
+  }
+  const pad = state.flowBracketPadding && result !== "" ? " " : "";
+  return `{${pad}${result}${pad}}`;
+}
+function sortKeyValue(key) {
+  return key.kind === "scalar" ? key.value : key;
+}
+function sortMappingItems(state, items) {
+  if (!state.sortKeys) return items;
+  const copy = items.slice();
+  if (state.sortKeys === true) copy.sort((a, b) => {
+    const x = sortKeyValue(a.key);
+    const y = sortKeyValue(b.key);
+    if (x < y) return -1;
+    if (x > y) return 1;
+    return 0;
+  });
+  else {
+    const fn = state.sortKeys;
+    copy.sort((a, b) => fn(sortKeyValue(a.key), sortKeyValue(b.key)));
+  }
+  return copy;
+}
+function writeBlockMapping(state, level, node, compact) {
+  let result = "";
+  const items = sortMappingItems(state, node.items);
+  for (let index2 = 0, length = items.length; index2 < length; index2 += 1) {
+    let pairBuffer = "";
+    if (!compact || result !== "") pairBuffer += generateNextLine(state, level);
+    const { key, value } = items[index2];
+    const keyIsBlock = (key.kind === "mapping" || key.kind === "sequence") && !key.style.flow && key.items.length !== 0 || key.kind === "scalar" && (key.style.literal || key.style.folded);
+    const keyText = keyIsBlock ? writeNode(state, level + 1, key, {
+      block: true,
+      compact: true,
+      isblockseq: !cannotBeCompact(state, key, level + 1)
+    }) : writeNode(state, level + 1, key, {
+      block: true,
+      compact: true,
+      iskey: true
+    });
+    const keyHasLineBreak = key.kind === "scalar" && key.value.indexOf("\n") !== -1;
+    const explicitPair = keyIsBlock || keyHasLineBreak || keyText.length > 1024;
+    if (explicitPair) if (keyText && CHAR_LINE_FEED === keyText.charCodeAt(0)) pairBuffer += "?";
+    else pairBuffer += "? ";
+    pairBuffer += keyText;
+    if (explicitPair) pairBuffer += generateNextLine(state, level);
+    const valueText = writeNode(state, level + 1, value, {
+      block: true,
+      compact: explicitPair,
+      isblockseq: explicitPair && !cannotBeCompact(state, value, level + 1)
+    });
+    const keyIsBareProps = key.kind === "scalar" && key.value === "" && keyText !== "" && keyText.charCodeAt(keyText.length - 1) !== CHAR_SINGLE_QUOTE && keyText.charCodeAt(keyText.length - 1) !== CHAR_DOUBLE_QUOTE;
+    const keyColonSep = !explicitPair && (key.kind === "alias" || keyIsBareProps) ? " " : "";
+    if (valueText === "" || CHAR_LINE_FEED === valueText.charCodeAt(0)) pairBuffer += `${keyColonSep}:`;
+    else pairBuffer += `${keyColonSep}: `;
+    pairBuffer += valueText;
+    result += pairBuffer;
+  }
+  return result;
+}
+function cannotBeCompact(state, node, level) {
+  return node.style.tagged || node.anchor !== void 0 || state.indent < 2 && level > 0;
+}
+function writeNode(state, level, node, ctx) {
+  if (node.kind === "alias") return `*${node.anchor}`;
+  const { block = false, iskey = false, isblockseq = false } = ctx;
+  let compact = ctx.compact ?? false;
+  const hasAnchor = node.anchor !== void 0;
+  if (cannotBeCompact(state, node, level)) compact = false;
+  let body;
+  let shouldPrintTag = node.style.tagged;
+  const useBlockCollection = block && (node.kind === "mapping" || node.kind === "sequence") && !node.style.flow && node.items.length !== 0;
+  if (node.kind === "mapping") if (useBlockCollection) body = writeBlockMapping(state, level, node, compact);
+  else body = writeFlowMapping(state, level, node);
+  else if (node.kind === "sequence") if (useBlockCollection) if (state.seqNoIndent && !isblockseq && level > 0) body = writeBlockSequence(state, level - 1, node, compact);
+  else body = writeBlockSequence(state, level, node, compact);
+  else body = writeFlowSequence(state, level, node);
+  else {
+    const layout = scalarLayout(state, level);
+    const style = resolveScalarStyle(state, node, layout, iskey, block);
+    body = renderScalarStyle(node.value, style, layout);
+    shouldPrintTag = node.style.tagged || style !== STYLE_PLAIN && node.tag !== state.defaultScalarTagName;
+  }
+  if (useBlockCollection && compact && level > 0 && state.indent > 2) body = `${" ".repeat(state.indent - 2)}${body}`;
+  if (shouldPrintTag || hasAnchor) {
+    const props = [];
+    const tag = shouldPrintTag ? nodeTagShort(node) : null;
+    const anchor = hasAnchor ? `&${node.anchor}` : null;
+    if (state.tagBeforeAnchor) {
+      if (tag !== null) props.push(tag);
+      if (anchor !== null) props.push(anchor);
+    } else {
+      if (anchor !== null) props.push(anchor);
+      if (tag !== null) props.push(tag);
     }
-    return true;
+    const sep7 = body === "" || body.charCodeAt(0) === CHAR_LINE_FEED ? "" : " ";
+    body = `${props.join(" ")}${sep7}${body}`;
   }
-  function getDuplicateReferences(object, state) {
-    const objects = [];
-    const duplicatesIndexes = [];
-    inspectNode(object, objects, duplicatesIndexes);
-    const length = duplicatesIndexes.length;
-    for (let index2 = 0; index2 < length; index2 += 1) state.duplicates.push(objects[duplicatesIndexes[index2]]);
-    state.usedDuplicates = new Array(length);
-  }
-  function inspectNode(object, objects, duplicatesIndexes) {
-    if (object !== null && typeof object === "object") {
-      const index2 = objects.indexOf(object);
-      if (index2 !== -1) {
-        if (duplicatesIndexes.indexOf(index2) === -1) duplicatesIndexes.push(index2);
-      } else {
-        objects.push(object);
-        if (Array.isArray(object)) for (let i = 0, length = object.length; i < length; i += 1) inspectNode(object[i], objects, duplicatesIndexes);
-        else {
-          const objectKeyList = Object.keys(object);
-          for (let i = 0, length = objectKeyList.length; i < length; i += 1) inspectNode(object[objectKeyList[i]], objects, duplicatesIndexes);
-        }
-      }
+  return body;
+}
+function rootStartsOwnLine(node) {
+  return (node.kind === "sequence" || node.kind === "mapping") && !node.style.flow && node.items.length !== 0 && !node.style.tagged && node.anchor === void 0;
+}
+function isOpenEnded(node) {
+  let leaf = node;
+  while ((leaf.kind === "sequence" || leaf.kind === "mapping") && !leaf.style.flow && leaf.items.length !== 0) leaf = leaf.kind === "sequence" ? leaf.items[leaf.items.length - 1] : leaf.items[leaf.items.length - 1].value;
+  if (leaf.kind !== "scalar" || !(leaf.style.literal || leaf.style.folded)) return false;
+  const { value } = leaf;
+  return value.endsWith("\n\n") || value === "\n";
+}
+function writeDocumentDirectives(doc) {
+  let result = "";
+  for (const directive of doc.directives) {
+    if (directive.kind === "yaml") {
+      result += `%YAML ${directive.version}
+`;
+      continue;
     }
+    const { handle, prefix } = directive;
+    result += `%TAG ${handle} ${prefix}
+`;
   }
-  function dump2(input, options) {
-    options = options || {};
-    const state = new State(options);
-    if (!state.noRefs) getDuplicateReferences(input, state);
-    let value = input;
-    if (state.replacer) value = state.replacer.call({ "": value }, "", value);
-    if (writeNode(state, 0, value, true, true)) return state.dump + "\n";
-    return "";
+  return result;
+}
+function present(documents, options) {
+  const state = createPresenterState(options);
+  let result = "";
+  let previousEnded = false;
+  for (let index2 = 0; index2 < documents.length; index2 += 1) {
+    const doc = documents[index2];
+    const directives = writeDocumentDirectives(doc);
+    const hasDirectives = directives !== "";
+    const marker = doc.explicitStart || hasDirectives || index2 > 0 && !previousEnded;
+    result += directives;
+    if (doc.contents === null) {
+      if (marker) result += "---\n";
+    } else if (marker) {
+      const body = writeNode(state, 0, doc.contents, {
+        block: true,
+        compact: true
+      });
+      const sep7 = body === "" ? "" : hasDirectives || rootStartsOwnLine(doc.contents) ? "\n" : " ";
+      result += `---${sep7}${body}
+`;
+    } else result += writeNode(state, 0, doc.contents, {
+      block: true,
+      compact: true
+    }) + "\n";
+    previousEnded = doc.explicitEnd || doc.contents !== null && isOpenEnded(doc.contents);
+    if (previousEnded) result += "...\n";
   }
-  module2.exports.dump = dump2;
-}));
-var import_js_yaml = /* @__PURE__ */ __toESM2((/* @__PURE__ */ __commonJSMin(((exports2, module2) => {
-  var loader = require_loader();
-  var dumper = require_dumper();
-  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.");
-    };
-  }
-  module2.exports.Type = require_type();
-  module2.exports.Schema = require_schema();
-  module2.exports.FAILSAFE_SCHEMA = require_failsafe();
-  module2.exports.JSON_SCHEMA = require_json();
-  module2.exports.CORE_SCHEMA = require_core2();
-  module2.exports.DEFAULT_SCHEMA = require_default();
-  module2.exports.load = loader.load;
-  module2.exports.loadAll = loader.loadAll;
-  module2.exports.dump = dumper.dump;
-  module2.exports.YAMLException = require_exception();
-  module2.exports.types = {
-    binary: require_binary(),
-    float: require_float(),
-    map: require_map(),
-    null: require_null(),
-    pairs: require_pairs(),
-    set: require_set(),
-    timestamp: require_timestamp(),
-    bool: require_bool(),
-    int: require_int(),
-    merge: require_merge(),
-    omap: require_omap(),
-    seq: require_seq(),
-    str: require_str()
+  return result;
+}
+var DEFAULT_DUMP_SCHEMA = YAML11_SCHEMA.withTags({
+  ...intYaml11Tag,
+  resolve: (source, isExplicit, tagName) => {
+    const result = intYaml11Tag.resolve(source, isExplicit, tagName);
+    return result === NOT_RESOLVED ? intCoreTag.resolve(source, isExplicit, tagName) : result;
+  }
+}, {
+  ...floatYaml11Tag,
+  resolve: (source, isExplicit, tagName) => {
+    const result = floatYaml11Tag.resolve(source, isExplicit, tagName);
+    return result === NOT_RESOLVED ? floatCoreTag.resolve(source, isExplicit, tagName) : result;
+  }
+});
+var DEFAULT_DUMP_OPTIONS = {
+  ...DEFAULT_PRESENTER_OPTIONS,
+  schema: DEFAULT_DUMP_SCHEMA,
+  skipInvalid: false,
+  noRefs: false,
+  flowLevel: -1,
+  transform: () => {
+  }
+};
+function dump(input, options = {}) {
+  const opts = {
+    ...DEFAULT_DUMP_OPTIONS,
+    ...options
   };
-  module2.exports.safeLoad = renamed("safeLoad", "load");
-  module2.exports.safeLoadAll = renamed("safeLoadAll", "loadAll");
-  module2.exports.safeDump = renamed("safeDump", "dump");
-})))(), 1);
-var { Type, Schema, FAILSAFE_SCHEMA, JSON_SCHEMA, CORE_SCHEMA, DEFAULT_SCHEMA, load, loadAll, dump, YAMLException, types, safeLoad, safeLoadAll, safeDump } = import_js_yaml.default;
-var index_vite_proxy_tmp_default = import_js_yaml.default;
+  const documents = jsToAst(input, opts.schema, {
+    noRefs: opts.noRefs,
+    skipInvalid: opts.skipInvalid
+  });
+  if (opts.flowLevel >= 0) visit(documents, (node, ctx) => {
+    if (ctx.depth < opts.flowLevel) return;
+    node.style.flow = true;
+    return VISIT_SKIP;
+  });
+  opts.transform(documents);
+  return present(documents, {
+    ...pick(opts, Object.keys(DEFAULT_PRESENTER_OPTIONS)),
+    schema: opts.schema
+  });
+}
 
 // src/util.ts
 var semver = __toESM(require_semver2());
@@ -155054,7 +155564,7 @@ extensions:
 `;
   let data = ranges.map((range2) => {
     const filename = path15.join(checkoutPath, range2.path).replaceAll(path15.sep, "/");
-    return `      - [${dump(filename, { forceQuotes: true }).trim()}, ${range2.startLine}, ${range2.endLine}]
+    return `      - [${dump(filename, { quoteStyle: "single" }).trim()}, ${range2.startLine}, ${range2.endLine}]
 `;
   }).join("");
   if (!data) {
@@ -158547,8 +159057,8 @@ var unescape2 = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {})
 
 // node_modules/readdir-glob/node_modules/minimatch/dist/esm/ast.js
 var _a;
-var types2 = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
-var isExtglobType = (c) => types2.has(c);
+var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
+var isExtglobType = (c) => types.has(c);
 var isExtglobAST = (c) => isExtglobType(c.type);
 var adoptionMap = /* @__PURE__ */ new Map([
   ["!", ["@"]],
@@ -165000,12 +165510,12 @@ function getCredentials(logger, registrySecrets, registriesCredentials, language
     if (registryTypeForLanguage && !registryTypeForLanguage.some((t) => t === e.type)) {
       continue;
     }
-    const isPrintable = (str) => {
+    const isPrintable2 = (str) => {
       return str ? /^[\x20-\x7E]*$/.test(str) : true;
     };
     for (const key of Object.keys(e)) {
       const val = e[key];
-      if (typeof val === "string" && !isPrintable(val)) {
+      if (typeof val === "string" && !isPrintable2(val)) {
         throw new ConfigurationError(
           "Invalid credentials - fields must contain only printable characters"
         );
@@ -165941,7 +166451,7 @@ tmp/lib/tmp.js:
    *)
 
 js-yaml/dist/js-yaml.mjs:
-  (*! js-yaml 4.2.0 https://github.com/nodeca/js-yaml @license MIT *)
+  (*! js-yaml 5.0.0 https://github.com/nodeca/js-yaml @license MIT *)
 
 long/index.js:
   (**
diff --git a/src/analyze.ts b/src/analyze.ts
index 63830445d2..6a668f19ad 100644
--- a/src/analyze.ts
+++ b/src/analyze.ts
@@ -281,11 +281,11 @@ extensions:
         .join(checkoutPath, range.path)
         .replaceAll(path.sep, "/");
 
-      // Using yaml.dump() with `forceQuotes: true` ensures that all special
+      // Using yaml.dump() with `quoteStyle: "double"` ensures that all special
       // characters are escaped, and that the path is always rendered as a
       // quoted string on a single line.
       return (
-        `      - [${yaml.dump(filename, { forceQuotes: true }).trim()}, ` +
+        `      - [${yaml.dump(filename, { quoteStyle: "single" }).trim()}, ` +
         `${range.startLine}, ${range.endLine}]\n`
       );
     })

From 85bb4c647667cf4dd8f2b9df4f596794281f4478 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 23 Jun 2026 14:20:21 +0100
Subject: [PATCH 45/65] Restore `edited` trigger for `label-pr-size` workflow

---
 .github/workflows/label-pr-size.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.github/workflows/label-pr-size.yml b/.github/workflows/label-pr-size.yml
index 29f0052c13..170ccb0744 100644
--- a/.github/workflows/label-pr-size.yml
+++ b/.github/workflows/label-pr-size.yml
@@ -2,6 +2,11 @@ name: Label PR with size
 
 on:
   pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - edited
 
 permissions:
   contents: read

From b9c90effa0914d8dc2603169bce18c9bc52ad055 Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Tue, 23 Jun 2026 16:09:07 +0100
Subject: [PATCH 46/65] Pin Swift macOS checks to macOS 15 for Xcode 16

`macos-latest-xlarge` now resolves to macOS 26, which ships only Xcode 26
(Swift 6.2) and no longer includes Xcode 16. The Swift-analysing PR checks
select Xcode 16 because CodeQL CLI versions before 2.24.0 only support Swift
up to 6.1, so `xcode-select -s /Applications/Xcode_16.app` fails on macOS 26.

Pin these checks to macOS 15, where Xcode 16 is still available, so we keep
testing the full matrix of supported CodeQL versions. This also pre-empts the
`swift-custom-build` check failing once plain `macos`/`macos-latest` migrates.

See https://github.com/actions/runner-images/issues/14167.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../workflows/__multi-language-autodetect.yml  | 18 +++++++++---------
 .github/workflows/__swift-custom-build.yml     |  6 +++---
 pr-checks/checks/multi-language-autodetect.yml |  5 ++++-
 pr-checks/checks/swift-custom-build.yml        |  6 +++++-
 4 files changed, 21 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/__multi-language-autodetect.yml b/.github/workflows/__multi-language-autodetect.yml
index f4849b9903..c6bf1e3557 100644
--- a/.github/workflows/__multi-language-autodetect.yml
+++ b/.github/workflows/__multi-language-autodetect.yml
@@ -61,39 +61,39 @@ jobs:
         include:
           - os: ubuntu-latest
             version: stable-v2.19.4
-          - os: macos-latest-xlarge
+          - os: macos-15-xlarge
             version: stable-v2.19.4
           - os: ubuntu-latest
             version: stable-v2.20.7
-          - os: macos-latest-xlarge
+          - os: macos-15-xlarge
             version: stable-v2.20.7
           - os: ubuntu-latest
             version: stable-v2.21.4
-          - os: macos-latest-xlarge
+          - os: macos-15-xlarge
             version: stable-v2.21.4
           - os: ubuntu-latest
             version: stable-v2.22.4
-          - os: macos-latest-xlarge
+          - os: macos-15-xlarge
             version: stable-v2.22.4
           - os: ubuntu-latest
             version: stable-v2.23.9
-          - os: macos-latest-xlarge
+          - os: macos-15-xlarge
             version: stable-v2.23.9
           - os: ubuntu-latest
             version: stable-v2.24.3
-          - os: macos-latest-xlarge
+          - os: macos-15-xlarge
             version: stable-v2.24.3
           - os: ubuntu-latest
             version: default
-          - os: macos-latest-xlarge
+          - os: macos-15-xlarge
             version: default
           - os: ubuntu-latest
             version: linked
-          - os: macos-latest-xlarge
+          - os: macos-15-xlarge
             version: linked
           - os: ubuntu-latest
             version: nightly-latest
-          - os: macos-latest-xlarge
+          - os: macos-15-xlarge
             version: nightly-latest
     name: Multi-language repository
     if: github.triggering_actor != 'dependabot[bot]'
diff --git a/.github/workflows/__swift-custom-build.yml b/.github/workflows/__swift-custom-build.yml
index 83c06ffd09..f0e4c21431 100644
--- a/.github/workflows/__swift-custom-build.yml
+++ b/.github/workflows/__swift-custom-build.yml
@@ -59,11 +59,11 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: macos-latest
+          - os: macos-15
             version: linked
-          - os: macos-latest
+          - os: macos-15
             version: default
-          - os: macos-latest
+          - os: macos-15
             version: nightly-latest
     name: Swift analysis using a custom build command
     if: github.triggering_actor != 'dependabot[bot]'
diff --git a/pr-checks/checks/multi-language-autodetect.yml b/pr-checks/checks/multi-language-autodetect.yml
index fcafe5fb35..4647d1b88b 100644
--- a/pr-checks/checks/multi-language-autodetect.yml
+++ b/pr-checks/checks/multi-language-autodetect.yml
@@ -2,8 +2,11 @@ name: "Multi-language repository"
 description: "An end-to-end integration test of a multi-language repository using automatic language detection"
 operatingSystems:
   - ubuntu
+  # Pin to macOS 15 rather than `macos-latest`: the older CodeQL CLI versions in the
+  # matrix only support Swift up to 6.1 (Xcode 16), which is not available on macOS 26
+  # (ships Xcode 26 / Swift 6.2). See https://github.com/actions/runner-images/issues/14167.
   - os: macos
-    runner-image: macos-latest-xlarge
+    runner-image: macos-15-xlarge
 env:
   CODEQL_ACTION_RESOLVE_SUPPORTED_LANGUAGES_USING_CLI: true
 installGo: true
diff --git a/pr-checks/checks/swift-custom-build.yml b/pr-checks/checks/swift-custom-build.yml
index 7a07d5b7e2..0c45152643 100644
--- a/pr-checks/checks/swift-custom-build.yml
+++ b/pr-checks/checks/swift-custom-build.yml
@@ -5,7 +5,11 @@ versions:
   - default
   - nightly-latest
 operatingSystems:
-  - macos
+  # Pin to macOS 15 rather than `macos-latest`: the `linked`/`default` CodeQL CLI versions
+  # are analysed with Xcode 16, which is not available on macOS 26 (ships Xcode 26 / Swift
+  # 6.2). See https://github.com/actions/runner-images/issues/14167.
+  - os: macos
+    runner-image: macos-15
 installGo: true
 installDotNet: true
 env:

From 6feed5452f778bbb41eb90c8d921ab6b56715987 Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Tue, 23 Jun 2026 16:23:41 +0100
Subject: [PATCH 47/65] Categorize Code Quality "not enabled" upload failure as
 user-error

When a repository requests Code Quality analysis but it is not enabled,
the SARIF upload to `PUT /repos/:owner/:repo/code-quality/analysis`
returns a 403 with the message "Code quality is not enabled for this
repository...". `isEnablementError` did not recognize this wording, so
`wrapApiConfigurationError` left it as a plain Error and the analyze job
was reported with `status=failure` instead of `user-error`.

Add a `/Code Quality is not enabled/i` pattern so the error becomes a
ConfigurationError and `getActionsStatus` categorizes it as `user-error`.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 lib/entry-points.js    | 3 ++-
 src/api-client.test.ts | 1 +
 src/api-client.ts      | 1 +
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 11a8c4c291..b0a8477b2c 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -149561,7 +149561,8 @@ function isEnablementError(msg) {
   return [
     /Code Security must be enabled/i,
     /Advanced Security must be enabled/i,
-    /Code Scanning is not enabled/i
+    /Code Scanning is not enabled/i,
+    /Code Quality is not enabled/i
   ].some((pattern) => pattern.test(msg));
 }
 function getFeatureEnablementError(message) {
diff --git a/src/api-client.test.ts b/src/api-client.test.ts
index f8846e7682..29cad338f7 100644
--- a/src/api-client.test.ts
+++ b/src/api-client.test.ts
@@ -181,6 +181,7 @@ test.serial(
       "Code Security must be enabled for this repository to use code scanning",
       "Advanced Security must be enabled for this repository to use code scanning",
       "Code Scanning is not enabled for this repository. Please enable code scanning in the repository settings.",
+      "Code quality is not enabled for this repository. Please enable code quality in the repository settings.",
     ];
     const transforms = [
       (msg: string) => msg,
diff --git a/src/api-client.ts b/src/api-client.ts
index 4a061d4828..333280f8e7 100644
--- a/src/api-client.ts
+++ b/src/api-client.ts
@@ -311,6 +311,7 @@ function isEnablementError(msg: string) {
     /Code Security must be enabled/i,
     /Advanced Security must be enabled/i,
     /Code Scanning is not enabled/i,
+    /Code Quality is not enabled/i,
   ].some((pattern) => pattern.test(msg));
 }
 

From e054b4b84862b154147f7b1f94e655296834a5c6 Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Tue, 23 Jun 2026 16:39:54 +0100
Subject: [PATCH 48/65] Address review: split macOS Swift checks by CodeQL
 version

Rather than pinning every macOS job to macOS 15, only run the older CodeQL CLI
versions (which need Xcode 16, and so macOS 15) there. Newer versions, which
support Swift 6.2, run on the latest macOS runner with its default Xcode, so we
keep exercising the common latest-CLI-on-latest-runner combination.

To express this, `sync.ts` now supports an optional per-OS-entry
`codeql-versions` filter, used by `multi-language-autodetect` to send old
versions to `macos-15-xlarge` and new versions to `macos-latest-xlarge`.

`swift-custom-build` only runs `linked`/`default`/`nightly`, which all support
Swift 6.2, so it no longer needs the Xcode 16 step or a macOS 15 pin.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../workflows/__multi-language-autodetect.yml | 11 ++++----
 .github/workflows/__swift-custom-build.yml    |  9 +++----
 .../checks/multi-language-autodetect.yml      | 25 ++++++++++++++++---
 pr-checks/checks/swift-custom-build.yml       |  9 +------
 pr-checks/sync.ts                             | 15 +++++++++++
 5 files changed, 46 insertions(+), 23 deletions(-)

diff --git a/.github/workflows/__multi-language-autodetect.yml b/.github/workflows/__multi-language-autodetect.yml
index c6bf1e3557..ea97041651 100644
--- a/.github/workflows/__multi-language-autodetect.yml
+++ b/.github/workflows/__multi-language-autodetect.yml
@@ -81,19 +81,19 @@ jobs:
             version: stable-v2.23.9
           - os: ubuntu-latest
             version: stable-v2.24.3
-          - os: macos-15-xlarge
+          - os: macos-latest-xlarge
             version: stable-v2.24.3
           - os: ubuntu-latest
             version: default
-          - os: macos-15-xlarge
+          - os: macos-latest-xlarge
             version: default
           - os: ubuntu-latest
             version: linked
-          - os: macos-15-xlarge
+          - os: macos-latest-xlarge
             version: linked
           - os: ubuntu-latest
             version: nightly-latest
-          - os: macos-15-xlarge
+          - os: macos-latest-xlarge
             version: nightly-latest
     name: Multi-language repository
     if: github.triggering_actor != 'dependabot[bot]'
@@ -130,7 +130,8 @@ jobs:
           python-version: '3.13'
 
       - name: Use Xcode 16
-        if: runner.os == 'macOS' && matrix.version != 'nightly-latest'
+        # Only the older CodeQL CLI versions need Xcode 16, and these run on macOS 15.
+        if: matrix.os == 'macos-15-xlarge'
         run: sudo xcode-select -s "/Applications/Xcode_16.app"
 
       - uses: ./../action/init
diff --git a/.github/workflows/__swift-custom-build.yml b/.github/workflows/__swift-custom-build.yml
index f0e4c21431..23db3651b6 100644
--- a/.github/workflows/__swift-custom-build.yml
+++ b/.github/workflows/__swift-custom-build.yml
@@ -59,11 +59,11 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - os: macos-15
+          - os: macos-latest
             version: linked
-          - os: macos-15
+          - os: macos-latest
             version: default
-          - os: macos-15
+          - os: macos-latest
             version: nightly-latest
     name: Swift analysis using a custom build command
     if: github.triggering_actor != 'dependabot[bot]'
@@ -91,9 +91,6 @@ jobs:
           version: ${{ matrix.version }}
           use-all-platform-bundle: 'false'
           setup-kotlin: 'true'
-      - name: Use Xcode 16
-        if: runner.os == 'macOS' && matrix.version != 'nightly-latest'
-        run: sudo xcode-select -s "/Applications/Xcode_16.app"
       - uses: ./../action/init
         id: init
         with:
diff --git a/pr-checks/checks/multi-language-autodetect.yml b/pr-checks/checks/multi-language-autodetect.yml
index 4647d1b88b..263dd9bc02 100644
--- a/pr-checks/checks/multi-language-autodetect.yml
+++ b/pr-checks/checks/multi-language-autodetect.yml
@@ -2,11 +2,27 @@ name: "Multi-language repository"
 description: "An end-to-end integration test of a multi-language repository using automatic language detection"
 operatingSystems:
   - ubuntu
-  # Pin to macOS 15 rather than `macos-latest`: the older CodeQL CLI versions in the
-  # matrix only support Swift up to 6.1 (Xcode 16), which is not available on macOS 26
-  # (ships Xcode 26 / Swift 6.2). See https://github.com/actions/runner-images/issues/14167.
+  # Newer CodeQL CLI versions support Swift 6.2, so analyse Swift on the latest macOS runner
+  # (currently macOS 26) with its default Xcode. This exercises the common combination of a
+  # recent CLI on a recent runner.
+  - os: macos
+    runner-image: macos-latest-xlarge
+    codeql-versions:
+      - stable-v2.24.3
+      - default
+      - linked
+      - nightly-latest
+  # Older CodeQL CLI versions only support Swift up to 6.1, which requires Xcode 16. That is
+  # not available on macOS 26, so run these versions on macOS 15 where we select Xcode 16
+  # below. See https://github.com/actions/runner-images/issues/14167.
   - os: macos
     runner-image: macos-15-xlarge
+    codeql-versions:
+      - stable-v2.19.4
+      - stable-v2.20.7
+      - stable-v2.21.4
+      - stable-v2.22.4
+      - stable-v2.23.9
 env:
   CODEQL_ACTION_RESOLVE_SUPPORTED_LANGUAGES_USING_CLI: true
 installGo: true
@@ -21,7 +37,8 @@ steps:
       python-version: "3.13"
 
   - name: Use Xcode 16
-    if: runner.os == 'macOS' && matrix.version != 'nightly-latest'
+    # Only the older CodeQL CLI versions need Xcode 16, and these run on macOS 15.
+    if: matrix.os == 'macos-15-xlarge'
     run: sudo xcode-select -s "/Applications/Xcode_16.app"
 
   - uses: ./../action/init
diff --git a/pr-checks/checks/swift-custom-build.yml b/pr-checks/checks/swift-custom-build.yml
index 0c45152643..a2d04421b8 100644
--- a/pr-checks/checks/swift-custom-build.yml
+++ b/pr-checks/checks/swift-custom-build.yml
@@ -5,19 +5,12 @@ versions:
   - default
   - nightly-latest
 operatingSystems:
-  # Pin to macOS 15 rather than `macos-latest`: the `linked`/`default` CodeQL CLI versions
-  # are analysed with Xcode 16, which is not available on macOS 26 (ships Xcode 26 / Swift
-  # 6.2). See https://github.com/actions/runner-images/issues/14167.
-  - os: macos
-    runner-image: macos-15
+  - macos
 installGo: true
 installDotNet: true
 env:
   DOTNET_GENERATE_ASPNET_CERTIFICATE: "false"
 steps:
-  - name: Use Xcode 16
-    if: runner.os == 'macOS' && matrix.version != 'nightly-latest'
-    run: sudo xcode-select -s "/Applications/Xcode_16.app"
   - uses: ./../action/init
     id: init
     with:
diff --git a/pr-checks/sync.ts b/pr-checks/sync.ts
index b969fcb937..0ee33e4f2d 100755
--- a/pr-checks/sync.ts
+++ b/pr-checks/sync.ts
@@ -54,6 +54,12 @@ type OperatingSystem =
       os: OperatingSystemIdentifier;
       /** Optional runner image label. */
       "runner-image"?: string;
+      /**
+       * Optional CodeQL versions to run on this entry. If specified, only these versions are
+       * tested on this runner image. This allows running different runner images for different
+       * CodeQL versions of the same OS.
+       */
+      "codeql-versions"?: string[];
     };
 
 /**
@@ -379,6 +385,15 @@ function generateJobMatrix(
         continue;
       }
 
+      // If this OS entry restricts itself to specific CodeQL versions, skip other versions.
+      const entryVersions =
+        typeof operatingSystemConfig === "string"
+          ? undefined
+          : operatingSystemConfig["codeql-versions"];
+      if (entryVersions && !entryVersions.includes(version)) {
+        continue;
+      }
+
       const runnerImagesForOs =
         typeof operatingSystemConfig === "string" ||
         operatingSystemConfig["runner-image"] === undefined

From cdcf50882b8559fbd061ffb6170b070a1d2e34bf Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Tue, 23 Jun 2026 17:33:14 +0100
Subject: [PATCH 49/65] Default macOS PR checks to latest runner, pin only old
 CLIs to macOS 15

Redesign the per-entry codeql-versions filter so an OS entry without a
version list catches all versions not claimed by its siblings. This lets
new CodeQL versions flow to macos-latest-xlarge automatically. Move
v2.23.9 (which supports Swift 6.2) off the macOS 15 list and simplify the
matrix filter logic.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../workflows/__multi-language-autodetect.yml |  2 +-
 .../checks/multi-language-autodetect.yml      |  9 -----
 pr-checks/sync.ts                             | 38 ++++++++++++++++---
 3 files changed, 33 insertions(+), 16 deletions(-)

diff --git a/.github/workflows/__multi-language-autodetect.yml b/.github/workflows/__multi-language-autodetect.yml
index ea97041651..4c75f5e5d5 100644
--- a/.github/workflows/__multi-language-autodetect.yml
+++ b/.github/workflows/__multi-language-autodetect.yml
@@ -77,7 +77,7 @@ jobs:
             version: stable-v2.22.4
           - os: ubuntu-latest
             version: stable-v2.23.9
-          - os: macos-15-xlarge
+          - os: macos-latest-xlarge
             version: stable-v2.23.9
           - os: ubuntu-latest
             version: stable-v2.24.3
diff --git a/pr-checks/checks/multi-language-autodetect.yml b/pr-checks/checks/multi-language-autodetect.yml
index 263dd9bc02..1608fcc6b7 100644
--- a/pr-checks/checks/multi-language-autodetect.yml
+++ b/pr-checks/checks/multi-language-autodetect.yml
@@ -2,16 +2,8 @@ name: "Multi-language repository"
 description: "An end-to-end integration test of a multi-language repository using automatic language detection"
 operatingSystems:
   - ubuntu
-  # Newer CodeQL CLI versions support Swift 6.2, so analyse Swift on the latest macOS runner
-  # (currently macOS 26) with its default Xcode. This exercises the common combination of a
-  # recent CLI on a recent runner.
   - os: macos
     runner-image: macos-latest-xlarge
-    codeql-versions:
-      - stable-v2.24.3
-      - default
-      - linked
-      - nightly-latest
   # Older CodeQL CLI versions only support Swift up to 6.1, which requires Xcode 16. That is
   # not available on macOS 26, so run these versions on macOS 15 where we select Xcode 16
   # below. See https://github.com/actions/runner-images/issues/14167.
@@ -22,7 +14,6 @@ operatingSystems:
       - stable-v2.20.7
       - stable-v2.21.4
       - stable-v2.22.4
-      - stable-v2.23.9
 env:
   CODEQL_ACTION_RESOLVE_SUPPORTED_LANGUAGES_USING_CLI: true
 installGo: true
diff --git a/pr-checks/sync.ts b/pr-checks/sync.ts
index 0ee33e4f2d..035f5b34de 100755
--- a/pr-checks/sync.ts
+++ b/pr-checks/sync.ts
@@ -55,9 +55,10 @@ type OperatingSystem =
       /** Optional runner image label. */
       "runner-image"?: string;
       /**
-       * Optional CodeQL versions to run on this entry. If specified, only these versions are
-       * tested on this runner image. This allows running different runner images for different
-       * CodeQL versions of the same OS.
+       * Optional CodeQL versions to run on this entry. If specified, this entry runs only these
+       * versions. A sibling entry for the same OS that omits `codeql-versions` runs all versions
+       * not claimed by any sibling entry. This allows pinning specific CodeQL versions to a
+       * particular runner image while letting the remaining versions default to another.
        */
       "codeql-versions"?: string[];
     };
@@ -358,6 +359,28 @@ function generateJobMatrix(
 ): Array<Record<string, any>> {
   let matrix: Array<Record<string, any>> = [];
 
+  const operatingSystems = checkSpecification.operatingSystems ?? ["ubuntu"];
+
+  // For each OS, collect the CodeQL versions explicitly claimed by entries that specify
+  // `codeql-versions`. A sibling entry for the same OS that omits `codeql-versions` runs all
+  // versions not in this set.
+  const claimedVersionsByOs = new Map<string, Set<string>>();
+  for (const operatingSystemConfig of operatingSystems) {
+    if (typeof operatingSystemConfig === "string") {
+      continue;
+    }
+    const entryVersions = operatingSystemConfig["codeql-versions"];
+    if (!entryVersions) {
+      continue;
+    }
+    const claimed =
+      claimedVersionsByOs.get(operatingSystemConfig.os) ?? new Set<string>();
+    for (const entryVersion of entryVersions) {
+      claimed.add(entryVersion);
+    }
+    claimedVersionsByOs.set(operatingSystemConfig.os, claimed);
+  }
+
   for (const version of checkSpecification.versions ?? defaultTestVersions) {
     if (version === "latest") {
       throw new Error(
@@ -370,7 +393,6 @@ function generateJobMatrix(
       "macos-latest",
       "windows-latest",
     ];
-    const operatingSystems = checkSpecification.operatingSystems ?? ["ubuntu"];
 
     for (const operatingSystemConfig of operatingSystems) {
       const operatingSystem =
@@ -385,12 +407,16 @@ function generateJobMatrix(
         continue;
       }
 
-      // If this OS entry restricts itself to specific CodeQL versions, skip other versions.
+      // An entry that specifies `codeql-versions` runs only those versions. A sibling entry for
+      // the same OS that omits `codeql-versions` runs all versions not claimed by its siblings.
       const entryVersions =
         typeof operatingSystemConfig === "string"
           ? undefined
           : operatingSystemConfig["codeql-versions"];
-      if (entryVersions && !entryVersions.includes(version)) {
+      const runsThisVersion = entryVersions
+        ? entryVersions.includes(version)
+        : !claimedVersionsByOs.get(operatingSystem)?.has(version);
+      if (!runsThisVersion) {
         continue;
       }
 

From 423f7de04213cc572ac8dd02eb61deb2258863d6 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Tue, 23 Jun 2026 19:09:38 +0100
Subject: [PATCH 50/65] Update `glob` to at least `13.0.6`

---
 lib/entry-points.js | 9777 +++++++++++++------------------------------
 package-lock.json   |  240 +-
 package.json        |    4 +-
 3 files changed, 2867 insertions(+), 7154 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 11a8c4c291..667db35b42 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -102450,7124 +102450,3025 @@ var require_isPlainObject = __commonJS({
   }
 });
 
-// node_modules/glob/node_modules/balanced-match/dist/commonjs/index.js
-var require_commonjs18 = __commonJS({
-  "node_modules/glob/node_modules/balanced-match/dist/commonjs/index.js"(exports2) {
+// node_modules/glob/dist/commonjs/index.min.js
+var require_index_min = __commonJS({
+  "node_modules/glob/dist/commonjs/index.min.js"(exports2) {
     "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.range = exports2.balanced = void 0;
-    var balanced2 = (a, b, str) => {
-      const ma = a instanceof RegExp ? maybeMatch2(a, str) : a;
-      const mb = b instanceof RegExp ? maybeMatch2(b, str) : b;
-      const r = ma !== null && mb != null && (0, exports2.range)(ma, mb, str);
-      return r && {
-        start: r[0],
-        end: r[1],
-        pre: str.slice(0, r[0]),
-        body: str.slice(r[0] + ma.length, r[1]),
-        post: str.slice(r[1] + mb.length)
-      };
-    };
-    exports2.balanced = balanced2;
-    var maybeMatch2 = (reg, str) => {
-      const m = str.match(reg);
-      return m ? m[0] : null;
-    };
-    var range2 = (a, b, str) => {
-      let begs, beg, left, right = void 0, result;
-      let ai = str.indexOf(a);
-      let bi = str.indexOf(b, ai + 1);
-      let i = ai;
-      if (ai >= 0 && bi > 0) {
-        if (a === b) {
-          return [ai, bi];
+    var R = (n, t) => () => (t || n((t = { exports: {} }).exports, t), t.exports);
+    var Ge = R((Y) => {
+      "use strict";
+      Object.defineProperty(Y, "__esModule", { value: true });
+      Y.range = Y.balanced = void 0;
+      var Gs = (n, t, e) => {
+        let s = n instanceof RegExp ? Ie(n, e) : n, i = t instanceof RegExp ? Ie(t, e) : t, r = s !== null && i != null && (0, Y.range)(s, i, e);
+        return r && { start: r[0], end: r[1], pre: e.slice(0, r[0]), body: e.slice(r[0] + s.length, r[1]), post: e.slice(r[1] + i.length) };
+      };
+      Y.balanced = Gs;
+      var Ie = (n, t) => {
+        let e = t.match(n);
+        return e ? e[0] : null;
+      }, zs = (n, t, e) => {
+        let s, i, r, h, o, a = e.indexOf(n), l = e.indexOf(t, a + 1), f = a;
+        if (a >= 0 && l > 0) {
+          if (n === t) return [a, l];
+          for (s = [], r = e.length; f >= 0 && !o; ) {
+            if (f === a) s.push(f), a = e.indexOf(n, f + 1);
+            else if (s.length === 1) {
+              let c = s.pop();
+              c !== void 0 && (o = [c, l]);
+            } else i = s.pop(), i !== void 0 && i < r && (r = i, h = l), l = e.indexOf(t, f + 1);
+            f = a < l && a >= 0 ? a : l;
+          }
+          s.length && h !== void 0 && (o = [r, h]);
+        }
+        return o;
+      };
+      Y.range = zs;
+    });
+    var Ke = R((it) => {
+      "use strict";
+      Object.defineProperty(it, "__esModule", { value: true });
+      it.EXPANSION_MAX = void 0;
+      it.expand = ei;
+      var ze = Ge(), Ue = "\0SLASH" + Math.random() + "\0", $e = "\0OPEN" + Math.random() + "\0", ue = "\0CLOSE" + Math.random() + "\0", qe = "\0COMMA" + Math.random() + "\0", He = "\0PERIOD" + Math.random() + "\0", Us = new RegExp(Ue, "g"), $s = new RegExp($e, "g"), qs = new RegExp(ue, "g"), Hs = new RegExp(qe, "g"), Vs = new RegExp(He, "g"), Ks = /\\\\/g, Xs = /\\{/g, Ys = /\\}/g, Js = /\\,/g, Zs = /\\./g;
+      it.EXPANSION_MAX = 1e5;
+      function ce(n) {
+        return isNaN(n) ? n.charCodeAt(0) : parseInt(n, 10);
+      }
+      function Qs(n) {
+        return n.replace(Ks, Ue).replace(Xs, $e).replace(Ys, ue).replace(Js, qe).replace(Zs, He);
+      }
+      function ti(n) {
+        return n.replace(Us, "\\").replace($s, "{").replace(qs, "}").replace(Hs, ",").replace(Vs, ".");
+      }
+      function Ve(n) {
+        if (!n) return [""];
+        let t = [], e = (0, ze.balanced)("{", "}", n);
+        if (!e) return n.split(",");
+        let { pre: s, body: i, post: r } = e, h = s.split(",");
+        h[h.length - 1] += "{" + i + "}";
+        let o = Ve(r);
+        return r.length && (h[h.length - 1] += o.shift(), h.push.apply(h, o)), t.push.apply(t, h), t;
+      }
+      function ei(n, t = {}) {
+        if (!n) return [];
+        let { max: e = it.EXPANSION_MAX } = t;
+        return n.slice(0, 2) === "{}" && (n = "\\{\\}" + n.slice(2)), ht(Qs(n), e, true).map(ti);
+      }
+      function si(n) {
+        return "{" + n + "}";
+      }
+      function ii(n) {
+        return /^-?0\d/.test(n);
+      }
+      function ri(n, t) {
+        return n <= t;
+      }
+      function ni(n, t) {
+        return n >= t;
+      }
+      function ht(n, t, e) {
+        let s = [], i = (0, ze.balanced)("{", "}", n);
+        if (!i) return [n];
+        let r = i.pre, h = i.post.length ? ht(i.post, t, false) : [""];
+        if (/\$$/.test(i.pre)) for (let o = 0; o < h.length && o < t; o++) {
+          let a = r + "{" + i.body + "}" + h[o];
+          s.push(a);
         }
-        begs = [];
-        left = str.length;
-        while (i >= 0 && !result) {
-          if (i === ai) {
-            begs.push(i);
-            ai = str.indexOf(a, i + 1);
-          } else if (begs.length === 1) {
-            const r = begs.pop();
-            if (r !== void 0)
-              result = [r, bi];
+        else {
+          let o = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(i.body), a = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(i.body), l = o || a, f = i.body.indexOf(",") >= 0;
+          if (!l && !f) return i.post.match(/,(?!,).*\}/) ? (n = i.pre + "{" + i.body + ue + i.post, ht(n, t, true)) : [n];
+          let c;
+          if (l) c = i.body.split(/\.\./);
+          else if (c = Ve(i.body), c.length === 1 && c[0] !== void 0 && (c = ht(c[0], t, false).map(si), c.length === 1)) return h.map((u) => i.pre + c[0] + u);
+          let d;
+          if (l && c[0] !== void 0 && c[1] !== void 0) {
+            let u = ce(c[0]), m = ce(c[1]), p = Math.max(c[0].length, c[1].length), b = c.length === 3 && c[2] !== void 0 ? Math.abs(ce(c[2])) : 1, w = ri;
+            m < u && (b *= -1, w = ni);
+            let E = c.some(ii);
+            d = [];
+            for (let y = u; w(y, m); y += b) {
+              let S;
+              if (a) S = String.fromCharCode(y), S === "\\" && (S = "");
+              else if (S = String(y), E) {
+                let B = p - S.length;
+                if (B > 0) {
+                  let U = new Array(B + 1).join("0");
+                  y < 0 ? S = "-" + U + S.slice(1) : S = U + S;
+                }
+              }
+              d.push(S);
+            }
           } else {
-            beg = begs.pop();
-            if (beg !== void 0 && beg < left) {
-              left = beg;
-              right = bi;
+            d = [];
+            for (let u = 0; u < c.length; u++) d.push.apply(d, ht(c[u], t, false));
+          }
+          for (let u = 0; u < d.length; u++) for (let m = 0; m < h.length && s.length < t; m++) {
+            let p = r + d[u] + h[m];
+            (!e || l || p) && s.push(p);
+          }
+        }
+        return s;
+      }
+    });
+    var Xe = R((Ct) => {
+      "use strict";
+      Object.defineProperty(Ct, "__esModule", { value: true });
+      Ct.assertValidPattern = void 0;
+      var hi = 1024 * 64, oi = (n) => {
+        if (typeof n != "string") throw new TypeError("invalid pattern");
+        if (n.length > hi) throw new TypeError("pattern is too long");
+      };
+      Ct.assertValidPattern = oi;
+    });
+    var Je = R((Rt) => {
+      "use strict";
+      Object.defineProperty(Rt, "__esModule", { value: true });
+      Rt.parseClass = void 0;
+      var ai = { "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true], "[:alpha:]": ["\\p{L}\\p{Nl}", true], "[:ascii:]": ["\\x00-\\x7f", false], "[:blank:]": ["\\p{Zs}\\t", true], "[:cntrl:]": ["\\p{Cc}", true], "[:digit:]": ["\\p{Nd}", true], "[:graph:]": ["\\p{Z}\\p{C}", true, true], "[:lower:]": ["\\p{Ll}", true], "[:print:]": ["\\p{C}", true], "[:punct:]": ["\\p{P}", true], "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true], "[:upper:]": ["\\p{Lu}", true], "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true], "[:xdigit:]": ["A-Fa-f0-9", false] }, ot = (n) => n.replace(/[[\]\\-]/g, "\\$&"), li = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), Ye = (n) => n.join(""), ci = (n, t) => {
+        let e = t;
+        if (n.charAt(e) !== "[") throw new Error("not in a brace expression");
+        let s = [], i = [], r = e + 1, h = false, o = false, a = false, l = false, f = e, c = "";
+        t: for (; r < n.length; ) {
+          let p = n.charAt(r);
+          if ((p === "!" || p === "^") && r === e + 1) {
+            l = true, r++;
+            continue;
+          }
+          if (p === "]" && h && !a) {
+            f = r + 1;
+            break;
+          }
+          if (h = true, p === "\\" && !a) {
+            a = true, r++;
+            continue;
+          }
+          if (p === "[" && !a) {
+            for (let [b, [w, v, E]] of Object.entries(ai)) if (n.startsWith(b, r)) {
+              if (c) return ["$.", false, n.length - e, true];
+              r += b.length, E ? i.push(w) : s.push(w), o = o || v;
+              continue t;
             }
-            bi = str.indexOf(b, i + 1);
           }
-          i = ai < bi && ai >= 0 ? ai : bi;
+          if (a = false, c) {
+            p > c ? s.push(ot(c) + "-" + ot(p)) : p === c && s.push(ot(p)), c = "", r++;
+            continue;
+          }
+          if (n.startsWith("-]", r + 1)) {
+            s.push(ot(p + "-")), r += 2;
+            continue;
+          }
+          if (n.startsWith("-", r + 1)) {
+            c = p, r += 2;
+            continue;
+          }
+          s.push(ot(p)), r++;
         }
-        if (begs.length && right !== void 0) {
-          result = [left, right];
+        if (f < r) return ["", false, 0, false];
+        if (!s.length && !i.length) return ["$.", false, n.length - e, true];
+        if (i.length === 0 && s.length === 1 && /^\\?.$/.test(s[0]) && !l) {
+          let p = s[0].length === 2 ? s[0].slice(-1) : s[0];
+          return [li(p), false, f - e, false];
         }
-      }
-      return result;
-    };
-    exports2.range = range2;
-  }
-});
-
-// node_modules/glob/node_modules/brace-expansion/dist/commonjs/index.js
-var require_commonjs19 = __commonJS({
-  "node_modules/glob/node_modules/brace-expansion/dist/commonjs/index.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.EXPANSION_MAX = void 0;
-    exports2.expand = expand3;
-    var balanced_match_1 = require_commonjs18();
-    var escSlash2 = "\0SLASH" + Math.random() + "\0";
-    var escOpen2 = "\0OPEN" + Math.random() + "\0";
-    var escClose2 = "\0CLOSE" + Math.random() + "\0";
-    var escComma2 = "\0COMMA" + Math.random() + "\0";
-    var escPeriod2 = "\0PERIOD" + Math.random() + "\0";
-    var escSlashPattern2 = new RegExp(escSlash2, "g");
-    var escOpenPattern2 = new RegExp(escOpen2, "g");
-    var escClosePattern2 = new RegExp(escClose2, "g");
-    var escCommaPattern2 = new RegExp(escComma2, "g");
-    var escPeriodPattern2 = new RegExp(escPeriod2, "g");
-    var slashPattern2 = /\\\\/g;
-    var openPattern2 = /\\{/g;
-    var closePattern2 = /\\}/g;
-    var commaPattern2 = /\\,/g;
-    var periodPattern2 = /\\\./g;
-    exports2.EXPANSION_MAX = 1e5;
-    function numeric2(str) {
-      return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
-    }
-    function escapeBraces2(str) {
-      return str.replace(slashPattern2, escSlash2).replace(openPattern2, escOpen2).replace(closePattern2, escClose2).replace(commaPattern2, escComma2).replace(periodPattern2, escPeriod2);
-    }
-    function unescapeBraces2(str) {
-      return str.replace(escSlashPattern2, "\\").replace(escOpenPattern2, "{").replace(escClosePattern2, "}").replace(escCommaPattern2, ",").replace(escPeriodPattern2, ".");
-    }
-    function parseCommaParts2(str) {
-      if (!str) {
-        return [""];
-      }
-      const parts = [];
-      const m = (0, balanced_match_1.balanced)("{", "}", str);
-      if (!m) {
-        return str.split(",");
-      }
-      const { pre, body, post } = m;
-      const p = pre.split(",");
-      p[p.length - 1] += "{" + body + "}";
-      const postParts = parseCommaParts2(post);
-      if (post.length) {
-        ;
-        p[p.length - 1] += postParts.shift();
-        p.push.apply(p, postParts);
-      }
-      parts.push.apply(parts, p);
-      return parts;
-    }
-    function expand3(str, options = {}) {
-      if (!str) {
-        return [];
-      }
-      const { max = exports2.EXPANSION_MAX } = options;
-      if (str.slice(0, 2) === "{}") {
-        str = "\\{\\}" + str.slice(2);
-      }
-      return expand_2(escapeBraces2(str), max, true).map(unescapeBraces2);
-    }
-    function embrace2(str) {
-      return "{" + str + "}";
-    }
-    function isPadded2(el) {
-      return /^-?0\d/.test(el);
-    }
-    function lte2(i, y) {
-      return i <= y;
-    }
-    function gte7(i, y) {
-      return i >= y;
-    }
-    function expand_2(str, max, isTop) {
-      const expansions = [];
-      const m = (0, balanced_match_1.balanced)("{", "}", str);
-      if (!m)
-        return [str];
-      const pre = m.pre;
-      const post = m.post.length ? expand_2(m.post, max, false) : [""];
-      if (/\$$/.test(m.pre)) {
-        for (let k = 0; k < post.length && k < max; k++) {
-          const expansion = pre + "{" + m.body + "}" + post[k];
-          expansions.push(expansion);
+        let d = "[" + (l ? "^" : "") + Ye(s) + "]", u = "[" + (l ? "" : "^") + Ye(i) + "]";
+        return [s.length && i.length ? "(" + d + "|" + u + ")" : s.length ? d : u, o, f - e, true];
+      };
+      Rt.parseClass = ci;
+    });
+    var kt = R((At) => {
+      "use strict";
+      Object.defineProperty(At, "__esModule", { value: true });
+      At.unescape = void 0;
+      var ui = (n, { windowsPathsNoEscape: t = false, magicalBraces: e = true } = {}) => e ? t ? n.replace(/\[([^\/\\])\]/g, "$1") : n.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1") : t ? n.replace(/\[([^\/\\{}])\]/g, "$1") : n.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
+      At.unescape = ui;
+    });
+    var pe = R((Dt) => {
+      "use strict";
+      Object.defineProperty(Dt, "__esModule", { value: true });
+      Dt.AST = void 0;
+      var fi = Je(), Mt = kt(), di = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]), Ze = (n) => di.has(n), pi = "(?!(?:^|/)\\.\\.?(?:$|/))", Pt = "(?!\\.)", mi = /* @__PURE__ */ new Set(["[", "."]), gi = /* @__PURE__ */ new Set(["..", "."]), wi = new Set("().*{}+?[]^$\\!"), bi = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), de = "[^/]", Qe = de + "*?", ts = de + "+?", fe = class n {
+        type;
+        #t;
+        #s;
+        #n = false;
+        #r = [];
+        #h;
+        #S;
+        #w;
+        #c = false;
+        #o;
+        #f;
+        #u = false;
+        constructor(t, e, s = {}) {
+          this.type = t, t && (this.#s = true), this.#h = e, this.#t = this.#h ? this.#h.#t : this, this.#o = this.#t === this ? s : this.#t.#o, this.#w = this.#t === this ? [] : this.#t.#w, t === "!" && !this.#t.#c && this.#w.push(this), this.#S = this.#h ? this.#h.#r.length : 0;
+        }
+        get hasMagic() {
+          if (this.#s !== void 0) return this.#s;
+          for (let t of this.#r) if (typeof t != "string" && (t.type || t.hasMagic)) return this.#s = true;
+          return this.#s;
         }
-      } else {
-        const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-        const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-        const isSequence = isNumericSequence || isAlphaSequence;
-        const isOptions = m.body.indexOf(",") >= 0;
-        if (!isSequence && !isOptions) {
-          if (m.post.match(/,(?!,).*\}/)) {
-            str = m.pre + "{" + m.body + escClose2 + m.post;
-            return expand_2(str, max, true);
-          }
-          return [str];
+        toString() {
+          return this.#f !== void 0 ? this.#f : this.type ? this.#f = this.type + "(" + this.#r.map((t) => String(t)).join("|") + ")" : this.#f = this.#r.map((t) => String(t)).join("");
         }
-        let n;
-        if (isSequence) {
-          n = m.body.split(/\.\./);
-        } else {
-          n = parseCommaParts2(m.body);
-          if (n.length === 1 && n[0] !== void 0) {
-            n = expand_2(n[0], max, false).map(embrace2);
-            if (n.length === 1) {
-              return post.map((p) => m.pre + n[0] + p);
+        #a() {
+          if (this !== this.#t) throw new Error("should only call on root");
+          if (this.#c) return this;
+          this.toString(), this.#c = true;
+          let t;
+          for (; t = this.#w.pop(); ) {
+            if (t.type !== "!") continue;
+            let e = t, s = e.#h;
+            for (; s; ) {
+              for (let i = e.#S + 1; !s.type && i < s.#r.length; i++) for (let r of t.#r) {
+                if (typeof r == "string") throw new Error("string part in extglob AST??");
+                r.copyIn(s.#r[i]);
+              }
+              e = s, s = e.#h;
             }
           }
+          return this;
         }
-        let N;
-        if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
-          const x = numeric2(n[0]);
-          const y = numeric2(n[1]);
-          const width = Math.max(n[0].length, n[1].length);
-          let incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric2(n[2])), 1) : 1;
-          let test = lte2;
-          const reverse = y < x;
-          if (reverse) {
-            incr *= -1;
-            test = gte7;
+        push(...t) {
+          for (let e of t) if (e !== "") {
+            if (typeof e != "string" && !(e instanceof n && e.#h === this)) throw new Error("invalid part: " + e);
+            this.#r.push(e);
           }
-          const pad = n.some(isPadded2);
-          N = [];
-          for (let i = x; test(i, y) && N.length < max; i += incr) {
-            let c;
-            if (isAlphaSequence) {
-              c = String.fromCharCode(i);
-              if (c === "\\") {
-                c = "";
+        }
+        toJSON() {
+          let t = this.type === null ? this.#r.slice().map((e) => typeof e == "string" ? e : e.toJSON()) : [this.type, ...this.#r.map((e) => e.toJSON())];
+          return this.isStart() && !this.type && t.unshift([]), this.isEnd() && (this === this.#t || this.#t.#c && this.#h?.type === "!") && t.push({}), t;
+        }
+        isStart() {
+          if (this.#t === this) return true;
+          if (!this.#h?.isStart()) return false;
+          if (this.#S === 0) return true;
+          let t = this.#h;
+          for (let e = 0; e < this.#S; e++) {
+            let s = t.#r[e];
+            if (!(s instanceof n && s.type === "!")) return false;
+          }
+          return true;
+        }
+        isEnd() {
+          if (this.#t === this || this.#h?.type === "!") return true;
+          if (!this.#h?.isEnd()) return false;
+          if (!this.type) return this.#h?.isEnd();
+          let t = this.#h ? this.#h.#r.length : 0;
+          return this.#S === t - 1;
+        }
+        copyIn(t) {
+          typeof t == "string" ? this.push(t) : this.push(t.clone(this));
+        }
+        clone(t) {
+          let e = new n(this.type, t);
+          for (let s of this.#r) e.copyIn(s);
+          return e;
+        }
+        static #i(t, e, s, i) {
+          let r = false, h = false, o = -1, a = false;
+          if (e.type === null) {
+            let u = s, m = "";
+            for (; u < t.length; ) {
+              let p = t.charAt(u++);
+              if (r || p === "\\") {
+                r = !r, m += p;
+                continue;
               }
-            } else {
-              c = String(i);
-              if (pad) {
-                const need = width - c.length;
-                if (need > 0) {
-                  const z = new Array(need + 1).join("0");
-                  if (i < 0) {
-                    c = "-" + z + c.slice(1);
-                  } else {
-                    c = z + c;
-                  }
-                }
+              if (h) {
+                u === o + 1 ? (p === "^" || p === "!") && (a = true) : p === "]" && !(u === o + 2 && a) && (h = false), m += p;
+                continue;
+              } else if (p === "[") {
+                h = true, o = u, a = false, m += p;
+                continue;
+              }
+              if (!i.noext && Ze(p) && t.charAt(u) === "(") {
+                e.push(m), m = "";
+                let b = new n(p, e);
+                u = n.#i(t, b, u, i), e.push(b);
+                continue;
               }
+              m += p;
             }
-            N.push(c);
-          }
-        } else {
-          N = [];
-          for (let j = 0; j < n.length; j++) {
-            N.push.apply(N, expand_2(n[j], max, false));
+            return e.push(m), u;
           }
-        }
-        for (let j = 0; j < N.length; j++) {
-          for (let k = 0; k < post.length && expansions.length < max; k++) {
-            const expansion = pre + N[j] + post[k];
-            if (!isTop || isSequence || expansion) {
-              expansions.push(expansion);
+          let l = s + 1, f = new n(null, e), c = [], d = "";
+          for (; l < t.length; ) {
+            let u = t.charAt(l++);
+            if (r || u === "\\") {
+              r = !r, d += u;
+              continue;
             }
+            if (h) {
+              l === o + 1 ? (u === "^" || u === "!") && (a = true) : u === "]" && !(l === o + 2 && a) && (h = false), d += u;
+              continue;
+            } else if (u === "[") {
+              h = true, o = l, a = false, d += u;
+              continue;
+            }
+            if (Ze(u) && t.charAt(l) === "(") {
+              f.push(d), d = "";
+              let m = new n(u, f);
+              f.push(m), l = n.#i(t, m, l, i);
+              continue;
+            }
+            if (u === "|") {
+              f.push(d), d = "", c.push(f), f = new n(null, e);
+              continue;
+            }
+            if (u === ")") return d === "" && e.#r.length === 0 && (e.#u = true), f.push(d), d = "", e.push(...c, f), l;
+            d += u;
+          }
+          return e.type = null, e.#s = void 0, e.#r = [t.substring(s - 1)], l;
+        }
+        static fromGlob(t, e = {}) {
+          let s = new n(null, void 0, e);
+          return n.#i(t, s, 0, e), s;
+        }
+        toMMPattern() {
+          if (this !== this.#t) return this.#t.toMMPattern();
+          let t = this.toString(), [e, s, i, r] = this.toRegExpSource();
+          if (!(i || this.#s || this.#o.nocase && !this.#o.nocaseMagicOnly && t.toUpperCase() !== t.toLowerCase())) return s;
+          let o = (this.#o.nocase ? "i" : "") + (r ? "u" : "");
+          return Object.assign(new RegExp(`^${e}$`, o), { _src: e, _glob: t });
+        }
+        get options() {
+          return this.#o;
+        }
+        toRegExpSource(t) {
+          let e = t ?? !!this.#o.dot;
+          if (this.#t === this && this.#a(), !this.type) {
+            let a = this.isStart() && this.isEnd() && !this.#r.some((u) => typeof u != "string"), l = this.#r.map((u) => {
+              let [m, p, b, w] = typeof u == "string" ? n.#v(u, this.#s, a) : u.toRegExpSource(t);
+              return this.#s = this.#s || b, this.#n = this.#n || w, m;
+            }).join(""), f = "";
+            if (this.isStart() && typeof this.#r[0] == "string" && !(this.#r.length === 1 && gi.has(this.#r[0]))) {
+              let m = mi, p = e && m.has(l.charAt(0)) || l.startsWith("\\.") && m.has(l.charAt(2)) || l.startsWith("\\.\\.") && m.has(l.charAt(4)), b = !e && !t && m.has(l.charAt(0));
+              f = p ? pi : b ? Pt : "";
+            }
+            let c = "";
+            return this.isEnd() && this.#t.#c && this.#h?.type === "!" && (c = "(?:$|\\/)"), [f + l + c, (0, Mt.unescape)(l), this.#s = !!this.#s, this.#n];
+          }
+          let s = this.type === "*" || this.type === "+", i = this.type === "!" ? "(?:(?!(?:" : "(?:", r = this.#d(e);
+          if (this.isStart() && this.isEnd() && !r && this.type !== "!") {
+            let a = this.toString();
+            return this.#r = [a], this.type = null, this.#s = void 0, [a, (0, Mt.unescape)(this.toString()), false, false];
+          }
+          let h = !s || t || e || !Pt ? "" : this.#d(true);
+          h === r && (h = ""), h && (r = `(?:${r})(?:${h})*?`);
+          let o = "";
+          if (this.type === "!" && this.#u) o = (this.isStart() && !e ? Pt : "") + ts;
+          else {
+            let a = this.type === "!" ? "))" + (this.isStart() && !e && !t ? Pt : "") + Qe + ")" : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && h ? ")" : this.type === "*" && h ? ")?" : `)${this.type}`;
+            o = i + r + a;
+          }
+          return [o, (0, Mt.unescape)(r), this.#s = !!this.#s, this.#n];
+        }
+        #d(t) {
+          return this.#r.map((e) => {
+            if (typeof e == "string") throw new Error("string type in extglob ast??");
+            let [s, i, r, h] = e.toRegExpSource(t);
+            return this.#n = this.#n || h, s;
+          }).filter((e) => !(this.isStart() && this.isEnd()) || !!e).join("|");
+        }
+        static #v(t, e, s = false) {
+          let i = false, r = "", h = false, o = false;
+          for (let a = 0; a < t.length; a++) {
+            let l = t.charAt(a);
+            if (i) {
+              i = false, r += (wi.has(l) ? "\\" : "") + l;
+              continue;
+            }
+            if (l === "*") {
+              if (o) continue;
+              o = true, r += s && /^[*]+$/.test(t) ? ts : Qe, e = true;
+              continue;
+            } else o = false;
+            if (l === "\\") {
+              a === t.length - 1 ? r += "\\\\" : i = true;
+              continue;
+            }
+            if (l === "[") {
+              let [f, c, d, u] = (0, fi.parseClass)(t, a);
+              if (d) {
+                r += f, h = h || c, a += d - 1, e = e || u;
+                continue;
+              }
+            }
+            if (l === "?") {
+              r += de, e = true;
+              continue;
+            }
+            r += bi(l);
           }
+          return [r, (0, Mt.unescape)(t), !!e, h];
         }
-      }
-      return expansions;
-    }
-  }
-});
-
-// node_modules/glob/node_modules/minimatch/dist/commonjs/assert-valid-pattern.js
-var require_assert_valid_pattern = __commonJS({
-  "node_modules/glob/node_modules/minimatch/dist/commonjs/assert-valid-pattern.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.assertValidPattern = void 0;
-    var MAX_PATTERN_LENGTH2 = 1024 * 64;
-    var assertValidPattern2 = (pattern) => {
-      if (typeof pattern !== "string") {
-        throw new TypeError("invalid pattern");
-      }
-      if (pattern.length > MAX_PATTERN_LENGTH2) {
-        throw new TypeError("pattern is too long");
-      }
-    };
-    exports2.assertValidPattern = assertValidPattern2;
-  }
-});
-
-// node_modules/glob/node_modules/minimatch/dist/commonjs/brace-expressions.js
-var require_brace_expressions = __commonJS({
-  "node_modules/glob/node_modules/minimatch/dist/commonjs/brace-expressions.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.parseClass = void 0;
-    var posixClasses2 = {
-      "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
-      "[:alpha:]": ["\\p{L}\\p{Nl}", true],
-      "[:ascii:]": ["\\x00-\\x7f", false],
-      "[:blank:]": ["\\p{Zs}\\t", true],
-      "[:cntrl:]": ["\\p{Cc}", true],
-      "[:digit:]": ["\\p{Nd}", true],
-      "[:graph:]": ["\\p{Z}\\p{C}", true, true],
-      "[:lower:]": ["\\p{Ll}", true],
-      "[:print:]": ["\\p{C}", true],
-      "[:punct:]": ["\\p{P}", true],
-      "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
-      "[:upper:]": ["\\p{Lu}", true],
-      "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
-      "[:xdigit:]": ["A-Fa-f0-9", false]
-    };
-    var braceEscape2 = (s) => s.replace(/[[\]\\-]/g, "\\$&");
-    var regexpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-    var rangesToString2 = (ranges) => ranges.join("");
-    var parseClass2 = (glob2, position) => {
-      const pos = position;
-      if (glob2.charAt(pos) !== "[") {
-        throw new Error("not in a brace expression");
-      }
-      const ranges = [];
-      const negs = [];
-      let i = pos + 1;
-      let sawStart = false;
-      let uflag = false;
-      let escaping = false;
-      let negate2 = false;
-      let endPos = pos;
-      let rangeStart = "";
-      WHILE: while (i < glob2.length) {
-        const c = glob2.charAt(i);
-        if ((c === "!" || c === "^") && i === pos + 1) {
-          negate2 = true;
-          i++;
-          continue;
+      };
+      Dt.AST = fe;
+    });
+    var me = R((Ft) => {
+      "use strict";
+      Object.defineProperty(Ft, "__esModule", { value: true });
+      Ft.escape = void 0;
+      var yi = (n, { windowsPathsNoEscape: t = false, magicalBraces: e = false } = {}) => e ? t ? n.replace(/[?*()[\]{}]/g, "[$&]") : n.replace(/[?*()[\]\\{}]/g, "\\$&") : t ? n.replace(/[?*()[\]]/g, "[$&]") : n.replace(/[?*()[\]\\]/g, "\\$&");
+      Ft.escape = yi;
+    });
+    var H = R((g) => {
+      "use strict";
+      Object.defineProperty(g, "__esModule", { value: true });
+      g.unescape = g.escape = g.AST = g.Minimatch = g.match = g.makeRe = g.braceExpand = g.defaults = g.filter = g.GLOBSTAR = g.sep = g.minimatch = void 0;
+      var Si = Ke(), jt = Xe(), is = pe(), vi = me(), Ei = kt(), _i = (n, t, e = {}) => ((0, jt.assertValidPattern)(t), !e.nocomment && t.charAt(0) === "#" ? false : new J(t, e).match(n));
+      g.minimatch = _i;
+      var Oi = /^\*+([^+@!?\*\[\(]*)$/, xi = (n) => (t) => !t.startsWith(".") && t.endsWith(n), Ti = (n) => (t) => t.endsWith(n), Ci = (n) => (n = n.toLowerCase(), (t) => !t.startsWith(".") && t.toLowerCase().endsWith(n)), Ri = (n) => (n = n.toLowerCase(), (t) => t.toLowerCase().endsWith(n)), Ai = /^\*+\.\*+$/, ki = (n) => !n.startsWith(".") && n.includes("."), Mi = (n) => n !== "." && n !== ".." && n.includes("."), Pi = /^\.\*+$/, Di = (n) => n !== "." && n !== ".." && n.startsWith("."), Fi = /^\*+$/, ji = (n) => n.length !== 0 && !n.startsWith("."), Ni = (n) => n.length !== 0 && n !== "." && n !== "..", Li = /^\?+([^+@!?\*\[\(]*)?$/, Wi = ([n, t = ""]) => {
+        let e = rs([n]);
+        return t ? (t = t.toLowerCase(), (s) => e(s) && s.toLowerCase().endsWith(t)) : e;
+      }, Bi = ([n, t = ""]) => {
+        let e = ns([n]);
+        return t ? (t = t.toLowerCase(), (s) => e(s) && s.toLowerCase().endsWith(t)) : e;
+      }, Ii = ([n, t = ""]) => {
+        let e = ns([n]);
+        return t ? (s) => e(s) && s.endsWith(t) : e;
+      }, Gi = ([n, t = ""]) => {
+        let e = rs([n]);
+        return t ? (s) => e(s) && s.endsWith(t) : e;
+      }, rs = ([n]) => {
+        let t = n.length;
+        return (e) => e.length === t && !e.startsWith(".");
+      }, ns = ([n]) => {
+        let t = n.length;
+        return (e) => e.length === t && e !== "." && e !== "..";
+      }, hs = typeof process == "object" && process ? typeof process.env == "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix", es = { win32: { sep: "\\" }, posix: { sep: "/" } };
+      g.sep = hs === "win32" ? es.win32.sep : es.posix.sep;
+      g.minimatch.sep = g.sep;
+      g.GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
+      g.minimatch.GLOBSTAR = g.GLOBSTAR;
+      var zi = "[^/]", Ui = zi + "*?", $i = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?", qi = "(?:(?!(?:\\/|^)\\.).)*?", Hi = (n, t = {}) => (e) => (0, g.minimatch)(e, n, t);
+      g.filter = Hi;
+      g.minimatch.filter = g.filter;
+      var F = (n, t = {}) => Object.assign({}, n, t), Vi = (n) => {
+        if (!n || typeof n != "object" || !Object.keys(n).length) return g.minimatch;
+        let t = g.minimatch;
+        return Object.assign((s, i, r = {}) => t(s, i, F(n, r)), { Minimatch: class extends t.Minimatch {
+          constructor(i, r = {}) {
+            super(i, F(n, r));
+          }
+          static defaults(i) {
+            return t.defaults(F(n, i)).Minimatch;
+          }
+        }, AST: class extends t.AST {
+          constructor(i, r, h = {}) {
+            super(i, r, F(n, h));
+          }
+          static fromGlob(i, r = {}) {
+            return t.AST.fromGlob(i, F(n, r));
+          }
+        }, unescape: (s, i = {}) => t.unescape(s, F(n, i)), escape: (s, i = {}) => t.escape(s, F(n, i)), filter: (s, i = {}) => t.filter(s, F(n, i)), defaults: (s) => t.defaults(F(n, s)), makeRe: (s, i = {}) => t.makeRe(s, F(n, i)), braceExpand: (s, i = {}) => t.braceExpand(s, F(n, i)), match: (s, i, r = {}) => t.match(s, i, F(n, r)), sep: t.sep, GLOBSTAR: g.GLOBSTAR });
+      };
+      g.defaults = Vi;
+      g.minimatch.defaults = g.defaults;
+      var Ki = (n, t = {}) => ((0, jt.assertValidPattern)(n), t.nobrace || !/\{(?:(?!\{).)*\}/.test(n) ? [n] : (0, Si.expand)(n, { max: t.braceExpandMax }));
+      g.braceExpand = Ki;
+      g.minimatch.braceExpand = g.braceExpand;
+      var Xi = (n, t = {}) => new J(n, t).makeRe();
+      g.makeRe = Xi;
+      g.minimatch.makeRe = g.makeRe;
+      var Yi = (n, t, e = {}) => {
+        let s = new J(t, e);
+        return n = n.filter((i) => s.match(i)), s.options.nonull && !n.length && n.push(t), n;
+      };
+      g.match = Yi;
+      g.minimatch.match = g.match;
+      var ss = /[?*]|[+@!]\(.*?\)|\[|\]/, Ji = (n) => n.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&"), J = class {
+        options;
+        set;
+        pattern;
+        windowsPathsNoEscape;
+        nonegate;
+        negate;
+        comment;
+        empty;
+        preserveMultipleSlashes;
+        partial;
+        globSet;
+        globParts;
+        nocase;
+        isWindows;
+        platform;
+        windowsNoMagicRoot;
+        regexp;
+        constructor(t, e = {}) {
+          (0, jt.assertValidPattern)(t), e = e || {}, this.options = e, this.pattern = t, this.platform = e.platform || hs, this.isWindows = this.platform === "win32";
+          let s = "allowWindowsEscape";
+          this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e[s] === false, this.windowsPathsNoEscape && (this.pattern = this.pattern.replace(/\\/g, "/")), this.preserveMultipleSlashes = !!e.preserveMultipleSlashes, this.regexp = null, this.negate = false, this.nonegate = !!e.nonegate, this.comment = false, this.empty = false, this.partial = !!e.partial, this.nocase = !!this.options.nocase, this.windowsNoMagicRoot = e.windowsNoMagicRoot !== void 0 ? e.windowsNoMagicRoot : !!(this.isWindows && this.nocase), this.globSet = [], this.globParts = [], this.set = [], this.make();
+        }
+        hasMagic() {
+          if (this.options.magicalBraces && this.set.length > 1) return true;
+          for (let t of this.set) for (let e of t) if (typeof e != "string") return true;
+          return false;
         }
-        if (c === "]" && sawStart && !escaping) {
-          endPos = i + 1;
-          break;
+        debug(...t) {
         }
-        sawStart = true;
-        if (c === "\\") {
-          if (!escaping) {
-            escaping = true;
-            i++;
-            continue;
+        make() {
+          let t = this.pattern, e = this.options;
+          if (!e.nocomment && t.charAt(0) === "#") {
+            this.comment = true;
+            return;
+          }
+          if (!t) {
+            this.empty = true;
+            return;
           }
+          this.parseNegate(), this.globSet = [...new Set(this.braceExpand())], e.debug && (this.debug = (...r) => console.error(...r)), this.debug(this.pattern, this.globSet);
+          let s = this.globSet.map((r) => this.slashSplit(r));
+          this.globParts = this.preprocess(s), this.debug(this.pattern, this.globParts);
+          let i = this.globParts.map((r, h, o) => {
+            if (this.isWindows && this.windowsNoMagicRoot) {
+              let a = r[0] === "" && r[1] === "" && (r[2] === "?" || !ss.test(r[2])) && !ss.test(r[3]), l = /^[a-z]:/i.test(r[0]);
+              if (a) return [...r.slice(0, 4), ...r.slice(4).map((f) => this.parse(f))];
+              if (l) return [r[0], ...r.slice(1).map((f) => this.parse(f))];
+            }
+            return r.map((a) => this.parse(a));
+          });
+          if (this.debug(this.pattern, i), this.set = i.filter((r) => r.indexOf(false) === -1), this.isWindows) for (let r = 0; r < this.set.length; r++) {
+            let h = this.set[r];
+            h[0] === "" && h[1] === "" && this.globParts[r][2] === "?" && typeof h[3] == "string" && /^[a-z]:$/i.test(h[3]) && (h[2] = "?");
+          }
+          this.debug(this.pattern, this.set);
+        }
+        preprocess(t) {
+          if (this.options.noglobstar) for (let s = 0; s < t.length; s++) for (let i = 0; i < t[s].length; i++) t[s][i] === "**" && (t[s][i] = "*");
+          let { optimizationLevel: e = 1 } = this.options;
+          return e >= 2 ? (t = this.firstPhasePreProcess(t), t = this.secondPhasePreProcess(t)) : e >= 1 ? t = this.levelOneOptimize(t) : t = this.adjascentGlobstarOptimize(t), t;
+        }
+        adjascentGlobstarOptimize(t) {
+          return t.map((e) => {
+            let s = -1;
+            for (; (s = e.indexOf("**", s + 1)) !== -1; ) {
+              let i = s;
+              for (; e[i + 1] === "**"; ) i++;
+              i !== s && e.splice(s, i - s);
+            }
+            return e;
+          });
         }
-        if (c === "[" && !escaping) {
-          for (const [cls, [unip, u, neg]] of Object.entries(posixClasses2)) {
-            if (glob2.startsWith(cls, i)) {
-              if (rangeStart) {
-                return ["$.", false, glob2.length - pos, true];
+        levelOneOptimize(t) {
+          return t.map((e) => (e = e.reduce((s, i) => {
+            let r = s[s.length - 1];
+            return i === "**" && r === "**" ? s : i === ".." && r && r !== ".." && r !== "." && r !== "**" ? (s.pop(), s) : (s.push(i), s);
+          }, []), e.length === 0 ? [""] : e));
+        }
+        levelTwoFileOptimize(t) {
+          Array.isArray(t) || (t = this.slashSplit(t));
+          let e = false;
+          do {
+            if (e = false, !this.preserveMultipleSlashes) {
+              for (let i = 1; i < t.length - 1; i++) {
+                let r = t[i];
+                i === 1 && r === "" && t[0] === "" || (r === "." || r === "") && (e = true, t.splice(i, 1), i--);
               }
-              i += cls.length;
-              if (neg)
-                negs.push(unip);
-              else
-                ranges.push(unip);
-              uflag = uflag || u;
-              continue WHILE;
+              t[0] === "." && t.length === 2 && (t[1] === "." || t[1] === "") && (e = true, t.pop());
             }
-          }
+            let s = 0;
+            for (; (s = t.indexOf("..", s + 1)) !== -1; ) {
+              let i = t[s - 1];
+              i && i !== "." && i !== ".." && i !== "**" && (e = true, t.splice(s - 1, 2), s -= 2);
+            }
+          } while (e);
+          return t.length === 0 ? [""] : t;
         }
-        escaping = false;
-        if (rangeStart) {
-          if (c > rangeStart) {
-            ranges.push(braceEscape2(rangeStart) + "-" + braceEscape2(c));
-          } else if (c === rangeStart) {
-            ranges.push(braceEscape2(c));
-          }
-          rangeStart = "";
-          i++;
-          continue;
+        firstPhasePreProcess(t) {
+          let e = false;
+          do {
+            e = false;
+            for (let s of t) {
+              let i = -1;
+              for (; (i = s.indexOf("**", i + 1)) !== -1; ) {
+                let h = i;
+                for (; s[h + 1] === "**"; ) h++;
+                h > i && s.splice(i + 1, h - i);
+                let o = s[i + 1], a = s[i + 2], l = s[i + 3];
+                if (o !== ".." || !a || a === "." || a === ".." || !l || l === "." || l === "..") continue;
+                e = true, s.splice(i, 1);
+                let f = s.slice(0);
+                f[i] = "**", t.push(f), i--;
+              }
+              if (!this.preserveMultipleSlashes) {
+                for (let h = 1; h < s.length - 1; h++) {
+                  let o = s[h];
+                  h === 1 && o === "" && s[0] === "" || (o === "." || o === "") && (e = true, s.splice(h, 1), h--);
+                }
+                s[0] === "." && s.length === 2 && (s[1] === "." || s[1] === "") && (e = true, s.pop());
+              }
+              let r = 0;
+              for (; (r = s.indexOf("..", r + 1)) !== -1; ) {
+                let h = s[r - 1];
+                if (h && h !== "." && h !== ".." && h !== "**") {
+                  e = true;
+                  let a = r === 1 && s[r + 1] === "**" ? ["."] : [];
+                  s.splice(r - 1, 2, ...a), s.length === 0 && s.push(""), r -= 2;
+                }
+              }
+            }
+          } while (e);
+          return t;
         }
-        if (glob2.startsWith("-]", i + 1)) {
-          ranges.push(braceEscape2(c + "-"));
-          i += 2;
-          continue;
+        secondPhasePreProcess(t) {
+          for (let e = 0; e < t.length - 1; e++) for (let s = e + 1; s < t.length; s++) {
+            let i = this.partsMatch(t[e], t[s], !this.preserveMultipleSlashes);
+            if (i) {
+              t[e] = [], t[s] = i;
+              break;
+            }
+          }
+          return t.filter((e) => e.length);
+        }
+        partsMatch(t, e, s = false) {
+          let i = 0, r = 0, h = [], o = "";
+          for (; i < t.length && r < e.length; ) if (t[i] === e[r]) h.push(o === "b" ? e[r] : t[i]), i++, r++;
+          else if (s && t[i] === "**" && e[r] === t[i + 1]) h.push(t[i]), i++;
+          else if (s && e[r] === "**" && t[i] === e[r + 1]) h.push(e[r]), r++;
+          else if (t[i] === "*" && e[r] && (this.options.dot || !e[r].startsWith(".")) && e[r] !== "**") {
+            if (o === "b") return false;
+            o = "a", h.push(t[i]), i++, r++;
+          } else if (e[r] === "*" && t[i] && (this.options.dot || !t[i].startsWith(".")) && t[i] !== "**") {
+            if (o === "a") return false;
+            o = "b", h.push(e[r]), i++, r++;
+          } else return false;
+          return t.length === e.length && h;
+        }
+        parseNegate() {
+          if (this.nonegate) return;
+          let t = this.pattern, e = false, s = 0;
+          for (let i = 0; i < t.length && t.charAt(i) === "!"; i++) e = !e, s++;
+          s && (this.pattern = t.slice(s)), this.negate = e;
+        }
+        matchOne(t, e, s = false) {
+          let i = this.options;
+          if (this.isWindows) {
+            let p = typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]), b = !p && t[0] === "" && t[1] === "" && t[2] === "?" && /^[a-z]:$/i.test(t[3]), w = typeof e[0] == "string" && /^[a-z]:$/i.test(e[0]), v = !w && e[0] === "" && e[1] === "" && e[2] === "?" && typeof e[3] == "string" && /^[a-z]:$/i.test(e[3]), E = b ? 3 : p ? 0 : void 0, y = v ? 3 : w ? 0 : void 0;
+            if (typeof E == "number" && typeof y == "number") {
+              let [S, B] = [t[E], e[y]];
+              S.toLowerCase() === B.toLowerCase() && (e[y] = S, y > E ? e = e.slice(y) : E > y && (t = t.slice(E)));
+            }
+          }
+          let { optimizationLevel: r = 1 } = this.options;
+          r >= 2 && (t = this.levelTwoFileOptimize(t)), this.debug("matchOne", this, { file: t, pattern: e }), this.debug("matchOne", t.length, e.length);
+          for (var h = 0, o = 0, a = t.length, l = e.length; h < a && o < l; h++, o++) {
+            this.debug("matchOne loop");
+            var f = e[o], c = t[h];
+            if (this.debug(e, f, c), f === false) return false;
+            if (f === g.GLOBSTAR) {
+              this.debug("GLOBSTAR", [e, f, c]);
+              var d = h, u = o + 1;
+              if (u === l) {
+                for (this.debug("** at the end"); h < a; h++) if (t[h] === "." || t[h] === ".." || !i.dot && t[h].charAt(0) === ".") return false;
+                return true;
+              }
+              for (; d < a; ) {
+                var m = t[d];
+                if (this.debug(`
+globstar while`, t, d, e, u, m), this.matchOne(t.slice(d), e.slice(u), s)) return this.debug("globstar found match!", d, a, m), true;
+                if (m === "." || m === ".." || !i.dot && m.charAt(0) === ".") {
+                  this.debug("dot detected!", t, d, e, u);
+                  break;
+                }
+                this.debug("globstar swallow a segment, and continue"), d++;
+              }
+              return !!(s && (this.debug(`
+>>> no match, partial?`, t, d, e, u), d === a));
+            }
+            let p;
+            if (typeof f == "string" ? (p = c === f, this.debug("string match", f, c, p)) : (p = f.test(c), this.debug("pattern match", f, c, p)), !p) return false;
+          }
+          if (h === a && o === l) return true;
+          if (h === a) return s;
+          if (o === l) return h === a - 1 && t[h] === "";
+          throw new Error("wtf?");
         }
-        if (glob2.startsWith("-", i + 1)) {
-          rangeStart = c;
-          i += 2;
-          continue;
+        braceExpand() {
+          return (0, g.braceExpand)(this.pattern, this.options);
+        }
+        parse(t) {
+          (0, jt.assertValidPattern)(t);
+          let e = this.options;
+          if (t === "**") return g.GLOBSTAR;
+          if (t === "") return "";
+          let s, i = null;
+          (s = t.match(Fi)) ? i = e.dot ? Ni : ji : (s = t.match(Oi)) ? i = (e.nocase ? e.dot ? Ri : Ci : e.dot ? Ti : xi)(s[1]) : (s = t.match(Li)) ? i = (e.nocase ? e.dot ? Bi : Wi : e.dot ? Ii : Gi)(s) : (s = t.match(Ai)) ? i = e.dot ? Mi : ki : (s = t.match(Pi)) && (i = Di);
+          let r = is.AST.fromGlob(t, this.options).toMMPattern();
+          return i && typeof r == "object" && Reflect.defineProperty(r, "test", { value: i }), r;
+        }
+        makeRe() {
+          if (this.regexp || this.regexp === false) return this.regexp;
+          let t = this.set;
+          if (!t.length) return this.regexp = false, this.regexp;
+          let e = this.options, s = e.noglobstar ? Ui : e.dot ? $i : qi, i = new Set(e.nocase ? ["i"] : []), r = t.map((a) => {
+            let l = a.map((c) => {
+              if (c instanceof RegExp) for (let d of c.flags.split("")) i.add(d);
+              return typeof c == "string" ? Ji(c) : c === g.GLOBSTAR ? g.GLOBSTAR : c._src;
+            });
+            l.forEach((c, d) => {
+              let u = l[d + 1], m = l[d - 1];
+              c !== g.GLOBSTAR || m === g.GLOBSTAR || (m === void 0 ? u !== void 0 && u !== g.GLOBSTAR ? l[d + 1] = "(?:\\/|" + s + "\\/)?" + u : l[d] = s : u === void 0 ? l[d - 1] = m + "(?:\\/|\\/" + s + ")?" : u !== g.GLOBSTAR && (l[d - 1] = m + "(?:\\/|\\/" + s + "\\/)" + u, l[d + 1] = g.GLOBSTAR));
+            });
+            let f = l.filter((c) => c !== g.GLOBSTAR);
+            if (this.partial && f.length >= 1) {
+              let c = [];
+              for (let d = 1; d <= f.length; d++) c.push(f.slice(0, d).join("/"));
+              return "(?:" + c.join("|") + ")";
+            }
+            return f.join("/");
+          }).join("|"), [h, o] = t.length > 1 ? ["(?:", ")"] : ["", ""];
+          r = "^" + h + r + o + "$", this.partial && (r = "^(?:\\/|" + h + r.slice(1, -1) + o + ")$"), this.negate && (r = "^(?!" + r + ").+$");
+          try {
+            this.regexp = new RegExp(r, [...i].join(""));
+          } catch {
+            this.regexp = false;
+          }
+          return this.regexp;
         }
-        ranges.push(braceEscape2(c));
-        i++;
-      }
-      if (endPos < i) {
-        return ["", false, 0, false];
-      }
-      if (!ranges.length && !negs.length) {
-        return ["$.", false, glob2.length - pos, true];
-      }
-      if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate2) {
-        const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
-        return [regexpEscape2(r), false, endPos - pos, false];
-      }
-      const sranges = "[" + (negate2 ? "^" : "") + rangesToString2(ranges) + "]";
-      const snegs = "[" + (negate2 ? "" : "^") + rangesToString2(negs) + "]";
-      const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
-      return [comb, uflag, endPos - pos, true];
-    };
-    exports2.parseClass = parseClass2;
-  }
-});
-
-// node_modules/glob/node_modules/minimatch/dist/commonjs/unescape.js
-var require_unescape = __commonJS({
-  "node_modules/glob/node_modules/minimatch/dist/commonjs/unescape.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.unescape = void 0;
-    var unescape3 = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
-      if (magicalBraces) {
-        return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
-      }
-      return windowsPathsNoEscape ? s.replace(/\[([^\/\\{}])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
-    };
-    exports2.unescape = unescape3;
-  }
-});
-
-// node_modules/glob/node_modules/minimatch/dist/commonjs/ast.js
-var require_ast = __commonJS({
-  "node_modules/glob/node_modules/minimatch/dist/commonjs/ast.js"(exports2) {
-    "use strict";
-    var _a2;
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.AST = void 0;
-    var brace_expressions_js_1 = require_brace_expressions();
-    var unescape_js_1 = require_unescape();
-    var types2 = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
-    var isExtglobType2 = (c) => types2.has(c);
-    var isExtglobAST2 = (c) => isExtglobType2(c.type);
-    var adoptionMap2 = /* @__PURE__ */ new Map([
-      ["!", ["@"]],
-      ["?", ["?", "@"]],
-      ["@", ["@"]],
-      ["*", ["*", "+", "?", "@"]],
-      ["+", ["+", "@"]]
-    ]);
-    var adoptionWithSpaceMap2 = /* @__PURE__ */ new Map([
-      ["!", ["?"]],
-      ["@", ["?"]],
-      ["+", ["?", "*"]]
-    ]);
-    var adoptionAnyMap2 = /* @__PURE__ */ new Map([
-      ["!", ["?", "@"]],
-      ["?", ["?", "@"]],
-      ["@", ["?", "@"]],
-      ["*", ["*", "+", "?", "@"]],
-      ["+", ["+", "@", "?", "*"]]
-    ]);
-    var usurpMap2 = /* @__PURE__ */ new Map([
-      ["!", /* @__PURE__ */ new Map([["!", "@"]])],
-      [
-        "?",
-        /* @__PURE__ */ new Map([
-          ["*", "*"],
-          ["+", "*"]
-        ])
-      ],
-      [
-        "@",
-        /* @__PURE__ */ new Map([
-          ["!", "!"],
-          ["?", "?"],
-          ["@", "@"],
-          ["*", "*"],
-          ["+", "+"]
-        ])
-      ],
-      [
-        "+",
-        /* @__PURE__ */ new Map([
-          ["?", "*"],
-          ["*", "*"]
-        ])
-      ]
-    ]);
-    var startNoTraversal2 = "(?!(?:^|/)\\.\\.?(?:$|/))";
-    var startNoDot2 = "(?!\\.)";
-    var addPatternStart2 = /* @__PURE__ */ new Set(["[", "."]);
-    var justDots2 = /* @__PURE__ */ new Set(["..", "."]);
-    var reSpecials2 = new Set("().*{}+?[]^$\\!");
-    var regExpEscape3 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-    var qmark3 = "[^/]";
-    var star3 = qmark3 + "*?";
-    var starNoEmpty2 = qmark3 + "+?";
-    var ID2 = 0;
-    var AST2 = class {
-      type;
-      #root;
-      #hasMagic;
-      #uflag = false;
-      #parts = [];
-      #parent;
-      #parentIndex;
-      #negs;
-      #filledNegs = false;
-      #options;
-      #toString;
-      // set to true if it's an extglob with no children
-      // (which really means one child of '')
-      #emptyExt = false;
-      id = ++ID2;
-      get depth() {
-        return (this.#parent?.depth ?? -1) + 1;
-      }
-      [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
-        return {
-          "@@type": "AST",
-          id: this.id,
-          type: this.type,
-          root: this.#root.id,
-          parent: this.#parent?.id,
-          depth: this.depth,
-          partsLength: this.#parts.length,
-          parts: this.#parts
-        };
-      }
-      constructor(type, parent, options = {}) {
-        this.type = type;
-        if (type)
-          this.#hasMagic = true;
-        this.#parent = parent;
-        this.#root = this.#parent ? this.#parent.#root : this;
-        this.#options = this.#root === this ? options : this.#root.#options;
-        this.#negs = this.#root === this ? [] : this.#root.#negs;
-        if (type === "!" && !this.#root.#filledNegs)
-          this.#negs.push(this);
-        this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
-      }
-      get hasMagic() {
-        if (this.#hasMagic !== void 0)
-          return this.#hasMagic;
-        for (const p of this.#parts) {
-          if (typeof p === "string")
-            continue;
-          if (p.type || p.hasMagic)
-            return this.#hasMagic = true;
-        }
-        return this.#hasMagic;
-      }
-      // reconstructs the pattern
-      toString() {
-        if (this.#toString !== void 0)
-          return this.#toString;
-        if (!this.type) {
-          return this.#toString = this.#parts.map((p) => String(p)).join("");
-        } else {
-          return this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
-        }
-      }
-      #fillNegs() {
-        if (this !== this.#root)
-          throw new Error("should only call on root");
-        if (this.#filledNegs)
-          return this;
-        this.toString();
-        this.#filledNegs = true;
-        let n;
-        while (n = this.#negs.pop()) {
-          if (n.type !== "!")
-            continue;
-          let p = n;
-          let pp = p.#parent;
-          while (pp) {
-            for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
-              for (const part of n.#parts) {
-                if (typeof part === "string") {
-                  throw new Error("string part in extglob AST??");
-                }
-                part.copyIn(pp.#parts[i]);
-              }
-            }
-            p = pp;
-            pp = p.#parent;
-          }
-        }
-        return this;
-      }
-      push(...parts) {
-        for (const p of parts) {
-          if (p === "")
-            continue;
-          if (typeof p !== "string" && !(p instanceof _a2 && p.#parent === this)) {
-            throw new Error("invalid part: " + p);
-          }
-          this.#parts.push(p);
-        }
-      }
-      toJSON() {
-        const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
-        if (this.isStart() && !this.type)
-          ret.unshift([]);
-        if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === "!")) {
-          ret.push({});
-        }
-        return ret;
-      }
-      isStart() {
-        if (this.#root === this)
-          return true;
-        if (!this.#parent?.isStart())
-          return false;
-        if (this.#parentIndex === 0)
-          return true;
-        const p = this.#parent;
-        for (let i = 0; i < this.#parentIndex; i++) {
-          const pp = p.#parts[i];
-          if (!(pp instanceof _a2 && pp.type === "!")) {
-            return false;
-          }
-        }
-        return true;
-      }
-      isEnd() {
-        if (this.#root === this)
-          return true;
-        if (this.#parent?.type === "!")
-          return true;
-        if (!this.#parent?.isEnd())
-          return false;
-        if (!this.type)
-          return this.#parent?.isEnd();
-        const pl = this.#parent ? this.#parent.#parts.length : 0;
-        return this.#parentIndex === pl - 1;
-      }
-      copyIn(part) {
-        if (typeof part === "string")
-          this.push(part);
-        else
-          this.push(part.clone(this));
-      }
-      clone(parent) {
-        const c = new _a2(this.type, parent);
-        for (const p of this.#parts) {
-          c.copyIn(p);
-        }
-        return c;
-      }
-      static #parseAST(str, ast, pos, opt, extDepth) {
-        const maxDepth = opt.maxExtglobRecursion ?? 2;
-        let escaping = false;
-        let inBrace = false;
-        let braceStart = -1;
-        let braceNeg = false;
-        if (ast.type === null) {
-          let i2 = pos;
-          let acc2 = "";
-          while (i2 < str.length) {
-            const c = str.charAt(i2++);
-            if (escaping || c === "\\") {
-              escaping = !escaping;
-              acc2 += c;
-              continue;
-            }
-            if (inBrace) {
-              if (i2 === braceStart + 1) {
-                if (c === "^" || c === "!") {
-                  braceNeg = true;
-                }
-              } else if (c === "]" && !(i2 === braceStart + 2 && braceNeg)) {
-                inBrace = false;
-              }
-              acc2 += c;
-              continue;
-            } else if (c === "[") {
-              inBrace = true;
-              braceStart = i2;
-              braceNeg = false;
-              acc2 += c;
-              continue;
-            }
-            const doRecurse = !opt.noext && isExtglobType2(c) && str.charAt(i2) === "(" && extDepth <= maxDepth;
-            if (doRecurse) {
-              ast.push(acc2);
-              acc2 = "";
-              const ext2 = new _a2(c, ast);
-              i2 = _a2.#parseAST(str, ext2, i2, opt, extDepth + 1);
-              ast.push(ext2);
-              continue;
-            }
-            acc2 += c;
-          }
-          ast.push(acc2);
-          return i2;
-        }
-        let i = pos + 1;
-        let part = new _a2(null, ast);
-        const parts = [];
-        let acc = "";
-        while (i < str.length) {
-          const c = str.charAt(i++);
-          if (escaping || c === "\\") {
-            escaping = !escaping;
-            acc += c;
-            continue;
-          }
-          if (inBrace) {
-            if (i === braceStart + 1) {
-              if (c === "^" || c === "!") {
-                braceNeg = true;
-              }
-            } else if (c === "]" && !(i === braceStart + 2 && braceNeg)) {
-              inBrace = false;
-            }
-            acc += c;
-            continue;
-          } else if (c === "[") {
-            inBrace = true;
-            braceStart = i;
-            braceNeg = false;
-            acc += c;
-            continue;
-          }
-          const doRecurse = !opt.noext && isExtglobType2(c) && str.charAt(i) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
-          (extDepth <= maxDepth || ast && ast.#canAdoptType(c));
-          if (doRecurse) {
-            const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
-            part.push(acc);
-            acc = "";
-            const ext2 = new _a2(c, part);
-            part.push(ext2);
-            i = _a2.#parseAST(str, ext2, i, opt, extDepth + depthAdd);
-            continue;
-          }
-          if (c === "|") {
-            part.push(acc);
-            acc = "";
-            parts.push(part);
-            part = new _a2(null, ast);
-            continue;
-          }
-          if (c === ")") {
-            if (acc === "" && ast.#parts.length === 0) {
-              ast.#emptyExt = true;
-            }
-            part.push(acc);
-            acc = "";
-            ast.push(...parts, part);
-            return i;
-          }
-          acc += c;
-        }
-        ast.type = null;
-        ast.#hasMagic = void 0;
-        ast.#parts = [str.substring(pos - 1)];
-        return i;
-      }
-      #canAdoptWithSpace(child) {
-        return this.#canAdopt(child, adoptionWithSpaceMap2);
-      }
-      #canAdopt(child, map = adoptionMap2) {
-        if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null) {
-          return false;
-        }
-        const gc = child.#parts[0];
-        if (!gc || typeof gc !== "object" || gc.type === null) {
-          return false;
-        }
-        return this.#canAdoptType(gc.type, map);
-      }
-      #canAdoptType(c, map = adoptionAnyMap2) {
-        return !!map.get(this.type)?.includes(c);
-      }
-      #adoptWithSpace(child, index2) {
-        const gc = child.#parts[0];
-        const blank = new _a2(null, gc, this.options);
-        blank.#parts.push("");
-        gc.push(blank);
-        this.#adopt(child, index2);
-      }
-      #adopt(child, index2) {
-        const gc = child.#parts[0];
-        this.#parts.splice(index2, 1, ...gc.#parts);
-        for (const p of gc.#parts) {
-          if (typeof p === "object")
-            p.#parent = this;
-        }
-        this.#toString = void 0;
-      }
-      #canUsurpType(c) {
-        const m = usurpMap2.get(this.type);
-        return !!m?.has(c);
-      }
-      #canUsurp(child) {
-        if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null || this.#parts.length !== 1) {
-          return false;
-        }
-        const gc = child.#parts[0];
-        if (!gc || typeof gc !== "object" || gc.type === null) {
-          return false;
-        }
-        return this.#canUsurpType(gc.type);
-      }
-      #usurp(child) {
-        const m = usurpMap2.get(this.type);
-        const gc = child.#parts[0];
-        const nt = m?.get(gc.type);
-        if (!nt)
-          return false;
-        this.#parts = gc.#parts;
-        for (const p of this.#parts) {
-          if (typeof p === "object") {
-            p.#parent = this;
-          }
-        }
-        this.type = nt;
-        this.#toString = void 0;
-        this.#emptyExt = false;
-      }
-      static fromGlob(pattern, options = {}) {
-        const ast = new _a2(null, void 0, options);
-        _a2.#parseAST(pattern, ast, 0, options, 0);
-        return ast;
-      }
-      // returns the regular expression if there's magic, or the unescaped
-      // string if not.
-      toMMPattern() {
-        if (this !== this.#root)
-          return this.#root.toMMPattern();
-        const glob2 = this.toString();
-        const [re, body, hasMagic, uflag] = this.toRegExpSource();
-        const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob2.toUpperCase() !== glob2.toLowerCase();
-        if (!anyMagic) {
-          return body;
-        }
-        const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
-        return Object.assign(new RegExp(`^${re}$`, flags), {
-          _src: re,
-          _glob: glob2
-        });
-      }
-      get options() {
-        return this.#options;
-      }
-      // returns the string match, the regexp source, whether there's magic
-      // in the regexp (so a regular expression is required) and whether or
-      // not the uflag is needed for the regular expression (for posix classes)
-      // TODO: instead of injecting the start/end at this point, just return
-      // the BODY of the regexp, along with the start/end portions suitable
-      // for binding the start/end in either a joined full-path makeRe context
-      // (where we bind to (^|/), or a standalone matchPart context (where
-      // we bind to ^, and not /).  Otherwise slashes get duped!
-      //
-      // In part-matching mode, the start is:
-      // - if not isStart: nothing
-      // - if traversal possible, but not allowed: ^(?!\.\.?$)
-      // - if dots allowed or not possible: ^
-      // - if dots possible and not allowed: ^(?!\.)
-      // end is:
-      // - if not isEnd(): nothing
-      // - else: $
-      //
-      // In full-path matching mode, we put the slash at the START of the
-      // pattern, so start is:
-      // - if first pattern: same as part-matching mode
-      // - if not isStart(): nothing
-      // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
-      // - if dots allowed or not possible: /
-      // - if dots possible and not allowed: /(?!\.)
-      // end is:
-      // - if last pattern, same as part-matching mode
-      // - else nothing
-      //
-      // Always put the (?:$|/) on negated tails, though, because that has to be
-      // there to bind the end of the negated pattern portion, and it's easier to
-      // just stick it in now rather than try to inject it later in the middle of
-      // the pattern.
-      //
-      // We can just always return the same end, and leave it up to the caller
-      // to know whether it's going to be used joined or in parts.
-      // And, if the start is adjusted slightly, can do the same there:
-      // - if not isStart: nothing
-      // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
-      // - if dots allowed or not possible: (?:/|^)
-      // - if dots possible and not allowed: (?:/|^)(?!\.)
-      //
-      // But it's better to have a simpler binding without a conditional, for
-      // performance, so probably better to return both start options.
-      //
-      // Then the caller just ignores the end if it's not the first pattern,
-      // and the start always gets applied.
-      //
-      // But that's always going to be $ if it's the ending pattern, or nothing,
-      // so the caller can just attach $ at the end of the pattern when building.
-      //
-      // So the todo is:
-      // - better detect what kind of start is needed
-      // - return both flavors of starting pattern
-      // - attach $ at the end of the pattern when creating the actual RegExp
-      //
-      // Ah, but wait, no, that all only applies to the root when the first pattern
-      // is not an extglob. If the first pattern IS an extglob, then we need all
-      // that dot prevention biz to live in the extglob portions, because eg
-      // +(*|.x*) can match .xy but not .yx.
-      //
-      // So, return the two flavors if it's #root and the first child is not an
-      // AST, otherwise leave it to the child AST to handle it, and there,
-      // use the (?:^|/) style of start binding.
-      //
-      // Even simplified further:
-      // - Since the start for a join is eg /(?!\.) and the start for a part
-      // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
-      // or start or whatever) and prepend ^ or / at the Regexp construction.
-      toRegExpSource(allowDot) {
-        const dot = allowDot ?? !!this.#options.dot;
-        if (this.#root === this) {
-          this.#flatten();
-          this.#fillNegs();
-        }
-        if (!isExtglobAST2(this)) {
-          const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s) => typeof s !== "string");
-          const src = this.#parts.map((p) => {
-            const [re, _2, hasMagic, uflag] = typeof p === "string" ? _a2.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
-            this.#hasMagic = this.#hasMagic || hasMagic;
-            this.#uflag = this.#uflag || uflag;
-            return re;
-          }).join("");
-          let start2 = "";
-          if (this.isStart()) {
-            if (typeof this.#parts[0] === "string") {
-              const dotTravAllowed = this.#parts.length === 1 && justDots2.has(this.#parts[0]);
-              if (!dotTravAllowed) {
-                const aps = addPatternStart2;
-                const needNoTrav = (
-                  // dots are allowed, and the pattern starts with [ or .
-                  dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
-                  src.startsWith("\\.") && aps.has(src.charAt(2)) || // the pattern starts with \.\., and then [ or .
-                  src.startsWith("\\.\\.") && aps.has(src.charAt(4))
-                );
-                const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
-                start2 = needNoTrav ? startNoTraversal2 : needNoDot ? startNoDot2 : "";
-              }
-            }
-          }
-          let end = "";
-          if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") {
-            end = "(?:$|\\/)";
-          }
-          const final2 = start2 + src + end;
-          return [
-            final2,
-            (0, unescape_js_1.unescape)(src),
-            this.#hasMagic = !!this.#hasMagic,
-            this.#uflag
-          ];
-        }
-        const repeated = this.type === "*" || this.type === "+";
-        const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
-        let body = this.#partsToRegExp(dot);
-        if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
-          const s = this.toString();
-          const me = this;
-          me.#parts = [s];
-          me.type = null;
-          me.#hasMagic = void 0;
-          return [s, (0, unescape_js_1.unescape)(this.toString()), false, false];
-        }
-        let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot2 ? "" : this.#partsToRegExp(true);
-        if (bodyDotAllowed === body) {
-          bodyDotAllowed = "";
-        }
-        if (bodyDotAllowed) {
-          body = `(?:${body})(?:${bodyDotAllowed})*?`;
-        }
-        let final = "";
-        if (this.type === "!" && this.#emptyExt) {
-          final = (this.isStart() && !dot ? startNoDot2 : "") + starNoEmpty2;
-        } else {
-          const close = this.type === "!" ? (
-            // !() must match something,but !(x) can match ''
-            "))" + (this.isStart() && !dot && !allowDot ? startNoDot2 : "") + star3 + ")"
-          ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
-          final = start + body + close;
-        }
-        return [
-          final,
-          (0, unescape_js_1.unescape)(body),
-          this.#hasMagic = !!this.#hasMagic,
-          this.#uflag
-        ];
-      }
-      #flatten() {
-        if (!isExtglobAST2(this)) {
-          for (const p of this.#parts) {
-            if (typeof p === "object") {
-              p.#flatten();
-            }
-          }
-        } else {
-          let iterations = 0;
-          let done = false;
-          do {
-            done = true;
-            for (let i = 0; i < this.#parts.length; i++) {
-              const c = this.#parts[i];
-              if (typeof c === "object") {
-                c.#flatten();
-                if (this.#canAdopt(c)) {
-                  done = false;
-                  this.#adopt(c, i);
-                } else if (this.#canAdoptWithSpace(c)) {
-                  done = false;
-                  this.#adoptWithSpace(c, i);
-                } else if (this.#canUsurp(c)) {
-                  done = false;
-                  this.#usurp(c);
-                }
-              }
-            }
-          } while (!done && ++iterations < 10);
-        }
-        this.#toString = void 0;
-      }
-      #partsToRegExp(dot) {
-        return this.#parts.map((p) => {
-          if (typeof p === "string") {
-            throw new Error("string type in extglob ast??");
-          }
-          const [re, _2, _hasMagic, uflag] = p.toRegExpSource(dot);
-          this.#uflag = this.#uflag || uflag;
-          return re;
-        }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
-      }
-      static #parseGlob(glob2, hasMagic, noEmpty = false) {
-        let escaping = false;
-        let re = "";
-        let uflag = false;
-        let inStar = false;
-        for (let i = 0; i < glob2.length; i++) {
-          const c = glob2.charAt(i);
-          if (escaping) {
-            escaping = false;
-            re += (reSpecials2.has(c) ? "\\" : "") + c;
-            continue;
-          }
-          if (c === "*") {
-            if (inStar)
-              continue;
-            inStar = true;
-            re += noEmpty && /^[*]+$/.test(glob2) ? starNoEmpty2 : star3;
-            hasMagic = true;
-            continue;
-          } else {
-            inStar = false;
-          }
-          if (c === "\\") {
-            if (i === glob2.length - 1) {
-              re += "\\\\";
-            } else {
-              escaping = true;
-            }
-            continue;
-          }
-          if (c === "[") {
-            const [src, needUflag, consumed, magic] = (0, brace_expressions_js_1.parseClass)(glob2, i);
-            if (consumed) {
-              re += src;
-              uflag = uflag || needUflag;
-              i += consumed - 1;
-              hasMagic = hasMagic || magic;
-              continue;
-            }
-          }
-          if (c === "?") {
-            re += qmark3;
-            hasMagic = true;
-            continue;
-          }
-          re += regExpEscape3(c);
-        }
-        return [re, (0, unescape_js_1.unescape)(glob2), !!hasMagic, uflag];
-      }
-    };
-    exports2.AST = AST2;
-    _a2 = AST2;
-  }
-});
-
-// node_modules/glob/node_modules/minimatch/dist/commonjs/escape.js
-var require_escape = __commonJS({
-  "node_modules/glob/node_modules/minimatch/dist/commonjs/escape.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.escape = void 0;
-    var escape3 = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
-      if (magicalBraces) {
-        return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
-      }
-      return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
-    };
-    exports2.escape = escape3;
-  }
-});
-
-// node_modules/glob/node_modules/minimatch/dist/commonjs/index.js
-var require_commonjs20 = __commonJS({
-  "node_modules/glob/node_modules/minimatch/dist/commonjs/index.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.unescape = exports2.escape = exports2.AST = exports2.Minimatch = exports2.match = exports2.makeRe = exports2.braceExpand = exports2.defaults = exports2.filter = exports2.GLOBSTAR = exports2.sep = exports2.minimatch = void 0;
-    var brace_expansion_1 = require_commonjs19();
-    var assert_valid_pattern_js_1 = require_assert_valid_pattern();
-    var ast_js_1 = require_ast();
-    var escape_js_1 = require_escape();
-    var unescape_js_1 = require_unescape();
-    var minimatch2 = (p, pattern, options = {}) => {
-      (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
-      if (!options.nocomment && pattern.charAt(0) === "#") {
-        return false;
-      }
-      return new Minimatch2(pattern, options).match(p);
-    };
-    exports2.minimatch = minimatch2;
-    var starDotExtRE2 = /^\*+([^+@!?\*\[\(]*)$/;
-    var starDotExtTest2 = (ext3) => (f) => !f.startsWith(".") && f.endsWith(ext3);
-    var starDotExtTestDot2 = (ext3) => (f) => f.endsWith(ext3);
-    var starDotExtTestNocase2 = (ext3) => {
-      ext3 = ext3.toLowerCase();
-      return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext3);
-    };
-    var starDotExtTestNocaseDot2 = (ext3) => {
-      ext3 = ext3.toLowerCase();
-      return (f) => f.toLowerCase().endsWith(ext3);
-    };
-    var starDotStarRE2 = /^\*+\.\*+$/;
-    var starDotStarTest2 = (f) => !f.startsWith(".") && f.includes(".");
-    var starDotStarTestDot2 = (f) => f !== "." && f !== ".." && f.includes(".");
-    var dotStarRE2 = /^\.\*+$/;
-    var dotStarTest2 = (f) => f !== "." && f !== ".." && f.startsWith(".");
-    var starRE2 = /^\*+$/;
-    var starTest2 = (f) => f.length !== 0 && !f.startsWith(".");
-    var starTestDot2 = (f) => f.length !== 0 && f !== "." && f !== "..";
-    var qmarksRE2 = /^\?+([^+@!?\*\[\(]*)?$/;
-    var qmarksTestNocase2 = ([$0, ext3 = ""]) => {
-      const noext = qmarksTestNoExt2([$0]);
-      if (!ext3)
-        return noext;
-      ext3 = ext3.toLowerCase();
-      return (f) => noext(f) && f.toLowerCase().endsWith(ext3);
-    };
-    var qmarksTestNocaseDot2 = ([$0, ext3 = ""]) => {
-      const noext = qmarksTestNoExtDot2([$0]);
-      if (!ext3)
-        return noext;
-      ext3 = ext3.toLowerCase();
-      return (f) => noext(f) && f.toLowerCase().endsWith(ext3);
-    };
-    var qmarksTestDot2 = ([$0, ext3 = ""]) => {
-      const noext = qmarksTestNoExtDot2([$0]);
-      return !ext3 ? noext : (f) => noext(f) && f.endsWith(ext3);
-    };
-    var qmarksTest2 = ([$0, ext3 = ""]) => {
-      const noext = qmarksTestNoExt2([$0]);
-      return !ext3 ? noext : (f) => noext(f) && f.endsWith(ext3);
-    };
-    var qmarksTestNoExt2 = ([$0]) => {
-      const len = $0.length;
-      return (f) => f.length === len && !f.startsWith(".");
-    };
-    var qmarksTestNoExtDot2 = ([$0]) => {
-      const len = $0.length;
-      return (f) => f.length === len && f !== "." && f !== "..";
-    };
-    var defaultPlatform2 = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-    var path29 = {
-      win32: { sep: "\\" },
-      posix: { sep: "/" }
-    };
-    exports2.sep = defaultPlatform2 === "win32" ? path29.win32.sep : path29.posix.sep;
-    exports2.minimatch.sep = exports2.sep;
-    exports2.GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
-    exports2.minimatch.GLOBSTAR = exports2.GLOBSTAR;
-    var qmark3 = "[^/]";
-    var star3 = qmark3 + "*?";
-    var twoStarDot2 = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
-    var twoStarNoDot2 = "(?:(?!(?:\\/|^)\\.).)*?";
-    var filter2 = (pattern, options = {}) => (p) => (0, exports2.minimatch)(p, pattern, options);
-    exports2.filter = filter2;
-    exports2.minimatch.filter = exports2.filter;
-    var ext2 = (a, b = {}) => Object.assign({}, a, b);
-    var defaults2 = (def) => {
-      if (!def || typeof def !== "object" || !Object.keys(def).length) {
-        return exports2.minimatch;
-      }
-      const orig = exports2.minimatch;
-      const m = (p, pattern, options = {}) => orig(p, pattern, ext2(def, options));
-      return Object.assign(m, {
-        Minimatch: class Minimatch extends orig.Minimatch {
-          constructor(pattern, options = {}) {
-            super(pattern, ext2(def, options));
-          }
-          static defaults(options) {
-            return orig.defaults(ext2(def, options)).Minimatch;
-          }
-        },
-        AST: class AST extends orig.AST {
-          /* c8 ignore start */
-          constructor(type, parent, options = {}) {
-            super(type, parent, ext2(def, options));
-          }
-          /* c8 ignore stop */
-          static fromGlob(pattern, options = {}) {
-            return orig.AST.fromGlob(pattern, ext2(def, options));
-          }
-        },
-        unescape: (s, options = {}) => orig.unescape(s, ext2(def, options)),
-        escape: (s, options = {}) => orig.escape(s, ext2(def, options)),
-        filter: (pattern, options = {}) => orig.filter(pattern, ext2(def, options)),
-        defaults: (options) => orig.defaults(ext2(def, options)),
-        makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext2(def, options)),
-        braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext2(def, options)),
-        match: (list, pattern, options = {}) => orig.match(list, pattern, ext2(def, options)),
-        sep: orig.sep,
-        GLOBSTAR: exports2.GLOBSTAR
-      });
-    };
-    exports2.defaults = defaults2;
-    exports2.minimatch.defaults = exports2.defaults;
-    var braceExpand2 = (pattern, options = {}) => {
-      (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
-      if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
-        return [pattern];
-      }
-      return (0, brace_expansion_1.expand)(pattern, { max: options.braceExpandMax });
-    };
-    exports2.braceExpand = braceExpand2;
-    exports2.minimatch.braceExpand = exports2.braceExpand;
-    var makeRe2 = (pattern, options = {}) => new Minimatch2(pattern, options).makeRe();
-    exports2.makeRe = makeRe2;
-    exports2.minimatch.makeRe = exports2.makeRe;
-    var match2 = (list, pattern, options = {}) => {
-      const mm = new Minimatch2(pattern, options);
-      list = list.filter((f) => mm.match(f));
-      if (mm.options.nonull && !list.length) {
-        list.push(pattern);
-      }
-      return list;
-    };
-    exports2.match = match2;
-    exports2.minimatch.match = exports2.match;
-    var globMagic2 = /[?*]|[+@!]\(.*?\)|\[|\]/;
-    var regExpEscape3 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
-    var Minimatch2 = class {
-      options;
-      set;
-      pattern;
-      windowsPathsNoEscape;
-      nonegate;
-      negate;
-      comment;
-      empty;
-      preserveMultipleSlashes;
-      partial;
-      globSet;
-      globParts;
-      nocase;
-      isWindows;
-      platform;
-      windowsNoMagicRoot;
-      maxGlobstarRecursion;
-      regexp;
-      constructor(pattern, options = {}) {
-        (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
-        options = options || {};
-        this.options = options;
-        this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;
-        this.pattern = pattern;
-        this.platform = options.platform || defaultPlatform2;
-        this.isWindows = this.platform === "win32";
-        const awe = "allowWindowsEscape";
-        this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options[awe] === false;
-        if (this.windowsPathsNoEscape) {
-          this.pattern = this.pattern.replace(/\\/g, "/");
-        }
-        this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
-        this.regexp = null;
-        this.negate = false;
-        this.nonegate = !!options.nonegate;
-        this.comment = false;
-        this.empty = false;
-        this.partial = !!options.partial;
-        this.nocase = !!this.options.nocase;
-        this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
-        this.globSet = [];
-        this.globParts = [];
-        this.set = [];
-        this.make();
-      }
-      hasMagic() {
-        if (this.options.magicalBraces && this.set.length > 1) {
-          return true;
-        }
-        for (const pattern of this.set) {
-          for (const part of pattern) {
-            if (typeof part !== "string")
-              return true;
-          }
-        }
-        return false;
-      }
-      debug(..._2) {
-      }
-      make() {
-        const pattern = this.pattern;
-        const options = this.options;
-        if (!options.nocomment && pattern.charAt(0) === "#") {
-          this.comment = true;
-          return;
-        }
-        if (!pattern) {
-          this.empty = true;
-          return;
-        }
-        this.parseNegate();
-        this.globSet = [...new Set(this.braceExpand())];
-        if (options.debug) {
-          this.debug = (...args) => console.error(...args);
-        }
-        this.debug(this.pattern, this.globSet);
-        const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
-        this.globParts = this.preprocess(rawGlobParts);
-        this.debug(this.pattern, this.globParts);
-        let set = this.globParts.map((s, _2, __) => {
-          if (this.isWindows && this.windowsNoMagicRoot) {
-            const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic2.test(s[2])) && !globMagic2.test(s[3]);
-            const isDrive = /^[a-z]:/i.test(s[0]);
-            if (isUNC) {
-              return [
-                ...s.slice(0, 4),
-                ...s.slice(4).map((ss) => this.parse(ss))
-              ];
-            } else if (isDrive) {
-              return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
-            }
-          }
-          return s.map((ss) => this.parse(ss));
-        });
-        this.debug(this.pattern, set);
-        this.set = set.filter((s) => s.indexOf(false) === -1);
-        if (this.isWindows) {
-          for (let i = 0; i < this.set.length; i++) {
-            const p = this.set[i];
-            if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) {
-              p[2] = "?";
-            }
-          }
-        }
-        this.debug(this.pattern, this.set);
-      }
-      // various transforms to equivalent pattern sets that are
-      // faster to process in a filesystem walk.  The goal is to
-      // eliminate what we can, and push all ** patterns as far
-      // to the right as possible, even if it increases the number
-      // of patterns that we have to process.
-      preprocess(globParts) {
-        if (this.options.noglobstar) {
-          for (let i = 0; i < globParts.length; i++) {
-            for (let j = 0; j < globParts[i].length; j++) {
-              if (globParts[i][j] === "**") {
-                globParts[i][j] = "*";
-              }
-            }
-          }
-        }
-        const { optimizationLevel = 1 } = this.options;
-        if (optimizationLevel >= 2) {
-          globParts = this.firstPhasePreProcess(globParts);
-          globParts = this.secondPhasePreProcess(globParts);
-        } else if (optimizationLevel >= 1) {
-          globParts = this.levelOneOptimize(globParts);
-        } else {
-          globParts = this.adjascentGlobstarOptimize(globParts);
-        }
-        return globParts;
-      }
-      // just get rid of adjascent ** portions
-      adjascentGlobstarOptimize(globParts) {
-        return globParts.map((parts) => {
-          let gs = -1;
-          while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
-            let i = gs;
-            while (parts[i + 1] === "**") {
-              i++;
-            }
-            if (i !== gs) {
-              parts.splice(gs, i - gs);
-            }
-          }
-          return parts;
-        });
-      }
-      // get rid of adjascent ** and resolve .. portions
-      levelOneOptimize(globParts) {
-        return globParts.map((parts) => {
-          parts = parts.reduce((set, part) => {
-            const prev = set[set.length - 1];
-            if (part === "**" && prev === "**") {
-              return set;
-            }
-            if (part === "..") {
-              if (prev && prev !== ".." && prev !== "." && prev !== "**") {
-                set.pop();
-                return set;
-              }
-            }
-            set.push(part);
-            return set;
-          }, []);
-          return parts.length === 0 ? [""] : parts;
-        });
-      }
-      levelTwoFileOptimize(parts) {
-        if (!Array.isArray(parts)) {
-          parts = this.slashSplit(parts);
-        }
-        let didSomething = false;
-        do {
-          didSomething = false;
-          if (!this.preserveMultipleSlashes) {
-            for (let i = 1; i < parts.length - 1; i++) {
-              const p = parts[i];
-              if (i === 1 && p === "" && parts[0] === "")
-                continue;
-              if (p === "." || p === "") {
-                didSomething = true;
-                parts.splice(i, 1);
-                i--;
-              }
-            }
-            if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
-              didSomething = true;
-              parts.pop();
-            }
-          }
-          let dd = 0;
-          while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
-            const p = parts[dd - 1];
-            if (p && p !== "." && p !== ".." && p !== "**") {
-              didSomething = true;
-              parts.splice(dd - 1, 2);
-              dd -= 2;
-            }
-          }
-        } while (didSomething);
-        return parts.length === 0 ? [""] : parts;
-      }
-      // First phase: single-pattern processing
-      // <pre> is 1 or more portions
-      // <rest> is 1 or more portions
-      // <p> is any portion other than ., .., '', or **
-      // <e> is . or ''
-      //
-      // **/.. is *brutal* for filesystem walking performance, because
-      // it effectively resets the recursive walk each time it occurs,
-      // and ** cannot be reduced out by a .. pattern part like a regexp
-      // or most strings (other than .., ., and '') can be.
-      //
-      // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
-      // <pre>/<e>/<rest> -> <pre>/<rest>
-      // <pre>/<p>/../<rest> -> <pre>/<rest>
-      // **/**/<rest> -> **/<rest>
-      //
-      // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
-      // this WOULD be allowed if ** did follow symlinks, or * didn't
-      firstPhasePreProcess(globParts) {
-        let didSomething = false;
-        do {
-          didSomething = false;
-          for (let parts of globParts) {
-            let gs = -1;
-            while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
-              let gss = gs;
-              while (parts[gss + 1] === "**") {
-                gss++;
-              }
-              if (gss > gs) {
-                parts.splice(gs + 1, gss - gs);
-              }
-              let next = parts[gs + 1];
-              const p = parts[gs + 2];
-              const p2 = parts[gs + 3];
-              if (next !== "..")
-                continue;
-              if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") {
-                continue;
-              }
-              didSomething = true;
-              parts.splice(gs, 1);
-              const other = parts.slice(0);
-              other[gs] = "**";
-              globParts.push(other);
-              gs--;
-            }
-            if (!this.preserveMultipleSlashes) {
-              for (let i = 1; i < parts.length - 1; i++) {
-                const p = parts[i];
-                if (i === 1 && p === "" && parts[0] === "")
-                  continue;
-                if (p === "." || p === "") {
-                  didSomething = true;
-                  parts.splice(i, 1);
-                  i--;
-                }
-              }
-              if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
-                didSomething = true;
-                parts.pop();
-              }
-            }
-            let dd = 0;
-            while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
-              const p = parts[dd - 1];
-              if (p && p !== "." && p !== ".." && p !== "**") {
-                didSomething = true;
-                const needDot = dd === 1 && parts[dd + 1] === "**";
-                const splin = needDot ? ["."] : [];
-                parts.splice(dd - 1, 2, ...splin);
-                if (parts.length === 0)
-                  parts.push("");
-                dd -= 2;
-              }
-            }
-          }
-        } while (didSomething);
-        return globParts;
-      }
-      // second phase: multi-pattern dedupes
-      // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
-      // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
-      // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
-      //
-      // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
-      // ^-- not valid because ** doens't follow symlinks
-      secondPhasePreProcess(globParts) {
-        for (let i = 0; i < globParts.length - 1; i++) {
-          for (let j = i + 1; j < globParts.length; j++) {
-            const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
-            if (matched) {
-              globParts[i] = [];
-              globParts[j] = matched;
-              break;
-            }
-          }
-        }
-        return globParts.filter((gs) => gs.length);
-      }
-      partsMatch(a, b, emptyGSMatch = false) {
-        let ai = 0;
-        let bi = 0;
-        let result = [];
-        let which9 = "";
-        while (ai < a.length && bi < b.length) {
-          if (a[ai] === b[bi]) {
-            result.push(which9 === "b" ? b[bi] : a[ai]);
-            ai++;
-            bi++;
-          } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
-            result.push(a[ai]);
-            ai++;
-          } else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
-            result.push(b[bi]);
-            bi++;
-          } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
-            if (which9 === "b")
-              return false;
-            which9 = "a";
-            result.push(a[ai]);
-            ai++;
-            bi++;
-          } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
-            if (which9 === "a")
-              return false;
-            which9 = "b";
-            result.push(b[bi]);
-            ai++;
-            bi++;
-          } else {
-            return false;
-          }
-        }
-        return a.length === b.length && result;
-      }
-      parseNegate() {
-        if (this.nonegate)
-          return;
-        const pattern = this.pattern;
-        let negate2 = false;
-        let negateOffset = 0;
-        for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
-          negate2 = !negate2;
-          negateOffset++;
-        }
-        if (negateOffset)
-          this.pattern = pattern.slice(negateOffset);
-        this.negate = negate2;
-      }
-      // set partial to true to test if, for example,
-      // "/a/b" matches the start of "/*/b/*/d"
-      // Partial means, if you run out of file before you run
-      // out of pattern, then that's fine, as long as all
-      // the parts match.
-      matchOne(file, pattern, partial = false) {
-        let fileStartIndex = 0;
-        let patternStartIndex = 0;
-        if (this.isWindows) {
-          const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
-          const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
-          const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
-          const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
-          const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
-          const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
-          if (typeof fdi === "number" && typeof pdi === "number") {
-            const [fd, pd] = [
-              file[fdi],
-              pattern[pdi]
-            ];
-            if (fd.toLowerCase() === pd.toLowerCase()) {
-              pattern[pdi] = fd;
-              patternStartIndex = pdi;
-              fileStartIndex = fdi;
-            }
-          }
-        }
-        const { optimizationLevel = 1 } = this.options;
-        if (optimizationLevel >= 2) {
-          file = this.levelTwoFileOptimize(file);
-        }
-        if (pattern.includes(exports2.GLOBSTAR)) {
-          return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
-        }
-        return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
-      }
-      #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
-        const firstgs = pattern.indexOf(exports2.GLOBSTAR, patternIndex);
-        const lastgs = pattern.lastIndexOf(exports2.GLOBSTAR);
-        const [head, body, tail] = partial ? [
-          pattern.slice(patternIndex, firstgs),
-          pattern.slice(firstgs + 1),
-          []
-        ] : [
-          pattern.slice(patternIndex, firstgs),
-          pattern.slice(firstgs + 1, lastgs),
-          pattern.slice(lastgs + 1)
-        ];
-        if (head.length) {
-          const fileHead = file.slice(fileIndex, fileIndex + head.length);
-          if (!this.#matchOne(fileHead, head, partial, 0, 0)) {
-            return false;
-          }
-          fileIndex += head.length;
-          patternIndex += head.length;
-        }
-        let fileTailMatch = 0;
-        if (tail.length) {
-          if (tail.length + fileIndex > file.length)
-            return false;
-          let tailStart = file.length - tail.length;
-          if (this.#matchOne(file, tail, partial, tailStart, 0)) {
-            fileTailMatch = tail.length;
-          } else {
-            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.length) {
-          let sawSome = !!fileTailMatch;
-          for (let i2 = fileIndex; i2 < file.length - fileTailMatch; i2++) {
-            const f = String(file[i2]);
-            sawSome = true;
-            if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
-              return false;
-            }
-          }
-          return partial || sawSome;
-        }
-        const bodySegments = [[[], 0]];
-        let currentBody = bodySegments[0];
-        let nonGsParts = 0;
-        const nonGsPartsSums = [0];
-        for (const b of body) {
-          if (b === exports2.GLOBSTAR) {
-            nonGsPartsSums.push(nonGsParts);
-            currentBody = [[], 0];
-            bodySegments.push(currentBody);
-          } else {
-            currentBody[0].push(b);
-            nonGsParts++;
-          }
-        }
-        let i = bodySegments.length - 1;
-        const fileLength = file.length - fileTailMatch;
-        for (const b of bodySegments) {
-          b[1] = fileLength - (nonGsPartsSums[i--] + b[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"
-      #matchGlobStarBodySections(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
-        const bs = bodySegments[bodyIndex];
-        if (!bs) {
-          for (let i = fileIndex; i < file.length; i++) {
-            sawTail = true;
-            const f = file[i];
-            if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
-              return false;
-            }
-          }
-          return sawTail;
-        }
-        const [body, after] = bs;
-        while (fileIndex <= after) {
-          const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
-          if (m && globStarDepth < this.maxGlobstarRecursion) {
-            const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
-            if (sub !== false) {
-              return sub;
-            }
-          }
-          const f = file[fileIndex];
-          if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
-            return false;
-          }
-          fileIndex++;
-        }
-        return partial || null;
-      }
-      #matchOne(file, pattern, partial, fileIndex, patternIndex) {
-        let fi;
-        let pi;
-        let pl;
-        let fl;
-        for (fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
-          this.debug("matchOne loop");
-          let p = pattern[pi];
-          let f = file[fi];
-          this.debug(pattern, p, f);
-          if (p === false || p === exports2.GLOBSTAR) {
-            return false;
-          }
-          let hit;
-          if (typeof p === "string") {
-            hit = f === p;
-            this.debug("string match", p, f, hit);
-          } else {
-            hit = p.test(f);
-            this.debug("pattern match", p, f, hit);
-          }
-          if (!hit)
-            return false;
-        }
-        if (fi === fl && pi === pl) {
-          return true;
-        } else if (fi === fl) {
-          return partial;
-        } else if (pi === pl) {
-          return fi === fl - 1 && file[fi] === "";
-        } else {
-          throw new Error("wtf?");
-        }
-      }
-      braceExpand() {
-        return (0, exports2.braceExpand)(this.pattern, this.options);
-      }
-      parse(pattern) {
-        (0, assert_valid_pattern_js_1.assertValidPattern)(pattern);
-        const options = this.options;
-        if (pattern === "**")
-          return exports2.GLOBSTAR;
-        if (pattern === "")
-          return "";
-        let m;
-        let fastTest = null;
-        if (m = pattern.match(starRE2)) {
-          fastTest = options.dot ? starTestDot2 : starTest2;
-        } else if (m = pattern.match(starDotExtRE2)) {
-          fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot2 : starDotExtTestNocase2 : options.dot ? starDotExtTestDot2 : starDotExtTest2)(m[1]);
-        } else if (m = pattern.match(qmarksRE2)) {
-          fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot2 : qmarksTestNocase2 : options.dot ? qmarksTestDot2 : qmarksTest2)(m);
-        } else if (m = pattern.match(starDotStarRE2)) {
-          fastTest = options.dot ? starDotStarTestDot2 : starDotStarTest2;
-        } else if (m = pattern.match(dotStarRE2)) {
-          fastTest = dotStarTest2;
-        }
-        const re = ast_js_1.AST.fromGlob(pattern, this.options).toMMPattern();
-        if (fastTest && typeof re === "object") {
-          Reflect.defineProperty(re, "test", { value: fastTest });
-        }
-        return re;
-      }
-      makeRe() {
-        if (this.regexp || this.regexp === false)
-          return this.regexp;
-        const set = this.set;
-        if (!set.length) {
-          this.regexp = false;
-          return this.regexp;
-        }
-        const options = this.options;
-        const twoStar = options.noglobstar ? star3 : options.dot ? twoStarDot2 : twoStarNoDot2;
-        const flags = new Set(options.nocase ? ["i"] : []);
-        let re = set.map((pattern) => {
-          const pp = pattern.map((p) => {
-            if (p instanceof RegExp) {
-              for (const f of p.flags.split(""))
-                flags.add(f);
-            }
-            return typeof p === "string" ? regExpEscape3(p) : p === exports2.GLOBSTAR ? exports2.GLOBSTAR : p._src;
-          });
-          pp.forEach((p, i) => {
-            const next = pp[i + 1];
-            const prev = pp[i - 1];
-            if (p !== exports2.GLOBSTAR || prev === exports2.GLOBSTAR) {
-              return;
-            }
-            if (prev === void 0) {
-              if (next !== void 0 && next !== exports2.GLOBSTAR) {
-                pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
-              } else {
-                pp[i] = twoStar;
-              }
-            } else if (next === void 0) {
-              pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
-            } else if (next !== exports2.GLOBSTAR) {
-              pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
-              pp[i + 1] = exports2.GLOBSTAR;
-            }
-          });
-          const filtered = pp.filter((p) => p !== exports2.GLOBSTAR);
-          if (this.partial && filtered.length >= 1) {
-            const prefixes = [];
-            for (let i = 1; i <= filtered.length; i++) {
-              prefixes.push(filtered.slice(0, i).join("/"));
-            }
-            return "(?:" + prefixes.join("|") + ")";
-          }
-          return filtered.join("/");
-        }).join("|");
-        const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
-        re = "^" + open + re + close + "$";
-        if (this.partial) {
-          re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
-        }
-        if (this.negate)
-          re = "^(?!" + re + ").+$";
-        try {
-          this.regexp = new RegExp(re, [...flags].join(""));
-        } catch (ex) {
-          this.regexp = false;
-        }
-        return this.regexp;
-      }
-      slashSplit(p) {
-        if (this.preserveMultipleSlashes) {
-          return p.split("/");
-        } else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
-          return ["", ...p.split(/\/+/)];
-        } else {
-          return p.split(/\/+/);
-        }
-      }
-      match(f, partial = this.partial) {
-        this.debug("match", f, this.pattern);
-        if (this.comment) {
-          return false;
-        }
-        if (this.empty) {
-          return f === "";
-        }
-        if (f === "/" && partial) {
-          return true;
-        }
-        const options = this.options;
-        if (this.isWindows) {
-          f = f.split("\\").join("/");
-        }
-        const ff = this.slashSplit(f);
-        this.debug(this.pattern, "split", ff);
-        const set = this.set;
-        this.debug(this.pattern, "set", set);
-        let filename = ff[ff.length - 1];
-        if (!filename) {
-          for (let i = ff.length - 2; !filename && i >= 0; i--) {
-            filename = ff[i];
-          }
-        }
-        for (let i = 0; i < set.length; i++) {
-          const pattern = set[i];
-          let file = ff;
-          if (options.matchBase && pattern.length === 1) {
-            file = [filename];
-          }
-          const hit = this.matchOne(file, pattern, partial);
-          if (hit) {
-            if (options.flipNegate) {
-              return true;
-            }
-            return !this.negate;
-          }
-        }
-        if (options.flipNegate) {
-          return false;
-        }
-        return this.negate;
-      }
-      static defaults(def) {
-        return exports2.minimatch.defaults(def).Minimatch;
-      }
-    };
-    exports2.Minimatch = Minimatch2;
-    var ast_js_2 = require_ast();
-    Object.defineProperty(exports2, "AST", { enumerable: true, get: function() {
-      return ast_js_2.AST;
-    } });
-    var escape_js_2 = require_escape();
-    Object.defineProperty(exports2, "escape", { enumerable: true, get: function() {
-      return escape_js_2.escape;
-    } });
-    var unescape_js_2 = require_unescape();
-    Object.defineProperty(exports2, "unescape", { enumerable: true, get: function() {
-      return unescape_js_2.unescape;
-    } });
-    exports2.minimatch.AST = ast_js_1.AST;
-    exports2.minimatch.Minimatch = Minimatch2;
-    exports2.minimatch.escape = escape_js_1.escape;
-    exports2.minimatch.unescape = unescape_js_1.unescape;
-  }
-});
-
-// node_modules/lru-cache/dist/commonjs/index.js
-var require_commonjs21 = __commonJS({
-  "node_modules/lru-cache/dist/commonjs/index.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.LRUCache = void 0;
-    var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
-    var warned = /* @__PURE__ */ new Set();
-    var PROCESS = typeof process === "object" && !!process ? process : {};
-    var emitWarning = (msg, type, code, fn) => {
-      typeof PROCESS.emitWarning === "function" ? PROCESS.emitWarning(msg, type, code, fn) : console.error(`[${code}] ${type}: ${msg}`);
-    };
-    var AC = globalThis.AbortController;
-    var AS = globalThis.AbortSignal;
-    if (typeof AC === "undefined") {
-      AS = class AbortSignal {
-        onabort;
-        _onabort = [];
-        reason;
-        aborted = false;
-        addEventListener(_2, fn) {
-          this._onabort.push(fn);
-        }
-      };
-      AC = class AbortController {
-        constructor() {
-          warnACPolyfill();
-        }
-        signal = new AS();
-        abort(reason) {
-          if (this.signal.aborted)
-            return;
-          this.signal.reason = reason;
-          this.signal.aborted = true;
-          for (const fn of this.signal._onabort) {
-            fn(reason);
-          }
-          this.signal.onabort?.(reason);
-        }
-      };
-      let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1";
-      const warnACPolyfill = () => {
-        if (!printACPolyfillWarning)
-          return;
-        printACPolyfillWarning = false;
-        emitWarning("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", warnACPolyfill);
-      };
-    }
-    var shouldWarn = (code) => !warned.has(code);
-    var isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
-    var getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
-    var ZeroArray = class extends Array {
-      constructor(size) {
-        super(size);
-        this.fill(0);
-      }
-    };
-    var Stack = class _Stack {
-      heap;
-      length;
-      // private constructor
-      static #constructing = false;
-      static create(max) {
-        const HeapCls = getUintArray(max);
-        if (!HeapCls)
-          return [];
-        _Stack.#constructing = true;
-        const s = new _Stack(max, HeapCls);
-        _Stack.#constructing = false;
-        return s;
-      }
-      constructor(max, HeapCls) {
-        if (!_Stack.#constructing) {
-          throw new TypeError("instantiate Stack using Stack.create(n)");
-        }
-        this.heap = new HeapCls(max);
-        this.length = 0;
-      }
-      push(n) {
-        this.heap[this.length++] = n;
-      }
-      pop() {
-        return this.heap[--this.length];
-      }
-    };
-    var LRUCache = class _LRUCache {
-      // options that cannot be changed without disaster
-      #max;
-      #maxSize;
-      #dispose;
-      #onInsert;
-      #disposeAfter;
-      #fetchMethod;
-      #memoMethod;
-      /**
-       * {@link LRUCache.OptionsBase.ttl}
-       */
-      ttl;
-      /**
-       * {@link LRUCache.OptionsBase.ttlResolution}
-       */
-      ttlResolution;
-      /**
-       * {@link LRUCache.OptionsBase.ttlAutopurge}
-       */
-      ttlAutopurge;
-      /**
-       * {@link LRUCache.OptionsBase.updateAgeOnGet}
-       */
-      updateAgeOnGet;
-      /**
-       * {@link LRUCache.OptionsBase.updateAgeOnHas}
-       */
-      updateAgeOnHas;
-      /**
-       * {@link LRUCache.OptionsBase.allowStale}
-       */
-      allowStale;
-      /**
-       * {@link LRUCache.OptionsBase.noDisposeOnSet}
-       */
-      noDisposeOnSet;
-      /**
-       * {@link LRUCache.OptionsBase.noUpdateTTL}
-       */
-      noUpdateTTL;
-      /**
-       * {@link LRUCache.OptionsBase.maxEntrySize}
-       */
-      maxEntrySize;
-      /**
-       * {@link LRUCache.OptionsBase.sizeCalculation}
-       */
-      sizeCalculation;
-      /**
-       * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
-       */
-      noDeleteOnFetchRejection;
-      /**
-       * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
-       */
-      noDeleteOnStaleGet;
-      /**
-       * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
-       */
-      allowStaleOnFetchAbort;
-      /**
-       * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
-       */
-      allowStaleOnFetchRejection;
-      /**
-       * {@link LRUCache.OptionsBase.ignoreFetchAbort}
-       */
-      ignoreFetchAbort;
-      // computed properties
-      #size;
-      #calculatedSize;
-      #keyMap;
-      #keyList;
-      #valList;
-      #next;
-      #prev;
-      #head;
-      #tail;
-      #free;
-      #disposed;
-      #sizes;
-      #starts;
-      #ttls;
-      #hasDispose;
-      #hasFetchMethod;
-      #hasDisposeAfter;
-      #hasOnInsert;
-      /**
-       * Do not call this method unless you need to inspect the
-       * inner workings of the cache.  If anything returned by this
-       * object is modified in any way, strange breakage may occur.
-       *
-       * These fields are private for a reason!
-       *
-       * @internal
-       */
-      static unsafeExposeInternals(c) {
-        return {
-          // properties
-          starts: c.#starts,
-          ttls: c.#ttls,
-          sizes: c.#sizes,
-          keyMap: c.#keyMap,
-          keyList: c.#keyList,
-          valList: c.#valList,
-          next: c.#next,
-          prev: c.#prev,
-          get head() {
-            return c.#head;
-          },
-          get tail() {
-            return c.#tail;
-          },
-          free: c.#free,
-          // methods
-          isBackgroundFetch: (p) => c.#isBackgroundFetch(p),
-          backgroundFetch: (k, index2, options, context5) => c.#backgroundFetch(k, index2, options, context5),
-          moveToTail: (index2) => c.#moveToTail(index2),
-          indexes: (options) => c.#indexes(options),
-          rindexes: (options) => c.#rindexes(options),
-          isStale: (index2) => c.#isStale(index2)
-        };
-      }
-      // Protected read-only members
-      /**
-       * {@link LRUCache.OptionsBase.max} (read-only)
-       */
-      get max() {
-        return this.#max;
-      }
-      /**
-       * {@link LRUCache.OptionsBase.maxSize} (read-only)
-       */
-      get maxSize() {
-        return this.#maxSize;
-      }
-      /**
-       * The total computed size of items in the cache (read-only)
-       */
-      get calculatedSize() {
-        return this.#calculatedSize;
-      }
-      /**
-       * The number of items stored in the cache (read-only)
-       */
-      get size() {
-        return this.#size;
-      }
-      /**
-       * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
-       */
-      get fetchMethod() {
-        return this.#fetchMethod;
-      }
-      get memoMethod() {
-        return this.#memoMethod;
-      }
-      /**
-       * {@link LRUCache.OptionsBase.dispose} (read-only)
-       */
-      get dispose() {
-        return this.#dispose;
-      }
-      /**
-       * {@link LRUCache.OptionsBase.onInsert} (read-only)
-       */
-      get onInsert() {
-        return this.#onInsert;
-      }
-      /**
-       * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
-       */
-      get disposeAfter() {
-        return this.#disposeAfter;
-      }
-      constructor(options) {
-        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, onInsert, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, memoMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort } = options;
-        if (max !== 0 && !isPosInt(max)) {
-          throw new TypeError("max option must be a nonnegative integer");
-        }
-        const UintArray = max ? getUintArray(max) : Array;
-        if (!UintArray) {
-          throw new Error("invalid max value: " + max);
-        }
-        this.#max = max;
-        this.#maxSize = maxSize;
-        this.maxEntrySize = maxEntrySize || this.#maxSize;
-        this.sizeCalculation = sizeCalculation;
-        if (this.sizeCalculation) {
-          if (!this.#maxSize && !this.maxEntrySize) {
-            throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
-          }
-          if (typeof this.sizeCalculation !== "function") {
-            throw new TypeError("sizeCalculation set to non-function");
-          }
-        }
-        if (memoMethod !== void 0 && typeof memoMethod !== "function") {
-          throw new TypeError("memoMethod must be a function if defined");
-        }
-        this.#memoMethod = memoMethod;
-        if (fetchMethod !== void 0 && typeof fetchMethod !== "function") {
-          throw new TypeError("fetchMethod must be a function if specified");
-        }
-        this.#fetchMethod = fetchMethod;
-        this.#hasFetchMethod = !!fetchMethod;
-        this.#keyMap = /* @__PURE__ */ new Map();
-        this.#keyList = new Array(max).fill(void 0);
-        this.#valList = new Array(max).fill(void 0);
-        this.#next = new UintArray(max);
-        this.#prev = new UintArray(max);
-        this.#head = 0;
-        this.#tail = 0;
-        this.#free = Stack.create(max);
-        this.#size = 0;
-        this.#calculatedSize = 0;
-        if (typeof dispose === "function") {
-          this.#dispose = dispose;
-        }
-        if (typeof onInsert === "function") {
-          this.#onInsert = onInsert;
-        }
-        if (typeof disposeAfter === "function") {
-          this.#disposeAfter = disposeAfter;
-          this.#disposed = [];
-        } else {
-          this.#disposeAfter = void 0;
-          this.#disposed = void 0;
-        }
-        this.#hasDispose = !!this.#dispose;
-        this.#hasOnInsert = !!this.#onInsert;
-        this.#hasDisposeAfter = !!this.#disposeAfter;
-        this.noDisposeOnSet = !!noDisposeOnSet;
-        this.noUpdateTTL = !!noUpdateTTL;
-        this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
-        this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
-        this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
-        this.ignoreFetchAbort = !!ignoreFetchAbort;
-        if (this.maxEntrySize !== 0) {
-          if (this.#maxSize !== 0) {
-            if (!isPosInt(this.#maxSize)) {
-              throw new TypeError("maxSize must be a positive integer if specified");
-            }
-          }
-          if (!isPosInt(this.maxEntrySize)) {
-            throw new TypeError("maxEntrySize must be a positive integer if specified");
-          }
-          this.#initializeSizeTracking();
-        }
-        this.allowStale = !!allowStale;
-        this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
-        this.updateAgeOnGet = !!updateAgeOnGet;
-        this.updateAgeOnHas = !!updateAgeOnHas;
-        this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
-        this.ttlAutopurge = !!ttlAutopurge;
-        this.ttl = ttl || 0;
-        if (this.ttl) {
-          if (!isPosInt(this.ttl)) {
-            throw new TypeError("ttl must be a positive integer if specified");
-          }
-          this.#initializeTTLTracking();
-        }
-        if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {
-          throw new TypeError("At least one of max, maxSize, or ttl is required");
-        }
-        if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
-          const code = "LRU_CACHE_UNBOUNDED";
-          if (shouldWarn(code)) {
-            warned.add(code);
-            const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";
-            emitWarning(msg, "UnboundedCacheWarning", code, _LRUCache);
-          }
-        }
-      }
-      /**
-       * Return the number of ms left in the item's TTL. If item is not in cache,
-       * returns `0`. Returns `Infinity` if item is in cache without a defined TTL.
-       */
-      getRemainingTTL(key) {
-        return this.#keyMap.has(key) ? Infinity : 0;
-      }
-      #initializeTTLTracking() {
-        const ttls = new ZeroArray(this.#max);
-        const starts = new ZeroArray(this.#max);
-        this.#ttls = ttls;
-        this.#starts = starts;
-        this.#setItemTTL = (index2, ttl, start = perf.now()) => {
-          starts[index2] = ttl !== 0 ? start : 0;
-          ttls[index2] = ttl;
-          if (ttl !== 0 && this.ttlAutopurge) {
-            const t = setTimeout(() => {
-              if (this.#isStale(index2)) {
-                this.#delete(this.#keyList[index2], "expire");
-              }
-            }, ttl + 1);
-            if (t.unref) {
-              t.unref();
-            }
-          }
-        };
-        this.#updateItemAge = (index2) => {
-          starts[index2] = ttls[index2] !== 0 ? perf.now() : 0;
-        };
-        this.#statusTTL = (status, index2) => {
-          if (ttls[index2]) {
-            const ttl = ttls[index2];
-            const start = starts[index2];
-            if (!ttl || !start)
-              return;
-            status.ttl = ttl;
-            status.start = start;
-            status.now = cachedNow || getNow();
-            const age = status.now - start;
-            status.remainingTTL = ttl - age;
-          }
-        };
-        let cachedNow = 0;
-        const getNow = () => {
-          const n = perf.now();
-          if (this.ttlResolution > 0) {
-            cachedNow = n;
-            const t = setTimeout(() => cachedNow = 0, this.ttlResolution);
-            if (t.unref) {
-              t.unref();
-            }
-          }
-          return n;
-        };
-        this.getRemainingTTL = (key) => {
-          const index2 = this.#keyMap.get(key);
-          if (index2 === void 0) {
-            return 0;
-          }
-          const ttl = ttls[index2];
-          const start = starts[index2];
-          if (!ttl || !start) {
-            return Infinity;
-          }
-          const age = (cachedNow || getNow()) - start;
-          return ttl - age;
-        };
-        this.#isStale = (index2) => {
-          const s = starts[index2];
-          const t = ttls[index2];
-          return !!t && !!s && (cachedNow || getNow()) - s > t;
-        };
-      }
-      // conditionally set private methods related to TTL
-      #updateItemAge = () => {
-      };
-      #statusTTL = () => {
-      };
-      #setItemTTL = () => {
-      };
-      /* c8 ignore stop */
-      #isStale = () => false;
-      #initializeSizeTracking() {
-        const sizes = new ZeroArray(this.#max);
-        this.#calculatedSize = 0;
-        this.#sizes = sizes;
-        this.#removeItemSize = (index2) => {
-          this.#calculatedSize -= sizes[index2];
-          sizes[index2] = 0;
-        };
-        this.#requireSize = (k, v, size, sizeCalculation) => {
-          if (this.#isBackgroundFetch(v)) {
-            return 0;
-          }
-          if (!isPosInt(size)) {
-            if (sizeCalculation) {
-              if (typeof sizeCalculation !== "function") {
-                throw new TypeError("sizeCalculation must be a function");
-              }
-              size = sizeCalculation(v, k);
-              if (!isPosInt(size)) {
-                throw new TypeError("sizeCalculation return invalid (expect positive integer)");
-              }
-            } else {
-              throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
-            }
-          }
-          return size;
-        };
-        this.#addItemSize = (index2, size, status) => {
-          sizes[index2] = size;
-          if (this.#maxSize) {
-            const maxSize = this.#maxSize - sizes[index2];
-            while (this.#calculatedSize > maxSize) {
-              this.#evict(true);
-            }
-          }
-          this.#calculatedSize += sizes[index2];
-          if (status) {
-            status.entrySize = size;
-            status.totalCalculatedSize = this.#calculatedSize;
-          }
-        };
-      }
-      #removeItemSize = (_i) => {
-      };
-      #addItemSize = (_i, _s, _st) => {
-      };
-      #requireSize = (_k, _v, size, sizeCalculation) => {
-        if (size || sizeCalculation) {
-          throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
-        }
-        return 0;
-      };
-      *#indexes({ allowStale = this.allowStale } = {}) {
-        if (this.#size) {
-          for (let i = this.#tail; true; ) {
-            if (!this.#isValidIndex(i)) {
-              break;
-            }
-            if (allowStale || !this.#isStale(i)) {
-              yield i;
-            }
-            if (i === this.#head) {
-              break;
-            } else {
-              i = this.#prev[i];
-            }
-          }
-        }
-      }
-      *#rindexes({ allowStale = this.allowStale } = {}) {
-        if (this.#size) {
-          for (let i = this.#head; true; ) {
-            if (!this.#isValidIndex(i)) {
-              break;
-            }
-            if (allowStale || !this.#isStale(i)) {
-              yield i;
-            }
-            if (i === this.#tail) {
-              break;
-            } else {
-              i = this.#next[i];
-            }
-          }
-        }
-      }
-      #isValidIndex(index2) {
-        return index2 !== void 0 && this.#keyMap.get(this.#keyList[index2]) === index2;
-      }
-      /**
-       * Return a generator yielding `[key, value]` pairs,
-       * in order from most recently used to least recently used.
-       */
-      *entries() {
-        for (const i of this.#indexes()) {
-          if (this.#valList[i] !== void 0 && this.#keyList[i] !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
-            yield [this.#keyList[i], this.#valList[i]];
-          }
-        }
-      }
-      /**
-       * Inverse order version of {@link LRUCache.entries}
-       *
-       * Return a generator yielding `[key, value]` pairs,
-       * in order from least recently used to most recently used.
-       */
-      *rentries() {
-        for (const i of this.#rindexes()) {
-          if (this.#valList[i] !== void 0 && this.#keyList[i] !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
-            yield [this.#keyList[i], this.#valList[i]];
-          }
-        }
-      }
-      /**
-       * Return a generator yielding the keys in the cache,
-       * in order from most recently used to least recently used.
-       */
-      *keys() {
-        for (const i of this.#indexes()) {
-          const k = this.#keyList[i];
-          if (k !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
-            yield k;
-          }
-        }
-      }
-      /**
-       * Inverse order version of {@link LRUCache.keys}
-       *
-       * Return a generator yielding the keys in the cache,
-       * in order from least recently used to most recently used.
-       */
-      *rkeys() {
-        for (const i of this.#rindexes()) {
-          const k = this.#keyList[i];
-          if (k !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
-            yield k;
-          }
-        }
-      }
-      /**
-       * Return a generator yielding the values in the cache,
-       * in order from most recently used to least recently used.
-       */
-      *values() {
-        for (const i of this.#indexes()) {
-          const v = this.#valList[i];
-          if (v !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
-            yield this.#valList[i];
-          }
-        }
-      }
-      /**
-       * Inverse order version of {@link LRUCache.values}
-       *
-       * Return a generator yielding the values in the cache,
-       * in order from least recently used to most recently used.
-       */
-      *rvalues() {
-        for (const i of this.#rindexes()) {
-          const v = this.#valList[i];
-          if (v !== void 0 && !this.#isBackgroundFetch(this.#valList[i])) {
-            yield this.#valList[i];
-          }
-        }
-      }
-      /**
-       * Iterating over the cache itself yields the same results as
-       * {@link LRUCache.entries}
-       */
-      [Symbol.iterator]() {
-        return this.entries();
-      }
-      /**
-       * A String value that is used in the creation of the default string
-       * description of an object. Called by the built-in method
-       * `Object.prototype.toString`.
-       */
-      [Symbol.toStringTag] = "LRUCache";
-      /**
-       * Find a value for which the supplied fn method returns a truthy value,
-       * similar to `Array.find()`. fn is called as `fn(value, key, cache)`.
-       */
-      find(fn, getOptions = {}) {
-        for (const i of this.#indexes()) {
-          const v = this.#valList[i];
-          const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-          if (value === void 0)
-            continue;
-          if (fn(value, this.#keyList[i], this)) {
-            return this.get(this.#keyList[i], getOptions);
-          }
-        }
-      }
-      /**
-       * Call the supplied function on each item in the cache, in order from most
-       * recently used to least recently used.
-       *
-       * `fn` is called as `fn(value, key, cache)`.
-       *
-       * If `thisp` is provided, function will be called in the `this`-context of
-       * the provided object, or the cache if no `thisp` object is provided.
-       *
-       * Does not update age or recenty of use, or iterate over stale values.
-       */
-      forEach(fn, thisp = this) {
-        for (const i of this.#indexes()) {
-          const v = this.#valList[i];
-          const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-          if (value === void 0)
-            continue;
-          fn.call(thisp, value, this.#keyList[i], this);
-        }
-      }
-      /**
-       * The same as {@link LRUCache.forEach} but items are iterated over in
-       * reverse order.  (ie, less recently used items are iterated over first.)
-       */
-      rforEach(fn, thisp = this) {
-        for (const i of this.#rindexes()) {
-          const v = this.#valList[i];
-          const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-          if (value === void 0)
-            continue;
-          fn.call(thisp, value, this.#keyList[i], this);
-        }
-      }
-      /**
-       * Delete any stale entries. Returns true if anything was removed,
-       * false otherwise.
-       */
-      purgeStale() {
-        let deleted = false;
-        for (const i of this.#rindexes({ allowStale: true })) {
-          if (this.#isStale(i)) {
-            this.#delete(this.#keyList[i], "expire");
-            deleted = true;
-          }
-        }
-        return deleted;
-      }
-      /**
-       * Get the extended info about a given entry, to get its value, size, and
-       * TTL info simultaneously. Returns `undefined` if the key is not present.
-       *
-       * Unlike {@link LRUCache#dump}, which is designed to be portable and survive
-       * serialization, the `start` value is always the current timestamp, and the
-       * `ttl` is a calculated remaining time to live (negative if expired).
-       *
-       * Always returns stale values, if their info is found in the cache, so be
-       * sure to check for expirations (ie, a negative {@link LRUCache.Entry#ttl})
-       * if relevant.
-       */
-      info(key) {
-        const i = this.#keyMap.get(key);
-        if (i === void 0)
-          return void 0;
-        const v = this.#valList[i];
-        const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-        if (value === void 0)
-          return void 0;
-        const entry = { value };
-        if (this.#ttls && this.#starts) {
-          const ttl = this.#ttls[i];
-          const start = this.#starts[i];
-          if (ttl && start) {
-            const remain = ttl - (perf.now() - start);
-            entry.ttl = remain;
-            entry.start = Date.now();
-          }
-        }
-        if (this.#sizes) {
-          entry.size = this.#sizes[i];
-        }
-        return entry;
-      }
-      /**
-       * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
-       * passed to {@link LRUCache#load}.
-       *
-       * The `start` fields are calculated relative to a portable `Date.now()`
-       * timestamp, even if `performance.now()` is available.
-       *
-       * Stale entries are always included in the `dump`, even if
-       * {@link LRUCache.OptionsBase.allowStale} is false.
-       *
-       * Note: this returns an actual array, not a generator, so it can be more
-       * easily passed around.
-       */
-      dump() {
-        const arr = [];
-        for (const i of this.#indexes({ allowStale: true })) {
-          const key = this.#keyList[i];
-          const v = this.#valList[i];
-          const value = this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-          if (value === void 0 || key === void 0)
-            continue;
-          const entry = { value };
-          if (this.#ttls && this.#starts) {
-            entry.ttl = this.#ttls[i];
-            const age = perf.now() - this.#starts[i];
-            entry.start = Math.floor(Date.now() - age);
-          }
-          if (this.#sizes) {
-            entry.size = this.#sizes[i];
-          }
-          arr.unshift([key, entry]);
-        }
-        return arr;
-      }
-      /**
-       * Reset the cache and load in the items in entries in the order listed.
-       *
-       * The shape of the resulting cache may be different if the same options are
-       * not used in both caches.
-       *
-       * The `start` fields are assumed to be calculated relative to a portable
-       * `Date.now()` timestamp, even if `performance.now()` is available.
-       */
-      load(arr) {
-        this.clear();
-        for (const [key, entry] of arr) {
-          if (entry.start) {
-            const age = Date.now() - entry.start;
-            entry.start = perf.now() - age;
-          }
-          this.set(key, entry.value, entry);
-        }
-      }
-      /**
-       * Add a value to the cache.
-       *
-       * Note: if `undefined` is specified as a value, this is an alias for
-       * {@link LRUCache#delete}
-       *
-       * Fields on the {@link LRUCache.SetOptions} options param will override
-       * their corresponding values in the constructor options for the scope
-       * of this single `set()` operation.
-       *
-       * If `start` is provided, then that will set the effective start
-       * time for the TTL calculation. Note that this must be a previous
-       * value of `performance.now()` if supported, or a previous value of
-       * `Date.now()` if not.
-       *
-       * Options object may also include `size`, which will prevent
-       * calling the `sizeCalculation` function and just use the specified
-       * number if it is a positive integer, and `noDisposeOnSet` which
-       * will prevent calling a `dispose` function in the case of
-       * overwrites.
-       *
-       * If the `size` (or return value of `sizeCalculation`) for a given
-       * entry is greater than `maxEntrySize`, then the item will not be
-       * added to the cache.
-       *
-       * Will update the recency of the entry.
-       *
-       * If the value is `undefined`, then this is an alias for
-       * `cache.delete(key)`. `undefined` is never stored in the cache.
-       */
-      set(k, v, setOptions = {}) {
-        if (v === void 0) {
-          this.delete(k);
-          return this;
-        }
-        const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status } = setOptions;
-        let { noUpdateTTL = this.noUpdateTTL } = setOptions;
-        const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
-        if (this.maxEntrySize && size > this.maxEntrySize) {
-          if (status) {
-            status.set = "miss";
-            status.maxEntrySizeExceeded = true;
-          }
-          this.#delete(k, "set");
-          return this;
-        }
-        let index2 = this.#size === 0 ? void 0 : this.#keyMap.get(k);
-        if (index2 === void 0) {
-          index2 = this.#size === 0 ? this.#tail : this.#free.length !== 0 ? this.#free.pop() : this.#size === this.#max ? this.#evict(false) : this.#size;
-          this.#keyList[index2] = k;
-          this.#valList[index2] = v;
-          this.#keyMap.set(k, index2);
-          this.#next[this.#tail] = index2;
-          this.#prev[index2] = this.#tail;
-          this.#tail = index2;
-          this.#size++;
-          this.#addItemSize(index2, size, status);
-          if (status)
-            status.set = "add";
-          noUpdateTTL = false;
-          if (this.#hasOnInsert) {
-            this.#onInsert?.(v, k, "add");
-          }
-        } else {
-          this.#moveToTail(index2);
-          const oldVal = this.#valList[index2];
-          if (v !== oldVal) {
-            if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
-              oldVal.__abortController.abort(new Error("replaced"));
-              const { __staleWhileFetching: s } = oldVal;
-              if (s !== void 0 && !noDisposeOnSet) {
-                if (this.#hasDispose) {
-                  this.#dispose?.(s, k, "set");
-                }
-                if (this.#hasDisposeAfter) {
-                  this.#disposed?.push([s, k, "set"]);
-                }
-              }
-            } else if (!noDisposeOnSet) {
-              if (this.#hasDispose) {
-                this.#dispose?.(oldVal, k, "set");
-              }
-              if (this.#hasDisposeAfter) {
-                this.#disposed?.push([oldVal, k, "set"]);
-              }
-            }
-            this.#removeItemSize(index2);
-            this.#addItemSize(index2, size, status);
-            this.#valList[index2] = v;
-            if (status) {
-              status.set = "replace";
-              const oldValue = oldVal && this.#isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
-              if (oldValue !== void 0)
-                status.oldValue = oldValue;
-            }
-          } else if (status) {
-            status.set = "update";
-          }
-          if (this.#hasOnInsert) {
-            this.onInsert?.(v, k, v === oldVal ? "update" : "replace");
-          }
-        }
-        if (ttl !== 0 && !this.#ttls) {
-          this.#initializeTTLTracking();
-        }
-        if (this.#ttls) {
-          if (!noUpdateTTL) {
-            this.#setItemTTL(index2, ttl, start);
-          }
-          if (status)
-            this.#statusTTL(status, index2);
-        }
-        if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
-          const dt = this.#disposed;
-          let task;
-          while (task = dt?.shift()) {
-            this.#disposeAfter?.(...task);
-          }
-        }
-        return this;
-      }
-      /**
-       * Evict the least recently used item, returning its value or
-       * `undefined` if cache is empty.
-       */
-      pop() {
-        try {
-          while (this.#size) {
-            const val = this.#valList[this.#head];
-            this.#evict(true);
-            if (this.#isBackgroundFetch(val)) {
-              if (val.__staleWhileFetching) {
-                return val.__staleWhileFetching;
-              }
-            } else if (val !== void 0) {
-              return val;
-            }
-          }
-        } finally {
-          if (this.#hasDisposeAfter && this.#disposed) {
-            const dt = this.#disposed;
-            let task;
-            while (task = dt?.shift()) {
-              this.#disposeAfter?.(...task);
-            }
-          }
-        }
-      }
-      #evict(free) {
-        const head = this.#head;
-        const k = this.#keyList[head];
-        const v = this.#valList[head];
-        if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
-          v.__abortController.abort(new Error("evicted"));
-        } else if (this.#hasDispose || this.#hasDisposeAfter) {
-          if (this.#hasDispose) {
-            this.#dispose?.(v, k, "evict");
-          }
-          if (this.#hasDisposeAfter) {
-            this.#disposed?.push([v, k, "evict"]);
-          }
-        }
-        this.#removeItemSize(head);
-        if (free) {
-          this.#keyList[head] = void 0;
-          this.#valList[head] = void 0;
-          this.#free.push(head);
-        }
-        if (this.#size === 1) {
-          this.#head = this.#tail = 0;
-          this.#free.length = 0;
-        } else {
-          this.#head = this.#next[head];
-        }
-        this.#keyMap.delete(k);
-        this.#size--;
-        return head;
-      }
-      /**
-       * Check if a key is in the cache, without updating the recency of use.
-       * Will return false if the item is stale, even though it is technically
-       * in the cache.
-       *
-       * Check if a key is in the cache, without updating the recency of
-       * use. Age is updated if {@link LRUCache.OptionsBase.updateAgeOnHas} is set
-       * to `true` in either the options or the constructor.
-       *
-       * Will return `false` if the item is stale, even though it is technically in
-       * the cache. The difference can be determined (if it matters) by using a
-       * `status` argument, and inspecting the `has` field.
-       *
-       * Will not update item age unless
-       * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
-       */
-      has(k, hasOptions = {}) {
-        const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
-        const index2 = this.#keyMap.get(k);
-        if (index2 !== void 0) {
-          const v = this.#valList[index2];
-          if (this.#isBackgroundFetch(v) && v.__staleWhileFetching === void 0) {
-            return false;
-          }
-          if (!this.#isStale(index2)) {
-            if (updateAgeOnHas) {
-              this.#updateItemAge(index2);
-            }
-            if (status) {
-              status.has = "hit";
-              this.#statusTTL(status, index2);
-            }
-            return true;
-          } else if (status) {
-            status.has = "stale";
-            this.#statusTTL(status, index2);
-          }
-        } else if (status) {
-          status.has = "miss";
-        }
-        return false;
-      }
-      /**
-       * Like {@link LRUCache#get} but doesn't update recency or delete stale
-       * items.
-       *
-       * Returns `undefined` if the item is stale, unless
-       * {@link LRUCache.OptionsBase.allowStale} is set.
-       */
-      peek(k, peekOptions = {}) {
-        const { allowStale = this.allowStale } = peekOptions;
-        const index2 = this.#keyMap.get(k);
-        if (index2 === void 0 || !allowStale && this.#isStale(index2)) {
-          return;
-        }
-        const v = this.#valList[index2];
-        return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
-      }
-      #backgroundFetch(k, index2, options, context5) {
-        const v = index2 === void 0 ? void 0 : this.#valList[index2];
-        if (this.#isBackgroundFetch(v)) {
-          return v;
-        }
-        const ac = new AC();
-        const { signal } = options;
-        signal?.addEventListener("abort", () => ac.abort(signal.reason), {
-          signal: ac.signal
-        });
-        const fetchOpts = {
-          signal: ac.signal,
-          options,
-          context: context5
-        };
-        const cb = (v2, updateCache = false) => {
-          const { aborted } = ac.signal;
-          const ignoreAbort = options.ignoreFetchAbort && v2 !== void 0;
-          if (options.status) {
-            if (aborted && !updateCache) {
-              options.status.fetchAborted = true;
-              options.status.fetchError = ac.signal.reason;
-              if (ignoreAbort)
-                options.status.fetchAbortIgnored = true;
-            } else {
-              options.status.fetchResolved = true;
-            }
-          }
-          if (aborted && !ignoreAbort && !updateCache) {
-            return fetchFail(ac.signal.reason);
-          }
-          const bf2 = p;
-          if (this.#valList[index2] === p) {
-            if (v2 === void 0) {
-              if (bf2.__staleWhileFetching) {
-                this.#valList[index2] = bf2.__staleWhileFetching;
-              } else {
-                this.#delete(k, "fetch");
-              }
-            } else {
-              if (options.status)
-                options.status.fetchUpdated = true;
-              this.set(k, v2, fetchOpts.options);
-            }
-          }
-          return v2;
-        };
-        const eb = (er) => {
-          if (options.status) {
-            options.status.fetchRejected = true;
-            options.status.fetchError = er;
-          }
-          return fetchFail(er);
-        };
-        const fetchFail = (er) => {
-          const { aborted } = ac.signal;
-          const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
-          const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
-          const noDelete = allowStale || options.noDeleteOnFetchRejection;
-          const bf2 = p;
-          if (this.#valList[index2] === p) {
-            const del = !noDelete || bf2.__staleWhileFetching === void 0;
-            if (del) {
-              this.#delete(k, "fetch");
-            } else if (!allowStaleAborted) {
-              this.#valList[index2] = bf2.__staleWhileFetching;
-            }
-          }
-          if (allowStale) {
-            if (options.status && bf2.__staleWhileFetching !== void 0) {
-              options.status.returnedStale = true;
-            }
-            return bf2.__staleWhileFetching;
-          } else if (bf2.__returned === bf2) {
-            throw er;
-          }
-        };
-        const pcall = (res, rej) => {
-          const fmp = this.#fetchMethod?.(k, v, fetchOpts);
-          if (fmp && fmp instanceof Promise) {
-            fmp.then((v2) => res(v2 === void 0 ? void 0 : v2), rej);
-          }
-          ac.signal.addEventListener("abort", () => {
-            if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
-              res(void 0);
-              if (options.allowStaleOnFetchAbort) {
-                res = (v2) => cb(v2, true);
-              }
-            }
-          });
-        };
-        if (options.status)
-          options.status.fetchDispatched = true;
-        const p = new Promise(pcall).then(cb, eb);
-        const bf = Object.assign(p, {
-          __abortController: ac,
-          __staleWhileFetching: v,
-          __returned: void 0
-        });
-        if (index2 === void 0) {
-          this.set(k, bf, { ...fetchOpts.options, status: void 0 });
-          index2 = this.#keyMap.get(k);
-        } else {
-          this.#valList[index2] = bf;
-        }
-        return bf;
-      }
-      #isBackgroundFetch(p) {
-        if (!this.#hasFetchMethod)
-          return false;
-        const b = p;
-        return !!b && b instanceof Promise && b.hasOwnProperty("__staleWhileFetching") && b.__abortController instanceof AC;
-      }
-      async fetch(k, fetchOptions = {}) {
-        const {
-          // get options
-          allowStale = this.allowStale,
-          updateAgeOnGet = this.updateAgeOnGet,
-          noDeleteOnStaleGet = this.noDeleteOnStaleGet,
-          // set options
-          ttl = this.ttl,
-          noDisposeOnSet = this.noDisposeOnSet,
-          size = 0,
-          sizeCalculation = this.sizeCalculation,
-          noUpdateTTL = this.noUpdateTTL,
-          // fetch exclusive options
-          noDeleteOnFetchRejection = this.noDeleteOnFetchRejection,
-          allowStaleOnFetchRejection = this.allowStaleOnFetchRejection,
-          ignoreFetchAbort = this.ignoreFetchAbort,
-          allowStaleOnFetchAbort = this.allowStaleOnFetchAbort,
-          context: context5,
-          forceRefresh = false,
-          status,
-          signal
-        } = fetchOptions;
-        if (!this.#hasFetchMethod) {
-          if (status)
-            status.fetch = "get";
-          return this.get(k, {
-            allowStale,
-            updateAgeOnGet,
-            noDeleteOnStaleGet,
-            status
-          });
-        }
-        const options = {
-          allowStale,
-          updateAgeOnGet,
-          noDeleteOnStaleGet,
-          ttl,
-          noDisposeOnSet,
-          size,
-          sizeCalculation,
-          noUpdateTTL,
-          noDeleteOnFetchRejection,
-          allowStaleOnFetchRejection,
-          allowStaleOnFetchAbort,
-          ignoreFetchAbort,
-          status,
-          signal
-        };
-        let index2 = this.#keyMap.get(k);
-        if (index2 === void 0) {
-          if (status)
-            status.fetch = "miss";
-          const p = this.#backgroundFetch(k, index2, options, context5);
-          return p.__returned = p;
-        } else {
-          const v = this.#valList[index2];
-          if (this.#isBackgroundFetch(v)) {
-            const stale = allowStale && v.__staleWhileFetching !== void 0;
-            if (status) {
-              status.fetch = "inflight";
-              if (stale)
-                status.returnedStale = true;
-            }
-            return stale ? v.__staleWhileFetching : v.__returned = v;
-          }
-          const isStale = this.#isStale(index2);
-          if (!forceRefresh && !isStale) {
-            if (status)
-              status.fetch = "hit";
-            this.#moveToTail(index2);
-            if (updateAgeOnGet) {
-              this.#updateItemAge(index2);
-            }
-            if (status)
-              this.#statusTTL(status, index2);
-            return v;
-          }
-          const p = this.#backgroundFetch(k, index2, options, context5);
-          const hasStale = p.__staleWhileFetching !== void 0;
-          const staleVal = hasStale && allowStale;
-          if (status) {
-            status.fetch = isStale ? "stale" : "refresh";
-            if (staleVal && isStale)
-              status.returnedStale = true;
-          }
-          return staleVal ? p.__staleWhileFetching : p.__returned = p;
-        }
-      }
-      async forceFetch(k, fetchOptions = {}) {
-        const v = await this.fetch(k, fetchOptions);
-        if (v === void 0)
-          throw new Error("fetch() returned undefined");
-        return v;
-      }
-      memo(k, memoOptions = {}) {
-        const memoMethod = this.#memoMethod;
-        if (!memoMethod) {
-          throw new Error("no memoMethod provided to constructor");
-        }
-        const { context: context5, forceRefresh, ...options } = memoOptions;
-        const v = this.get(k, options);
-        if (!forceRefresh && v !== void 0)
-          return v;
-        const vv = memoMethod(k, v, {
-          options,
-          context: context5
-        });
-        this.set(k, vv, options);
-        return vv;
-      }
-      /**
-       * Return a value from the cache. Will update the recency of the cache
-       * entry found.
-       *
-       * If the key is not found, get() will return `undefined`.
-       */
-      get(k, getOptions = {}) {
-        const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status } = getOptions;
-        const index2 = this.#keyMap.get(k);
-        if (index2 !== void 0) {
-          const value = this.#valList[index2];
-          const fetching = this.#isBackgroundFetch(value);
-          if (status)
-            this.#statusTTL(status, index2);
-          if (this.#isStale(index2)) {
-            if (status)
-              status.get = "stale";
-            if (!fetching) {
-              if (!noDeleteOnStaleGet) {
-                this.#delete(k, "expire");
-              }
-              if (status && allowStale)
-                status.returnedStale = true;
-              return allowStale ? value : void 0;
-            } else {
-              if (status && allowStale && value.__staleWhileFetching !== void 0) {
-                status.returnedStale = true;
-              }
-              return allowStale ? value.__staleWhileFetching : void 0;
-            }
-          } else {
-            if (status)
-              status.get = "hit";
-            if (fetching) {
-              return value.__staleWhileFetching;
-            }
-            this.#moveToTail(index2);
-            if (updateAgeOnGet) {
-              this.#updateItemAge(index2);
-            }
-            return value;
-          }
-        } else if (status) {
-          status.get = "miss";
-        }
-      }
-      #connect(p, n) {
-        this.#prev[n] = p;
-        this.#next[p] = n;
-      }
-      #moveToTail(index2) {
-        if (index2 !== this.#tail) {
-          if (index2 === this.#head) {
-            this.#head = this.#next[index2];
-          } else {
-            this.#connect(this.#prev[index2], this.#next[index2]);
-          }
-          this.#connect(this.#tail, index2);
-          this.#tail = index2;
-        }
-      }
-      /**
-       * Deletes a key out of the cache.
-       *
-       * Returns true if the key was deleted, false otherwise.
-       */
-      delete(k) {
-        return this.#delete(k, "delete");
-      }
-      #delete(k, reason) {
-        let deleted = false;
-        if (this.#size !== 0) {
-          const index2 = this.#keyMap.get(k);
-          if (index2 !== void 0) {
-            deleted = true;
-            if (this.#size === 1) {
-              this.#clear(reason);
-            } else {
-              this.#removeItemSize(index2);
-              const v = this.#valList[index2];
-              if (this.#isBackgroundFetch(v)) {
-                v.__abortController.abort(new Error("deleted"));
-              } else if (this.#hasDispose || this.#hasDisposeAfter) {
-                if (this.#hasDispose) {
-                  this.#dispose?.(v, k, reason);
-                }
-                if (this.#hasDisposeAfter) {
-                  this.#disposed?.push([v, k, reason]);
-                }
-              }
-              this.#keyMap.delete(k);
-              this.#keyList[index2] = void 0;
-              this.#valList[index2] = void 0;
-              if (index2 === this.#tail) {
-                this.#tail = this.#prev[index2];
-              } else if (index2 === this.#head) {
-                this.#head = this.#next[index2];
-              } else {
-                const pi = this.#prev[index2];
-                this.#next[pi] = this.#next[index2];
-                const ni = this.#next[index2];
-                this.#prev[ni] = this.#prev[index2];
-              }
-              this.#size--;
-              this.#free.push(index2);
-            }
-          }
-        }
-        if (this.#hasDisposeAfter && this.#disposed?.length) {
-          const dt = this.#disposed;
-          let task;
-          while (task = dt?.shift()) {
-            this.#disposeAfter?.(...task);
-          }
-        }
-        return deleted;
-      }
-      /**
-       * Clear the cache entirely, throwing away all values.
-       */
-      clear() {
-        return this.#clear("delete");
-      }
-      #clear(reason) {
-        for (const index2 of this.#rindexes({ allowStale: true })) {
-          const v = this.#valList[index2];
-          if (this.#isBackgroundFetch(v)) {
-            v.__abortController.abort(new Error("deleted"));
-          } else {
-            const k = this.#keyList[index2];
-            if (this.#hasDispose) {
-              this.#dispose?.(v, k, reason);
-            }
-            if (this.#hasDisposeAfter) {
-              this.#disposed?.push([v, k, reason]);
-            }
-          }
-        }
-        this.#keyMap.clear();
-        this.#valList.fill(void 0);
-        this.#keyList.fill(void 0);
-        if (this.#ttls && this.#starts) {
-          this.#ttls.fill(0);
-          this.#starts.fill(0);
-        }
-        if (this.#sizes) {
-          this.#sizes.fill(0);
-        }
-        this.#head = 0;
-        this.#tail = 0;
-        this.#free.length = 0;
-        this.#calculatedSize = 0;
-        this.#size = 0;
-        if (this.#hasDisposeAfter && this.#disposed) {
-          const dt = this.#disposed;
-          let task;
-          while (task = dt?.shift()) {
-            this.#disposeAfter?.(...task);
-          }
-        }
-      }
-    };
-    exports2.LRUCache = LRUCache;
-  }
-});
-
-// node_modules/minipass/dist/commonjs/index.js
-var require_commonjs22 = __commonJS({
-  "node_modules/minipass/dist/commonjs/index.js"(exports2) {
-    "use strict";
-    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.Minipass = exports2.isWritable = exports2.isReadable = exports2.isStream = void 0;
-    var proc = typeof process === "object" && process ? process : {
-      stdout: null,
-      stderr: null
-    };
-    var node_events_1 = require("node:events");
-    var node_stream_1 = __importDefault2(require("node:stream"));
-    var node_string_decoder_1 = require("node:string_decoder");
-    var isStream2 = (s) => !!s && typeof s === "object" && (s instanceof Minipass || s instanceof node_stream_1.default || (0, exports2.isReadable)(s) || (0, exports2.isWritable)(s));
-    exports2.isStream = isStream2;
-    var isReadable = (s) => !!s && typeof s === "object" && s instanceof node_events_1.EventEmitter && typeof s.pipe === "function" && // node core Writable streams have a pipe() method, but it throws
-    s.pipe !== node_stream_1.default.Writable.prototype.pipe;
-    exports2.isReadable = isReadable;
-    var isWritable = (s) => !!s && typeof s === "object" && s instanceof node_events_1.EventEmitter && typeof s.write === "function" && typeof s.end === "function";
-    exports2.isWritable = isWritable;
-    var EOF2 = /* @__PURE__ */ Symbol("EOF");
-    var MAYBE_EMIT_END = /* @__PURE__ */ Symbol("maybeEmitEnd");
-    var EMITTED_END = /* @__PURE__ */ Symbol("emittedEnd");
-    var EMITTING_END = /* @__PURE__ */ Symbol("emittingEnd");
-    var EMITTED_ERROR = /* @__PURE__ */ Symbol("emittedError");
-    var CLOSED = /* @__PURE__ */ Symbol("closed");
-    var READ = /* @__PURE__ */ Symbol("read");
-    var FLUSH = /* @__PURE__ */ Symbol("flush");
-    var FLUSHCHUNK = /* @__PURE__ */ Symbol("flushChunk");
-    var ENCODING = /* @__PURE__ */ Symbol("encoding");
-    var DECODER = /* @__PURE__ */ Symbol("decoder");
-    var FLOWING = /* @__PURE__ */ Symbol("flowing");
-    var PAUSED = /* @__PURE__ */ Symbol("paused");
-    var RESUME = /* @__PURE__ */ Symbol("resume");
-    var BUFFER = /* @__PURE__ */ Symbol("buffer");
-    var PIPES = /* @__PURE__ */ Symbol("pipes");
-    var BUFFERLENGTH = /* @__PURE__ */ Symbol("bufferLength");
-    var BUFFERPUSH = /* @__PURE__ */ Symbol("bufferPush");
-    var BUFFERSHIFT = /* @__PURE__ */ Symbol("bufferShift");
-    var OBJECTMODE = /* @__PURE__ */ Symbol("objectMode");
-    var DESTROYED = /* @__PURE__ */ Symbol("destroyed");
-    var ERROR = /* @__PURE__ */ Symbol("error");
-    var EMITDATA = /* @__PURE__ */ Symbol("emitData");
-    var EMITEND = /* @__PURE__ */ Symbol("emitEnd");
-    var EMITEND2 = /* @__PURE__ */ Symbol("emitEnd2");
-    var ASYNC = /* @__PURE__ */ Symbol("async");
-    var ABORT = /* @__PURE__ */ Symbol("abort");
-    var ABORTED = /* @__PURE__ */ Symbol("aborted");
-    var SIGNAL = /* @__PURE__ */ Symbol("signal");
-    var DATALISTENERS = /* @__PURE__ */ Symbol("dataListeners");
-    var DISCARDED = /* @__PURE__ */ Symbol("discarded");
-    var defer = (fn) => Promise.resolve().then(fn);
-    var nodefer = (fn) => fn();
-    var isEndish = (ev) => ev === "end" || ev === "finish" || ev === "prefinish";
-    var isArrayBufferLike = (b) => b instanceof ArrayBuffer || !!b && typeof b === "object" && b.constructor && b.constructor.name === "ArrayBuffer" && b.byteLength >= 0;
-    var isArrayBufferView = (b) => !Buffer.isBuffer(b) && ArrayBuffer.isView(b);
-    var Pipe = class {
-      src;
-      dest;
-      opts;
-      ondrain;
-      constructor(src, dest, opts) {
-        this.src = src;
-        this.dest = dest;
-        this.opts = opts;
-        this.ondrain = () => src[RESUME]();
-        this.dest.on("drain", this.ondrain);
-      }
-      unpipe() {
-        this.dest.removeListener("drain", this.ondrain);
-      }
-      // only here for the prototype
-      /* c8 ignore start */
-      proxyErrors(_er) {
-      }
-      /* c8 ignore stop */
-      end() {
-        this.unpipe();
-        if (this.opts.end)
-          this.dest.end();
-      }
-    };
-    var PipeProxyErrors = class extends Pipe {
-      unpipe() {
-        this.src.removeListener("error", this.proxyErrors);
-        super.unpipe();
-      }
-      constructor(src, dest, opts) {
-        super(src, dest, opts);
-        this.proxyErrors = (er) => dest.emit("error", er);
-        src.on("error", this.proxyErrors);
-      }
-    };
-    var isObjectModeOptions = (o) => !!o.objectMode;
-    var isEncodingOptions = (o) => !o.objectMode && !!o.encoding && o.encoding !== "buffer";
-    var Minipass = class extends node_events_1.EventEmitter {
-      [FLOWING] = false;
-      [PAUSED] = false;
-      [PIPES] = [];
-      [BUFFER] = [];
-      [OBJECTMODE];
-      [ENCODING];
-      [ASYNC];
-      [DECODER];
-      [EOF2] = false;
-      [EMITTED_END] = false;
-      [EMITTING_END] = false;
-      [CLOSED] = false;
-      [EMITTED_ERROR] = null;
-      [BUFFERLENGTH] = 0;
-      [DESTROYED] = false;
-      [SIGNAL];
-      [ABORTED] = false;
-      [DATALISTENERS] = 0;
-      [DISCARDED] = false;
-      /**
-       * true if the stream can be written
-       */
-      writable = true;
-      /**
-       * true if the stream can be read
-       */
-      readable = true;
-      /**
-       * If `RType` is Buffer, then options do not need to be provided.
-       * Otherwise, an options object must be provided to specify either
-       * {@link Minipass.SharedOptions.objectMode} or
-       * {@link Minipass.SharedOptions.encoding}, as appropriate.
-       */
-      constructor(...args) {
-        const options = args[0] || {};
-        super();
-        if (options.objectMode && typeof options.encoding === "string") {
-          throw new TypeError("Encoding and objectMode may not be used together");
-        }
-        if (isObjectModeOptions(options)) {
-          this[OBJECTMODE] = true;
-          this[ENCODING] = null;
-        } else if (isEncodingOptions(options)) {
-          this[ENCODING] = options.encoding;
-          this[OBJECTMODE] = false;
-        } else {
-          this[OBJECTMODE] = false;
-          this[ENCODING] = null;
-        }
-        this[ASYNC] = !!options.async;
-        this[DECODER] = this[ENCODING] ? new node_string_decoder_1.StringDecoder(this[ENCODING]) : null;
-        if (options && options.debugExposeBuffer === true) {
-          Object.defineProperty(this, "buffer", { get: () => this[BUFFER] });
-        }
-        if (options && options.debugExposePipes === true) {
-          Object.defineProperty(this, "pipes", { get: () => this[PIPES] });
-        }
-        const { signal } = options;
-        if (signal) {
-          this[SIGNAL] = signal;
-          if (signal.aborted) {
-            this[ABORT]();
-          } else {
-            signal.addEventListener("abort", () => this[ABORT]());
-          }
-        }
-      }
-      /**
-       * The amount of data stored in the buffer waiting to be read.
-       *
-       * For Buffer strings, this will be the total byte length.
-       * For string encoding streams, this will be the string character length,
-       * according to JavaScript's `string.length` logic.
-       * For objectMode streams, this is a count of the items waiting to be
-       * emitted.
-       */
-      get bufferLength() {
-        return this[BUFFERLENGTH];
-      }
-      /**
-       * The `BufferEncoding` currently in use, or `null`
-       */
-      get encoding() {
-        return this[ENCODING];
-      }
-      /**
-       * @deprecated - This is a read only property
-       */
-      set encoding(_enc) {
-        throw new Error("Encoding must be set at instantiation time");
-      }
-      /**
-       * @deprecated - Encoding may only be set at instantiation time
-       */
-      setEncoding(_enc) {
-        throw new Error("Encoding must be set at instantiation time");
-      }
-      /**
-       * True if this is an objectMode stream
-       */
-      get objectMode() {
-        return this[OBJECTMODE];
-      }
-      /**
-       * @deprecated - This is a read-only property
-       */
-      set objectMode(_om) {
-        throw new Error("objectMode must be set at instantiation time");
-      }
-      /**
-       * true if this is an async stream
-       */
-      get ["async"]() {
-        return this[ASYNC];
-      }
-      /**
-       * Set to true to make this stream async.
-       *
-       * Once set, it cannot be unset, as this would potentially cause incorrect
-       * behavior.  Ie, a sync stream can be made async, but an async stream
-       * cannot be safely made sync.
-       */
-      set ["async"](a) {
-        this[ASYNC] = this[ASYNC] || !!a;
-      }
-      // drop everything and get out of the flow completely
-      [ABORT]() {
-        this[ABORTED] = true;
-        this.emit("abort", this[SIGNAL]?.reason);
-        this.destroy(this[SIGNAL]?.reason);
-      }
-      /**
-       * True if the stream has been aborted.
-       */
-      get aborted() {
-        return this[ABORTED];
-      }
-      /**
-       * No-op setter. Stream aborted status is set via the AbortSignal provided
-       * in the constructor options.
-       */
-      set aborted(_2) {
-      }
-      write(chunk, encoding, cb) {
-        if (this[ABORTED])
-          return false;
-        if (this[EOF2])
-          throw new Error("write after end");
-        if (this[DESTROYED]) {
-          this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" }));
-          return true;
-        }
-        if (typeof encoding === "function") {
-          cb = encoding;
-          encoding = "utf8";
-        }
-        if (!encoding)
-          encoding = "utf8";
-        const fn = this[ASYNC] ? defer : nodefer;
-        if (!this[OBJECTMODE] && !Buffer.isBuffer(chunk)) {
-          if (isArrayBufferView(chunk)) {
-            chunk = Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength);
-          } else if (isArrayBufferLike(chunk)) {
-            chunk = Buffer.from(chunk);
-          } else if (typeof chunk !== "string") {
-            throw new Error("Non-contiguous data written to non-objectMode stream");
-          }
-        }
-        if (this[OBJECTMODE]) {
-          if (this[FLOWING] && this[BUFFERLENGTH] !== 0)
-            this[FLUSH](true);
-          if (this[FLOWING])
-            this.emit("data", chunk);
-          else
-            this[BUFFERPUSH](chunk);
-          if (this[BUFFERLENGTH] !== 0)
-            this.emit("readable");
-          if (cb)
-            fn(cb);
-          return this[FLOWING];
-        }
-        if (!chunk.length) {
-          if (this[BUFFERLENGTH] !== 0)
-            this.emit("readable");
-          if (cb)
-            fn(cb);
-          return this[FLOWING];
-        }
-        if (typeof chunk === "string" && // unless it is a string already ready for us to use
-        !(encoding === this[ENCODING] && !this[DECODER]?.lastNeed)) {
-          chunk = Buffer.from(chunk, encoding);
-        }
-        if (Buffer.isBuffer(chunk) && this[ENCODING]) {
-          chunk = this[DECODER].write(chunk);
-        }
-        if (this[FLOWING] && this[BUFFERLENGTH] !== 0)
-          this[FLUSH](true);
-        if (this[FLOWING])
-          this.emit("data", chunk);
-        else
-          this[BUFFERPUSH](chunk);
-        if (this[BUFFERLENGTH] !== 0)
-          this.emit("readable");
-        if (cb)
-          fn(cb);
-        return this[FLOWING];
-      }
-      /**
-       * Low-level explicit read method.
-       *
-       * In objectMode, the argument is ignored, and one item is returned if
-       * available.
-       *
-       * `n` is the number of bytes (or in the case of encoding streams,
-       * characters) to consume. If `n` is not provided, then the entire buffer
-       * is returned, or `null` is returned if no data is available.
-       *
-       * If `n` is greater that the amount of data in the internal buffer,
-       * then `null` is returned.
-       */
-      read(n) {
-        if (this[DESTROYED])
-          return null;
-        this[DISCARDED] = false;
-        if (this[BUFFERLENGTH] === 0 || n === 0 || n && n > this[BUFFERLENGTH]) {
-          this[MAYBE_EMIT_END]();
-          return null;
-        }
-        if (this[OBJECTMODE])
-          n = null;
-        if (this[BUFFER].length > 1 && !this[OBJECTMODE]) {
-          this[BUFFER] = [
-            this[ENCODING] ? this[BUFFER].join("") : Buffer.concat(this[BUFFER], this[BUFFERLENGTH])
-          ];
-        }
-        const ret = this[READ](n || null, this[BUFFER][0]);
-        this[MAYBE_EMIT_END]();
-        return ret;
-      }
-      [READ](n, chunk) {
-        if (this[OBJECTMODE])
-          this[BUFFERSHIFT]();
-        else {
-          const c = chunk;
-          if (n === c.length || n === null)
-            this[BUFFERSHIFT]();
-          else if (typeof c === "string") {
-            this[BUFFER][0] = c.slice(n);
-            chunk = c.slice(0, n);
-            this[BUFFERLENGTH] -= n;
-          } else {
-            this[BUFFER][0] = c.subarray(n);
-            chunk = c.subarray(0, n);
-            this[BUFFERLENGTH] -= n;
-          }
-        }
-        this.emit("data", chunk);
-        if (!this[BUFFER].length && !this[EOF2])
-          this.emit("drain");
-        return chunk;
-      }
-      end(chunk, encoding, cb) {
-        if (typeof chunk === "function") {
-          cb = chunk;
-          chunk = void 0;
-        }
-        if (typeof encoding === "function") {
-          cb = encoding;
-          encoding = "utf8";
-        }
-        if (chunk !== void 0)
-          this.write(chunk, encoding);
-        if (cb)
-          this.once("end", cb);
-        this[EOF2] = true;
-        this.writable = false;
-        if (this[FLOWING] || !this[PAUSED])
-          this[MAYBE_EMIT_END]();
-        return this;
-      }
-      // don't let the internal resume be overwritten
-      [RESUME]() {
-        if (this[DESTROYED])
-          return;
-        if (!this[DATALISTENERS] && !this[PIPES].length) {
-          this[DISCARDED] = true;
-        }
-        this[PAUSED] = false;
-        this[FLOWING] = true;
-        this.emit("resume");
-        if (this[BUFFER].length)
-          this[FLUSH]();
-        else if (this[EOF2])
-          this[MAYBE_EMIT_END]();
-        else
-          this.emit("drain");
-      }
-      /**
-       * Resume the stream if it is currently in a paused state
-       *
-       * If called when there are no pipe destinations or `data` event listeners,
-       * this will place the stream in a "discarded" state, where all data will
-       * be thrown away. The discarded state is removed if a pipe destination or
-       * data handler is added, if pause() is called, or if any synchronous or
-       * asynchronous iteration is started.
-       */
-      resume() {
-        return this[RESUME]();
-      }
-      /**
-       * Pause the stream
-       */
-      pause() {
-        this[FLOWING] = false;
-        this[PAUSED] = true;
-        this[DISCARDED] = false;
-      }
-      /**
-       * true if the stream has been forcibly destroyed
-       */
-      get destroyed() {
-        return this[DESTROYED];
-      }
-      /**
-       * true if the stream is currently in a flowing state, meaning that
-       * any writes will be immediately emitted.
-       */
-      get flowing() {
-        return this[FLOWING];
-      }
-      /**
-       * true if the stream is currently in a paused state
-       */
-      get paused() {
-        return this[PAUSED];
-      }
-      [BUFFERPUSH](chunk) {
-        if (this[OBJECTMODE])
-          this[BUFFERLENGTH] += 1;
-        else
-          this[BUFFERLENGTH] += chunk.length;
-        this[BUFFER].push(chunk);
-      }
-      [BUFFERSHIFT]() {
-        if (this[OBJECTMODE])
-          this[BUFFERLENGTH] -= 1;
-        else
-          this[BUFFERLENGTH] -= this[BUFFER][0].length;
-        return this[BUFFER].shift();
-      }
-      [FLUSH](noDrain = false) {
-        do {
-        } while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length);
-        if (!noDrain && !this[BUFFER].length && !this[EOF2])
-          this.emit("drain");
-      }
-      [FLUSHCHUNK](chunk) {
-        this.emit("data", chunk);
-        return this[FLOWING];
-      }
-      /**
-       * Pipe all data emitted by this stream into the destination provided.
-       *
-       * Triggers the flow of data.
-       */
-      pipe(dest, opts) {
-        if (this[DESTROYED])
-          return dest;
-        this[DISCARDED] = false;
-        const ended = this[EMITTED_END];
-        opts = opts || {};
-        if (dest === proc.stdout || dest === proc.stderr)
-          opts.end = false;
-        else
-          opts.end = opts.end !== false;
-        opts.proxyErrors = !!opts.proxyErrors;
-        if (ended) {
-          if (opts.end)
-            dest.end();
-        } else {
-          this[PIPES].push(!opts.proxyErrors ? new Pipe(this, dest, opts) : new PipeProxyErrors(this, dest, opts));
-          if (this[ASYNC])
-            defer(() => this[RESUME]());
-          else
-            this[RESUME]();
-        }
-        return dest;
-      }
-      /**
-       * Fully unhook a piped destination stream.
-       *
-       * If the destination stream was the only consumer of this stream (ie,
-       * there are no other piped destinations or `'data'` event listeners)
-       * then the flow of data will stop until there is another consumer or
-       * {@link Minipass#resume} is explicitly called.
-       */
-      unpipe(dest) {
-        const p = this[PIPES].find((p2) => p2.dest === dest);
-        if (p) {
-          if (this[PIPES].length === 1) {
-            if (this[FLOWING] && this[DATALISTENERS] === 0) {
-              this[FLOWING] = false;
-            }
-            this[PIPES] = [];
-          } else
-            this[PIPES].splice(this[PIPES].indexOf(p), 1);
-          p.unpipe();
-        }
-      }
-      /**
-       * Alias for {@link Minipass#on}
-       */
-      addListener(ev, handler2) {
-        return this.on(ev, handler2);
-      }
-      /**
-       * Mostly identical to `EventEmitter.on`, with the following
-       * behavior differences to prevent data loss and unnecessary hangs:
-       *
-       * - Adding a 'data' event handler will trigger the flow of data
-       *
-       * - Adding a 'readable' event handler when there is data waiting to be read
-       *   will cause 'readable' to be emitted immediately.
-       *
-       * - Adding an 'endish' event handler ('end', 'finish', etc.) which has
-       *   already passed will cause the event to be emitted immediately and all
-       *   handlers removed.
-       *
-       * - Adding an 'error' event handler after an error has been emitted will
-       *   cause the event to be re-emitted immediately with the error previously
-       *   raised.
-       */
-      on(ev, handler2) {
-        const ret = super.on(ev, handler2);
-        if (ev === "data") {
-          this[DISCARDED] = false;
-          this[DATALISTENERS]++;
-          if (!this[PIPES].length && !this[FLOWING]) {
-            this[RESUME]();
-          }
-        } else if (ev === "readable" && this[BUFFERLENGTH] !== 0) {
-          super.emit("readable");
-        } else if (isEndish(ev) && this[EMITTED_END]) {
-          super.emit(ev);
-          this.removeAllListeners(ev);
-        } else if (ev === "error" && this[EMITTED_ERROR]) {
-          const h = handler2;
-          if (this[ASYNC])
-            defer(() => h.call(this, this[EMITTED_ERROR]));
-          else
-            h.call(this, this[EMITTED_ERROR]);
-        }
-        return ret;
-      }
-      /**
-       * Alias for {@link Minipass#off}
-       */
-      removeListener(ev, handler2) {
-        return this.off(ev, handler2);
-      }
-      /**
-       * Mostly identical to `EventEmitter.off`
-       *
-       * If a 'data' event handler is removed, and it was the last consumer
-       * (ie, there are no pipe destinations or other 'data' event listeners),
-       * then the flow of data will stop until there is another consumer or
-       * {@link Minipass#resume} is explicitly called.
-       */
-      off(ev, handler2) {
-        const ret = super.off(ev, handler2);
-        if (ev === "data") {
-          this[DATALISTENERS] = this.listeners("data").length;
-          if (this[DATALISTENERS] === 0 && !this[DISCARDED] && !this[PIPES].length) {
-            this[FLOWING] = false;
-          }
-        }
-        return ret;
-      }
-      /**
-       * Mostly identical to `EventEmitter.removeAllListeners`
-       *
-       * If all 'data' event handlers are removed, and they were the last consumer
-       * (ie, there are no pipe destinations), then the flow of data will stop
-       * until there is another consumer or {@link Minipass#resume} is explicitly
-       * called.
-       */
-      removeAllListeners(ev) {
-        const ret = super.removeAllListeners(ev);
-        if (ev === "data" || ev === void 0) {
-          this[DATALISTENERS] = 0;
-          if (!this[DISCARDED] && !this[PIPES].length) {
-            this[FLOWING] = false;
-          }
-        }
-        return ret;
-      }
-      /**
-       * true if the 'end' event has been emitted
-       */
-      get emittedEnd() {
-        return this[EMITTED_END];
-      }
-      [MAYBE_EMIT_END]() {
-        if (!this[EMITTING_END] && !this[EMITTED_END] && !this[DESTROYED] && this[BUFFER].length === 0 && this[EOF2]) {
-          this[EMITTING_END] = true;
-          this.emit("end");
-          this.emit("prefinish");
-          this.emit("finish");
-          if (this[CLOSED])
-            this.emit("close");
-          this[EMITTING_END] = false;
-        }
-      }
-      /**
-       * Mostly identical to `EventEmitter.emit`, with the following
-       * behavior differences to prevent data loss and unnecessary hangs:
-       *
-       * If the stream has been destroyed, and the event is something other
-       * than 'close' or 'error', then `false` is returned and no handlers
-       * are called.
-       *
-       * If the event is 'end', and has already been emitted, then the event
-       * is ignored. If the stream is in a paused or non-flowing state, then
-       * the event will be deferred until data flow resumes. If the stream is
-       * async, then handlers will be called on the next tick rather than
-       * immediately.
-       *
-       * If the event is 'close', and 'end' has not yet been emitted, then
-       * the event will be deferred until after 'end' is emitted.
-       *
-       * If the event is 'error', and an AbortSignal was provided for the stream,
-       * and there are no listeners, then the event is ignored, matching the
-       * behavior of node core streams in the presense of an AbortSignal.
-       *
-       * If the event is 'finish' or 'prefinish', then all listeners will be
-       * removed after emitting the event, to prevent double-firing.
-       */
-      emit(ev, ...args) {
-        const data = args[0];
-        if (ev !== "error" && ev !== "close" && ev !== DESTROYED && this[DESTROYED]) {
-          return false;
-        } else if (ev === "data") {
-          return !this[OBJECTMODE] && !data ? false : this[ASYNC] ? (defer(() => this[EMITDATA](data)), true) : this[EMITDATA](data);
-        } else if (ev === "end") {
-          return this[EMITEND]();
-        } else if (ev === "close") {
-          this[CLOSED] = true;
-          if (!this[EMITTED_END] && !this[DESTROYED])
-            return false;
-          const ret2 = super.emit("close");
-          this.removeAllListeners("close");
-          return ret2;
-        } else if (ev === "error") {
-          this[EMITTED_ERROR] = data;
-          super.emit(ERROR, data);
-          const ret2 = !this[SIGNAL] || this.listeners("error").length ? super.emit("error", data) : false;
-          this[MAYBE_EMIT_END]();
-          return ret2;
-        } else if (ev === "resume") {
-          const ret2 = super.emit("resume");
-          this[MAYBE_EMIT_END]();
-          return ret2;
-        } else if (ev === "finish" || ev === "prefinish") {
-          const ret2 = super.emit(ev);
-          this.removeAllListeners(ev);
-          return ret2;
-        }
-        const ret = super.emit(ev, ...args);
-        this[MAYBE_EMIT_END]();
-        return ret;
-      }
-      [EMITDATA](data) {
-        for (const p of this[PIPES]) {
-          if (p.dest.write(data) === false)
-            this.pause();
-        }
-        const ret = this[DISCARDED] ? false : super.emit("data", data);
-        this[MAYBE_EMIT_END]();
-        return ret;
-      }
-      [EMITEND]() {
-        if (this[EMITTED_END])
-          return false;
-        this[EMITTED_END] = true;
-        this.readable = false;
-        return this[ASYNC] ? (defer(() => this[EMITEND2]()), true) : this[EMITEND2]();
-      }
-      [EMITEND2]() {
-        if (this[DECODER]) {
-          const data = this[DECODER].end();
-          if (data) {
-            for (const p of this[PIPES]) {
-              p.dest.write(data);
-            }
-            if (!this[DISCARDED])
-              super.emit("data", data);
-          }
-        }
-        for (const p of this[PIPES]) {
-          p.end();
-        }
-        const ret = super.emit("end");
-        this.removeAllListeners("end");
-        return ret;
-      }
-      /**
-       * Return a Promise that resolves to an array of all emitted data once
-       * the stream ends.
-       */
-      async collect() {
-        const buf = Object.assign([], {
-          dataLength: 0
-        });
-        if (!this[OBJECTMODE])
-          buf.dataLength = 0;
-        const p = this.promise();
-        this.on("data", (c) => {
-          buf.push(c);
-          if (!this[OBJECTMODE])
-            buf.dataLength += c.length;
-        });
-        await p;
-        return buf;
-      }
-      /**
-       * Return a Promise that resolves to the concatenation of all emitted data
-       * once the stream ends.
-       *
-       * Not allowed on objectMode streams.
-       */
-      async concat() {
-        if (this[OBJECTMODE]) {
-          throw new Error("cannot concat in objectMode");
-        }
-        const buf = await this.collect();
-        return this[ENCODING] ? buf.join("") : Buffer.concat(buf, buf.dataLength);
-      }
-      /**
-       * Return a void Promise that resolves once the stream ends.
-       */
-      async promise() {
-        return new Promise((resolve14, reject) => {
-          this.on(DESTROYED, () => reject(new Error("stream destroyed")));
-          this.on("error", (er) => reject(er));
-          this.on("end", () => resolve14());
-        });
-      }
-      /**
-       * Asynchronous `for await of` iteration.
-       *
-       * This will continue emitting all chunks until the stream terminates.
-       */
-      [Symbol.asyncIterator]() {
-        this[DISCARDED] = false;
-        let stopped = false;
-        const stop = async () => {
-          this.pause();
-          stopped = true;
-          return { value: void 0, done: true };
-        };
-        const next = () => {
-          if (stopped)
-            return stop();
-          const res = this.read();
-          if (res !== null)
-            return Promise.resolve({ done: false, value: res });
-          if (this[EOF2])
-            return stop();
-          let resolve14;
-          let reject;
-          const onerr = (er) => {
-            this.off("data", ondata);
-            this.off("end", onend);
-            this.off(DESTROYED, ondestroy);
-            stop();
-            reject(er);
-          };
-          const ondata = (value) => {
-            this.off("error", onerr);
-            this.off("end", onend);
-            this.off(DESTROYED, ondestroy);
-            this.pause();
-            resolve14({ value, done: !!this[EOF2] });
-          };
-          const onend = () => {
-            this.off("error", onerr);
-            this.off("data", ondata);
-            this.off(DESTROYED, ondestroy);
-            stop();
-            resolve14({ done: true, value: void 0 });
-          };
-          const ondestroy = () => onerr(new Error("stream destroyed"));
-          return new Promise((res2, rej) => {
-            reject = rej;
-            resolve14 = res2;
-            this.once(DESTROYED, ondestroy);
-            this.once("error", onerr);
-            this.once("end", onend);
-            this.once("data", ondata);
-          });
-        };
-        return {
-          next,
-          throw: stop,
-          return: stop,
-          [Symbol.asyncIterator]() {
-            return this;
+        slashSplit(t) {
+          return this.preserveMultipleSlashes ? t.split("/") : this.isWindows && /^\/\/[^\/]+/.test(t) ? ["", ...t.split(/\/+/)] : t.split(/\/+/);
+        }
+        match(t, e = this.partial) {
+          if (this.debug("match", t, this.pattern), this.comment) return false;
+          if (this.empty) return t === "";
+          if (t === "/" && e) return true;
+          let s = this.options;
+          this.isWindows && (t = t.split("\\").join("/"));
+          let i = this.slashSplit(t);
+          this.debug(this.pattern, "split", i);
+          let r = this.set;
+          this.debug(this.pattern, "set", r);
+          let h = i[i.length - 1];
+          if (!h) for (let o = i.length - 2; !h && o >= 0; o--) h = i[o];
+          for (let o = 0; o < r.length; o++) {
+            let a = r[o], l = i;
+            if (s.matchBase && a.length === 1 && (l = [h]), this.matchOne(l, a, e)) return s.flipNegate ? true : !this.negate;
+          }
+          return s.flipNegate ? false : this.negate;
+        }
+        static defaults(t) {
+          return g.minimatch.defaults(t).Minimatch;
+        }
+      };
+      g.Minimatch = J;
+      var Zi = pe();
+      Object.defineProperty(g, "AST", { enumerable: true, get: function() {
+        return Zi.AST;
+      } });
+      var Qi = me();
+      Object.defineProperty(g, "escape", { enumerable: true, get: function() {
+        return Qi.escape;
+      } });
+      var tr = kt();
+      Object.defineProperty(g, "unescape", { enumerable: true, get: function() {
+        return tr.unescape;
+      } });
+      g.minimatch.AST = is.AST;
+      g.minimatch.Minimatch = J;
+      g.minimatch.escape = vi.escape;
+      g.minimatch.unescape = Ei.unescape;
+    });
+    var fs31 = R((Wt) => {
+      "use strict";
+      Object.defineProperty(Wt, "__esModule", { value: true });
+      Wt.LRUCache = void 0;
+      var er = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date, as = /* @__PURE__ */ new Set(), ge = typeof process == "object" && process ? process : {}, ls = (n, t, e, s) => {
+        typeof ge.emitWarning == "function" ? ge.emitWarning(n, t, e, s) : console.error(`[${e}] ${t}: ${n}`);
+      }, Lt = globalThis.AbortController, os7 = globalThis.AbortSignal;
+      if (typeof Lt > "u") {
+        os7 = class {
+          onabort;
+          _onabort = [];
+          reason;
+          aborted = false;
+          addEventListener(e, s) {
+            this._onabort.push(s);
+          }
+        }, Lt = class {
+          constructor() {
+            t();
+          }
+          signal = new os7();
+          abort(e) {
+            if (!this.signal.aborted) {
+              this.signal.reason = e, this.signal.aborted = true;
+              for (let s of this.signal._onabort) s(e);
+              this.signal.onabort?.(e);
+            }
           }
         };
-      }
-      /**
-       * Synchronous `for of` iteration.
-       *
-       * The iteration will terminate when the internal buffer runs out, even
-       * if the stream has not yet terminated.
-       */
-      [Symbol.iterator]() {
-        this[DISCARDED] = false;
-        let stopped = false;
-        const stop = () => {
-          this.pause();
-          this.off(ERROR, stop);
-          this.off(DESTROYED, stop);
-          this.off("end", stop);
-          stopped = true;
-          return { done: true, value: void 0 };
-        };
-        const next = () => {
-          if (stopped)
-            return stop();
-          const value = this.read();
-          return value === null ? stop() : { done: false, value };
-        };
-        this.once("end", stop);
-        this.once(ERROR, stop);
-        this.once(DESTROYED, stop);
-        return {
-          next,
-          throw: stop,
-          return: stop,
-          [Symbol.iterator]() {
-            return this;
-          }
+        let n = ge.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t = () => {
+          n && (n = false, ls("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", t));
         };
       }
-      /**
-       * Destroy a stream, preventing it from being used for any further purpose.
-       *
-       * If the stream has a `close()` method, then it will be called on
-       * destruction.
-       *
-       * After destruction, any attempt to write data, read data, or emit most
-       * events will be ignored.
-       *
-       * If an error argument is provided, then it will be emitted in an
-       * 'error' event.
-       */
-      destroy(er) {
-        if (this[DESTROYED]) {
-          if (er)
-            this.emit("error", er);
-          else
-            this.emit(DESTROYED);
-          return this;
-        }
-        this[DESTROYED] = true;
-        this[DISCARDED] = true;
-        this[BUFFER].length = 0;
-        this[BUFFERLENGTH] = 0;
-        const wc = this;
-        if (typeof wc.close === "function" && !this[CLOSED])
-          wc.close();
-        if (er)
-          this.emit("error", er);
-        else
-          this.emit(DESTROYED);
-        return this;
-      }
-      /**
-       * Alias for {@link isStream}
-       *
-       * Former export location, maintained for backwards compatibility.
-       *
-       * @deprecated
-       */
-      static get isStream() {
-        return exports2.isStream;
-      }
-    };
-    exports2.Minipass = Minipass;
-  }
-});
-
-// node_modules/path-scurry/dist/commonjs/index.js
-var require_commonjs23 = __commonJS({
-  "node_modules/path-scurry/dist/commonjs/index.js"(exports2) {
-    "use strict";
-    var __createBinding2 = exports2 && exports2.__createBinding || (Object.create ? (function(o, m, k, k2) {
-      if (k2 === void 0) 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 === void 0) k2 = k;
-      o[k2] = m[k];
-    }));
-    var __setModuleDefault2 = exports2 && exports2.__setModuleDefault || (Object.create ? (function(o, v) {
-      Object.defineProperty(o, "default", { enumerable: true, value: v });
-    }) : function(o, v) {
-      o["default"] = v;
-    });
-    var __importStar2 = exports2 && exports2.__importStar || function(mod) {
-      if (mod && mod.__esModule) return mod;
-      var result = {};
-      if (mod != null) {
-        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding2(result, mod, k);
-      }
-      __setModuleDefault2(result, mod);
-      return result;
-    };
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.PathScurry = exports2.Path = exports2.PathScurryDarwin = exports2.PathScurryPosix = exports2.PathScurryWin32 = exports2.PathScurryBase = exports2.PathPosix = exports2.PathWin32 = exports2.PathBase = exports2.ChildrenCache = exports2.ResolveCache = void 0;
-    var lru_cache_1 = require_commonjs21();
-    var node_path_1 = require("node:path");
-    var node_url_1 = require("node:url");
-    var fs_1 = require("fs");
-    var actualFS = __importStar2(require("node:fs"));
-    var realpathSync = fs_1.realpathSync.native;
-    var promises_1 = require("node:fs/promises");
-    var minipass_1 = require_commonjs22();
-    var defaultFS = {
-      lstatSync: fs_1.lstatSync,
-      readdir: fs_1.readdir,
-      readdirSync: fs_1.readdirSync,
-      readlinkSync: fs_1.readlinkSync,
-      realpathSync,
-      promises: {
-        lstat: promises_1.lstat,
-        readdir: promises_1.readdir,
-        readlink: promises_1.readlink,
-        realpath: promises_1.realpath
-      }
-    };
-    var fsFromOption = (fsOption) => !fsOption || fsOption === defaultFS || fsOption === actualFS ? defaultFS : {
-      ...defaultFS,
-      ...fsOption,
-      promises: {
-        ...defaultFS.promises,
-        ...fsOption.promises || {}
-      }
-    };
-    var uncDriveRegexp = /^\\\\\?\\([a-z]:)\\?$/i;
-    var uncToDrive = (rootPath) => rootPath.replace(/\//g, "\\").replace(uncDriveRegexp, "$1\\");
-    var eitherSep = /[\\\/]/;
-    var UNKNOWN = 0;
-    var IFIFO = 1;
-    var IFCHR = 2;
-    var IFDIR = 4;
-    var IFBLK = 6;
-    var IFREG = 8;
-    var IFLNK = 10;
-    var IFSOCK = 12;
-    var IFMT = 15;
-    var IFMT_UNKNOWN = ~IFMT;
-    var READDIR_CALLED = 16;
-    var LSTAT_CALLED = 32;
-    var ENOTDIR = 64;
-    var ENOENT = 128;
-    var ENOREADLINK = 256;
-    var ENOREALPATH = 512;
-    var ENOCHILD = ENOTDIR | ENOENT | ENOREALPATH;
-    var TYPEMASK = 1023;
-    var entToType = (s) => s.isFile() ? IFREG : s.isDirectory() ? IFDIR : s.isSymbolicLink() ? IFLNK : s.isCharacterDevice() ? IFCHR : s.isBlockDevice() ? IFBLK : s.isSocket() ? IFSOCK : s.isFIFO() ? IFIFO : UNKNOWN;
-    var normalizeCache = /* @__PURE__ */ new Map();
-    var normalize3 = (s) => {
-      const c = normalizeCache.get(s);
-      if (c)
-        return c;
-      const n = s.normalize("NFKD");
-      normalizeCache.set(s, n);
-      return n;
-    };
-    var normalizeNocaseCache = /* @__PURE__ */ new Map();
-    var normalizeNocase = (s) => {
-      const c = normalizeNocaseCache.get(s);
-      if (c)
-        return c;
-      const n = normalize3(s.toLowerCase());
-      normalizeNocaseCache.set(s, n);
-      return n;
-    };
-    var ResolveCache = class extends lru_cache_1.LRUCache {
-      constructor() {
-        super({ max: 256 });
-      }
-    };
-    exports2.ResolveCache = ResolveCache;
-    var ChildrenCache = class extends lru_cache_1.LRUCache {
-      constructor(maxSize = 16 * 1024) {
-        super({
-          maxSize,
-          // parent + children
-          sizeCalculation: (a) => a.length + 1
-        });
-      }
-    };
-    exports2.ChildrenCache = ChildrenCache;
-    var setAsCwd = /* @__PURE__ */ Symbol("PathScurry setAsCwd");
-    var PathBase = class {
-      /**
-       * the basename of this path
-       *
-       * **Important**: *always* test the path name against any test string
-       * usingthe {@link isNamed} method, and not by directly comparing this
-       * string. Otherwise, unicode path strings that the system sees as identical
-       * will not be properly treated as the same path, leading to incorrect
-       * behavior and possible security issues.
-       */
-      name;
-      /**
-       * the Path entry corresponding to the path root.
-       *
-       * @internal
-       */
-      root;
-      /**
-       * All roots found within the current PathScurry family
-       *
-       * @internal
-       */
-      roots;
-      /**
-       * a reference to the parent path, or undefined in the case of root entries
-       *
-       * @internal
-       */
-      parent;
-      /**
-       * boolean indicating whether paths are compared case-insensitively
-       * @internal
-       */
-      nocase;
-      /**
-       * boolean indicating that this path is the current working directory
-       * of the PathScurry collection that contains it.
-       */
-      isCWD = false;
-      // potential default fs override
-      #fs;
-      // Stats fields
-      #dev;
-      get dev() {
-        return this.#dev;
-      }
-      #mode;
-      get mode() {
-        return this.#mode;
-      }
-      #nlink;
-      get nlink() {
-        return this.#nlink;
-      }
-      #uid;
-      get uid() {
-        return this.#uid;
-      }
-      #gid;
-      get gid() {
-        return this.#gid;
-      }
-      #rdev;
-      get rdev() {
-        return this.#rdev;
-      }
-      #blksize;
-      get blksize() {
-        return this.#blksize;
-      }
-      #ino;
-      get ino() {
-        return this.#ino;
-      }
-      #size;
-      get size() {
-        return this.#size;
-      }
-      #blocks;
-      get blocks() {
-        return this.#blocks;
-      }
-      #atimeMs;
-      get atimeMs() {
-        return this.#atimeMs;
-      }
-      #mtimeMs;
-      get mtimeMs() {
-        return this.#mtimeMs;
-      }
-      #ctimeMs;
-      get ctimeMs() {
-        return this.#ctimeMs;
-      }
-      #birthtimeMs;
-      get birthtimeMs() {
-        return this.#birthtimeMs;
-      }
-      #atime;
-      get atime() {
-        return this.#atime;
-      }
-      #mtime;
-      get mtime() {
-        return this.#mtime;
-      }
-      #ctime;
-      get ctime() {
-        return this.#ctime;
-      }
-      #birthtime;
-      get birthtime() {
-        return this.#birthtime;
-      }
-      #matchName;
-      #depth;
-      #fullpath;
-      #fullpathPosix;
-      #relative;
-      #relativePosix;
-      #type;
-      #children;
-      #linkTarget;
-      #realpath;
-      /**
-       * This property is for compatibility with the Dirent class as of
-       * Node v20, where Dirent['parentPath'] refers to the path of the
-       * directory that was passed to readdir. For root entries, it's the path
-       * to the entry itself.
-       */
-      get parentPath() {
-        return (this.parent || this).fullpath();
-      }
-      /**
-       * Deprecated alias for Dirent['parentPath'] Somewhat counterintuitively,
-       * this property refers to the *parent* path, not the path object itself.
-       *
-       * @deprecated
-       */
-      get path() {
-        return this.parentPath;
-      }
-      /**
-       * Do not create new Path objects directly.  They should always be accessed
-       * via the PathScurry class or other methods on the Path class.
-       *
-       * @internal
-       */
-      constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
-        this.name = name;
-        this.#matchName = nocase ? normalizeNocase(name) : normalize3(name);
-        this.#type = type & TYPEMASK;
-        this.nocase = nocase;
-        this.roots = roots;
-        this.root = root || this;
-        this.#children = children;
-        this.#fullpath = opts.fullpath;
-        this.#relative = opts.relative;
-        this.#relativePosix = opts.relativePosix;
-        this.parent = opts.parent;
-        if (this.parent) {
-          this.#fs = this.parent.#fs;
-        } else {
-          this.#fs = fsFromOption(opts.fs);
-        }
-      }
-      /**
-       * Returns the depth of the Path object from its root.
-       *
-       * For example, a path at `/foo/bar` would have a depth of 2.
-       */
-      depth() {
-        if (this.#depth !== void 0)
-          return this.#depth;
-        if (!this.parent)
-          return this.#depth = 0;
-        return this.#depth = this.parent.depth() + 1;
-      }
-      /**
-       * @internal
-       */
-      childrenCache() {
-        return this.#children;
-      }
-      /**
-       * Get the Path object referenced by the string path, resolved from this Path
-       */
-      resolve(path29) {
-        if (!path29) {
-          return this;
-        }
-        const rootPath = this.getRootString(path29);
-        const dir = path29.substring(rootPath.length);
-        const dirParts = dir.split(this.splitSep);
-        const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
-        return result;
-      }
-      #resolveParts(dirParts) {
-        let p = this;
-        for (const part of dirParts) {
-          p = p.child(part);
-        }
-        return p;
-      }
-      /**
-       * Returns the cached children Path objects, if still available.  If they
-       * have fallen out of the cache, then returns an empty array, and resets the
-       * READDIR_CALLED bit, so that future calls to readdir() will require an fs
-       * lookup.
-       *
-       * @internal
-       */
-      children() {
-        const cached = this.#children.get(this);
-        if (cached) {
-          return cached;
-        }
-        const children = Object.assign([], { provisional: 0 });
-        this.#children.set(this, children);
-        this.#type &= ~READDIR_CALLED;
-        return children;
-      }
-      /**
-       * Resolves a path portion and returns or creates the child Path.
-       *
-       * Returns `this` if pathPart is `''` or `'.'`, or `parent` if pathPart is
-       * `'..'`.
-       *
-       * This should not be called directly.  If `pathPart` contains any path
-       * separators, it will lead to unsafe undefined behavior.
-       *
-       * Use `Path.resolve()` instead.
-       *
-       * @internal
-       */
-      child(pathPart, opts) {
-        if (pathPart === "" || pathPart === ".") {
-          return this;
-        }
-        if (pathPart === "..") {
-          return this.parent || this;
-        }
-        const children = this.children();
-        const name = this.nocase ? normalizeNocase(pathPart) : normalize3(pathPart);
-        for (const p of children) {
-          if (p.#matchName === name) {
-            return p;
-          }
-        }
-        const s = this.parent ? this.sep : "";
-        const fullpath = this.#fullpath ? this.#fullpath + s + pathPart : void 0;
-        const pchild = this.newChild(pathPart, UNKNOWN, {
-          ...opts,
-          parent: this,
-          fullpath
-        });
-        if (!this.canReaddir()) {
-          pchild.#type |= ENOENT;
-        }
-        children.push(pchild);
-        return pchild;
-      }
-      /**
-       * The relative path from the cwd. If it does not share an ancestor with
-       * the cwd, then this ends up being equivalent to the fullpath()
-       */
-      relative() {
-        if (this.isCWD)
-          return "";
-        if (this.#relative !== void 0) {
-          return this.#relative;
-        }
-        const name = this.name;
-        const p = this.parent;
-        if (!p) {
-          return this.#relative = this.name;
-        }
-        const pv = p.relative();
-        return pv + (!pv || !p.parent ? "" : this.sep) + name;
-      }
-      /**
-       * The relative path from the cwd, using / as the path separator.
-       * If it does not share an ancestor with
-       * the cwd, then this ends up being equivalent to the fullpathPosix()
-       * On posix systems, this is identical to relative().
-       */
-      relativePosix() {
-        if (this.sep === "/")
-          return this.relative();
-        if (this.isCWD)
-          return "";
-        if (this.#relativePosix !== void 0)
-          return this.#relativePosix;
-        const name = this.name;
-        const p = this.parent;
-        if (!p) {
-          return this.#relativePosix = this.fullpathPosix();
-        }
-        const pv = p.relativePosix();
-        return pv + (!pv || !p.parent ? "" : "/") + name;
-      }
-      /**
-       * The fully resolved path string for this Path entry
-       */
-      fullpath() {
-        if (this.#fullpath !== void 0) {
-          return this.#fullpath;
+      var sr = (n) => !as.has(n), V = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n), cs = (n) => V(n) ? n <= Math.pow(2, 8) ? Uint8Array : n <= Math.pow(2, 16) ? Uint16Array : n <= Math.pow(2, 32) ? Uint32Array : n <= Number.MAX_SAFE_INTEGER ? Nt : null : null, Nt = class extends Array {
+        constructor(n) {
+          super(n), this.fill(0);
         }
-        const name = this.name;
-        const p = this.parent;
-        if (!p) {
-          return this.#fullpath = this.name;
+      }, ir = class at {
+        heap;
+        length;
+        static #t = false;
+        static create(t) {
+          let e = cs(t);
+          if (!e) return [];
+          at.#t = true;
+          let s = new at(t, e);
+          return at.#t = false, s;
         }
-        const pv = p.fullpath();
-        const fp = pv + (!p.parent ? "" : this.sep) + name;
-        return this.#fullpath = fp;
-      }
-      /**
-       * On platforms other than windows, this is identical to fullpath.
-       *
-       * On windows, this is overridden to return the forward-slash form of the
-       * full UNC path.
-       */
-      fullpathPosix() {
-        if (this.#fullpathPosix !== void 0)
-          return this.#fullpathPosix;
-        if (this.sep === "/")
-          return this.#fullpathPosix = this.fullpath();
-        if (!this.parent) {
-          const p2 = this.fullpath().replace(/\\/g, "/");
-          if (/^[a-z]:\//i.test(p2)) {
-            return this.#fullpathPosix = `//?/${p2}`;
-          } else {
-            return this.#fullpathPosix = p2;
-          }
+        constructor(t, e) {
+          if (!at.#t) throw new TypeError("instantiate Stack using Stack.create(n)");
+          this.heap = new e(t), this.length = 0;
         }
-        const p = this.parent;
-        const pfpp = p.fullpathPosix();
-        const fpp = pfpp + (!pfpp || !p.parent ? "" : "/") + this.name;
-        return this.#fullpathPosix = fpp;
-      }
-      /**
-       * Is the Path of an unknown type?
-       *
-       * Note that we might know *something* about it if there has been a previous
-       * filesystem operation, for example that it does not exist, or is not a
-       * link, or whether it has child entries.
-       */
-      isUnknown() {
-        return (this.#type & IFMT) === UNKNOWN;
-      }
-      isType(type) {
-        return this[`is${type}`]();
-      }
-      getType() {
-        return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : (
-          /* c8 ignore start */
-          this.isSocket() ? "Socket" : "Unknown"
-        );
-      }
-      /**
-       * Is the Path a regular file?
-       */
-      isFile() {
-        return (this.#type & IFMT) === IFREG;
-      }
-      /**
-       * Is the Path a directory?
-       */
-      isDirectory() {
-        return (this.#type & IFMT) === IFDIR;
-      }
-      /**
-       * Is the path a character device?
-       */
-      isCharacterDevice() {
-        return (this.#type & IFMT) === IFCHR;
-      }
-      /**
-       * Is the path a block device?
-       */
-      isBlockDevice() {
-        return (this.#type & IFMT) === IFBLK;
-      }
-      /**
-       * Is the path a FIFO pipe?
-       */
-      isFIFO() {
-        return (this.#type & IFMT) === IFIFO;
-      }
-      /**
-       * Is the path a socket?
-       */
-      isSocket() {
-        return (this.#type & IFMT) === IFSOCK;
-      }
-      /**
-       * Is the path a symbolic link?
-       */
-      isSymbolicLink() {
-        return (this.#type & IFLNK) === IFLNK;
-      }
-      /**
-       * Return the entry if it has been subject of a successful lstat, or
-       * undefined otherwise.
-       *
-       * Does not read the filesystem, so an undefined result *could* simply
-       * mean that we haven't called lstat on it.
-       */
-      lstatCached() {
-        return this.#type & LSTAT_CALLED ? this : void 0;
-      }
-      /**
-       * Return the cached link target if the entry has been the subject of a
-       * successful readlink, or undefined otherwise.
-       *
-       * Does not read the filesystem, so an undefined result *could* just mean we
-       * don't have any cached data. Only use it if you are very sure that a
-       * readlink() has been called at some point.
-       */
-      readlinkCached() {
-        return this.#linkTarget;
-      }
-      /**
-       * Returns the cached realpath target if the entry has been the subject
-       * of a successful realpath, or undefined otherwise.
-       *
-       * Does not read the filesystem, so an undefined result *could* just mean we
-       * don't have any cached data. Only use it if you are very sure that a
-       * realpath() has been called at some point.
-       */
-      realpathCached() {
-        return this.#realpath;
-      }
-      /**
-       * Returns the cached child Path entries array if the entry has been the
-       * subject of a successful readdir(), or [] otherwise.
-       *
-       * Does not read the filesystem, so an empty array *could* just mean we
-       * don't have any cached data. Only use it if you are very sure that a
-       * readdir() has been called recently enough to still be valid.
-       */
-      readdirCached() {
-        const children = this.children();
-        return children.slice(0, children.provisional);
-      }
-      /**
-       * Return true if it's worth trying to readlink.  Ie, we don't (yet) have
-       * any indication that readlink will definitely fail.
-       *
-       * Returns false if the path is known to not be a symlink, if a previous
-       * readlink failed, or if the entry does not exist.
-       */
-      canReadlink() {
-        if (this.#linkTarget)
-          return true;
-        if (!this.parent)
-          return false;
-        const ifmt = this.#type & IFMT;
-        return !(ifmt !== UNKNOWN && ifmt !== IFLNK || this.#type & ENOREADLINK || this.#type & ENOENT);
-      }
-      /**
-       * Return true if readdir has previously been successfully called on this
-       * path, indicating that cachedReaddir() is likely valid.
-       */
-      calledReaddir() {
-        return !!(this.#type & READDIR_CALLED);
-      }
-      /**
-       * Returns true if the path is known to not exist. That is, a previous lstat
-       * or readdir failed to verify its existence when that would have been
-       * expected, or a parent entry was marked either enoent or enotdir.
-       */
-      isENOENT() {
-        return !!(this.#type & ENOENT);
-      }
-      /**
-       * Return true if the path is a match for the given path name.  This handles
-       * case sensitivity and unicode normalization.
-       *
-       * Note: even on case-sensitive systems, it is **not** safe to test the
-       * equality of the `.name` property to determine whether a given pathname
-       * matches, due to unicode normalization mismatches.
-       *
-       * Always use this method instead of testing the `path.name` property
-       * directly.
-       */
-      isNamed(n) {
-        return !this.nocase ? this.#matchName === normalize3(n) : this.#matchName === normalizeNocase(n);
-      }
-      /**
-       * Return the Path object corresponding to the target of a symbolic link.
-       *
-       * If the Path is not a symbolic link, or if the readlink call fails for any
-       * reason, `undefined` is returned.
-       *
-       * Result is cached, and thus may be outdated if the filesystem is mutated.
-       */
-      async readlink() {
-        const target = this.#linkTarget;
-        if (target) {
-          return target;
+        push(t) {
+          this.heap[this.length++] = t;
         }
-        if (!this.canReadlink()) {
-          return void 0;
+        pop() {
+          return this.heap[--this.length];
+        }
+      }, rr = class us {
+        #t;
+        #s;
+        #n;
+        #r;
+        #h;
+        #S;
+        #w;
+        #c;
+        get perf() {
+          return this.#c;
+        }
+        ttl;
+        ttlResolution;
+        ttlAutopurge;
+        updateAgeOnGet;
+        updateAgeOnHas;
+        allowStale;
+        noDisposeOnSet;
+        noUpdateTTL;
+        maxEntrySize;
+        sizeCalculation;
+        noDeleteOnFetchRejection;
+        noDeleteOnStaleGet;
+        allowStaleOnFetchAbort;
+        allowStaleOnFetchRejection;
+        ignoreFetchAbort;
+        #o;
+        #f;
+        #u;
+        #a;
+        #i;
+        #d;
+        #v;
+        #y;
+        #p;
+        #R;
+        #m;
+        #O;
+        #x;
+        #g;
+        #b;
+        #E;
+        #T;
+        #e;
+        #F;
+        static unsafeExposeInternals(t) {
+          return { starts: t.#x, ttls: t.#g, autopurgeTimers: t.#b, sizes: t.#O, keyMap: t.#u, keyList: t.#a, valList: t.#i, next: t.#d, prev: t.#v, get head() {
+            return t.#y;
+          }, get tail() {
+            return t.#p;
+          }, free: t.#R, isBackgroundFetch: (e) => t.#l(e), backgroundFetch: (e, s, i, r) => t.#z(e, s, i, r), moveToTail: (e) => t.#N(e), indexes: (e) => t.#k(e), rindexes: (e) => t.#M(e), isStale: (e) => t.#_(e) };
+        }
+        get max() {
+          return this.#t;
+        }
+        get maxSize() {
+          return this.#s;
+        }
+        get calculatedSize() {
+          return this.#f;
         }
-        if (!this.parent) {
-          return void 0;
+        get size() {
+          return this.#o;
+        }
+        get fetchMethod() {
+          return this.#S;
+        }
+        get memoMethod() {
+          return this.#w;
+        }
+        get dispose() {
+          return this.#n;
+        }
+        get onInsert() {
+          return this.#r;
+        }
+        get disposeAfter() {
+          return this.#h;
+        }
+        constructor(t) {
+          let { max: e = 0, ttl: s, ttlResolution: i = 1, ttlAutopurge: r, updateAgeOnGet: h, updateAgeOnHas: o, allowStale: a, dispose: l, onInsert: f, disposeAfter: c, noDisposeOnSet: d, noUpdateTTL: u, maxSize: m = 0, maxEntrySize: p = 0, sizeCalculation: b, fetchMethod: w, memoMethod: v, noDeleteOnFetchRejection: E, noDeleteOnStaleGet: y, allowStaleOnFetchRejection: S, allowStaleOnFetchAbort: B, ignoreFetchAbort: U, perf: et } = t;
+          if (et !== void 0 && typeof et?.now != "function") throw new TypeError("perf option must have a now() method if specified");
+          if (this.#c = et ?? er, e !== 0 && !V(e)) throw new TypeError("max option must be a nonnegative integer");
+          let st = e ? cs(e) : Array;
+          if (!st) throw new Error("invalid max value: " + e);
+          if (this.#t = e, this.#s = m, this.maxEntrySize = p || this.#s, this.sizeCalculation = b, this.sizeCalculation) {
+            if (!this.#s && !this.maxEntrySize) throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+            if (typeof this.sizeCalculation != "function") throw new TypeError("sizeCalculation set to non-function");
+          }
+          if (v !== void 0 && typeof v != "function") throw new TypeError("memoMethod must be a function if defined");
+          if (this.#w = v, w !== void 0 && typeof w != "function") throw new TypeError("fetchMethod must be a function if specified");
+          if (this.#S = w, this.#T = !!w, this.#u = /* @__PURE__ */ new Map(), this.#a = new Array(e).fill(void 0), this.#i = new Array(e).fill(void 0), this.#d = new st(e), this.#v = new st(e), this.#y = 0, this.#p = 0, this.#R = ir.create(e), this.#o = 0, this.#f = 0, typeof l == "function" && (this.#n = l), typeof f == "function" && (this.#r = f), typeof c == "function" ? (this.#h = c, this.#m = []) : (this.#h = void 0, this.#m = void 0), this.#E = !!this.#n, this.#F = !!this.#r, this.#e = !!this.#h, this.noDisposeOnSet = !!d, this.noUpdateTTL = !!u, this.noDeleteOnFetchRejection = !!E, this.allowStaleOnFetchRejection = !!S, this.allowStaleOnFetchAbort = !!B, this.ignoreFetchAbort = !!U, this.maxEntrySize !== 0) {
+            if (this.#s !== 0 && !V(this.#s)) throw new TypeError("maxSize must be a positive integer if specified");
+            if (!V(this.maxEntrySize)) throw new TypeError("maxEntrySize must be a positive integer if specified");
+            this.#$();
+          }
+          if (this.allowStale = !!a, this.noDeleteOnStaleGet = !!y, this.updateAgeOnGet = !!h, this.updateAgeOnHas = !!o, this.ttlResolution = V(i) || i === 0 ? i : 1, this.ttlAutopurge = !!r, this.ttl = s || 0, this.ttl) {
+            if (!V(this.ttl)) throw new TypeError("ttl must be a positive integer if specified");
+            this.#P();
+          }
+          if (this.#t === 0 && this.ttl === 0 && this.#s === 0) throw new TypeError("At least one of max, maxSize, or ttl is required");
+          if (!this.ttlAutopurge && !this.#t && !this.#s) {
+            let le = "LRU_CACHE_UNBOUNDED";
+            sr(le) && (as.add(le), ls("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", le, us));
+          }
+        }
+        getRemainingTTL(t) {
+          return this.#u.has(t) ? 1 / 0 : 0;
+        }
+        #P() {
+          let t = new Nt(this.#t), e = new Nt(this.#t);
+          this.#g = t, this.#x = e;
+          let s = this.ttlAutopurge ? new Array(this.#t) : void 0;
+          this.#b = s, this.#W = (h, o, a = this.#c.now()) => {
+            if (e[h] = o !== 0 ? a : 0, t[h] = o, s?.[h] && (clearTimeout(s[h]), s[h] = void 0), o !== 0 && s) {
+              let l = setTimeout(() => {
+                this.#_(h) && this.#A(this.#a[h], "expire");
+              }, o + 1);
+              l.unref && l.unref(), s[h] = l;
+            }
+          }, this.#C = (h) => {
+            e[h] = t[h] !== 0 ? this.#c.now() : 0;
+          }, this.#D = (h, o) => {
+            if (t[o]) {
+              let a = t[o], l = e[o];
+              if (!a || !l) return;
+              h.ttl = a, h.start = l, h.now = i || r();
+              let f = h.now - l;
+              h.remainingTTL = a - f;
+            }
+          };
+          let i = 0, r = () => {
+            let h = this.#c.now();
+            if (this.ttlResolution > 0) {
+              i = h;
+              let o = setTimeout(() => i = 0, this.ttlResolution);
+              o.unref && o.unref();
+            }
+            return h;
+          };
+          this.getRemainingTTL = (h) => {
+            let o = this.#u.get(h);
+            if (o === void 0) return 0;
+            let a = t[o], l = e[o];
+            if (!a || !l) return 1 / 0;
+            let f = (i || r()) - l;
+            return a - f;
+          }, this.#_ = (h) => {
+            let o = e[h], a = t[h];
+            return !!a && !!o && (i || r()) - o > a;
+          };
         }
-        try {
-          const read = await this.#fs.promises.readlink(this.fullpath());
-          const linkTarget = (await this.parent.realpath())?.resolve(read);
-          if (linkTarget) {
-            return this.#linkTarget = linkTarget;
-          }
-        } catch (er) {
-          this.#readlinkFail(er.code);
-          return void 0;
+        #C = () => {
+        };
+        #D = () => {
+        };
+        #W = () => {
+        };
+        #_ = () => false;
+        #$() {
+          let t = new Nt(this.#t);
+          this.#f = 0, this.#O = t, this.#L = (e) => {
+            this.#f -= t[e], t[e] = 0;
+          }, this.#B = (e, s, i, r) => {
+            if (this.#l(s)) return 0;
+            if (!V(i)) if (r) {
+              if (typeof r != "function") throw new TypeError("sizeCalculation must be a function");
+              if (i = r(s, e), !V(i)) throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+            } else throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+            return i;
+          }, this.#j = (e, s, i) => {
+            if (t[e] = s, this.#s) {
+              let r = this.#s - t[e];
+              for (; this.#f > r; ) this.#G(true);
+            }
+            this.#f += t[e], i && (i.entrySize = s, i.totalCalculatedSize = this.#f);
+          };
         }
-      }
-      /**
-       * Synchronous {@link PathBase.readlink}
-       */
-      readlinkSync() {
-        const target = this.#linkTarget;
-        if (target) {
-          return target;
+        #L = (t) => {
+        };
+        #j = (t, e, s) => {
+        };
+        #B = (t, e, s, i) => {
+          if (s || i) throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+          return 0;
+        };
+        *#k({ allowStale: t = this.allowStale } = {}) {
+          if (this.#o) for (let e = this.#p; !(!this.#I(e) || ((t || !this.#_(e)) && (yield e), e === this.#y)); ) e = this.#v[e];
         }
-        if (!this.canReadlink()) {
-          return void 0;
+        *#M({ allowStale: t = this.allowStale } = {}) {
+          if (this.#o) for (let e = this.#y; !(!this.#I(e) || ((t || !this.#_(e)) && (yield e), e === this.#p)); ) e = this.#d[e];
         }
-        if (!this.parent) {
-          return void 0;
+        #I(t) {
+          return t !== void 0 && this.#u.get(this.#a[t]) === t;
         }
-        try {
-          const read = this.#fs.readlinkSync(this.fullpath());
-          const linkTarget = this.parent.realpathSync()?.resolve(read);
-          if (linkTarget) {
-            return this.#linkTarget = linkTarget;
+        *entries() {
+          for (let t of this.#k()) this.#i[t] !== void 0 && this.#a[t] !== void 0 && !this.#l(this.#i[t]) && (yield [this.#a[t], this.#i[t]]);
+        }
+        *rentries() {
+          for (let t of this.#M()) this.#i[t] !== void 0 && this.#a[t] !== void 0 && !this.#l(this.#i[t]) && (yield [this.#a[t], this.#i[t]]);
+        }
+        *keys() {
+          for (let t of this.#k()) {
+            let e = this.#a[t];
+            e !== void 0 && !this.#l(this.#i[t]) && (yield e);
           }
-        } catch (er) {
-          this.#readlinkFail(er.code);
-          return void 0;
         }
-      }
-      #readdirSuccess(children) {
-        this.#type |= READDIR_CALLED;
-        for (let p = children.provisional; p < children.length; p++) {
-          const c = children[p];
-          if (c)
-            c.#markENOENT();
+        *rkeys() {
+          for (let t of this.#M()) {
+            let e = this.#a[t];
+            e !== void 0 && !this.#l(this.#i[t]) && (yield e);
+          }
         }
-      }
-      #markENOENT() {
-        if (this.#type & ENOENT)
-          return;
-        this.#type = (this.#type | ENOENT) & IFMT_UNKNOWN;
-        this.#markChildrenENOENT();
-      }
-      #markChildrenENOENT() {
-        const children = this.children();
-        children.provisional = 0;
-        for (const p of children) {
-          p.#markENOENT();
+        *values() {
+          for (let t of this.#k()) this.#i[t] !== void 0 && !this.#l(this.#i[t]) && (yield this.#i[t]);
         }
-      }
-      #markENOREALPATH() {
-        this.#type |= ENOREALPATH;
-        this.#markENOTDIR();
-      }
-      // save the information when we know the entry is not a dir
-      #markENOTDIR() {
-        if (this.#type & ENOTDIR)
-          return;
-        let t = this.#type;
-        if ((t & IFMT) === IFDIR)
-          t &= IFMT_UNKNOWN;
-        this.#type = t | ENOTDIR;
-        this.#markChildrenENOENT();
-      }
-      #readdirFail(code = "") {
-        if (code === "ENOTDIR" || code === "EPERM") {
-          this.#markENOTDIR();
-        } else if (code === "ENOENT") {
-          this.#markENOENT();
-        } else {
-          this.children().provisional = 0;
+        *rvalues() {
+          for (let t of this.#M()) this.#i[t] !== void 0 && !this.#l(this.#i[t]) && (yield this.#i[t]);
         }
-      }
-      #lstatFail(code = "") {
-        if (code === "ENOTDIR") {
-          const p = this.parent;
-          p.#markENOTDIR();
-        } else if (code === "ENOENT") {
-          this.#markENOENT();
+        [Symbol.iterator]() {
+          return this.entries();
         }
-      }
-      #readlinkFail(code = "") {
-        let ter = this.#type;
-        ter |= ENOREADLINK;
-        if (code === "ENOENT")
-          ter |= ENOENT;
-        if (code === "EINVAL" || code === "UNKNOWN") {
-          ter &= IFMT_UNKNOWN;
+        [Symbol.toStringTag] = "LRUCache";
+        find(t, e = {}) {
+          for (let s of this.#k()) {
+            let i = this.#i[s], r = this.#l(i) ? i.__staleWhileFetching : i;
+            if (r !== void 0 && t(r, this.#a[s], this)) return this.get(this.#a[s], e);
+          }
         }
-        this.#type = ter;
-        if (code === "ENOTDIR" && this.parent) {
-          this.parent.#markENOTDIR();
+        forEach(t, e = this) {
+          for (let s of this.#k()) {
+            let i = this.#i[s], r = this.#l(i) ? i.__staleWhileFetching : i;
+            r !== void 0 && t.call(e, r, this.#a[s], this);
+          }
         }
-      }
-      #readdirAddChild(e, c) {
-        return this.#readdirMaybePromoteChild(e, c) || this.#readdirAddNewChild(e, c);
-      }
-      #readdirAddNewChild(e, c) {
-        const type = entToType(e);
-        const child = this.newChild(e.name, type, { parent: this });
-        const ifmt = child.#type & IFMT;
-        if (ifmt !== IFDIR && ifmt !== IFLNK && ifmt !== UNKNOWN) {
-          child.#type |= ENOTDIR;
+        rforEach(t, e = this) {
+          for (let s of this.#M()) {
+            let i = this.#i[s], r = this.#l(i) ? i.__staleWhileFetching : i;
+            r !== void 0 && t.call(e, r, this.#a[s], this);
+          }
         }
-        c.unshift(child);
-        c.provisional++;
-        return child;
-      }
-      #readdirMaybePromoteChild(e, c) {
-        for (let p = c.provisional; p < c.length; p++) {
-          const pchild = c[p];
-          const name = this.nocase ? normalizeNocase(e.name) : normalize3(e.name);
-          if (name !== pchild.#matchName) {
-            continue;
+        purgeStale() {
+          let t = false;
+          for (let e of this.#M({ allowStale: true })) this.#_(e) && (this.#A(this.#a[e], "expire"), t = true);
+          return t;
+        }
+        info(t) {
+          let e = this.#u.get(t);
+          if (e === void 0) return;
+          let s = this.#i[e], i = this.#l(s) ? s.__staleWhileFetching : s;
+          if (i === void 0) return;
+          let r = { value: i };
+          if (this.#g && this.#x) {
+            let h = this.#g[e], o = this.#x[e];
+            if (h && o) {
+              let a = h - (this.#c.now() - o);
+              r.ttl = a, r.start = Date.now();
+            }
           }
-          return this.#readdirPromoteChild(e, pchild, p, c);
+          return this.#O && (r.size = this.#O[e]), r;
         }
-      }
-      #readdirPromoteChild(e, p, index2, c) {
-        const v = p.name;
-        p.#type = p.#type & IFMT_UNKNOWN | entToType(e);
-        if (v !== e.name)
-          p.name = e.name;
-        if (index2 !== c.provisional) {
-          if (index2 === c.length - 1)
-            c.pop();
-          else
-            c.splice(index2, 1);
-          c.unshift(p);
+        dump() {
+          let t = [];
+          for (let e of this.#k({ allowStale: true })) {
+            let s = this.#a[e], i = this.#i[e], r = this.#l(i) ? i.__staleWhileFetching : i;
+            if (r === void 0 || s === void 0) continue;
+            let h = { value: r };
+            if (this.#g && this.#x) {
+              h.ttl = this.#g[e];
+              let o = this.#c.now() - this.#x[e];
+              h.start = Math.floor(Date.now() - o);
+            }
+            this.#O && (h.size = this.#O[e]), t.unshift([s, h]);
+          }
+          return t;
         }
-        c.provisional++;
-        return p;
-      }
-      /**
-       * Call lstat() on this Path, and update all known information that can be
-       * determined.
-       *
-       * Note that unlike `fs.lstat()`, the returned value does not contain some
-       * information, such as `mode`, `dev`, `nlink`, and `ino`.  If that
-       * information is required, you will need to call `fs.lstat` yourself.
-       *
-       * If the Path refers to a nonexistent file, or if the lstat call fails for
-       * any reason, `undefined` is returned.  Otherwise the updated Path object is
-       * returned.
-       *
-       * Results are cached, and thus may be out of date if the filesystem is
-       * mutated.
-       */
-      async lstat() {
-        if ((this.#type & ENOENT) === 0) {
-          try {
-            this.#applyStat(await this.#fs.promises.lstat(this.fullpath()));
-            return this;
-          } catch (er) {
-            this.#lstatFail(er.code);
+        load(t) {
+          this.clear();
+          for (let [e, s] of t) {
+            if (s.start) {
+              let i = Date.now() - s.start;
+              s.start = this.#c.now() - i;
+            }
+            this.set(e, s.value, s);
           }
         }
-      }
-      /**
-       * synchronous {@link PathBase.lstat}
-       */
-      lstatSync() {
-        if ((this.#type & ENOENT) === 0) {
+        set(t, e, s = {}) {
+          if (e === void 0) return this.delete(t), this;
+          let { ttl: i = this.ttl, start: r, noDisposeOnSet: h = this.noDisposeOnSet, sizeCalculation: o = this.sizeCalculation, status: a } = s, { noUpdateTTL: l = this.noUpdateTTL } = s, f = this.#B(t, e, s.size || 0, o);
+          if (this.maxEntrySize && f > this.maxEntrySize) return a && (a.set = "miss", a.maxEntrySizeExceeded = true), this.#A(t, "set"), this;
+          let c = this.#o === 0 ? void 0 : this.#u.get(t);
+          if (c === void 0) c = this.#o === 0 ? this.#p : this.#R.length !== 0 ? this.#R.pop() : this.#o === this.#t ? this.#G(false) : this.#o, this.#a[c] = t, this.#i[c] = e, this.#u.set(t, c), this.#d[this.#p] = c, this.#v[c] = this.#p, this.#p = c, this.#o++, this.#j(c, f, a), a && (a.set = "add"), l = false, this.#F && this.#r?.(e, t, "add");
+          else {
+            this.#N(c);
+            let d = this.#i[c];
+            if (e !== d) {
+              if (this.#T && this.#l(d)) {
+                d.__abortController.abort(new Error("replaced"));
+                let { __staleWhileFetching: u } = d;
+                u !== void 0 && !h && (this.#E && this.#n?.(u, t, "set"), this.#e && this.#m?.push([u, t, "set"]));
+              } else h || (this.#E && this.#n?.(d, t, "set"), this.#e && this.#m?.push([d, t, "set"]));
+              if (this.#L(c), this.#j(c, f, a), this.#i[c] = e, a) {
+                a.set = "replace";
+                let u = d && this.#l(d) ? d.__staleWhileFetching : d;
+                u !== void 0 && (a.oldValue = u);
+              }
+            } else a && (a.set = "update");
+            this.#F && this.onInsert?.(e, t, e === d ? "update" : "replace");
+          }
+          if (i !== 0 && !this.#g && this.#P(), this.#g && (l || this.#W(c, i, r), a && this.#D(a, c)), !h && this.#e && this.#m) {
+            let d = this.#m, u;
+            for (; u = d?.shift(); ) this.#h?.(...u);
+          }
+          return this;
+        }
+        pop() {
           try {
-            this.#applyStat(this.#fs.lstatSync(this.fullpath()));
-            return this;
-          } catch (er) {
-            this.#lstatFail(er.code);
-          }
-        }
-      }
-      #applyStat(st) {
-        const { atime, atimeMs, birthtime, birthtimeMs, blksize, blocks, ctime, ctimeMs, dev, gid, ino, mode, mtime, mtimeMs, nlink, rdev, size, uid } = st;
-        this.#atime = atime;
-        this.#atimeMs = atimeMs;
-        this.#birthtime = birthtime;
-        this.#birthtimeMs = birthtimeMs;
-        this.#blksize = blksize;
-        this.#blocks = blocks;
-        this.#ctime = ctime;
-        this.#ctimeMs = ctimeMs;
-        this.#dev = dev;
-        this.#gid = gid;
-        this.#ino = ino;
-        this.#mode = mode;
-        this.#mtime = mtime;
-        this.#mtimeMs = mtimeMs;
-        this.#nlink = nlink;
-        this.#rdev = rdev;
-        this.#size = size;
-        this.#uid = uid;
-        const ifmt = entToType(st);
-        this.#type = this.#type & IFMT_UNKNOWN | ifmt | LSTAT_CALLED;
-        if (ifmt !== UNKNOWN && ifmt !== IFDIR && ifmt !== IFLNK) {
-          this.#type |= ENOTDIR;
-        }
-      }
-      #onReaddirCB = [];
-      #readdirCBInFlight = false;
-      #callOnReaddirCB(children) {
-        this.#readdirCBInFlight = false;
-        const cbs = this.#onReaddirCB.slice();
-        this.#onReaddirCB.length = 0;
-        cbs.forEach((cb) => cb(null, children));
-      }
-      /**
-       * Standard node-style callback interface to get list of directory entries.
-       *
-       * If the Path cannot or does not contain any children, then an empty array
-       * is returned.
-       *
-       * Results are cached, and thus may be out of date if the filesystem is
-       * mutated.
-       *
-       * @param cb The callback called with (er, entries).  Note that the `er`
-       * param is somewhat extraneous, as all readdir() errors are handled and
-       * simply result in an empty set of entries being returned.
-       * @param allowZalgo Boolean indicating that immediately known results should
-       * *not* be deferred with `queueMicrotask`. Defaults to `false`. Release
-       * zalgo at your peril, the dark pony lord is devious and unforgiving.
-       */
-      readdirCB(cb, allowZalgo = false) {
-        if (!this.canReaddir()) {
-          if (allowZalgo)
-            cb(null, []);
-          else
-            queueMicrotask(() => cb(null, []));
-          return;
+            for (; this.#o; ) {
+              let t = this.#i[this.#y];
+              if (this.#G(true), this.#l(t)) {
+                if (t.__staleWhileFetching) return t.__staleWhileFetching;
+              } else if (t !== void 0) return t;
+            }
+          } finally {
+            if (this.#e && this.#m) {
+              let t = this.#m, e;
+              for (; e = t?.shift(); ) this.#h?.(...e);
+            }
+          }
         }
-        const children = this.children();
-        if (this.calledReaddir()) {
-          const c = children.slice(0, children.provisional);
-          if (allowZalgo)
-            cb(null, c);
-          else
-            queueMicrotask(() => cb(null, c));
-          return;
+        #G(t) {
+          let e = this.#y, s = this.#a[e], i = this.#i[e];
+          return this.#T && this.#l(i) ? i.__abortController.abort(new Error("evicted")) : (this.#E || this.#e) && (this.#E && this.#n?.(i, s, "evict"), this.#e && this.#m?.push([i, s, "evict"])), this.#L(e), this.#b?.[e] && (clearTimeout(this.#b[e]), this.#b[e] = void 0), t && (this.#a[e] = void 0, this.#i[e] = void 0, this.#R.push(e)), this.#o === 1 ? (this.#y = this.#p = 0, this.#R.length = 0) : this.#y = this.#d[e], this.#u.delete(s), this.#o--, e;
         }
-        this.#onReaddirCB.push(cb);
-        if (this.#readdirCBInFlight) {
-          return;
+        has(t, e = {}) {
+          let { updateAgeOnHas: s = this.updateAgeOnHas, status: i } = e, r = this.#u.get(t);
+          if (r !== void 0) {
+            let h = this.#i[r];
+            if (this.#l(h) && h.__staleWhileFetching === void 0) return false;
+            if (this.#_(r)) i && (i.has = "stale", this.#D(i, r));
+            else return s && this.#C(r), i && (i.has = "hit", this.#D(i, r)), true;
+          } else i && (i.has = "miss");
+          return false;
         }
-        this.#readdirCBInFlight = true;
-        const fullpath = this.fullpath();
-        this.#fs.readdir(fullpath, { withFileTypes: true }, (er, entries) => {
-          if (er) {
-            this.#readdirFail(er.code);
-            children.provisional = 0;
+        peek(t, e = {}) {
+          let { allowStale: s = this.allowStale } = e, i = this.#u.get(t);
+          if (i === void 0 || !s && this.#_(i)) return;
+          let r = this.#i[i];
+          return this.#l(r) ? r.__staleWhileFetching : r;
+        }
+        #z(t, e, s, i) {
+          let r = e === void 0 ? void 0 : this.#i[e];
+          if (this.#l(r)) return r;
+          let h = new Lt(), { signal: o } = s;
+          o?.addEventListener("abort", () => h.abort(o.reason), { signal: h.signal });
+          let a = { signal: h.signal, options: s, context: i }, l = (p, b = false) => {
+            let { aborted: w } = h.signal, v = s.ignoreFetchAbort && p !== void 0, E = s.ignoreFetchAbort || !!(s.allowStaleOnFetchAbort && p !== void 0);
+            if (s.status && (w && !b ? (s.status.fetchAborted = true, s.status.fetchError = h.signal.reason, v && (s.status.fetchAbortIgnored = true)) : s.status.fetchResolved = true), w && !v && !b) return c(h.signal.reason, E);
+            let y = u, S = this.#i[e];
+            return (S === u || v && b && S === void 0) && (p === void 0 ? y.__staleWhileFetching !== void 0 ? this.#i[e] = y.__staleWhileFetching : this.#A(t, "fetch") : (s.status && (s.status.fetchUpdated = true), this.set(t, p, a.options))), p;
+          }, f = (p) => (s.status && (s.status.fetchRejected = true, s.status.fetchError = p), c(p, false)), c = (p, b) => {
+            let { aborted: w } = h.signal, v = w && s.allowStaleOnFetchAbort, E = v || s.allowStaleOnFetchRejection, y = E || s.noDeleteOnFetchRejection, S = u;
+            if (this.#i[e] === u && (!y || !b && S.__staleWhileFetching === void 0 ? this.#A(t, "fetch") : v || (this.#i[e] = S.__staleWhileFetching)), E) return s.status && S.__staleWhileFetching !== void 0 && (s.status.returnedStale = true), S.__staleWhileFetching;
+            if (S.__returned === S) throw p;
+          }, d = (p, b) => {
+            let w = this.#S?.(t, r, a);
+            w && w instanceof Promise && w.then((v) => p(v === void 0 ? void 0 : v), b), h.signal.addEventListener("abort", () => {
+              (!s.ignoreFetchAbort || s.allowStaleOnFetchAbort) && (p(void 0), s.allowStaleOnFetchAbort && (p = (v) => l(v, true)));
+            });
+          };
+          s.status && (s.status.fetchDispatched = true);
+          let u = new Promise(d).then(l, f), m = Object.assign(u, { __abortController: h, __staleWhileFetching: r, __returned: void 0 });
+          return e === void 0 ? (this.set(t, m, { ...a.options, status: void 0 }), e = this.#u.get(t)) : this.#i[e] = m, m;
+        }
+        #l(t) {
+          if (!this.#T) return false;
+          let e = t;
+          return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof Lt;
+        }
+        async fetch(t, e = {}) {
+          let { allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: r = this.noDeleteOnStaleGet, ttl: h = this.ttl, noDisposeOnSet: o = this.noDisposeOnSet, size: a = 0, sizeCalculation: l = this.sizeCalculation, noUpdateTTL: f = this.noUpdateTTL, noDeleteOnFetchRejection: c = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: u = this.ignoreFetchAbort, allowStaleOnFetchAbort: m = this.allowStaleOnFetchAbort, context: p, forceRefresh: b = false, status: w, signal: v } = e;
+          if (!this.#T) return w && (w.fetch = "get"), this.get(t, { allowStale: s, updateAgeOnGet: i, noDeleteOnStaleGet: r, status: w });
+          let E = { allowStale: s, updateAgeOnGet: i, noDeleteOnStaleGet: r, ttl: h, noDisposeOnSet: o, size: a, sizeCalculation: l, noUpdateTTL: f, noDeleteOnFetchRejection: c, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: m, ignoreFetchAbort: u, status: w, signal: v }, y = this.#u.get(t);
+          if (y === void 0) {
+            w && (w.fetch = "miss");
+            let S = this.#z(t, y, E, p);
+            return S.__returned = S;
           } else {
-            for (const e of entries) {
-              this.#readdirAddChild(e, children);
+            let S = this.#i[y];
+            if (this.#l(S)) {
+              let st = s && S.__staleWhileFetching !== void 0;
+              return w && (w.fetch = "inflight", st && (w.returnedStale = true)), st ? S.__staleWhileFetching : S.__returned = S;
             }
-            this.#readdirSuccess(children);
+            let B = this.#_(y);
+            if (!b && !B) return w && (w.fetch = "hit"), this.#N(y), i && this.#C(y), w && this.#D(w, y), S;
+            let U = this.#z(t, y, E, p), et = U.__staleWhileFetching !== void 0 && s;
+            return w && (w.fetch = B ? "stale" : "refresh", et && B && (w.returnedStale = true)), et ? U.__staleWhileFetching : U.__returned = U;
           }
-          this.#callOnReaddirCB(children.slice(0, children.provisional));
-          return;
-        });
-      }
-      #asyncReaddirInFlight;
-      /**
-       * Return an array of known child entries.
-       *
-       * If the Path cannot or does not contain any children, then an empty array
-       * is returned.
-       *
-       * Results are cached, and thus may be out of date if the filesystem is
-       * mutated.
-       */
-      async readdir() {
-        if (!this.canReaddir()) {
-          return [];
         }
-        const children = this.children();
-        if (this.calledReaddir()) {
-          return children.slice(0, children.provisional);
+        async forceFetch(t, e = {}) {
+          let s = await this.fetch(t, e);
+          if (s === void 0) throw new Error("fetch() returned undefined");
+          return s;
         }
-        const fullpath = this.fullpath();
-        if (this.#asyncReaddirInFlight) {
-          await this.#asyncReaddirInFlight;
-        } else {
-          let resolve14 = () => {
-          };
-          this.#asyncReaddirInFlight = new Promise((res) => resolve14 = res);
-          try {
-            for (const e of await this.#fs.promises.readdir(fullpath, {
-              withFileTypes: true
-            })) {
-              this.#readdirAddChild(e, children);
+        memo(t, e = {}) {
+          let s = this.#w;
+          if (!s) throw new Error("no memoMethod provided to constructor");
+          let { context: i, forceRefresh: r, ...h } = e, o = this.get(t, h);
+          if (!r && o !== void 0) return o;
+          let a = s(t, o, { options: h, context: i });
+          return this.set(t, a, h), a;
+        }
+        get(t, e = {}) {
+          let { allowStale: s = this.allowStale, updateAgeOnGet: i = this.updateAgeOnGet, noDeleteOnStaleGet: r = this.noDeleteOnStaleGet, status: h } = e, o = this.#u.get(t);
+          if (o !== void 0) {
+            let a = this.#i[o], l = this.#l(a);
+            return h && this.#D(h, o), this.#_(o) ? (h && (h.get = "stale"), l ? (h && s && a.__staleWhileFetching !== void 0 && (h.returnedStale = true), s ? a.__staleWhileFetching : void 0) : (r || this.#A(t, "expire"), h && s && (h.returnedStale = true), s ? a : void 0)) : (h && (h.get = "hit"), l ? a.__staleWhileFetching : (this.#N(o), i && this.#C(o), a));
+          } else h && (h.get = "miss");
+        }
+        #U(t, e) {
+          this.#v[e] = t, this.#d[t] = e;
+        }
+        #N(t) {
+          t !== this.#p && (t === this.#y ? this.#y = this.#d[t] : this.#U(this.#v[t], this.#d[t]), this.#U(this.#p, t), this.#p = t);
+        }
+        delete(t) {
+          return this.#A(t, "delete");
+        }
+        #A(t, e) {
+          let s = false;
+          if (this.#o !== 0) {
+            let i = this.#u.get(t);
+            if (i !== void 0) if (this.#b?.[i] && (clearTimeout(this.#b?.[i]), this.#b[i] = void 0), s = true, this.#o === 1) this.#q(e);
+            else {
+              this.#L(i);
+              let r = this.#i[i];
+              if (this.#l(r) ? r.__abortController.abort(new Error("deleted")) : (this.#E || this.#e) && (this.#E && this.#n?.(r, t, e), this.#e && this.#m?.push([r, t, e])), this.#u.delete(t), this.#a[i] = void 0, this.#i[i] = void 0, i === this.#p) this.#p = this.#v[i];
+              else if (i === this.#y) this.#y = this.#d[i];
+              else {
+                let h = this.#v[i];
+                this.#d[h] = this.#d[i];
+                let o = this.#d[i];
+                this.#v[o] = this.#v[i];
+              }
+              this.#o--, this.#R.push(i);
             }
-            this.#readdirSuccess(children);
-          } catch (er) {
-            this.#readdirFail(er.code);
-            children.provisional = 0;
           }
-          this.#asyncReaddirInFlight = void 0;
-          resolve14();
+          if (this.#e && this.#m?.length) {
+            let i = this.#m, r;
+            for (; r = i?.shift(); ) this.#h?.(...r);
+          }
+          return s;
         }
-        return children.slice(0, children.provisional);
-      }
-      /**
-       * synchronous {@link PathBase.readdir}
-       */
-      readdirSync() {
-        if (!this.canReaddir()) {
-          return [];
+        clear() {
+          return this.#q("delete");
         }
-        const children = this.children();
-        if (this.calledReaddir()) {
-          return children.slice(0, children.provisional);
+        #q(t) {
+          for (let e of this.#M({ allowStale: true })) {
+            let s = this.#i[e];
+            if (this.#l(s)) s.__abortController.abort(new Error("deleted"));
+            else {
+              let i = this.#a[e];
+              this.#E && this.#n?.(s, i, t), this.#e && this.#m?.push([s, i, t]);
+            }
+          }
+          if (this.#u.clear(), this.#i.fill(void 0), this.#a.fill(void 0), this.#g && this.#x) {
+            this.#g.fill(0), this.#x.fill(0);
+            for (let e of this.#b ?? []) e !== void 0 && clearTimeout(e);
+            this.#b?.fill(void 0);
+          }
+          if (this.#O && this.#O.fill(0), this.#y = 0, this.#p = 0, this.#R.length = 0, this.#f = 0, this.#o = 0, this.#e && this.#m) {
+            let e = this.#m, s;
+            for (; s = e?.shift(); ) this.#h?.(...s);
+          }
         }
-        const fullpath = this.fullpath();
-        try {
-          for (const e of this.#fs.readdirSync(fullpath, {
-            withFileTypes: true
-          })) {
-            this.#readdirAddChild(e, children);
+      };
+      Wt.LRUCache = rr;
+    });
+    var Oe = R((P) => {
+      "use strict";
+      var nr = P && P.__importDefault || function(n) {
+        return n && n.__esModule ? n : { default: n };
+      };
+      Object.defineProperty(P, "__esModule", { value: true });
+      P.Minipass = P.isWritable = P.isReadable = P.isStream = void 0;
+      var ds = typeof process == "object" && process ? process : { stdout: null, stderr: null }, _e = require("node:events"), ws = nr(require("node:stream")), hr = require("node:string_decoder"), or2 = (n) => !!n && typeof n == "object" && (n instanceof qt || n instanceof ws.default || (0, P.isReadable)(n) || (0, P.isWritable)(n));
+      P.isStream = or2;
+      var ar = (n) => !!n && typeof n == "object" && n instanceof _e.EventEmitter && typeof n.pipe == "function" && n.pipe !== ws.default.Writable.prototype.pipe;
+      P.isReadable = ar;
+      var lr = (n) => !!n && typeof n == "object" && n instanceof _e.EventEmitter && typeof n.write == "function" && typeof n.end == "function";
+      P.isWritable = lr;
+      var $ = /* @__PURE__ */ Symbol("EOF"), q = /* @__PURE__ */ Symbol("maybeEmitEnd"), K = /* @__PURE__ */ Symbol("emittedEnd"), Bt = /* @__PURE__ */ Symbol("emittingEnd"), lt2 = /* @__PURE__ */ Symbol("emittedError"), It = /* @__PURE__ */ Symbol("closed"), ps = /* @__PURE__ */ Symbol("read"), Gt = /* @__PURE__ */ Symbol("flush"), ms = /* @__PURE__ */ Symbol("flushChunk"), L = /* @__PURE__ */ Symbol("encoding"), rt = /* @__PURE__ */ Symbol("decoder"), x = /* @__PURE__ */ Symbol("flowing"), ct = /* @__PURE__ */ Symbol("paused"), nt = /* @__PURE__ */ Symbol("resume"), T = /* @__PURE__ */ Symbol("buffer"), M = /* @__PURE__ */ Symbol("pipes"), C = /* @__PURE__ */ Symbol("bufferLength"), we = /* @__PURE__ */ Symbol("bufferPush"), zt = /* @__PURE__ */ Symbol("bufferShift"), k = /* @__PURE__ */ Symbol("objectMode"), O = /* @__PURE__ */ Symbol("destroyed"), be = /* @__PURE__ */ Symbol("error"), ye = /* @__PURE__ */ Symbol("emitData"), gs = /* @__PURE__ */ Symbol("emitEnd"), Se = /* @__PURE__ */ Symbol("emitEnd2"), I = /* @__PURE__ */ Symbol("async"), ve = /* @__PURE__ */ Symbol("abort"), Ut = /* @__PURE__ */ Symbol("aborted"), ut = /* @__PURE__ */ Symbol("signal"), Z = /* @__PURE__ */ Symbol("dataListeners"), D = /* @__PURE__ */ Symbol("discarded"), ft = (n) => Promise.resolve().then(n), cr2 = (n) => n(), ur = (n) => n === "end" || n === "finish" || n === "prefinish", fr = (n) => n instanceof ArrayBuffer || !!n && typeof n == "object" && n.constructor && n.constructor.name === "ArrayBuffer" && n.byteLength >= 0, dr = (n) => !Buffer.isBuffer(n) && ArrayBuffer.isView(n), $t = class {
+        src;
+        dest;
+        opts;
+        ondrain;
+        constructor(t, e, s) {
+          this.src = t, this.dest = e, this.opts = s, this.ondrain = () => t[nt](), this.dest.on("drain", this.ondrain);
+        }
+        unpipe() {
+          this.dest.removeListener("drain", this.ondrain);
+        }
+        proxyErrors(t) {
+        }
+        end() {
+          this.unpipe(), this.opts.end && this.dest.end();
+        }
+      }, Ee = class extends $t {
+        unpipe() {
+          this.src.removeListener("error", this.proxyErrors), super.unpipe();
+        }
+        constructor(t, e, s) {
+          super(t, e, s), this.proxyErrors = (i) => this.dest.emit("error", i), t.on("error", this.proxyErrors);
+        }
+      }, pr = (n) => !!n.objectMode, mr = (n) => !n.objectMode && !!n.encoding && n.encoding !== "buffer", qt = class extends _e.EventEmitter {
+        [x] = false;
+        [ct] = false;
+        [M] = [];
+        [T] = [];
+        [k];
+        [L];
+        [I];
+        [rt];
+        [$] = false;
+        [K] = false;
+        [Bt] = false;
+        [It] = false;
+        [lt2] = null;
+        [C] = 0;
+        [O] = false;
+        [ut];
+        [Ut] = false;
+        [Z] = 0;
+        [D] = false;
+        writable = true;
+        readable = true;
+        constructor(...t) {
+          let e = t[0] || {};
+          if (super(), e.objectMode && typeof e.encoding == "string") throw new TypeError("Encoding and objectMode may not be used together");
+          pr(e) ? (this[k] = true, this[L] = null) : mr(e) ? (this[L] = e.encoding, this[k] = false) : (this[k] = false, this[L] = null), this[I] = !!e.async, this[rt] = this[L] ? new hr.StringDecoder(this[L]) : null, e && e.debugExposeBuffer === true && Object.defineProperty(this, "buffer", { get: () => this[T] }), e && e.debugExposePipes === true && Object.defineProperty(this, "pipes", { get: () => this[M] });
+          let { signal: s } = e;
+          s && (this[ut] = s, s.aborted ? this[ve]() : s.addEventListener("abort", () => this[ve]()));
+        }
+        get bufferLength() {
+          return this[C];
+        }
+        get encoding() {
+          return this[L];
+        }
+        set encoding(t) {
+          throw new Error("Encoding must be set at instantiation time");
+        }
+        setEncoding(t) {
+          throw new Error("Encoding must be set at instantiation time");
+        }
+        get objectMode() {
+          return this[k];
+        }
+        set objectMode(t) {
+          throw new Error("objectMode must be set at instantiation time");
+        }
+        get async() {
+          return this[I];
+        }
+        set async(t) {
+          this[I] = this[I] || !!t;
+        }
+        [ve]() {
+          this[Ut] = true, this.emit("abort", this[ut]?.reason), this.destroy(this[ut]?.reason);
+        }
+        get aborted() {
+          return this[Ut];
+        }
+        set aborted(t) {
+        }
+        write(t, e, s) {
+          if (this[Ut]) return false;
+          if (this[$]) throw new Error("write after end");
+          if (this[O]) return this.emit("error", Object.assign(new Error("Cannot call write after a stream was destroyed"), { code: "ERR_STREAM_DESTROYED" })), true;
+          typeof e == "function" && (s = e, e = "utf8"), e || (e = "utf8");
+          let i = this[I] ? ft : cr2;
+          if (!this[k] && !Buffer.isBuffer(t)) {
+            if (dr(t)) t = Buffer.from(t.buffer, t.byteOffset, t.byteLength);
+            else if (fr(t)) t = Buffer.from(t);
+            else if (typeof t != "string") throw new Error("Non-contiguous data written to non-objectMode stream");
+          }
+          return this[k] ? (this[x] && this[C] !== 0 && this[Gt](true), this[x] ? this.emit("data", t) : this[we](t), this[C] !== 0 && this.emit("readable"), s && i(s), this[x]) : t.length ? (typeof t == "string" && !(e === this[L] && !this[rt]?.lastNeed) && (t = Buffer.from(t, e)), Buffer.isBuffer(t) && this[L] && (t = this[rt].write(t)), this[x] && this[C] !== 0 && this[Gt](true), this[x] ? this.emit("data", t) : this[we](t), this[C] !== 0 && this.emit("readable"), s && i(s), this[x]) : (this[C] !== 0 && this.emit("readable"), s && i(s), this[x]);
+        }
+        read(t) {
+          if (this[O]) return null;
+          if (this[D] = false, this[C] === 0 || t === 0 || t && t > this[C]) return this[q](), null;
+          this[k] && (t = null), this[T].length > 1 && !this[k] && (this[T] = [this[L] ? this[T].join("") : Buffer.concat(this[T], this[C])]);
+          let e = this[ps](t || null, this[T][0]);
+          return this[q](), e;
+        }
+        [ps](t, e) {
+          if (this[k]) this[zt]();
+          else {
+            let s = e;
+            t === s.length || t === null ? this[zt]() : typeof s == "string" ? (this[T][0] = s.slice(t), e = s.slice(0, t), this[C] -= t) : (this[T][0] = s.subarray(t), e = s.subarray(0, t), this[C] -= t);
           }
-          this.#readdirSuccess(children);
-        } catch (er) {
-          this.#readdirFail(er.code);
-          children.provisional = 0;
+          return this.emit("data", e), !this[T].length && !this[$] && this.emit("drain"), e;
         }
-        return children.slice(0, children.provisional);
-      }
-      canReaddir() {
-        if (this.#type & ENOCHILD)
-          return false;
-        const ifmt = IFMT & this.#type;
-        if (!(ifmt === UNKNOWN || ifmt === IFDIR || ifmt === IFLNK)) {
-          return false;
+        end(t, e, s) {
+          return typeof t == "function" && (s = t, t = void 0), typeof e == "function" && (s = e, e = "utf8"), t !== void 0 && this.write(t, e), s && this.once("end", s), this[$] = true, this.writable = false, (this[x] || !this[ct]) && this[q](), this;
         }
-        return true;
-      }
-      shouldWalk(dirs, walkFilter) {
-        return (this.#type & IFDIR) === IFDIR && !(this.#type & ENOCHILD) && !dirs.has(this) && (!walkFilter || walkFilter(this));
-      }
-      /**
-       * Return the Path object corresponding to path as resolved
-       * by realpath(3).
-       *
-       * If the realpath call fails for any reason, `undefined` is returned.
-       *
-       * Result is cached, and thus may be outdated if the filesystem is mutated.
-       * On success, returns a Path object.
-       */
-      async realpath() {
-        if (this.#realpath)
-          return this.#realpath;
-        if ((ENOREALPATH | ENOREADLINK | ENOENT) & this.#type)
-          return void 0;
-        try {
-          const rp = await this.#fs.promises.realpath(this.fullpath());
-          return this.#realpath = this.resolve(rp);
-        } catch (_2) {
-          this.#markENOREALPATH();
+        [nt]() {
+          this[O] || (!this[Z] && !this[M].length && (this[D] = true), this[ct] = false, this[x] = true, this.emit("resume"), this[T].length ? this[Gt]() : this[$] ? this[q]() : this.emit("drain"));
         }
-      }
-      /**
-       * Synchronous {@link realpath}
-       */
-      realpathSync() {
-        if (this.#realpath)
-          return this.#realpath;
-        if ((ENOREALPATH | ENOREADLINK | ENOENT) & this.#type)
-          return void 0;
-        try {
-          const rp = this.#fs.realpathSync(this.fullpath());
-          return this.#realpath = this.resolve(rp);
-        } catch (_2) {
-          this.#markENOREALPATH();
+        resume() {
+          return this[nt]();
         }
-      }
-      /**
-       * Internal method to mark this Path object as the scurry cwd,
-       * called by {@link PathScurry#chdir}
-       *
-       * @internal
-       */
-      [setAsCwd](oldCwd) {
-        if (oldCwd === this)
-          return;
-        oldCwd.isCWD = false;
-        this.isCWD = true;
-        const changed = /* @__PURE__ */ new Set([]);
-        let rp = [];
-        let p = this;
-        while (p && p.parent) {
-          changed.add(p);
-          p.#relative = rp.join(this.sep);
-          p.#relativePosix = rp.join("/");
-          p = p.parent;
-          rp.push("..");
+        pause() {
+          this[x] = false, this[ct] = true, this[D] = false;
         }
-        p = oldCwd;
-        while (p && p.parent && !changed.has(p)) {
-          p.#relative = void 0;
-          p.#relativePosix = void 0;
-          p = p.parent;
+        get destroyed() {
+          return this[O];
         }
-      }
-    };
-    exports2.PathBase = PathBase;
-    var PathWin32 = class _PathWin32 extends PathBase {
-      /**
-       * Separator for generating path strings.
-       */
-      sep = "\\";
-      /**
-       * Separator for parsing path strings.
-       */
-      splitSep = eitherSep;
-      /**
-       * Do not create new Path objects directly.  They should always be accessed
-       * via the PathScurry class or other methods on the Path class.
-       *
-       * @internal
-       */
-      constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
-        super(name, type, root, roots, nocase, children, opts);
-      }
-      /**
-       * @internal
-       */
-      newChild(name, type = UNKNOWN, opts = {}) {
-        return new _PathWin32(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
-      }
-      /**
-       * @internal
-       */
-      getRootString(path29) {
-        return node_path_1.win32.parse(path29).root;
-      }
-      /**
-       * @internal
-       */
-      getRoot(rootPath) {
-        rootPath = uncToDrive(rootPath.toUpperCase());
-        if (rootPath === this.root.name) {
-          return this.root;
+        get flowing() {
+          return this[x];
+        }
+        get paused() {
+          return this[ct];
+        }
+        [we](t) {
+          this[k] ? this[C] += 1 : this[C] += t.length, this[T].push(t);
+        }
+        [zt]() {
+          return this[k] ? this[C] -= 1 : this[C] -= this[T][0].length, this[T].shift();
+        }
+        [Gt](t = false) {
+          do
+            ;
+          while (this[ms](this[zt]()) && this[T].length);
+          !t && !this[T].length && !this[$] && this.emit("drain");
         }
-        for (const [compare3, root] of Object.entries(this.roots)) {
-          if (this.sameRoot(rootPath, compare3)) {
-            return this.roots[rootPath] = root;
+        [ms](t) {
+          return this.emit("data", t), this[x];
+        }
+        pipe(t, e) {
+          if (this[O]) return t;
+          this[D] = false;
+          let s = this[K];
+          return e = e || {}, t === ds.stdout || t === ds.stderr ? e.end = false : e.end = e.end !== false, e.proxyErrors = !!e.proxyErrors, s ? e.end && t.end() : (this[M].push(e.proxyErrors ? new Ee(this, t, e) : new $t(this, t, e)), this[I] ? ft(() => this[nt]()) : this[nt]()), t;
+        }
+        unpipe(t) {
+          let e = this[M].find((s) => s.dest === t);
+          e && (this[M].length === 1 ? (this[x] && this[Z] === 0 && (this[x] = false), this[M] = []) : this[M].splice(this[M].indexOf(e), 1), e.unpipe());
+        }
+        addListener(t, e) {
+          return this.on(t, e);
+        }
+        on(t, e) {
+          let s = super.on(t, e);
+          if (t === "data") this[D] = false, this[Z]++, !this[M].length && !this[x] && this[nt]();
+          else if (t === "readable" && this[C] !== 0) super.emit("readable");
+          else if (ur(t) && this[K]) super.emit(t), this.removeAllListeners(t);
+          else if (t === "error" && this[lt2]) {
+            let i = e;
+            this[I] ? ft(() => i.call(this, this[lt2])) : i.call(this, this[lt2]);
           }
+          return s;
         }
-        return this.roots[rootPath] = new PathScurryWin32(rootPath, this).root;
-      }
-      /**
-       * @internal
-       */
-      sameRoot(rootPath, compare3 = this.root.name) {
-        rootPath = rootPath.toUpperCase().replace(/\//g, "\\").replace(uncDriveRegexp, "$1\\");
-        return rootPath === compare3;
-      }
-    };
-    exports2.PathWin32 = PathWin32;
-    var PathPosix = class _PathPosix extends PathBase {
-      /**
-       * separator for parsing path strings
-       */
-      splitSep = "/";
-      /**
-       * separator for generating path strings
-       */
-      sep = "/";
-      /**
-       * Do not create new Path objects directly.  They should always be accessed
-       * via the PathScurry class or other methods on the Path class.
-       *
-       * @internal
-       */
-      constructor(name, type = UNKNOWN, root, roots, nocase, children, opts) {
-        super(name, type, root, roots, nocase, children, opts);
-      }
-      /**
-       * @internal
-       */
-      getRootString(path29) {
-        return path29.startsWith("/") ? "/" : "";
-      }
-      /**
-       * @internal
-       */
-      getRoot(_rootPath) {
-        return this.root;
-      }
-      /**
-       * @internal
-       */
-      newChild(name, type = UNKNOWN, opts = {}) {
-        return new _PathPosix(name, type, this.root, this.roots, this.nocase, this.childrenCache(), opts);
-      }
-    };
-    exports2.PathPosix = PathPosix;
-    var PathScurryBase = class {
-      /**
-       * The root Path entry for the current working directory of this Scurry
-       */
-      root;
-      /**
-       * The string path for the root of this Scurry's current working directory
-       */
-      rootPath;
-      /**
-       * A collection of all roots encountered, referenced by rootPath
-       */
-      roots;
-      /**
-       * The Path entry corresponding to this PathScurry's current working directory.
-       */
-      cwd;
-      #resolveCache;
-      #resolvePosixCache;
-      #children;
-      /**
-       * Perform path comparisons case-insensitively.
-       *
-       * Defaults true on Darwin and Windows systems, false elsewhere.
-       */
-      nocase;
-      #fs;
-      /**
-       * This class should not be instantiated directly.
-       *
-       * Use PathScurryWin32, PathScurryDarwin, PathScurryPosix, or PathScurry
-       *
-       * @internal
-       */
-      constructor(cwd = process.cwd(), pathImpl, sep7, { nocase, childrenCacheSize = 16 * 1024, fs: fs31 = defaultFS } = {}) {
-        this.#fs = fsFromOption(fs31);
-        if (cwd instanceof URL || cwd.startsWith("file://")) {
-          cwd = (0, node_url_1.fileURLToPath)(cwd);
-        }
-        const cwdPath = pathImpl.resolve(cwd);
-        this.roots = /* @__PURE__ */ Object.create(null);
-        this.rootPath = this.parseRootPath(cwdPath);
-        this.#resolveCache = new ResolveCache();
-        this.#resolvePosixCache = new ResolveCache();
-        this.#children = new ChildrenCache(childrenCacheSize);
-        const split = cwdPath.substring(this.rootPath.length).split(sep7);
-        if (split.length === 1 && !split[0]) {
-          split.pop();
-        }
-        if (nocase === void 0) {
-          throw new TypeError("must provide nocase setting to PathScurryBase ctor");
-        }
-        this.nocase = nocase;
-        this.root = this.newRoot(this.#fs);
-        this.roots[this.rootPath] = this.root;
-        let prev = this.root;
-        let len = split.length - 1;
-        const joinSep = pathImpl.sep;
-        let abs = this.rootPath;
-        let sawFirst = false;
-        for (const part of split) {
-          const l = len--;
-          prev = prev.child(part, {
-            relative: new Array(l).fill("..").join(joinSep),
-            relativePosix: new Array(l).fill("..").join("/"),
-            fullpath: abs += (sawFirst ? "" : joinSep) + part
+        removeListener(t, e) {
+          return this.off(t, e);
+        }
+        off(t, e) {
+          let s = super.off(t, e);
+          return t === "data" && (this[Z] = this.listeners("data").length, this[Z] === 0 && !this[D] && !this[M].length && (this[x] = false)), s;
+        }
+        removeAllListeners(t) {
+          let e = super.removeAllListeners(t);
+          return (t === "data" || t === void 0) && (this[Z] = 0, !this[D] && !this[M].length && (this[x] = false)), e;
+        }
+        get emittedEnd() {
+          return this[K];
+        }
+        [q]() {
+          !this[Bt] && !this[K] && !this[O] && this[T].length === 0 && this[$] && (this[Bt] = true, this.emit("end"), this.emit("prefinish"), this.emit("finish"), this[It] && this.emit("close"), this[Bt] = false);
+        }
+        emit(t, ...e) {
+          let s = e[0];
+          if (t !== "error" && t !== "close" && t !== O && this[O]) return false;
+          if (t === "data") return !this[k] && !s ? false : this[I] ? (ft(() => this[ye](s)), true) : this[ye](s);
+          if (t === "end") return this[gs]();
+          if (t === "close") {
+            if (this[It] = true, !this[K] && !this[O]) return false;
+            let r = super.emit("close");
+            return this.removeAllListeners("close"), r;
+          } else if (t === "error") {
+            this[lt2] = s, super.emit(be, s);
+            let r = !this[ut] || this.listeners("error").length ? super.emit("error", s) : false;
+            return this[q](), r;
+          } else if (t === "resume") {
+            let r = super.emit("resume");
+            return this[q](), r;
+          } else if (t === "finish" || t === "prefinish") {
+            let r = super.emit(t);
+            return this.removeAllListeners(t), r;
+          }
+          let i = super.emit(t, ...e);
+          return this[q](), i;
+        }
+        [ye](t) {
+          for (let s of this[M]) s.dest.write(t) === false && this.pause();
+          let e = this[D] ? false : super.emit("data", t);
+          return this[q](), e;
+        }
+        [gs]() {
+          return this[K] ? false : (this[K] = true, this.readable = false, this[I] ? (ft(() => this[Se]()), true) : this[Se]());
+        }
+        [Se]() {
+          if (this[rt]) {
+            let e = this[rt].end();
+            if (e) {
+              for (let s of this[M]) s.dest.write(e);
+              this[D] || super.emit("data", e);
+            }
+          }
+          for (let e of this[M]) e.end();
+          let t = super.emit("end");
+          return this.removeAllListeners("end"), t;
+        }
+        async collect() {
+          let t = Object.assign([], { dataLength: 0 });
+          this[k] || (t.dataLength = 0);
+          let e = this.promise();
+          return this.on("data", (s) => {
+            t.push(s), this[k] || (t.dataLength += s.length);
+          }), await e, t;
+        }
+        async concat() {
+          if (this[k]) throw new Error("cannot concat in objectMode");
+          let t = await this.collect();
+          return this[L] ? t.join("") : Buffer.concat(t, t.dataLength);
+        }
+        async promise() {
+          return new Promise((t, e) => {
+            this.on(O, () => e(new Error("stream destroyed"))), this.on("error", (s) => e(s)), this.on("end", () => t());
           });
-          sawFirst = true;
         }
-        this.cwd = prev;
-      }
-      /**
-       * Get the depth of a provided path, string, or the cwd
-       */
-      depth(path29 = this.cwd) {
-        if (typeof path29 === "string") {
-          path29 = this.cwd.resolve(path29);
+        [Symbol.asyncIterator]() {
+          this[D] = false;
+          let t = false, e = async () => (this.pause(), t = true, { value: void 0, done: true });
+          return { next: () => {
+            if (t) return e();
+            let i = this.read();
+            if (i !== null) return Promise.resolve({ done: false, value: i });
+            if (this[$]) return e();
+            let r, h, o = (c) => {
+              this.off("data", a), this.off("end", l), this.off(O, f), e(), h(c);
+            }, a = (c) => {
+              this.off("error", o), this.off("end", l), this.off(O, f), this.pause(), r({ value: c, done: !!this[$] });
+            }, l = () => {
+              this.off("error", o), this.off("data", a), this.off(O, f), e(), r({ done: true, value: void 0 });
+            }, f = () => o(new Error("stream destroyed"));
+            return new Promise((c, d) => {
+              h = d, r = c, this.once(O, f), this.once("error", o), this.once("end", l), this.once("data", a);
+            });
+          }, throw: e, return: e, [Symbol.asyncIterator]() {
+            return this;
+          }, [Symbol.asyncDispose]: async () => {
+          } };
+        }
+        [Symbol.iterator]() {
+          this[D] = false;
+          let t = false, e = () => (this.pause(), this.off(be, e), this.off(O, e), this.off("end", e), t = true, { done: true, value: void 0 }), s = () => {
+            if (t) return e();
+            let i = this.read();
+            return i === null ? e() : { done: false, value: i };
+          };
+          return this.once("end", e), this.once(be, e), this.once(O, e), { next: s, throw: e, return: e, [Symbol.iterator]() {
+            return this;
+          }, [Symbol.dispose]: () => {
+          } };
+        }
+        destroy(t) {
+          if (this[O]) return t ? this.emit("error", t) : this.emit(O), this;
+          this[O] = true, this[D] = true, this[T].length = 0, this[C] = 0;
+          let e = this;
+          return typeof e.close == "function" && !this[It] && e.close(), t ? this.emit("error", t) : this.emit(O), this;
+        }
+        static get isStream() {
+          return P.isStream;
+        }
+      };
+      P.Minipass = qt;
+    });
+    var Ms = R((_2) => {
+      "use strict";
+      var gr = _2 && _2.__createBinding || (Object.create ? (function(n, t, e, s) {
+        s === void 0 && (s = e);
+        var i = Object.getOwnPropertyDescriptor(t, e);
+        (!i || ("get" in i ? !t.__esModule : i.writable || i.configurable)) && (i = { enumerable: true, get: function() {
+          return t[e];
+        } }), Object.defineProperty(n, s, i);
+      }) : (function(n, t, e, s) {
+        s === void 0 && (s = e), n[s] = t[e];
+      })), wr = _2 && _2.__setModuleDefault || (Object.create ? (function(n, t) {
+        Object.defineProperty(n, "default", { enumerable: true, value: t });
+      }) : function(n, t) {
+        n.default = t;
+      }), br = _2 && _2.__importStar || function(n) {
+        if (n && n.__esModule) return n;
+        var t = {};
+        if (n != null) for (var e in n) e !== "default" && Object.prototype.hasOwnProperty.call(n, e) && gr(t, n, e);
+        return wr(t, n), t;
+      };
+      Object.defineProperty(_2, "__esModule", { value: true });
+      _2.PathScurry = _2.Path = _2.PathScurryDarwin = _2.PathScurryPosix = _2.PathScurryWin32 = _2.PathScurryBase = _2.PathPosix = _2.PathWin32 = _2.PathBase = _2.ChildrenCache = _2.ResolveCache = void 0;
+      var Qt = fs31(), Yt = require("node:path"), yr = require("node:url"), pt = require("fs"), Sr = br(require("node:fs")), vr = pt.realpathSync.native, Ht = require("node:fs/promises"), bs = Oe(), mt = { lstatSync: pt.lstatSync, readdir: pt.readdir, readdirSync: pt.readdirSync, readlinkSync: pt.readlinkSync, realpathSync: vr, promises: { lstat: Ht.lstat, readdir: Ht.readdir, readlink: Ht.readlink, realpath: Ht.realpath } }, _s = (n) => !n || n === mt || n === Sr ? mt : { ...mt, ...n, promises: { ...mt.promises, ...n.promises || {} } }, Os = /^\\\\\?\\([a-z]:)\\?$/i, Er = (n) => n.replace(/\//g, "\\").replace(Os, "$1\\"), _r = /[\\\/]/, N = 0, xs = 1, Ts = 2, G = 4, Cs = 6, Rs = 8, Q = 10, As = 12, j = 15, dt = ~j, xe = 16, ys = 32, gt = 64, W = 128, Vt = 256, Xt = 512, Ss = gt | W | Xt, Or = 1023, Te = (n) => n.isFile() ? Rs : n.isDirectory() ? G : n.isSymbolicLink() ? Q : n.isCharacterDevice() ? Ts : n.isBlockDevice() ? Cs : n.isSocket() ? As : n.isFIFO() ? xs : N, vs = new Qt.LRUCache({ max: 2 ** 12 }), wt = (n) => {
+        let t = vs.get(n);
+        if (t) return t;
+        let e = n.normalize("NFKD");
+        return vs.set(n, e), e;
+      }, Es = new Qt.LRUCache({ max: 2 ** 12 }), Kt = (n) => {
+        let t = Es.get(n);
+        if (t) return t;
+        let e = wt(n.toLowerCase());
+        return Es.set(n, e), e;
+      }, bt = class extends Qt.LRUCache {
+        constructor() {
+          super({ max: 256 });
+        }
+      };
+      _2.ResolveCache = bt;
+      var Jt = class extends Qt.LRUCache {
+        constructor(t = 16 * 1024) {
+          super({ maxSize: t, sizeCalculation: (e) => e.length + 1 });
+        }
+      };
+      _2.ChildrenCache = Jt;
+      var ks = /* @__PURE__ */ Symbol("PathScurry setAsCwd"), A = class {
+        name;
+        root;
+        roots;
+        parent;
+        nocase;
+        isCWD = false;
+        #t;
+        #s;
+        get dev() {
+          return this.#s;
+        }
+        #n;
+        get mode() {
+          return this.#n;
+        }
+        #r;
+        get nlink() {
+          return this.#r;
+        }
+        #h;
+        get uid() {
+          return this.#h;
+        }
+        #S;
+        get gid() {
+          return this.#S;
+        }
+        #w;
+        get rdev() {
+          return this.#w;
+        }
+        #c;
+        get blksize() {
+          return this.#c;
+        }
+        #o;
+        get ino() {
+          return this.#o;
+        }
+        #f;
+        get size() {
+          return this.#f;
+        }
+        #u;
+        get blocks() {
+          return this.#u;
+        }
+        #a;
+        get atimeMs() {
+          return this.#a;
+        }
+        #i;
+        get mtimeMs() {
+          return this.#i;
+        }
+        #d;
+        get ctimeMs() {
+          return this.#d;
+        }
+        #v;
+        get birthtimeMs() {
+          return this.#v;
+        }
+        #y;
+        get atime() {
+          return this.#y;
+        }
+        #p;
+        get mtime() {
+          return this.#p;
+        }
+        #R;
+        get ctime() {
+          return this.#R;
+        }
+        #m;
+        get birthtime() {
+          return this.#m;
+        }
+        #O;
+        #x;
+        #g;
+        #b;
+        #E;
+        #T;
+        #e;
+        #F;
+        #P;
+        #C;
+        get parentPath() {
+          return (this.parent || this).fullpath();
+        }
+        get path() {
+          return this.parentPath;
+        }
+        constructor(t, e = N, s, i, r, h, o) {
+          this.name = t, this.#O = r ? Kt(t) : wt(t), this.#e = e & Or, this.nocase = r, this.roots = i, this.root = s || this, this.#F = h, this.#g = o.fullpath, this.#E = o.relative, this.#T = o.relativePosix, this.parent = o.parent, this.parent ? this.#t = this.parent.#t : this.#t = _s(o.fs);
+        }
+        depth() {
+          return this.#x !== void 0 ? this.#x : this.parent ? this.#x = this.parent.depth() + 1 : this.#x = 0;
+        }
+        childrenCache() {
+          return this.#F;
+        }
+        resolve(t) {
+          if (!t) return this;
+          let e = this.getRootString(t), i = t.substring(e.length).split(this.splitSep);
+          return e ? this.getRoot(e).#D(i) : this.#D(i);
+        }
+        #D(t) {
+          let e = this;
+          for (let s of t) e = e.child(s);
+          return e;
+        }
+        children() {
+          let t = this.#F.get(this);
+          if (t) return t;
+          let e = Object.assign([], { provisional: 0 });
+          return this.#F.set(this, e), this.#e &= ~xe, e;
+        }
+        child(t, e) {
+          if (t === "" || t === ".") return this;
+          if (t === "..") return this.parent || this;
+          let s = this.children(), i = this.nocase ? Kt(t) : wt(t);
+          for (let a of s) if (a.#O === i) return a;
+          let r = this.parent ? this.sep : "", h = this.#g ? this.#g + r + t : void 0, o = this.newChild(t, N, { ...e, parent: this, fullpath: h });
+          return this.canReaddir() || (o.#e |= W), s.push(o), o;
+        }
+        relative() {
+          if (this.isCWD) return "";
+          if (this.#E !== void 0) return this.#E;
+          let t = this.name, e = this.parent;
+          if (!e) return this.#E = this.name;
+          let s = e.relative();
+          return s + (!s || !e.parent ? "" : this.sep) + t;
+        }
+        relativePosix() {
+          if (this.sep === "/") return this.relative();
+          if (this.isCWD) return "";
+          if (this.#T !== void 0) return this.#T;
+          let t = this.name, e = this.parent;
+          if (!e) return this.#T = this.fullpathPosix();
+          let s = e.relativePosix();
+          return s + (!s || !e.parent ? "" : "/") + t;
+        }
+        fullpath() {
+          if (this.#g !== void 0) return this.#g;
+          let t = this.name, e = this.parent;
+          if (!e) return this.#g = this.name;
+          let i = e.fullpath() + (e.parent ? this.sep : "") + t;
+          return this.#g = i;
+        }
+        fullpathPosix() {
+          if (this.#b !== void 0) return this.#b;
+          if (this.sep === "/") return this.#b = this.fullpath();
+          if (!this.parent) {
+            let i = this.fullpath().replace(/\\/g, "/");
+            return /^[a-z]:\//i.test(i) ? this.#b = `//?/${i}` : this.#b = i;
+          }
+          let t = this.parent, e = t.fullpathPosix(), s = e + (!e || !t.parent ? "" : "/") + this.name;
+          return this.#b = s;
+        }
+        isUnknown() {
+          return (this.#e & j) === N;
+        }
+        isType(t) {
+          return this[`is${t}`]();
+        }
+        getType() {
+          return this.isUnknown() ? "Unknown" : this.isDirectory() ? "Directory" : this.isFile() ? "File" : this.isSymbolicLink() ? "SymbolicLink" : this.isFIFO() ? "FIFO" : this.isCharacterDevice() ? "CharacterDevice" : this.isBlockDevice() ? "BlockDevice" : this.isSocket() ? "Socket" : "Unknown";
+        }
+        isFile() {
+          return (this.#e & j) === Rs;
+        }
+        isDirectory() {
+          return (this.#e & j) === G;
+        }
+        isCharacterDevice() {
+          return (this.#e & j) === Ts;
+        }
+        isBlockDevice() {
+          return (this.#e & j) === Cs;
+        }
+        isFIFO() {
+          return (this.#e & j) === xs;
+        }
+        isSocket() {
+          return (this.#e & j) === As;
+        }
+        isSymbolicLink() {
+          return (this.#e & Q) === Q;
+        }
+        lstatCached() {
+          return this.#e & ys ? this : void 0;
+        }
+        readlinkCached() {
+          return this.#P;
+        }
+        realpathCached() {
+          return this.#C;
+        }
+        readdirCached() {
+          let t = this.children();
+          return t.slice(0, t.provisional);
+        }
+        canReadlink() {
+          if (this.#P) return true;
+          if (!this.parent) return false;
+          let t = this.#e & j;
+          return !(t !== N && t !== Q || this.#e & Vt || this.#e & W);
+        }
+        calledReaddir() {
+          return !!(this.#e & xe);
+        }
+        isENOENT() {
+          return !!(this.#e & W);
+        }
+        isNamed(t) {
+          return this.nocase ? this.#O === Kt(t) : this.#O === wt(t);
+        }
+        async readlink() {
+          let t = this.#P;
+          if (t) return t;
+          if (this.canReadlink() && this.parent) try {
+            let e = await this.#t.promises.readlink(this.fullpath()), s = (await this.parent.realpath())?.resolve(e);
+            if (s) return this.#P = s;
+          } catch (e) {
+            this.#M(e.code);
+            return;
+          }
+        }
+        readlinkSync() {
+          let t = this.#P;
+          if (t) return t;
+          if (this.canReadlink() && this.parent) try {
+            let e = this.#t.readlinkSync(this.fullpath()), s = this.parent.realpathSync()?.resolve(e);
+            if (s) return this.#P = s;
+          } catch (e) {
+            this.#M(e.code);
+            return;
+          }
         }
-        return path29.depth();
-      }
-      /**
-       * Return the cache of child entries.  Exposed so subclasses can create
-       * child Path objects in a platform-specific way.
-       *
-       * @internal
-       */
-      childrenCache() {
-        return this.#children;
-      }
-      /**
-       * Resolve one or more path strings to a resolved string
-       *
-       * Same interface as require('path').resolve.
-       *
-       * Much faster than path.resolve() when called multiple times for the same
-       * path, because the resolved Path objects are cached.  Much slower
-       * otherwise.
-       */
-      resolve(...paths) {
-        let r = "";
-        for (let i = paths.length - 1; i >= 0; i--) {
-          const p = paths[i];
-          if (!p || p === ".")
-            continue;
-          r = r ? `${p}/${r}` : p;
-          if (this.isAbsolute(p)) {
-            break;
+        #W(t) {
+          this.#e |= xe;
+          for (let e = t.provisional; e < t.length; e++) {
+            let s = t[e];
+            s && s.#_();
           }
         }
-        const cached = this.#resolveCache.get(r);
-        if (cached !== void 0) {
-          return cached;
+        #_() {
+          this.#e & W || (this.#e = (this.#e | W) & dt, this.#$());
         }
-        const result = this.cwd.resolve(r).fullpath();
-        this.#resolveCache.set(r, result);
-        return result;
-      }
-      /**
-       * Resolve one or more path strings to a resolved string, returning
-       * the posix path.  Identical to .resolve() on posix systems, but on
-       * windows will return a forward-slash separated UNC path.
-       *
-       * Same interface as require('path').resolve.
-       *
-       * Much faster than path.resolve() when called multiple times for the same
-       * path, because the resolved Path objects are cached.  Much slower
-       * otherwise.
-       */
-      resolvePosix(...paths) {
-        let r = "";
-        for (let i = paths.length - 1; i >= 0; i--) {
-          const p = paths[i];
-          if (!p || p === ".")
-            continue;
-          r = r ? `${p}/${r}` : p;
-          if (this.isAbsolute(p)) {
-            break;
-          }
+        #$() {
+          let t = this.children();
+          t.provisional = 0;
+          for (let e of t) e.#_();
         }
-        const cached = this.#resolvePosixCache.get(r);
-        if (cached !== void 0) {
-          return cached;
+        #L() {
+          this.#e |= Xt, this.#j();
         }
-        const result = this.cwd.resolve(r).fullpathPosix();
-        this.#resolvePosixCache.set(r, result);
-        return result;
-      }
-      /**
-       * find the relative path from the cwd to the supplied path string or entry
-       */
-      relative(entry = this.cwd) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
+        #j() {
+          if (this.#e & gt) return;
+          let t = this.#e;
+          (t & j) === G && (t &= dt), this.#e = t | gt, this.#$();
         }
-        return entry.relative();
-      }
-      /**
-       * find the relative path from the cwd to the supplied path string or
-       * entry, using / as the path delimiter, even on Windows.
-       */
-      relativePosix(entry = this.cwd) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
+        #B(t = "") {
+          t === "ENOTDIR" || t === "EPERM" ? this.#j() : t === "ENOENT" ? this.#_() : this.children().provisional = 0;
         }
-        return entry.relativePosix();
-      }
-      /**
-       * Return the basename for the provided string or Path object
-       */
-      basename(entry = this.cwd) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
+        #k(t = "") {
+          t === "ENOTDIR" ? this.parent.#j() : t === "ENOENT" && this.#_();
         }
-        return entry.name;
-      }
-      /**
-       * Return the dirname for the provided string or Path object
-       */
-      dirname(entry = this.cwd) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
+        #M(t = "") {
+          let e = this.#e;
+          e |= Vt, t === "ENOENT" && (e |= W), (t === "EINVAL" || t === "UNKNOWN") && (e &= dt), this.#e = e, t === "ENOTDIR" && this.parent && this.parent.#j();
         }
-        return (entry.parent || entry).fullpath();
-      }
-      async readdir(entry = this.cwd, opts = {
-        withFileTypes: true
-      }) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
-        } else if (!(entry instanceof PathBase)) {
-          opts = entry;
-          entry = this.cwd;
-        }
-        const { withFileTypes } = opts;
-        if (!entry.canReaddir()) {
-          return [];
-        } else {
-          const p = await entry.readdir();
-          return withFileTypes ? p : p.map((e) => e.name);
+        #I(t, e) {
+          return this.#z(t, e) || this.#G(t, e);
         }
-      }
-      readdirSync(entry = this.cwd, opts = {
-        withFileTypes: true
-      }) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
-        } else if (!(entry instanceof PathBase)) {
-          opts = entry;
-          entry = this.cwd;
-        }
-        const { withFileTypes = true } = opts;
-        if (!entry.canReaddir()) {
-          return [];
-        } else if (withFileTypes) {
-          return entry.readdirSync();
-        } else {
-          return entry.readdirSync().map((e) => e.name);
+        #G(t, e) {
+          let s = Te(t), i = this.newChild(t.name, s, { parent: this }), r = i.#e & j;
+          return r !== G && r !== Q && r !== N && (i.#e |= gt), e.unshift(i), e.provisional++, i;
         }
-      }
-      /**
-       * Call lstat() on the string or Path object, and update all known
-       * information that can be determined.
-       *
-       * Note that unlike `fs.lstat()`, the returned value does not contain some
-       * information, such as `mode`, `dev`, `nlink`, and `ino`.  If that
-       * information is required, you will need to call `fs.lstat` yourself.
-       *
-       * If the Path refers to a nonexistent file, or if the lstat call fails for
-       * any reason, `undefined` is returned.  Otherwise the updated Path object is
-       * returned.
-       *
-       * Results are cached, and thus may be out of date if the filesystem is
-       * mutated.
-       */
-      async lstat(entry = this.cwd) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
+        #z(t, e) {
+          for (let s = e.provisional; s < e.length; s++) {
+            let i = e[s];
+            if ((this.nocase ? Kt(t.name) : wt(t.name)) === i.#O) return this.#l(t, i, s, e);
+          }
         }
-        return entry.lstat();
-      }
-      /**
-       * synchronous {@link PathScurryBase.lstat}
-       */
-      lstatSync(entry = this.cwd) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
+        #l(t, e, s, i) {
+          let r = e.name;
+          return e.#e = e.#e & dt | Te(t), r !== t.name && (e.name = t.name), s !== i.provisional && (s === i.length - 1 ? i.pop() : i.splice(s, 1), i.unshift(e)), i.provisional++, e;
         }
-        return entry.lstatSync();
-      }
-      async readlink(entry = this.cwd, { withFileTypes } = {
-        withFileTypes: false
-      }) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
-        } else if (!(entry instanceof PathBase)) {
-          withFileTypes = entry.withFileTypes;
-          entry = this.cwd;
+        async lstat() {
+          if ((this.#e & W) === 0) try {
+            return this.#U(await this.#t.promises.lstat(this.fullpath())), this;
+          } catch (t) {
+            this.#k(t.code);
+          }
         }
-        const e = await entry.readlink();
-        return withFileTypes ? e : e?.fullpath();
-      }
-      readlinkSync(entry = this.cwd, { withFileTypes } = {
-        withFileTypes: false
-      }) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
-        } else if (!(entry instanceof PathBase)) {
-          withFileTypes = entry.withFileTypes;
-          entry = this.cwd;
+        lstatSync() {
+          if ((this.#e & W) === 0) try {
+            return this.#U(this.#t.lstatSync(this.fullpath())), this;
+          } catch (t) {
+            this.#k(t.code);
+          }
         }
-        const e = entry.readlinkSync();
-        return withFileTypes ? e : e?.fullpath();
-      }
-      async realpath(entry = this.cwd, { withFileTypes } = {
-        withFileTypes: false
-      }) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
-        } else if (!(entry instanceof PathBase)) {
-          withFileTypes = entry.withFileTypes;
-          entry = this.cwd;
+        #U(t) {
+          let { atime: e, atimeMs: s, birthtime: i, birthtimeMs: r, blksize: h, blocks: o, ctime: a, ctimeMs: l, dev: f, gid: c, ino: d, mode: u, mtime: m, mtimeMs: p, nlink: b, rdev: w, size: v, uid: E } = t;
+          this.#y = e, this.#a = s, this.#m = i, this.#v = r, this.#c = h, this.#u = o, this.#R = a, this.#d = l, this.#s = f, this.#S = c, this.#o = d, this.#n = u, this.#p = m, this.#i = p, this.#r = b, this.#w = w, this.#f = v, this.#h = E;
+          let y = Te(t);
+          this.#e = this.#e & dt | y | ys, y !== N && y !== G && y !== Q && (this.#e |= gt);
         }
-        const e = await entry.realpath();
-        return withFileTypes ? e : e?.fullpath();
-      }
-      realpathSync(entry = this.cwd, { withFileTypes } = {
-        withFileTypes: false
-      }) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
-        } else if (!(entry instanceof PathBase)) {
-          withFileTypes = entry.withFileTypes;
-          entry = this.cwd;
-        }
-        const e = entry.realpathSync();
-        return withFileTypes ? e : e?.fullpath();
-      }
-      async walk(entry = this.cwd, opts = {}) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
-        } else if (!(entry instanceof PathBase)) {
-          opts = entry;
-          entry = this.cwd;
-        }
-        const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
-        const results = [];
-        if (!filter2 || filter2(entry)) {
-          results.push(withFileTypes ? entry : entry.fullpath());
-        }
-        const dirs = /* @__PURE__ */ new Set();
-        const walk = (dir, cb) => {
-          dirs.add(dir);
-          dir.readdirCB((er, entries) => {
-            if (er) {
-              return cb(er);
-            }
-            let len = entries.length;
-            if (!len)
-              return cb();
-            const next = () => {
-              if (--len === 0) {
-                cb();
-              }
-            };
-            for (const e of entries) {
-              if (!filter2 || filter2(e)) {
-                results.push(withFileTypes ? e : e.fullpath());
-              }
-              if (follow && e.isSymbolicLink()) {
-                e.realpath().then((r) => r?.isUnknown() ? r.lstat() : r).then((r) => r?.shouldWalk(dirs, walkFilter) ? walk(r, next) : next());
-              } else {
-                if (e.shouldWalk(dirs, walkFilter)) {
-                  walk(e, next);
-                } else {
-                  next();
-                }
-              }
+        #N = [];
+        #A = false;
+        #q(t) {
+          this.#A = false;
+          let e = this.#N.slice();
+          this.#N.length = 0, e.forEach((s) => s(null, t));
+        }
+        readdirCB(t, e = false) {
+          if (!this.canReaddir()) {
+            e ? t(null, []) : queueMicrotask(() => t(null, []));
+            return;
+          }
+          let s = this.children();
+          if (this.calledReaddir()) {
+            let r = s.slice(0, s.provisional);
+            e ? t(null, r) : queueMicrotask(() => t(null, r));
+            return;
+          }
+          if (this.#N.push(t), this.#A) return;
+          this.#A = true;
+          let i = this.fullpath();
+          this.#t.readdir(i, { withFileTypes: true }, (r, h) => {
+            if (r) this.#B(r.code), s.provisional = 0;
+            else {
+              for (let o of h) this.#I(o, s);
+              this.#W(s);
             }
-          }, true);
-        };
-        const start = entry;
-        return new Promise((res, rej) => {
-          walk(start, (er) => {
-            if (er)
-              return rej(er);
-            res(results);
+            this.#q(s.slice(0, s.provisional));
           });
-        });
-      }
-      walkSync(entry = this.cwd, opts = {}) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
-        } else if (!(entry instanceof PathBase)) {
-          opts = entry;
-          entry = this.cwd;
-        }
-        const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
-        const results = [];
-        if (!filter2 || filter2(entry)) {
-          results.push(withFileTypes ? entry : entry.fullpath());
-        }
-        const dirs = /* @__PURE__ */ new Set([entry]);
-        for (const dir of dirs) {
-          const entries = dir.readdirSync();
-          for (const e of entries) {
-            if (!filter2 || filter2(e)) {
-              results.push(withFileTypes ? e : e.fullpath());
-            }
-            let r = e;
-            if (e.isSymbolicLink()) {
-              if (!(follow && (r = e.realpathSync())))
-                continue;
-              if (r.isUnknown())
-                r.lstatSync();
-            }
-            if (r.shouldWalk(dirs, walkFilter)) {
-              dirs.add(r);
+        }
+        #H;
+        async readdir() {
+          if (!this.canReaddir()) return [];
+          let t = this.children();
+          if (this.calledReaddir()) return t.slice(0, t.provisional);
+          let e = this.fullpath();
+          if (this.#H) await this.#H;
+          else {
+            let s = () => {
+            };
+            this.#H = new Promise((i) => s = i);
+            try {
+              for (let i of await this.#t.promises.readdir(e, { withFileTypes: true })) this.#I(i, t);
+              this.#W(t);
+            } catch (i) {
+              this.#B(i.code), t.provisional = 0;
             }
+            this.#H = void 0, s();
           }
+          return t.slice(0, t.provisional);
         }
-        return results;
-      }
-      /**
-       * Support for `for await`
-       *
-       * Alias for {@link PathScurryBase.iterate}
-       *
-       * Note: As of Node 19, this is very slow, compared to other methods of
-       * walking.  Consider using {@link PathScurryBase.stream} if memory overhead
-       * and backpressure are concerns, or {@link PathScurryBase.walk} if not.
-       */
-      [Symbol.asyncIterator]() {
-        return this.iterate();
-      }
-      iterate(entry = this.cwd, options = {}) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
-        } else if (!(entry instanceof PathBase)) {
-          options = entry;
-          entry = this.cwd;
+        readdirSync() {
+          if (!this.canReaddir()) return [];
+          let t = this.children();
+          if (this.calledReaddir()) return t.slice(0, t.provisional);
+          let e = this.fullpath();
+          try {
+            for (let s of this.#t.readdirSync(e, { withFileTypes: true })) this.#I(s, t);
+            this.#W(t);
+          } catch (s) {
+            this.#B(s.code), t.provisional = 0;
+          }
+          return t.slice(0, t.provisional);
+        }
+        canReaddir() {
+          if (this.#e & Ss) return false;
+          let t = j & this.#e;
+          return t === N || t === G || t === Q;
+        }
+        shouldWalk(t, e) {
+          return (this.#e & G) === G && !(this.#e & Ss) && !t.has(this) && (!e || e(this));
+        }
+        async realpath() {
+          if (this.#C) return this.#C;
+          if (!((Xt | Vt | W) & this.#e)) try {
+            let t = await this.#t.promises.realpath(this.fullpath());
+            return this.#C = this.resolve(t);
+          } catch {
+            this.#L();
+          }
         }
-        return this.stream(entry, options)[Symbol.asyncIterator]();
-      }
-      /**
-       * Iterating over a PathScurry performs a synchronous walk.
-       *
-       * Alias for {@link PathScurryBase.iterateSync}
-       */
-      [Symbol.iterator]() {
-        return this.iterateSync();
-      }
-      *iterateSync(entry = this.cwd, opts = {}) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
-        } else if (!(entry instanceof PathBase)) {
-          opts = entry;
-          entry = this.cwd;
-        }
-        const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
-        if (!filter2 || filter2(entry)) {
-          yield withFileTypes ? entry : entry.fullpath();
-        }
-        const dirs = /* @__PURE__ */ new Set([entry]);
-        for (const dir of dirs) {
-          const entries = dir.readdirSync();
-          for (const e of entries) {
-            if (!filter2 || filter2(e)) {
-              yield withFileTypes ? e : e.fullpath();
-            }
-            let r = e;
-            if (e.isSymbolicLink()) {
-              if (!(follow && (r = e.realpathSync())))
-                continue;
-              if (r.isUnknown())
-                r.lstatSync();
-            }
-            if (r.shouldWalk(dirs, walkFilter)) {
-              dirs.add(r);
-            }
+        realpathSync() {
+          if (this.#C) return this.#C;
+          if (!((Xt | Vt | W) & this.#e)) try {
+            let t = this.#t.realpathSync(this.fullpath());
+            return this.#C = this.resolve(t);
+          } catch {
+            this.#L();
           }
         }
-      }
-      stream(entry = this.cwd, opts = {}) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
-        } else if (!(entry instanceof PathBase)) {
-          opts = entry;
-          entry = this.cwd;
+        [ks](t) {
+          if (t === this) return;
+          t.isCWD = false, this.isCWD = true;
+          let e = /* @__PURE__ */ new Set([]), s = [], i = this;
+          for (; i && i.parent; ) e.add(i), i.#E = s.join(this.sep), i.#T = s.join("/"), i = i.parent, s.push("..");
+          for (i = t; i && i.parent && !e.has(i); ) i.#E = void 0, i.#T = void 0, i = i.parent;
         }
-        const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
-        const results = new minipass_1.Minipass({ objectMode: true });
-        if (!filter2 || filter2(entry)) {
-          results.write(withFileTypes ? entry : entry.fullpath());
+      };
+      _2.PathBase = A;
+      var yt = class n extends A {
+        sep = "\\";
+        splitSep = _r;
+        constructor(t, e = N, s, i, r, h, o) {
+          super(t, e, s, i, r, h, o);
         }
-        const dirs = /* @__PURE__ */ new Set();
-        const queue2 = [entry];
-        let processing = 0;
-        const process2 = () => {
-          let paused = false;
-          while (!paused) {
-            const dir = queue2.shift();
-            if (!dir) {
-              if (processing === 0)
-                results.end();
-              return;
-            }
-            processing++;
-            dirs.add(dir);
-            const onReaddir = (er, entries, didRealpaths = false) => {
-              if (er)
-                return results.emit("error", er);
-              if (follow && !didRealpaths) {
-                const promises6 = [];
-                for (const e of entries) {
-                  if (e.isSymbolicLink()) {
-                    promises6.push(e.realpath().then((r) => r?.isUnknown() ? r.lstat() : r));
-                  }
-                }
-                if (promises6.length) {
-                  Promise.all(promises6).then(() => onReaddir(null, entries, true));
-                  return;
-                }
-              }
-              for (const e of entries) {
-                if (e && (!filter2 || filter2(e))) {
-                  if (!results.write(withFileTypes ? e : e.fullpath())) {
-                    paused = true;
-                  }
-                }
-              }
-              processing--;
-              for (const e of entries) {
-                const r = e.realpathCached() || e;
-                if (r.shouldWalk(dirs, walkFilter)) {
-                  queue2.push(r);
-                }
-              }
-              if (paused && !results.flowing) {
-                results.once("drain", process2);
-              } else if (!sync) {
-                process2();
-              }
-            };
-            let sync = true;
-            dir.readdirCB(onReaddir, true);
-            sync = false;
-          }
-        };
-        process2();
-        return results;
-      }
-      streamSync(entry = this.cwd, opts = {}) {
-        if (typeof entry === "string") {
-          entry = this.cwd.resolve(entry);
-        } else if (!(entry instanceof PathBase)) {
-          opts = entry;
-          entry = this.cwd;
-        }
-        const { withFileTypes = true, follow = false, filter: filter2, walkFilter } = opts;
-        const results = new minipass_1.Minipass({ objectMode: true });
-        const dirs = /* @__PURE__ */ new Set();
-        if (!filter2 || filter2(entry)) {
-          results.write(withFileTypes ? entry : entry.fullpath());
-        }
-        const queue2 = [entry];
-        let processing = 0;
-        const process2 = () => {
-          let paused = false;
-          while (!paused) {
-            const dir = queue2.shift();
-            if (!dir) {
-              if (processing === 0)
-                results.end();
-              return;
-            }
-            processing++;
-            dirs.add(dir);
-            const entries = dir.readdirSync();
-            for (const e of entries) {
-              if (!filter2 || filter2(e)) {
-                if (!results.write(withFileTypes ? e : e.fullpath())) {
-                  paused = true;
-                }
-              }
-            }
-            processing--;
-            for (const e of entries) {
-              let r = e;
-              if (e.isSymbolicLink()) {
-                if (!(follow && (r = e.realpathSync())))
-                  continue;
-                if (r.isUnknown())
-                  r.lstatSync();
-              }
-              if (r.shouldWalk(dirs, walkFilter)) {
-                queue2.push(r);
-              }
-            }
-          }
-          if (paused && !results.flowing)
-            results.once("drain", process2);
-        };
-        process2();
-        return results;
-      }
-      chdir(path29 = this.cwd) {
-        const oldCwd = this.cwd;
-        this.cwd = typeof path29 === "string" ? this.cwd.resolve(path29) : path29;
-        this.cwd[setAsCwd](oldCwd);
-      }
-    };
-    exports2.PathScurryBase = PathScurryBase;
-    var PathScurryWin32 = class extends PathScurryBase {
-      /**
-       * separator for generating path strings
-       */
-      sep = "\\";
-      constructor(cwd = process.cwd(), opts = {}) {
-        const { nocase = true } = opts;
-        super(cwd, node_path_1.win32, "\\", { ...opts, nocase });
-        this.nocase = nocase;
-        for (let p = this.cwd; p; p = p.parent) {
-          p.nocase = this.nocase;
+        newChild(t, e = N, s = {}) {
+          return new n(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
         }
-      }
-      /**
-       * @internal
-       */
-      parseRootPath(dir) {
-        return node_path_1.win32.parse(dir).root.toUpperCase();
-      }
-      /**
-       * @internal
-       */
-      newRoot(fs31) {
-        return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs31 });
-      }
-      /**
-       * Return true if the provided path string is an absolute path
-       */
-      isAbsolute(p) {
-        return p.startsWith("/") || p.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(p);
-      }
-    };
-    exports2.PathScurryWin32 = PathScurryWin32;
-    var PathScurryPosix = class extends PathScurryBase {
-      /**
-       * separator for generating path strings
-       */
-      sep = "/";
-      constructor(cwd = process.cwd(), opts = {}) {
-        const { nocase = false } = opts;
-        super(cwd, node_path_1.posix, "/", { ...opts, nocase });
-        this.nocase = nocase;
-      }
-      /**
-       * @internal
-       */
-      parseRootPath(_dir) {
-        return "/";
-      }
-      /**
-       * @internal
-       */
-      newRoot(fs31) {
-        return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs31 });
-      }
-      /**
-       * Return true if the provided path string is an absolute path
-       */
-      isAbsolute(p) {
-        return p.startsWith("/");
-      }
-    };
-    exports2.PathScurryPosix = PathScurryPosix;
-    var PathScurryDarwin = class extends PathScurryPosix {
-      constructor(cwd = process.cwd(), opts = {}) {
-        const { nocase = true } = opts;
-        super(cwd, { ...opts, nocase });
-      }
-    };
-    exports2.PathScurryDarwin = PathScurryDarwin;
-    exports2.Path = process.platform === "win32" ? PathWin32 : PathPosix;
-    exports2.PathScurry = process.platform === "win32" ? PathScurryWin32 : process.platform === "darwin" ? PathScurryDarwin : PathScurryPosix;
-  }
-});
-
-// node_modules/glob/dist/commonjs/pattern.js
-var require_pattern = __commonJS({
-  "node_modules/glob/dist/commonjs/pattern.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.Pattern = void 0;
-    var minimatch_1 = require_commonjs20();
-    var isPatternList = (pl) => pl.length >= 1;
-    var isGlobList = (gl) => gl.length >= 1;
-    var Pattern = class _Pattern {
-      #patternList;
-      #globList;
-      #index;
-      length;
-      #platform;
-      #rest;
-      #globString;
-      #isDrive;
-      #isUNC;
-      #isAbsolute;
-      #followGlobstar = true;
-      constructor(patternList, globList, index2, platform2) {
-        if (!isPatternList(patternList)) {
-          throw new TypeError("empty pattern list");
+        getRootString(t) {
+          return Yt.win32.parse(t).root;
         }
-        if (!isGlobList(globList)) {
-          throw new TypeError("empty glob list");
+        getRoot(t) {
+          if (t = Er(t.toUpperCase()), t === this.root.name) return this.root;
+          for (let [e, s] of Object.entries(this.roots)) if (this.sameRoot(t, e)) return this.roots[t] = s;
+          return this.roots[t] = new Et(t, this).root;
         }
-        if (globList.length !== patternList.length) {
-          throw new TypeError("mismatched pattern list and glob list lengths");
+        sameRoot(t, e = this.root.name) {
+          return t = t.toUpperCase().replace(/\//g, "\\").replace(Os, "$1\\"), t === e;
         }
-        this.length = patternList.length;
-        if (index2 < 0 || index2 >= this.length) {
-          throw new TypeError("index out of range");
+      };
+      _2.PathWin32 = yt;
+      var St = class n extends A {
+        splitSep = "/";
+        sep = "/";
+        constructor(t, e = N, s, i, r, h, o) {
+          super(t, e, s, i, r, h, o);
         }
-        this.#patternList = patternList;
-        this.#globList = globList;
-        this.#index = index2;
-        this.#platform = platform2;
-        if (this.#index === 0) {
-          if (this.isUNC()) {
-            const [p0, p1, p2, p3, ...prest] = this.#patternList;
-            const [g0, g1, g2, g3, ...grest] = this.#globList;
-            if (prest[0] === "") {
-              prest.shift();
-              grest.shift();
-            }
-            const p = [p0, p1, p2, p3, ""].join("/");
-            const g = [g0, g1, g2, g3, ""].join("/");
-            this.#patternList = [p, ...prest];
-            this.#globList = [g, ...grest];
-            this.length = this.#patternList.length;
-          } else if (this.isDrive() || this.isAbsolute()) {
-            const [p1, ...prest] = this.#patternList;
-            const [g1, ...grest] = this.#globList;
-            if (prest[0] === "") {
-              prest.shift();
-              grest.shift();
-            }
-            const p = p1 + "/";
-            const g = g1 + "/";
-            this.#patternList = [p, ...prest];
-            this.#globList = [g, ...grest];
-            this.length = this.#patternList.length;
-          }
+        getRootString(t) {
+          return t.startsWith("/") ? "/" : "";
         }
-      }
-      /**
-       * The first entry in the parsed list of patterns
-       */
-      pattern() {
-        return this.#patternList[this.#index];
-      }
-      /**
-       * true of if pattern() returns a string
-       */
-      isString() {
-        return typeof this.#patternList[this.#index] === "string";
-      }
-      /**
-       * true of if pattern() returns GLOBSTAR
-       */
-      isGlobstar() {
-        return this.#patternList[this.#index] === minimatch_1.GLOBSTAR;
-      }
-      /**
-       * true if pattern() returns a regexp
-       */
-      isRegExp() {
-        return this.#patternList[this.#index] instanceof RegExp;
-      }
-      /**
-       * The /-joined set of glob parts that make up this pattern
-       */
-      globString() {
-        return this.#globString = this.#globString || (this.#index === 0 ? this.isAbsolute() ? this.#globList[0] + this.#globList.slice(1).join("/") : this.#globList.join("/") : this.#globList.slice(this.#index).join("/"));
-      }
-      /**
-       * true if there are more pattern parts after this one
-       */
-      hasMore() {
-        return this.length > this.#index + 1;
-      }
-      /**
-       * The rest of the pattern after this part, or null if this is the end
-       */
-      rest() {
-        if (this.#rest !== void 0)
-          return this.#rest;
-        if (!this.hasMore())
-          return this.#rest = null;
-        this.#rest = new _Pattern(this.#patternList, this.#globList, this.#index + 1, this.#platform);
-        this.#rest.#isAbsolute = this.#isAbsolute;
-        this.#rest.#isUNC = this.#isUNC;
-        this.#rest.#isDrive = this.#isDrive;
-        return this.#rest;
-      }
-      /**
-       * true if the pattern represents a //unc/path/ on windows
-       */
-      isUNC() {
-        const pl = this.#patternList;
-        return this.#isUNC !== void 0 ? this.#isUNC : this.#isUNC = this.#platform === "win32" && this.#index === 0 && pl[0] === "" && pl[1] === "" && typeof pl[2] === "string" && !!pl[2] && typeof pl[3] === "string" && !!pl[3];
-      }
-      // pattern like C:/...
-      // split = ['C:', ...]
-      // XXX: would be nice to handle patterns like `c:*` to test the cwd
-      // in c: for *, but I don't know of a way to even figure out what that
-      // cwd is without actually chdir'ing into it?
-      /**
-       * True if the pattern starts with a drive letter on Windows
-       */
-      isDrive() {
-        const pl = this.#patternList;
-        return this.#isDrive !== void 0 ? this.#isDrive : this.#isDrive = this.#platform === "win32" && this.#index === 0 && this.length > 1 && typeof pl[0] === "string" && /^[a-z]:$/i.test(pl[0]);
-      }
-      // pattern = '/' or '/...' or '/x/...'
-      // split = ['', ''] or ['', ...] or ['', 'x', ...]
-      // Drive and UNC both considered absolute on windows
-      /**
-       * True if the pattern is rooted on an absolute path
-       */
-      isAbsolute() {
-        const pl = this.#patternList;
-        return this.#isAbsolute !== void 0 ? this.#isAbsolute : this.#isAbsolute = pl[0] === "" && pl.length > 1 || this.isDrive() || this.isUNC();
-      }
-      /**
-       * consume the root of the pattern, and return it
-       */
-      root() {
-        const p = this.#patternList[0];
-        return typeof p === "string" && this.isAbsolute() && this.#index === 0 ? p : "";
-      }
-      /**
-       * Check to see if the current globstar pattern is allowed to follow
-       * a symbolic link.
-       */
-      checkFollowGlobstar() {
-        return !(this.#index === 0 || !this.isGlobstar() || !this.#followGlobstar);
-      }
-      /**
-       * Mark that the current globstar pattern is following a symbolic link
-       */
-      markFollowGlobstar() {
-        if (this.#index === 0 || !this.isGlobstar() || !this.#followGlobstar)
-          return false;
-        this.#followGlobstar = false;
-        return true;
-      }
-    };
-    exports2.Pattern = Pattern;
-  }
-});
-
-// node_modules/glob/dist/commonjs/ignore.js
-var require_ignore = __commonJS({
-  "node_modules/glob/dist/commonjs/ignore.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.Ignore = void 0;
-    var minimatch_1 = require_commonjs20();
-    var pattern_js_1 = require_pattern();
-    var defaultPlatform2 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
-    var Ignore = class {
-      relative;
-      relativeChildren;
-      absolute;
-      absoluteChildren;
-      platform;
-      mmopts;
-      constructor(ignored, { nobrace, nocase, noext, noglobstar, platform: platform2 = defaultPlatform2 }) {
-        this.relative = [];
-        this.absolute = [];
-        this.relativeChildren = [];
-        this.absoluteChildren = [];
-        this.platform = platform2;
-        this.mmopts = {
-          dot: true,
-          nobrace,
-          nocase,
-          noext,
-          noglobstar,
-          optimizationLevel: 2,
-          platform: platform2,
-          nocomment: true,
-          nonegate: true
-        };
-        for (const ign of ignored)
-          this.add(ign);
-      }
-      add(ign) {
-        const mm = new minimatch_1.Minimatch(ign, this.mmopts);
-        for (let i = 0; i < mm.set.length; i++) {
-          const parsed = mm.set[i];
-          const globParts = mm.globParts[i];
-          if (!parsed || !globParts) {
-            throw new Error("invalid pattern object");
-          }
-          while (parsed[0] === "." && globParts[0] === ".") {
-            parsed.shift();
-            globParts.shift();
-          }
-          const p = new pattern_js_1.Pattern(parsed, globParts, 0, this.platform);
-          const m = new minimatch_1.Minimatch(p.globString(), this.mmopts);
-          const children = globParts[globParts.length - 1] === "**";
-          const absolute = p.isAbsolute();
-          if (absolute)
-            this.absolute.push(m);
-          else
-            this.relative.push(m);
-          if (children) {
-            if (absolute)
-              this.absoluteChildren.push(m);
-            else
-              this.relativeChildren.push(m);
-          }
+        getRoot(t) {
+          return this.root;
+        }
+        newChild(t, e = N, s = {}) {
+          return new n(t, e, this.root, this.roots, this.nocase, this.childrenCache(), s);
+        }
+      };
+      _2.PathPosix = St;
+      var vt = class {
+        root;
+        rootPath;
+        roots;
+        cwd;
+        #t;
+        #s;
+        #n;
+        nocase;
+        #r;
+        constructor(t = process.cwd(), e, s, { nocase: i, childrenCacheSize: r = 16 * 1024, fs: h = mt } = {}) {
+          this.#r = _s(h), (t instanceof URL || t.startsWith("file://")) && (t = (0, yr.fileURLToPath)(t));
+          let o = e.resolve(t);
+          this.roots = /* @__PURE__ */ Object.create(null), this.rootPath = this.parseRootPath(o), this.#t = new bt(), this.#s = new bt(), this.#n = new Jt(r);
+          let a = o.substring(this.rootPath.length).split(s);
+          if (a.length === 1 && !a[0] && a.pop(), i === void 0) throw new TypeError("must provide nocase setting to PathScurryBase ctor");
+          this.nocase = i, this.root = this.newRoot(this.#r), this.roots[this.rootPath] = this.root;
+          let l = this.root, f = a.length - 1, c = e.sep, d = this.rootPath, u = false;
+          for (let m of a) {
+            let p = f--;
+            l = l.child(m, { relative: new Array(p).fill("..").join(c), relativePosix: new Array(p).fill("..").join("/"), fullpath: d += (u ? "" : c) + m }), u = true;
+          }
+          this.cwd = l;
+        }
+        depth(t = this.cwd) {
+          return typeof t == "string" && (t = this.cwd.resolve(t)), t.depth();
+        }
+        childrenCache() {
+          return this.#n;
+        }
+        resolve(...t) {
+          let e = "";
+          for (let r = t.length - 1; r >= 0; r--) {
+            let h = t[r];
+            if (!(!h || h === ".") && (e = e ? `${h}/${e}` : h, this.isAbsolute(h))) break;
+          }
+          let s = this.#t.get(e);
+          if (s !== void 0) return s;
+          let i = this.cwd.resolve(e).fullpath();
+          return this.#t.set(e, i), i;
+        }
+        resolvePosix(...t) {
+          let e = "";
+          for (let r = t.length - 1; r >= 0; r--) {
+            let h = t[r];
+            if (!(!h || h === ".") && (e = e ? `${h}/${e}` : h, this.isAbsolute(h))) break;
+          }
+          let s = this.#s.get(e);
+          if (s !== void 0) return s;
+          let i = this.cwd.resolve(e).fullpathPosix();
+          return this.#s.set(e, i), i;
+        }
+        relative(t = this.cwd) {
+          return typeof t == "string" && (t = this.cwd.resolve(t)), t.relative();
+        }
+        relativePosix(t = this.cwd) {
+          return typeof t == "string" && (t = this.cwd.resolve(t)), t.relativePosix();
+        }
+        basename(t = this.cwd) {
+          return typeof t == "string" && (t = this.cwd.resolve(t)), t.name;
+        }
+        dirname(t = this.cwd) {
+          return typeof t == "string" && (t = this.cwd.resolve(t)), (t.parent || t).fullpath();
+        }
+        async readdir(t = this.cwd, e = { withFileTypes: true }) {
+          typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof A || (e = t, t = this.cwd);
+          let { withFileTypes: s } = e;
+          if (t.canReaddir()) {
+            let i = await t.readdir();
+            return s ? i : i.map((r) => r.name);
+          } else return [];
+        }
+        readdirSync(t = this.cwd, e = { withFileTypes: true }) {
+          typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof A || (e = t, t = this.cwd);
+          let { withFileTypes: s = true } = e;
+          return t.canReaddir() ? s ? t.readdirSync() : t.readdirSync().map((i) => i.name) : [];
+        }
+        async lstat(t = this.cwd) {
+          return typeof t == "string" && (t = this.cwd.resolve(t)), t.lstat();
+        }
+        lstatSync(t = this.cwd) {
+          return typeof t == "string" && (t = this.cwd.resolve(t)), t.lstatSync();
+        }
+        async readlink(t = this.cwd, { withFileTypes: e } = { withFileTypes: false }) {
+          typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof A || (e = t.withFileTypes, t = this.cwd);
+          let s = await t.readlink();
+          return e ? s : s?.fullpath();
+        }
+        readlinkSync(t = this.cwd, { withFileTypes: e } = { withFileTypes: false }) {
+          typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof A || (e = t.withFileTypes, t = this.cwd);
+          let s = t.readlinkSync();
+          return e ? s : s?.fullpath();
+        }
+        async realpath(t = this.cwd, { withFileTypes: e } = { withFileTypes: false }) {
+          typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof A || (e = t.withFileTypes, t = this.cwd);
+          let s = await t.realpath();
+          return e ? s : s?.fullpath();
+        }
+        realpathSync(t = this.cwd, { withFileTypes: e } = { withFileTypes: false }) {
+          typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof A || (e = t.withFileTypes, t = this.cwd);
+          let s = t.realpathSync();
+          return e ? s : s?.fullpath();
+        }
+        async walk(t = this.cwd, e = {}) {
+          typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof A || (e = t, t = this.cwd);
+          let { withFileTypes: s = true, follow: i = false, filter: r, walkFilter: h } = e, o = [];
+          (!r || r(t)) && o.push(s ? t : t.fullpath());
+          let a = /* @__PURE__ */ new Set(), l = (c, d) => {
+            a.add(c), c.readdirCB((u, m) => {
+              if (u) return d(u);
+              let p = m.length;
+              if (!p) return d();
+              let b = () => {
+                --p === 0 && d();
+              };
+              for (let w of m) (!r || r(w)) && o.push(s ? w : w.fullpath()), i && w.isSymbolicLink() ? w.realpath().then((v) => v?.isUnknown() ? v.lstat() : v).then((v) => v?.shouldWalk(a, h) ? l(v, b) : b()) : w.shouldWalk(a, h) ? l(w, b) : b();
+            }, true);
+          }, f = t;
+          return new Promise((c, d) => {
+            l(f, (u) => {
+              if (u) return d(u);
+              c(o);
+            });
+          });
+        }
+        walkSync(t = this.cwd, e = {}) {
+          typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof A || (e = t, t = this.cwd);
+          let { withFileTypes: s = true, follow: i = false, filter: r, walkFilter: h } = e, o = [];
+          (!r || r(t)) && o.push(s ? t : t.fullpath());
+          let a = /* @__PURE__ */ new Set([t]);
+          for (let l of a) {
+            let f = l.readdirSync();
+            for (let c of f) {
+              (!r || r(c)) && o.push(s ? c : c.fullpath());
+              let d = c;
+              if (c.isSymbolicLink()) {
+                if (!(i && (d = c.realpathSync()))) continue;
+                d.isUnknown() && d.lstatSync();
+              }
+              d.shouldWalk(a, h) && a.add(d);
+            }
+          }
+          return o;
+        }
+        [Symbol.asyncIterator]() {
+          return this.iterate();
+        }
+        iterate(t = this.cwd, e = {}) {
+          return typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof A || (e = t, t = this.cwd), this.stream(t, e)[Symbol.asyncIterator]();
+        }
+        [Symbol.iterator]() {
+          return this.iterateSync();
+        }
+        *iterateSync(t = this.cwd, e = {}) {
+          typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof A || (e = t, t = this.cwd);
+          let { withFileTypes: s = true, follow: i = false, filter: r, walkFilter: h } = e;
+          (!r || r(t)) && (yield s ? t : t.fullpath());
+          let o = /* @__PURE__ */ new Set([t]);
+          for (let a of o) {
+            let l = a.readdirSync();
+            for (let f of l) {
+              (!r || r(f)) && (yield s ? f : f.fullpath());
+              let c = f;
+              if (f.isSymbolicLink()) {
+                if (!(i && (c = f.realpathSync()))) continue;
+                c.isUnknown() && c.lstatSync();
+              }
+              c.shouldWalk(o, h) && o.add(c);
+            }
+          }
+        }
+        stream(t = this.cwd, e = {}) {
+          typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof A || (e = t, t = this.cwd);
+          let { withFileTypes: s = true, follow: i = false, filter: r, walkFilter: h } = e, o = new bs.Minipass({ objectMode: true });
+          (!r || r(t)) && o.write(s ? t : t.fullpath());
+          let a = /* @__PURE__ */ new Set(), l = [t], f = 0, c = () => {
+            let d = false;
+            for (; !d; ) {
+              let u = l.shift();
+              if (!u) {
+                f === 0 && o.end();
+                return;
+              }
+              f++, a.add(u);
+              let m = (b, w, v = false) => {
+                if (b) return o.emit("error", b);
+                if (i && !v) {
+                  let E = [];
+                  for (let y of w) y.isSymbolicLink() && E.push(y.realpath().then((S) => S?.isUnknown() ? S.lstat() : S));
+                  if (E.length) {
+                    Promise.all(E).then(() => m(null, w, true));
+                    return;
+                  }
+                }
+                for (let E of w) E && (!r || r(E)) && (o.write(s ? E : E.fullpath()) || (d = true));
+                f--;
+                for (let E of w) {
+                  let y = E.realpathCached() || E;
+                  y.shouldWalk(a, h) && l.push(y);
+                }
+                d && !o.flowing ? o.once("drain", c) : p || c();
+              }, p = true;
+              u.readdirCB(m, true), p = false;
+            }
+          };
+          return c(), o;
+        }
+        streamSync(t = this.cwd, e = {}) {
+          typeof t == "string" ? t = this.cwd.resolve(t) : t instanceof A || (e = t, t = this.cwd);
+          let { withFileTypes: s = true, follow: i = false, filter: r, walkFilter: h } = e, o = new bs.Minipass({ objectMode: true }), a = /* @__PURE__ */ new Set();
+          (!r || r(t)) && o.write(s ? t : t.fullpath());
+          let l = [t], f = 0, c = () => {
+            let d = false;
+            for (; !d; ) {
+              let u = l.shift();
+              if (!u) {
+                f === 0 && o.end();
+                return;
+              }
+              f++, a.add(u);
+              let m = u.readdirSync();
+              for (let p of m) (!r || r(p)) && (o.write(s ? p : p.fullpath()) || (d = true));
+              f--;
+              for (let p of m) {
+                let b = p;
+                if (p.isSymbolicLink()) {
+                  if (!(i && (b = p.realpathSync()))) continue;
+                  b.isUnknown() && b.lstatSync();
+                }
+                b.shouldWalk(a, h) && l.push(b);
+              }
+            }
+            d && !o.flowing && o.once("drain", c);
+          };
+          return c(), o;
         }
-      }
-      ignored(p) {
-        const fullpath = p.fullpath();
-        const fullpaths = `${fullpath}/`;
-        const relative3 = p.relative() || ".";
-        const relatives = `${relative3}/`;
-        for (const m of this.relative) {
-          if (m.match(relative3) || m.match(relatives))
-            return true;
+        chdir(t = this.cwd) {
+          let e = this.cwd;
+          this.cwd = typeof t == "string" ? this.cwd.resolve(t) : t, this.cwd[ks](e);
         }
-        for (const m of this.absolute) {
-          if (m.match(fullpath) || m.match(fullpaths))
-            return true;
+      };
+      _2.PathScurryBase = vt;
+      var Et = class extends vt {
+        sep = "\\";
+        constructor(t = process.cwd(), e = {}) {
+          let { nocase: s = true } = e;
+          super(t, Yt.win32, "\\", { ...e, nocase: s }), this.nocase = s;
+          for (let i = this.cwd; i; i = i.parent) i.nocase = this.nocase;
         }
-        return false;
-      }
-      childrenIgnored(p) {
-        const fullpath = p.fullpath() + "/";
-        const relative3 = (p.relative() || ".") + "/";
-        for (const m of this.relativeChildren) {
-          if (m.match(relative3))
-            return true;
+        parseRootPath(t) {
+          return Yt.win32.parse(t).root.toUpperCase();
         }
-        for (const m of this.absoluteChildren) {
-          if (m.match(fullpath))
-            return true;
+        newRoot(t) {
+          return new yt(this.rootPath, G, void 0, this.roots, this.nocase, this.childrenCache(), { fs: t });
         }
-        return false;
-      }
-    };
-    exports2.Ignore = Ignore;
-  }
-});
-
-// node_modules/glob/dist/commonjs/processor.js
-var require_processor = __commonJS({
-  "node_modules/glob/dist/commonjs/processor.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.Processor = exports2.SubWalks = exports2.MatchRecord = exports2.HasWalkedCache = void 0;
-    var minimatch_1 = require_commonjs20();
-    var HasWalkedCache = class _HasWalkedCache {
-      store;
-      constructor(store = /* @__PURE__ */ new Map()) {
-        this.store = store;
-      }
-      copy() {
-        return new _HasWalkedCache(new Map(this.store));
-      }
-      hasWalked(target, pattern) {
-        return this.store.get(target.fullpath())?.has(pattern.globString());
-      }
-      storeWalked(target, pattern) {
-        const fullpath = target.fullpath();
-        const cached = this.store.get(fullpath);
-        if (cached)
-          cached.add(pattern.globString());
-        else
-          this.store.set(fullpath, /* @__PURE__ */ new Set([pattern.globString()]));
-      }
-    };
-    exports2.HasWalkedCache = HasWalkedCache;
-    var MatchRecord = class {
-      store = /* @__PURE__ */ new Map();
-      add(target, absolute, ifDir) {
-        const n = (absolute ? 2 : 0) | (ifDir ? 1 : 0);
-        const current = this.store.get(target);
-        this.store.set(target, current === void 0 ? n : n & current);
-      }
-      // match, absolute, ifdir
-      entries() {
-        return [...this.store.entries()].map(([path29, n]) => [
-          path29,
-          !!(n & 2),
-          !!(n & 1)
-        ]);
-      }
-    };
-    exports2.MatchRecord = MatchRecord;
-    var SubWalks = class {
-      store = /* @__PURE__ */ new Map();
-      add(target, pattern) {
-        if (!target.canReaddir()) {
-          return;
+        isAbsolute(t) {
+          return t.startsWith("/") || t.startsWith("\\") || /^[a-z]:(\/|\\)/i.test(t);
         }
-        const subs = this.store.get(target);
-        if (subs) {
-          if (!subs.find((p) => p.globString() === pattern.globString())) {
-            subs.push(pattern);
-          }
-        } else
-          this.store.set(target, [pattern]);
-      }
-      get(target) {
-        const subs = this.store.get(target);
-        if (!subs) {
-          throw new Error("attempting to walk unknown path");
-        }
-        return subs;
-      }
-      entries() {
-        return this.keys().map((k) => [k, this.store.get(k)]);
-      }
-      keys() {
-        return [...this.store.keys()].filter((t) => t.canReaddir());
-      }
-    };
-    exports2.SubWalks = SubWalks;
-    var Processor = class _Processor {
-      hasWalkedCache;
-      matches = new MatchRecord();
-      subwalks = new SubWalks();
-      patterns;
-      follow;
-      dot;
-      opts;
-      constructor(opts, hasWalkedCache) {
-        this.opts = opts;
-        this.follow = !!opts.follow;
-        this.dot = !!opts.dot;
-        this.hasWalkedCache = hasWalkedCache ? hasWalkedCache.copy() : new HasWalkedCache();
-      }
-      processPatterns(target, patterns) {
-        this.patterns = patterns;
-        const processingSet = patterns.map((p) => [target, p]);
-        for (let [t, pattern] of processingSet) {
-          this.hasWalkedCache.storeWalked(t, pattern);
-          const root = pattern.root();
-          const absolute = pattern.isAbsolute() && this.opts.absolute !== false;
-          if (root) {
-            t = t.resolve(root === "/" && this.opts.root !== void 0 ? this.opts.root : root);
-            const rest2 = pattern.rest();
-            if (!rest2) {
-              this.matches.add(t, true, false);
-              continue;
-            } else {
-              pattern = rest2;
+      };
+      _2.PathScurryWin32 = Et;
+      var _t = class extends vt {
+        sep = "/";
+        constructor(t = process.cwd(), e = {}) {
+          let { nocase: s = false } = e;
+          super(t, Yt.posix, "/", { ...e, nocase: s }), this.nocase = s;
+        }
+        parseRootPath(t) {
+          return "/";
+        }
+        newRoot(t) {
+          return new St(this.rootPath, G, void 0, this.roots, this.nocase, this.childrenCache(), { fs: t });
+        }
+        isAbsolute(t) {
+          return t.startsWith("/");
+        }
+      };
+      _2.PathScurryPosix = _t;
+      var Zt = class extends _t {
+        constructor(t = process.cwd(), e = {}) {
+          let { nocase: s = true } = e;
+          super(t, { ...e, nocase: s });
+        }
+      };
+      _2.PathScurryDarwin = Zt;
+      _2.Path = process.platform === "win32" ? yt : St;
+      _2.PathScurry = process.platform === "win32" ? Et : process.platform === "darwin" ? Zt : _t;
+    });
+    var Re = R((te) => {
+      "use strict";
+      Object.defineProperty(te, "__esModule", { value: true });
+      te.Pattern = void 0;
+      var xr = H(), Tr = (n) => n.length >= 1, Cr = (n) => n.length >= 1, Rr = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom"), Ce = class n {
+        #t;
+        #s;
+        #n;
+        length;
+        #r;
+        #h;
+        #S;
+        #w;
+        #c;
+        #o;
+        #f = true;
+        constructor(t, e, s, i) {
+          if (!Tr(t)) throw new TypeError("empty pattern list");
+          if (!Cr(e)) throw new TypeError("empty glob list");
+          if (e.length !== t.length) throw new TypeError("mismatched pattern list and glob list lengths");
+          if (this.length = t.length, s < 0 || s >= this.length) throw new TypeError("index out of range");
+          if (this.#t = t, this.#s = e, this.#n = s, this.#r = i, this.#n === 0) {
+            if (this.isUNC()) {
+              let [r, h, o, a, ...l] = this.#t, [f, c, d, u, ...m] = this.#s;
+              l[0] === "" && (l.shift(), m.shift());
+              let p = [r, h, o, a, ""].join("/"), b = [f, c, d, u, ""].join("/");
+              this.#t = [p, ...l], this.#s = [b, ...m], this.length = this.#t.length;
+            } else if (this.isDrive() || this.isAbsolute()) {
+              let [r, ...h] = this.#t, [o, ...a] = this.#s;
+              h[0] === "" && (h.shift(), a.shift());
+              let l = r + "/", f = o + "/";
+              this.#t = [l, ...h], this.#s = [f, ...a], this.length = this.#t.length;
+            }
+          }
+        }
+        [Rr]() {
+          return "Pattern <" + this.#s.slice(this.#n).join("/") + ">";
+        }
+        pattern() {
+          return this.#t[this.#n];
+        }
+        isString() {
+          return typeof this.#t[this.#n] == "string";
+        }
+        isGlobstar() {
+          return this.#t[this.#n] === xr.GLOBSTAR;
+        }
+        isRegExp() {
+          return this.#t[this.#n] instanceof RegExp;
+        }
+        globString() {
+          return this.#S = this.#S || (this.#n === 0 ? this.isAbsolute() ? this.#s[0] + this.#s.slice(1).join("/") : this.#s.join("/") : this.#s.slice(this.#n).join("/"));
+        }
+        hasMore() {
+          return this.length > this.#n + 1;
+        }
+        rest() {
+          return this.#h !== void 0 ? this.#h : this.hasMore() ? (this.#h = new n(this.#t, this.#s, this.#n + 1, this.#r), this.#h.#o = this.#o, this.#h.#c = this.#c, this.#h.#w = this.#w, this.#h) : this.#h = null;
+        }
+        isUNC() {
+          let t = this.#t;
+          return this.#c !== void 0 ? this.#c : this.#c = this.#r === "win32" && this.#n === 0 && t[0] === "" && t[1] === "" && typeof t[2] == "string" && !!t[2] && typeof t[3] == "string" && !!t[3];
+        }
+        isDrive() {
+          let t = this.#t;
+          return this.#w !== void 0 ? this.#w : this.#w = this.#r === "win32" && this.#n === 0 && this.length > 1 && typeof t[0] == "string" && /^[a-z]:$/i.test(t[0]);
+        }
+        isAbsolute() {
+          let t = this.#t;
+          return this.#o !== void 0 ? this.#o : this.#o = t[0] === "" && t.length > 1 || this.isDrive() || this.isUNC();
+        }
+        root() {
+          let t = this.#t[0];
+          return typeof t == "string" && this.isAbsolute() && this.#n === 0 ? t : "";
+        }
+        checkFollowGlobstar() {
+          return !(this.#n === 0 || !this.isGlobstar() || !this.#f);
+        }
+        markFollowGlobstar() {
+          return this.#n === 0 || !this.isGlobstar() || !this.#f ? false : (this.#f = false, true);
+        }
+      };
+      te.Pattern = Ce;
+    });
+    var ke = R((ee) => {
+      "use strict";
+      Object.defineProperty(ee, "__esModule", { value: true });
+      ee.Ignore = void 0;
+      var Ps = H(), Ar = Re(), kr = typeof process == "object" && process && typeof process.platform == "string" ? process.platform : "linux", Ae = class {
+        relative;
+        relativeChildren;
+        absolute;
+        absoluteChildren;
+        platform;
+        mmopts;
+        constructor(t, { nobrace: e, nocase: s, noext: i, noglobstar: r, platform: h = kr }) {
+          this.relative = [], this.absolute = [], this.relativeChildren = [], this.absoluteChildren = [], this.platform = h, this.mmopts = { dot: true, nobrace: e, nocase: s, noext: i, noglobstar: r, optimizationLevel: 2, platform: h, nocomment: true, nonegate: true };
+          for (let o of t) this.add(o);
+        }
+        add(t) {
+          let e = new Ps.Minimatch(t, this.mmopts);
+          for (let s = 0; s < e.set.length; s++) {
+            let i = e.set[s], r = e.globParts[s];
+            if (!i || !r) throw new Error("invalid pattern object");
+            for (; i[0] === "." && r[0] === "."; ) i.shift(), r.shift();
+            let h = new Ar.Pattern(i, r, 0, this.platform), o = new Ps.Minimatch(h.globString(), this.mmopts), a = r[r.length - 1] === "**", l = h.isAbsolute();
+            l ? this.absolute.push(o) : this.relative.push(o), a && (l ? this.absoluteChildren.push(o) : this.relativeChildren.push(o));
+          }
+        }
+        ignored(t) {
+          let e = t.fullpath(), s = `${e}/`, i = t.relative() || ".", r = `${i}/`;
+          for (let h of this.relative) if (h.match(i) || h.match(r)) return true;
+          for (let h of this.absolute) if (h.match(e) || h.match(s)) return true;
+          return false;
+        }
+        childrenIgnored(t) {
+          let e = t.fullpath() + "/", s = (t.relative() || ".") + "/";
+          for (let i of this.relativeChildren) if (i.match(s)) return true;
+          for (let i of this.absoluteChildren) if (i.match(e)) return true;
+          return false;
+        }
+      };
+      ee.Ignore = Ae;
+    });
+    var Fs = R((z) => {
+      "use strict";
+      Object.defineProperty(z, "__esModule", { value: true });
+      z.Processor = z.SubWalks = z.MatchRecord = z.HasWalkedCache = void 0;
+      var Ds = H(), se = class n {
+        store;
+        constructor(t = /* @__PURE__ */ new Map()) {
+          this.store = t;
+        }
+        copy() {
+          return new n(new Map(this.store));
+        }
+        hasWalked(t, e) {
+          return this.store.get(t.fullpath())?.has(e.globString());
+        }
+        storeWalked(t, e) {
+          let s = t.fullpath(), i = this.store.get(s);
+          i ? i.add(e.globString()) : this.store.set(s, /* @__PURE__ */ new Set([e.globString()]));
+        }
+      };
+      z.HasWalkedCache = se;
+      var ie = class {
+        store = /* @__PURE__ */ new Map();
+        add(t, e, s) {
+          let i = (e ? 2 : 0) | (s ? 1 : 0), r = this.store.get(t);
+          this.store.set(t, r === void 0 ? i : i & r);
+        }
+        entries() {
+          return [...this.store.entries()].map(([t, e]) => [t, !!(e & 2), !!(e & 1)]);
+        }
+      };
+      z.MatchRecord = ie;
+      var re = class {
+        store = /* @__PURE__ */ new Map();
+        add(t, e) {
+          if (!t.canReaddir()) return;
+          let s = this.store.get(t);
+          s ? s.find((i) => i.globString() === e.globString()) || s.push(e) : this.store.set(t, [e]);
+        }
+        get(t) {
+          let e = this.store.get(t);
+          if (!e) throw new Error("attempting to walk unknown path");
+          return e;
+        }
+        entries() {
+          return this.keys().map((t) => [t, this.store.get(t)]);
+        }
+        keys() {
+          return [...this.store.keys()].filter((t) => t.canReaddir());
+        }
+      };
+      z.SubWalks = re;
+      var Me = class n {
+        hasWalkedCache;
+        matches = new ie();
+        subwalks = new re();
+        patterns;
+        follow;
+        dot;
+        opts;
+        constructor(t, e) {
+          this.opts = t, this.follow = !!t.follow, this.dot = !!t.dot, this.hasWalkedCache = e ? e.copy() : new se();
+        }
+        processPatterns(t, e) {
+          this.patterns = e;
+          let s = e.map((i) => [t, i]);
+          for (let [i, r] of s) {
+            this.hasWalkedCache.storeWalked(i, r);
+            let h = r.root(), o = r.isAbsolute() && this.opts.absolute !== false;
+            if (h) {
+              i = i.resolve(h === "/" && this.opts.root !== void 0 ? this.opts.root : h);
+              let c = r.rest();
+              if (c) r = c;
+              else {
+                this.matches.add(i, true, false);
+                continue;
+              }
             }
-          }
-          if (t.isENOENT())
-            continue;
-          let p;
-          let rest;
-          let changed = false;
-          while (typeof (p = pattern.pattern()) === "string" && (rest = pattern.rest())) {
-            const c = t.resolve(p);
-            t = c;
-            pattern = rest;
-            changed = true;
-          }
-          p = pattern.pattern();
-          rest = pattern.rest();
-          if (changed) {
-            if (this.hasWalkedCache.hasWalked(t, pattern))
+            if (i.isENOENT()) continue;
+            let a, l, f = false;
+            for (; typeof (a = r.pattern()) == "string" && (l = r.rest()); ) i = i.resolve(a), r = l, f = true;
+            if (a = r.pattern(), l = r.rest(), f) {
+              if (this.hasWalkedCache.hasWalked(i, r)) continue;
+              this.hasWalkedCache.storeWalked(i, r);
+            }
+            if (typeof a == "string") {
+              let c = a === ".." || a === "" || a === ".";
+              this.matches.add(i.resolve(a), o, c);
               continue;
-            this.hasWalkedCache.storeWalked(t, pattern);
-          }
-          if (typeof p === "string") {
-            const ifDir = p === ".." || p === "" || p === ".";
-            this.matches.add(t.resolve(p), absolute, ifDir);
-            continue;
-          } else if (p === minimatch_1.GLOBSTAR) {
-            if (!t.isSymbolicLink() || this.follow || pattern.checkFollowGlobstar()) {
-              this.subwalks.add(t, pattern);
-            }
-            const rp = rest?.pattern();
-            const rrest = rest?.rest();
-            if (!rest || (rp === "" || rp === ".") && !rrest) {
-              this.matches.add(t, absolute, rp === "" || rp === ".");
-            } else {
-              if (rp === "..") {
-                const tp = t.parent || t;
-                if (!rrest)
-                  this.matches.add(tp, absolute, true);
-                else if (!this.hasWalkedCache.hasWalked(tp, rrest)) {
-                  this.subwalks.add(tp, rrest);
-                }
+            } else if (a === Ds.GLOBSTAR) {
+              (!i.isSymbolicLink() || this.follow || r.checkFollowGlobstar()) && this.subwalks.add(i, r);
+              let c = l?.pattern(), d = l?.rest();
+              if (!l || (c === "" || c === ".") && !d) this.matches.add(i, o, c === "" || c === ".");
+              else if (c === "..") {
+                let u = i.parent || i;
+                d ? this.hasWalkedCache.hasWalked(u, d) || this.subwalks.add(u, d) : this.matches.add(u, o, true);
               }
-            }
-          } else if (p instanceof RegExp) {
-            this.subwalks.add(t, pattern);
+            } else a instanceof RegExp && this.subwalks.add(i, r);
           }
+          return this;
         }
-        return this;
-      }
-      subwalkTargets() {
-        return this.subwalks.keys();
-      }
-      child() {
-        return new _Processor(this.opts, this.hasWalkedCache);
-      }
-      // return a new Processor containing the subwalks for each
-      // child entry, and a set of matches, and
-      // a hasWalkedCache that's a copy of this one
-      // then we're going to call
-      filterEntries(parent, entries) {
-        const patterns = this.subwalks.get(parent);
-        const results = this.child();
-        for (const e of entries) {
-          for (const pattern of patterns) {
-            const absolute = pattern.isAbsolute();
-            const p = pattern.pattern();
-            const rest = pattern.rest();
-            if (p === minimatch_1.GLOBSTAR) {
-              results.testGlobstar(e, pattern, rest, absolute);
-            } else if (p instanceof RegExp) {
-              results.testRegExp(e, p, rest, absolute);
-            } else {
-              results.testString(e, p, rest, absolute);
-            }
-          }
+        subwalkTargets() {
+          return this.subwalks.keys();
         }
-        return results;
-      }
-      testGlobstar(e, pattern, rest, absolute) {
-        if (this.dot || !e.name.startsWith(".")) {
-          if (!pattern.hasMore()) {
-            this.matches.add(e, absolute, false);
-          }
-          if (e.canReaddir()) {
-            if (this.follow || !e.isSymbolicLink()) {
-              this.subwalks.add(e, pattern);
-            } else if (e.isSymbolicLink()) {
-              if (rest && pattern.checkFollowGlobstar()) {
-                this.subwalks.add(e, rest);
-              } else if (pattern.markFollowGlobstar()) {
-                this.subwalks.add(e, pattern);
-              }
-            }
+        child() {
+          return new n(this.opts, this.hasWalkedCache);
+        }
+        filterEntries(t, e) {
+          let s = this.subwalks.get(t), i = this.child();
+          for (let r of e) for (let h of s) {
+            let o = h.isAbsolute(), a = h.pattern(), l = h.rest();
+            a === Ds.GLOBSTAR ? i.testGlobstar(r, h, l, o) : a instanceof RegExp ? i.testRegExp(r, a, l, o) : i.testString(r, a, l, o);
           }
+          return i;
         }
-        if (rest) {
-          const rp = rest.pattern();
-          if (typeof rp === "string" && // dots and empty were handled already
-          rp !== ".." && rp !== "" && rp !== ".") {
-            this.testString(e, rp, rest.rest(), absolute);
-          } else if (rp === "..") {
-            const ep = e.parent || e;
-            this.subwalks.add(ep, rest);
-          } else if (rp instanceof RegExp) {
-            this.testRegExp(e, rp, rest.rest(), absolute);
+        testGlobstar(t, e, s, i) {
+          if ((this.dot || !t.name.startsWith(".")) && (e.hasMore() || this.matches.add(t, i, false), t.canReaddir() && (this.follow || !t.isSymbolicLink() ? this.subwalks.add(t, e) : t.isSymbolicLink() && (s && e.checkFollowGlobstar() ? this.subwalks.add(t, s) : e.markFollowGlobstar() && this.subwalks.add(t, e)))), s) {
+            let r = s.pattern();
+            if (typeof r == "string" && r !== ".." && r !== "" && r !== ".") this.testString(t, r, s.rest(), i);
+            else if (r === "..") {
+              let h = t.parent || t;
+              this.subwalks.add(h, s);
+            } else r instanceof RegExp && this.testRegExp(t, r, s.rest(), i);
           }
         }
-      }
-      testRegExp(e, p, rest, absolute) {
-        if (!p.test(e.name))
-          return;
-        if (!rest) {
-          this.matches.add(e, absolute, false);
-        } else {
-          this.subwalks.add(e, rest);
+        testRegExp(t, e, s, i) {
+          e.test(t.name) && (s ? this.subwalks.add(t, s) : this.matches.add(t, i, false));
         }
-      }
-      testString(e, p, rest, absolute) {
-        if (!e.isNamed(p))
-          return;
-        if (!rest) {
-          this.matches.add(e, absolute, false);
-        } else {
-          this.subwalks.add(e, rest);
+        testString(t, e, s, i) {
+          t.isNamed(e) && (s ? this.subwalks.add(t, s) : this.matches.add(t, i, false));
         }
-      }
-    };
-    exports2.Processor = Processor;
-  }
-});
-
-// node_modules/glob/dist/commonjs/walker.js
-var require_walker = __commonJS({
-  "node_modules/glob/dist/commonjs/walker.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.GlobStream = exports2.GlobWalker = exports2.GlobUtil = void 0;
-    var minipass_1 = require_commonjs22();
-    var ignore_js_1 = require_ignore();
-    var processor_js_1 = require_processor();
-    var makeIgnore = (ignore, opts) => typeof ignore === "string" ? new ignore_js_1.Ignore([ignore], opts) : Array.isArray(ignore) ? new ignore_js_1.Ignore(ignore, opts) : ignore;
-    var GlobUtil = class {
-      path;
-      patterns;
-      opts;
-      seen = /* @__PURE__ */ new Set();
-      paused = false;
-      aborted = false;
-      #onResume = [];
-      #ignore;
-      #sep;
-      signal;
-      maxDepth;
-      includeChildMatches;
-      constructor(patterns, path29, opts) {
-        this.patterns = patterns;
-        this.path = path29;
-        this.opts = opts;
-        this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
-        this.includeChildMatches = opts.includeChildMatches !== false;
-        if (opts.ignore || !this.includeChildMatches) {
-          this.#ignore = makeIgnore(opts.ignore ?? [], opts);
-          if (!this.includeChildMatches && typeof this.#ignore.add !== "function") {
-            const m = "cannot ignore child matches, ignore lacks add() method.";
-            throw new Error(m);
-          }
-        }
-        this.maxDepth = opts.maxDepth || Infinity;
-        if (opts.signal) {
-          this.signal = opts.signal;
-          this.signal.addEventListener("abort", () => {
-            this.#onResume.length = 0;
-          });
+      };
+      z.Processor = Me;
+    });
+    var Ls = R((X) => {
+      "use strict";
+      Object.defineProperty(X, "__esModule", { value: true });
+      X.GlobStream = X.GlobWalker = X.GlobUtil = void 0;
+      var Mr = Oe(), js = ke(), Ns = Fs(), Pr = (n, t) => typeof n == "string" ? new js.Ignore([n], t) : Array.isArray(n) ? new js.Ignore(n, t) : n, Ot = class {
+        path;
+        patterns;
+        opts;
+        seen = /* @__PURE__ */ new Set();
+        paused = false;
+        aborted = false;
+        #t = [];
+        #s;
+        #n;
+        signal;
+        maxDepth;
+        includeChildMatches;
+        constructor(t, e, s) {
+          if (this.patterns = t, this.path = e, this.opts = s, this.#n = !s.posix && s.platform === "win32" ? "\\" : "/", this.includeChildMatches = s.includeChildMatches !== false, (s.ignore || !this.includeChildMatches) && (this.#s = Pr(s.ignore ?? [], s), !this.includeChildMatches && typeof this.#s.add != "function")) {
+            let i = "cannot ignore child matches, ignore lacks add() method.";
+            throw new Error(i);
+          }
+          this.maxDepth = s.maxDepth || 1 / 0, s.signal && (this.signal = s.signal, this.signal.addEventListener("abort", () => {
+            this.#t.length = 0;
+          }));
         }
-      }
-      #ignored(path29) {
-        return this.seen.has(path29) || !!this.#ignore?.ignored?.(path29);
-      }
-      #childrenIgnored(path29) {
-        return !!this.#ignore?.childrenIgnored?.(path29);
-      }
-      // backpressure mechanism
-      pause() {
-        this.paused = true;
-      }
-      resume() {
-        if (this.signal?.aborted)
-          return;
-        this.paused = false;
-        let fn = void 0;
-        while (!this.paused && (fn = this.#onResume.shift())) {
-          fn();
+        #r(t) {
+          return this.seen.has(t) || !!this.#s?.ignored?.(t);
         }
-      }
-      onResume(fn) {
-        if (this.signal?.aborted)
-          return;
-        if (!this.paused) {
-          fn();
-        } else {
-          this.#onResume.push(fn);
+        #h(t) {
+          return !!this.#s?.childrenIgnored?.(t);
         }
-      }
-      // do the requisite realpath/stat checking, and return the path
-      // to add or undefined to filter it out.
-      async matchCheck(e, ifDir) {
-        if (ifDir && this.opts.nodir)
-          return void 0;
-        let rpc;
-        if (this.opts.realpath) {
-          rpc = e.realpathCached() || await e.realpath();
-          if (!rpc)
-            return void 0;
-          e = rpc;
+        pause() {
+          this.paused = true;
         }
-        const needStat = e.isUnknown() || this.opts.stat;
-        const s = needStat ? await e.lstat() : e;
-        if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
-          const target = await s.realpath();
-          if (target && (target.isUnknown() || this.opts.stat)) {
-            await target.lstat();
+        resume() {
+          if (this.signal?.aborted) return;
+          this.paused = false;
+          let t;
+          for (; !this.paused && (t = this.#t.shift()); ) t();
+        }
+        onResume(t) {
+          this.signal?.aborted || (this.paused ? this.#t.push(t) : t());
+        }
+        async matchCheck(t, e) {
+          if (e && this.opts.nodir) return;
+          let s;
+          if (this.opts.realpath) {
+            if (s = t.realpathCached() || await t.realpath(), !s) return;
+            t = s;
+          }
+          let r = t.isUnknown() || this.opts.stat ? await t.lstat() : t;
+          if (this.opts.follow && this.opts.nodir && r?.isSymbolicLink()) {
+            let h = await r.realpath();
+            h && (h.isUnknown() || this.opts.stat) && await h.lstat();
+          }
+          return this.matchCheckTest(r, e);
+        }
+        matchCheckTest(t, e) {
+          return t && (this.maxDepth === 1 / 0 || t.depth() <= this.maxDepth) && (!e || t.canReaddir()) && (!this.opts.nodir || !t.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !t.isSymbolicLink() || !t.realpathCached()?.isDirectory()) && !this.#r(t) ? t : void 0;
+        }
+        matchCheckSync(t, e) {
+          if (e && this.opts.nodir) return;
+          let s;
+          if (this.opts.realpath) {
+            if (s = t.realpathCached() || t.realpathSync(), !s) return;
+            t = s;
+          }
+          let r = t.isUnknown() || this.opts.stat ? t.lstatSync() : t;
+          if (this.opts.follow && this.opts.nodir && r?.isSymbolicLink()) {
+            let h = r.realpathSync();
+            h && (h?.isUnknown() || this.opts.stat) && h.lstatSync();
+          }
+          return this.matchCheckTest(r, e);
+        }
+        matchFinish(t, e) {
+          if (this.#r(t)) return;
+          if (!this.includeChildMatches && this.#s?.add) {
+            let r = `${t.relativePosix()}/**`;
+            this.#s.add(r);
+          }
+          let s = this.opts.absolute === void 0 ? e : this.opts.absolute;
+          this.seen.add(t);
+          let i = this.opts.mark && t.isDirectory() ? this.#n : "";
+          if (this.opts.withFileTypes) this.matchEmit(t);
+          else if (s) {
+            let r = this.opts.posix ? t.fullpathPosix() : t.fullpath();
+            this.matchEmit(r + i);
+          } else {
+            let r = this.opts.posix ? t.relativePosix() : t.relative(), h = this.opts.dotRelative && !r.startsWith(".." + this.#n) ? "." + this.#n : "";
+            this.matchEmit(r ? h + r + i : "." + i);
           }
         }
-        return this.matchCheckTest(s, ifDir);
-      }
-      matchCheckTest(e, ifDir) {
-        return e && (this.maxDepth === Infinity || e.depth() <= this.maxDepth) && (!ifDir || e.canReaddir()) && (!this.opts.nodir || !e.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !e.isSymbolicLink() || !e.realpathCached()?.isDirectory()) && !this.#ignored(e) ? e : void 0;
-      }
-      matchCheckSync(e, ifDir) {
-        if (ifDir && this.opts.nodir)
-          return void 0;
-        let rpc;
-        if (this.opts.realpath) {
-          rpc = e.realpathCached() || e.realpathSync();
-          if (!rpc)
-            return void 0;
-          e = rpc;
+        async match(t, e, s) {
+          let i = await this.matchCheck(t, s);
+          i && this.matchFinish(i, e);
         }
-        const needStat = e.isUnknown() || this.opts.stat;
-        const s = needStat ? e.lstatSync() : e;
-        if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
-          const target = s.realpathSync();
-          if (target && (target?.isUnknown() || this.opts.stat)) {
-            target.lstatSync();
-          }
+        matchSync(t, e, s) {
+          let i = this.matchCheckSync(t, s);
+          i && this.matchFinish(i, e);
         }
-        return this.matchCheckTest(s, ifDir);
-      }
-      matchFinish(e, absolute) {
-        if (this.#ignored(e))
-          return;
-        if (!this.includeChildMatches && this.#ignore?.add) {
-          const ign = `${e.relativePosix()}/**`;
-          this.#ignore.add(ign);
-        }
-        const abs = this.opts.absolute === void 0 ? absolute : this.opts.absolute;
-        this.seen.add(e);
-        const mark = this.opts.mark && e.isDirectory() ? this.#sep : "";
-        if (this.opts.withFileTypes) {
-          this.matchEmit(e);
-        } else if (abs) {
-          const abs2 = this.opts.posix ? e.fullpathPosix() : e.fullpath();
-          this.matchEmit(abs2 + mark);
-        } else {
-          const rel = this.opts.posix ? e.relativePosix() : e.relative();
-          const pre = this.opts.dotRelative && !rel.startsWith(".." + this.#sep) ? "." + this.#sep : "";
-          this.matchEmit(!rel ? "." + mark : pre + rel + mark);
+        walkCB(t, e, s) {
+          this.signal?.aborted && s(), this.walkCB2(t, e, new Ns.Processor(this.opts), s);
         }
-      }
-      async match(e, absolute, ifDir) {
-        const p = await this.matchCheck(e, ifDir);
-        if (p)
-          this.matchFinish(p, absolute);
-      }
-      matchSync(e, absolute, ifDir) {
-        const p = this.matchCheckSync(e, ifDir);
-        if (p)
-          this.matchFinish(p, absolute);
-      }
-      walkCB(target, patterns, cb) {
-        if (this.signal?.aborted)
-          cb();
-        this.walkCB2(target, patterns, new processor_js_1.Processor(this.opts), cb);
-      }
-      walkCB2(target, patterns, processor, cb) {
-        if (this.#childrenIgnored(target))
-          return cb();
-        if (this.signal?.aborted)
-          cb();
-        if (this.paused) {
-          this.onResume(() => this.walkCB2(target, patterns, processor, cb));
-          return;
+        walkCB2(t, e, s, i) {
+          if (this.#h(t)) return i();
+          if (this.signal?.aborted && i(), this.paused) {
+            this.onResume(() => this.walkCB2(t, e, s, i));
+            return;
+          }
+          s.processPatterns(t, e);
+          let r = 1, h = () => {
+            --r === 0 && i();
+          };
+          for (let [o, a, l] of s.matches.entries()) this.#r(o) || (r++, this.match(o, a, l).then(() => h()));
+          for (let o of s.subwalkTargets()) {
+            if (this.maxDepth !== 1 / 0 && o.depth() >= this.maxDepth) continue;
+            r++;
+            let a = o.readdirCached();
+            o.calledReaddir() ? this.walkCB3(o, a, s, h) : o.readdirCB((l, f) => this.walkCB3(o, f, s, h), true);
+          }
+          h();
+        }
+        walkCB3(t, e, s, i) {
+          s = s.filterEntries(t, e);
+          let r = 1, h = () => {
+            --r === 0 && i();
+          };
+          for (let [o, a, l] of s.matches.entries()) this.#r(o) || (r++, this.match(o, a, l).then(() => h()));
+          for (let [o, a] of s.subwalks.entries()) r++, this.walkCB2(o, a, s.child(), h);
+          h();
         }
-        processor.processPatterns(target, patterns);
-        let tasks = 1;
-        const next = () => {
-          if (--tasks === 0)
-            cb();
-        };
-        for (const [m, absolute, ifDir] of processor.matches.entries()) {
-          if (this.#ignored(m))
-            continue;
-          tasks++;
-          this.match(m, absolute, ifDir).then(() => next());
+        walkCBSync(t, e, s) {
+          this.signal?.aborted && s(), this.walkCB2Sync(t, e, new Ns.Processor(this.opts), s);
         }
-        for (const t of processor.subwalkTargets()) {
-          if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
-            continue;
-          }
-          tasks++;
-          const childrenCached = t.readdirCached();
-          if (t.calledReaddir())
-            this.walkCB3(t, childrenCached, processor, next);
-          else {
-            t.readdirCB((_2, entries) => this.walkCB3(t, entries, processor, next), true);
+        walkCB2Sync(t, e, s, i) {
+          if (this.#h(t)) return i();
+          if (this.signal?.aborted && i(), this.paused) {
+            this.onResume(() => this.walkCB2Sync(t, e, s, i));
+            return;
           }
+          s.processPatterns(t, e);
+          let r = 1, h = () => {
+            --r === 0 && i();
+          };
+          for (let [o, a, l] of s.matches.entries()) this.#r(o) || this.matchSync(o, a, l);
+          for (let o of s.subwalkTargets()) {
+            if (this.maxDepth !== 1 / 0 && o.depth() >= this.maxDepth) continue;
+            r++;
+            let a = o.readdirSync();
+            this.walkCB3Sync(o, a, s, h);
+          }
+          h();
+        }
+        walkCB3Sync(t, e, s, i) {
+          s = s.filterEntries(t, e);
+          let r = 1, h = () => {
+            --r === 0 && i();
+          };
+          for (let [o, a, l] of s.matches.entries()) this.#r(o) || this.matchSync(o, a, l);
+          for (let [o, a] of s.subwalks.entries()) r++, this.walkCB2Sync(o, a, s.child(), h);
+          h();
         }
-        next();
-      }
-      walkCB3(target, entries, processor, cb) {
-        processor = processor.filterEntries(target, entries);
-        let tasks = 1;
-        const next = () => {
-          if (--tasks === 0)
-            cb();
-        };
-        for (const [m, absolute, ifDir] of processor.matches.entries()) {
-          if (this.#ignored(m))
-            continue;
-          tasks++;
-          this.match(m, absolute, ifDir).then(() => next());
+      };
+      X.GlobUtil = Ot;
+      var Pe = class extends Ot {
+        matches = /* @__PURE__ */ new Set();
+        constructor(t, e, s) {
+          super(t, e, s);
         }
-        for (const [target2, patterns] of processor.subwalks.entries()) {
-          tasks++;
-          this.walkCB2(target2, patterns, processor.child(), next);
+        matchEmit(t) {
+          this.matches.add(t);
         }
-        next();
-      }
-      walkCBSync(target, patterns, cb) {
-        if (this.signal?.aborted)
-          cb();
-        this.walkCB2Sync(target, patterns, new processor_js_1.Processor(this.opts), cb);
-      }
-      walkCB2Sync(target, patterns, processor, cb) {
-        if (this.#childrenIgnored(target))
-          return cb();
-        if (this.signal?.aborted)
-          cb();
-        if (this.paused) {
-          this.onResume(() => this.walkCB2Sync(target, patterns, processor, cb));
-          return;
+        async walk() {
+          if (this.signal?.aborted) throw this.signal.reason;
+          return this.path.isUnknown() && await this.path.lstat(), await new Promise((t, e) => {
+            this.walkCB(this.path, this.patterns, () => {
+              this.signal?.aborted ? e(this.signal.reason) : t(this.matches);
+            });
+          }), this.matches;
         }
-        processor.processPatterns(target, patterns);
-        let tasks = 1;
-        const next = () => {
-          if (--tasks === 0)
-            cb();
-        };
-        for (const [m, absolute, ifDir] of processor.matches.entries()) {
-          if (this.#ignored(m))
-            continue;
-          this.matchSync(m, absolute, ifDir);
+        walkSync() {
+          if (this.signal?.aborted) throw this.signal.reason;
+          return this.path.isUnknown() && this.path.lstatSync(), this.walkCBSync(this.path, this.patterns, () => {
+            if (this.signal?.aborted) throw this.signal.reason;
+          }), this.matches;
         }
-        for (const t of processor.subwalkTargets()) {
-          if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
-            continue;
-          }
-          tasks++;
-          const children = t.readdirSync();
-          this.walkCB3Sync(t, children, processor, next);
+      };
+      X.GlobWalker = Pe;
+      var De = class extends Ot {
+        results;
+        constructor(t, e, s) {
+          super(t, e, s), this.results = new Mr.Minipass({ signal: this.signal, objectMode: true }), this.results.on("drain", () => this.resume()), this.results.on("resume", () => this.resume());
         }
-        next();
-      }
-      walkCB3Sync(target, entries, processor, cb) {
-        processor = processor.filterEntries(target, entries);
-        let tasks = 1;
-        const next = () => {
-          if (--tasks === 0)
-            cb();
-        };
-        for (const [m, absolute, ifDir] of processor.matches.entries()) {
-          if (this.#ignored(m))
-            continue;
-          this.matchSync(m, absolute, ifDir);
+        matchEmit(t) {
+          this.results.write(t), this.results.flowing || this.pause();
         }
-        for (const [target2, patterns] of processor.subwalks.entries()) {
-          tasks++;
-          this.walkCB2Sync(target2, patterns, processor.child(), next);
+        stream() {
+          let t = this.path;
+          return t.isUnknown() ? t.lstat().then(() => {
+            this.walkCB(t, this.patterns, () => this.results.end());
+          }) : this.walkCB(t, this.patterns, () => this.results.end()), this.results;
         }
-        next();
-      }
-    };
-    exports2.GlobUtil = GlobUtil;
-    var GlobWalker = class extends GlobUtil {
-      matches = /* @__PURE__ */ new Set();
-      constructor(patterns, path29, opts) {
-        super(patterns, path29, opts);
-      }
-      matchEmit(e) {
-        this.matches.add(e);
-      }
-      async walk() {
-        if (this.signal?.aborted)
-          throw this.signal.reason;
-        if (this.path.isUnknown()) {
-          await this.path.lstat();
+        streamSync() {
+          return this.path.isUnknown() && this.path.lstatSync(), this.walkCBSync(this.path, this.patterns, () => this.results.end()), this.results;
         }
-        await new Promise((res, rej) => {
-          this.walkCB(this.path, this.patterns, () => {
-            if (this.signal?.aborted) {
-              rej(this.signal.reason);
-            } else {
-              res(this.matches);
-            }
+      };
+      X.GlobStream = De;
+    });
+    var je = R((oe) => {
+      "use strict";
+      Object.defineProperty(oe, "__esModule", { value: true });
+      oe.Glob = void 0;
+      var Dr = H(), Fr = require("node:url"), ne = Ms(), jr = Re(), he = Ls(), Nr = typeof process == "object" && process && typeof process.platform == "string" ? process.platform : "linux", Fe = class {
+        absolute;
+        cwd;
+        root;
+        dot;
+        dotRelative;
+        follow;
+        ignore;
+        magicalBraces;
+        mark;
+        matchBase;
+        maxDepth;
+        nobrace;
+        nocase;
+        nodir;
+        noext;
+        noglobstar;
+        pattern;
+        platform;
+        realpath;
+        scurry;
+        stat;
+        signal;
+        windowsPathsNoEscape;
+        withFileTypes;
+        includeChildMatches;
+        opts;
+        patterns;
+        constructor(t, e) {
+          if (!e) throw new TypeError("glob options required");
+          if (this.withFileTypes = !!e.withFileTypes, this.signal = e.signal, this.follow = !!e.follow, this.dot = !!e.dot, this.dotRelative = !!e.dotRelative, this.nodir = !!e.nodir, this.mark = !!e.mark, e.cwd ? (e.cwd instanceof URL || e.cwd.startsWith("file://")) && (e.cwd = (0, Fr.fileURLToPath)(e.cwd)) : this.cwd = "", this.cwd = e.cwd || "", this.root = e.root, this.magicalBraces = !!e.magicalBraces, this.nobrace = !!e.nobrace, this.noext = !!e.noext, this.realpath = !!e.realpath, this.absolute = e.absolute, this.includeChildMatches = e.includeChildMatches !== false, this.noglobstar = !!e.noglobstar, this.matchBase = !!e.matchBase, this.maxDepth = typeof e.maxDepth == "number" ? e.maxDepth : 1 / 0, this.stat = !!e.stat, this.ignore = e.ignore, this.withFileTypes && this.absolute !== void 0) throw new Error("cannot set absolute and withFileTypes:true");
+          if (typeof t == "string" && (t = [t]), this.windowsPathsNoEscape = !!e.windowsPathsNoEscape || e.allowWindowsEscape === false, this.windowsPathsNoEscape && (t = t.map((a) => a.replace(/\\/g, "/"))), this.matchBase) {
+            if (e.noglobstar) throw new TypeError("base matching requires globstar");
+            t = t.map((a) => a.includes("/") ? a : `./**/${a}`);
+          }
+          if (this.pattern = t, this.platform = e.platform || Nr, this.opts = { ...e, platform: this.platform }, e.scurry) {
+            if (this.scurry = e.scurry, e.nocase !== void 0 && e.nocase !== e.scurry.nocase) throw new Error("nocase option contradicts provided scurry option");
+          } else {
+            let a = e.platform === "win32" ? ne.PathScurryWin32 : e.platform === "darwin" ? ne.PathScurryDarwin : e.platform ? ne.PathScurryPosix : ne.PathScurry;
+            this.scurry = new a(this.cwd, { nocase: e.nocase, fs: e.fs });
+          }
+          this.nocase = this.scurry.nocase;
+          let s = this.platform === "darwin" || this.platform === "win32", i = { braceExpandMax: 1e4, ...e, dot: this.dot, matchBase: this.matchBase, nobrace: this.nobrace, nocase: this.nocase, nocaseMagicOnly: s, nocomment: true, noext: this.noext, nonegate: true, optimizationLevel: 2, platform: this.platform, windowsPathsNoEscape: this.windowsPathsNoEscape, debug: !!this.opts.debug }, r = this.pattern.map((a) => new Dr.Minimatch(a, i)), [h, o] = r.reduce((a, l) => (a[0].push(...l.set), a[1].push(...l.globParts), a), [[], []]);
+          this.patterns = h.map((a, l) => {
+            let f = o[l];
+            if (!f) throw new Error("invalid pattern object");
+            return new jr.Pattern(a, f, 0, this.platform);
           });
-        });
-        return this.matches;
-      }
-      walkSync() {
-        if (this.signal?.aborted)
-          throw this.signal.reason;
-        if (this.path.isUnknown()) {
-          this.path.lstatSync();
         }
-        this.walkCBSync(this.path, this.patterns, () => {
-          if (this.signal?.aborted)
-            throw this.signal.reason;
-        });
-        return this.matches;
-      }
-    };
-    exports2.GlobWalker = GlobWalker;
-    var GlobStream = class extends GlobUtil {
-      results;
-      constructor(patterns, path29, opts) {
-        super(patterns, path29, opts);
-        this.results = new minipass_1.Minipass({
-          signal: this.signal,
-          objectMode: true
-        });
-        this.results.on("drain", () => this.resume());
-        this.results.on("resume", () => this.resume());
-      }
-      matchEmit(e) {
-        this.results.write(e);
-        if (!this.results.flowing)
-          this.pause();
-      }
-      stream() {
-        const target = this.path;
-        if (target.isUnknown()) {
-          target.lstat().then(() => {
-            this.walkCB(target, this.patterns, () => this.results.end());
-          });
-        } else {
-          this.walkCB(target, this.patterns, () => this.results.end());
+        async walk() {
+          return [...await new he.GlobWalker(this.patterns, this.scurry.cwd, { ...this.opts, maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0, platform: this.platform, nocase: this.nocase, includeChildMatches: this.includeChildMatches }).walk()];
         }
-        return this.results;
-      }
-      streamSync() {
-        if (this.path.isUnknown()) {
-          this.path.lstatSync();
+        walkSync() {
+          return [...new he.GlobWalker(this.patterns, this.scurry.cwd, { ...this.opts, maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0, platform: this.platform, nocase: this.nocase, includeChildMatches: this.includeChildMatches }).walkSync()];
         }
-        this.walkCBSync(this.path, this.patterns, () => this.results.end());
-        return this.results;
-      }
-    };
-    exports2.GlobStream = GlobStream;
-  }
-});
-
-// node_modules/glob/dist/commonjs/glob.js
-var require_glob2 = __commonJS({
-  "node_modules/glob/dist/commonjs/glob.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.Glob = void 0;
-    var minimatch_1 = require_commonjs20();
-    var node_url_1 = require("node:url");
-    var path_scurry_1 = require_commonjs23();
-    var pattern_js_1 = require_pattern();
-    var walker_js_1 = require_walker();
-    var defaultPlatform2 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
-    var Glob = class {
-      absolute;
-      cwd;
-      root;
-      dot;
-      dotRelative;
-      follow;
-      ignore;
-      magicalBraces;
-      mark;
-      matchBase;
-      maxDepth;
-      nobrace;
-      nocase;
-      nodir;
-      noext;
-      noglobstar;
-      pattern;
-      platform;
-      realpath;
-      scurry;
-      stat;
-      signal;
-      windowsPathsNoEscape;
-      withFileTypes;
-      includeChildMatches;
-      /**
-       * The options provided to the constructor.
-       */
-      opts;
-      /**
-       * An array of parsed immutable {@link Pattern} objects.
-       */
-      patterns;
-      /**
-       * All options are stored as properties on the `Glob` object.
-       *
-       * See {@link GlobOptions} for full options descriptions.
-       *
-       * Note that a previous `Glob` object can be passed as the
-       * `GlobOptions` to another `Glob` instantiation to re-use settings
-       * and caches with a new pattern.
-       *
-       * Traversal functions can be called multiple times to run the walk
-       * again.
-       */
-      constructor(pattern, opts) {
-        if (!opts)
-          throw new TypeError("glob options required");
-        this.withFileTypes = !!opts.withFileTypes;
-        this.signal = opts.signal;
-        this.follow = !!opts.follow;
-        this.dot = !!opts.dot;
-        this.dotRelative = !!opts.dotRelative;
-        this.nodir = !!opts.nodir;
-        this.mark = !!opts.mark;
-        if (!opts.cwd) {
-          this.cwd = "";
-        } else if (opts.cwd instanceof URL || opts.cwd.startsWith("file://")) {
-          opts.cwd = (0, node_url_1.fileURLToPath)(opts.cwd);
-        }
-        this.cwd = opts.cwd || "";
-        this.root = opts.root;
-        this.magicalBraces = !!opts.magicalBraces;
-        this.nobrace = !!opts.nobrace;
-        this.noext = !!opts.noext;
-        this.realpath = !!opts.realpath;
-        this.absolute = opts.absolute;
-        this.includeChildMatches = opts.includeChildMatches !== false;
-        this.noglobstar = !!opts.noglobstar;
-        this.matchBase = !!opts.matchBase;
-        this.maxDepth = typeof opts.maxDepth === "number" ? opts.maxDepth : Infinity;
-        this.stat = !!opts.stat;
-        this.ignore = opts.ignore;
-        if (this.withFileTypes && this.absolute !== void 0) {
-          throw new Error("cannot set absolute and withFileTypes:true");
-        }
-        if (typeof pattern === "string") {
-          pattern = [pattern];
-        }
-        this.windowsPathsNoEscape = !!opts.windowsPathsNoEscape || opts.allowWindowsEscape === false;
-        if (this.windowsPathsNoEscape) {
-          pattern = pattern.map((p) => p.replace(/\\/g, "/"));
+        stream() {
+          return new he.GlobStream(this.patterns, this.scurry.cwd, { ...this.opts, maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0, platform: this.platform, nocase: this.nocase, includeChildMatches: this.includeChildMatches }).stream();
         }
-        if (this.matchBase) {
-          if (opts.noglobstar) {
-            throw new TypeError("base matching requires globstar");
-          }
-          pattern = pattern.map((p) => p.includes("/") ? p : `./**/${p}`);
+        streamSync() {
+          return new he.GlobStream(this.patterns, this.scurry.cwd, { ...this.opts, maxDepth: this.maxDepth !== 1 / 0 ? this.maxDepth + this.scurry.cwd.depth() : 1 / 0, platform: this.platform, nocase: this.nocase, includeChildMatches: this.includeChildMatches }).streamSync();
         }
-        this.pattern = pattern;
-        this.platform = opts.platform || defaultPlatform2;
-        this.opts = { ...opts, platform: this.platform };
-        if (opts.scurry) {
-          this.scurry = opts.scurry;
-          if (opts.nocase !== void 0 && opts.nocase !== opts.scurry.nocase) {
-            throw new Error("nocase option contradicts provided scurry option");
-          }
-        } else {
-          const Scurry = opts.platform === "win32" ? path_scurry_1.PathScurryWin32 : opts.platform === "darwin" ? path_scurry_1.PathScurryDarwin : opts.platform ? path_scurry_1.PathScurryPosix : path_scurry_1.PathScurry;
-          this.scurry = new Scurry(this.cwd, {
-            nocase: opts.nocase,
-            fs: opts.fs
-          });
+        iterateSync() {
+          return this.streamSync()[Symbol.iterator]();
         }
-        this.nocase = this.scurry.nocase;
-        const nocaseMagicOnly = this.platform === "darwin" || this.platform === "win32";
-        const mmo = {
-          // default nocase based on platform
-          ...opts,
-          dot: this.dot,
-          matchBase: this.matchBase,
-          nobrace: this.nobrace,
-          nocase: this.nocase,
-          nocaseMagicOnly,
-          nocomment: true,
-          noext: this.noext,
-          nonegate: true,
-          optimizationLevel: 2,
-          platform: this.platform,
-          windowsPathsNoEscape: this.windowsPathsNoEscape,
-          debug: !!this.opts.debug
-        };
-        const mms = this.pattern.map((p) => new minimatch_1.Minimatch(p, mmo));
-        const [matchSet, globParts] = mms.reduce((set, m) => {
-          set[0].push(...m.set);
-          set[1].push(...m.globParts);
-          return set;
-        }, [[], []]);
-        this.patterns = matchSet.map((set, i) => {
-          const g = globParts[i];
-          if (!g)
-            throw new Error("invalid pattern object");
-          return new pattern_js_1.Pattern(set, g, 0, this.platform);
-        });
-      }
-      async walk() {
-        return [
-          ...await new walker_js_1.GlobWalker(this.patterns, this.scurry.cwd, {
-            ...this.opts,
-            maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
-            platform: this.platform,
-            nocase: this.nocase,
-            includeChildMatches: this.includeChildMatches
-          }).walk()
-        ];
-      }
-      walkSync() {
-        return [
-          ...new walker_js_1.GlobWalker(this.patterns, this.scurry.cwd, {
-            ...this.opts,
-            maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
-            platform: this.platform,
-            nocase: this.nocase,
-            includeChildMatches: this.includeChildMatches
-          }).walkSync()
-        ];
-      }
-      stream() {
-        return new walker_js_1.GlobStream(this.patterns, this.scurry.cwd, {
-          ...this.opts,
-          maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
-          platform: this.platform,
-          nocase: this.nocase,
-          includeChildMatches: this.includeChildMatches
-        }).stream();
-      }
-      streamSync() {
-        return new walker_js_1.GlobStream(this.patterns, this.scurry.cwd, {
-          ...this.opts,
-          maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
-          platform: this.platform,
-          nocase: this.nocase,
-          includeChildMatches: this.includeChildMatches
-        }).streamSync();
-      }
-      /**
-       * Default sync iteration function. Returns a Generator that
-       * iterates over the results.
-       */
-      iterateSync() {
-        return this.streamSync()[Symbol.iterator]();
-      }
-      [Symbol.iterator]() {
-        return this.iterateSync();
-      }
-      /**
-       * Default async iteration function. Returns an AsyncGenerator that
-       * iterates over the results.
-       */
-      iterate() {
-        return this.stream()[Symbol.asyncIterator]();
-      }
-      [Symbol.asyncIterator]() {
-        return this.iterate();
-      }
-    };
-    exports2.Glob = Glob;
-  }
-});
-
-// node_modules/glob/dist/commonjs/has-magic.js
-var require_has_magic = __commonJS({
-  "node_modules/glob/dist/commonjs/has-magic.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.hasMagic = void 0;
-    var minimatch_1 = require_commonjs20();
-    var hasMagic = (pattern, options = {}) => {
-      if (!Array.isArray(pattern)) {
-        pattern = [pattern];
-      }
-      for (const p of pattern) {
-        if (new minimatch_1.Minimatch(p, options).hasMagic())
-          return true;
-      }
-      return false;
-    };
-    exports2.hasMagic = hasMagic;
-  }
-});
-
-// node_modules/glob/dist/commonjs/index.js
-var require_commonjs24 = __commonJS({
-  "node_modules/glob/dist/commonjs/index.js"(exports2) {
-    "use strict";
+        [Symbol.iterator]() {
+          return this.iterateSync();
+        }
+        iterate() {
+          return this.stream()[Symbol.asyncIterator]();
+        }
+        [Symbol.asyncIterator]() {
+          return this.iterate();
+        }
+      };
+      oe.Glob = Fe;
+    });
+    var Ne = R((ae) => {
+      "use strict";
+      Object.defineProperty(ae, "__esModule", { value: true });
+      ae.hasMagic = void 0;
+      var Lr = H(), Wr = (n, t = {}) => {
+        Array.isArray(n) || (n = [n]);
+        for (let e of n) if (new Lr.Minimatch(e, t).hasMagic()) return true;
+        return false;
+      };
+      ae.hasMagic = Wr;
+    });
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.glob = exports2.sync = exports2.iterate = exports2.iterateSync = exports2.stream = exports2.streamSync = exports2.Ignore = exports2.hasMagic = exports2.Glob = exports2.unescape = exports2.escape = void 0;
-    exports2.globStreamSync = globStreamSync;
-    exports2.globStream = globStream;
-    exports2.globSync = globSync;
-    exports2.globIterateSync = globIterateSync;
-    exports2.globIterate = globIterate;
-    var minimatch_1 = require_commonjs20();
-    var glob_js_1 = require_glob2();
-    var has_magic_js_1 = require_has_magic();
-    var minimatch_2 = require_commonjs20();
+    exports2.globStreamSync = xt;
+    exports2.globStream = Le;
+    exports2.globSync = We;
+    exports2.globIterateSync = Tt;
+    exports2.globIterate = Be;
+    var Ws = H();
+    var tt = je();
+    var Br = Ne();
+    var Is = H();
     Object.defineProperty(exports2, "escape", { enumerable: true, get: function() {
-      return minimatch_2.escape;
+      return Is.escape;
     } });
     Object.defineProperty(exports2, "unescape", { enumerable: true, get: function() {
-      return minimatch_2.unescape;
+      return Is.unescape;
     } });
-    var glob_js_2 = require_glob2();
+    var Ir = je();
     Object.defineProperty(exports2, "Glob", { enumerable: true, get: function() {
-      return glob_js_2.Glob;
+      return Ir.Glob;
     } });
-    var has_magic_js_2 = require_has_magic();
+    var Gr = Ne();
     Object.defineProperty(exports2, "hasMagic", { enumerable: true, get: function() {
-      return has_magic_js_2.hasMagic;
+      return Gr.hasMagic;
     } });
-    var ignore_js_1 = require_ignore();
+    var zr = ke();
     Object.defineProperty(exports2, "Ignore", { enumerable: true, get: function() {
-      return ignore_js_1.Ignore;
+      return zr.Ignore;
     } });
-    function globStreamSync(pattern, options = {}) {
-      return new glob_js_1.Glob(pattern, options).streamSync();
+    function xt(n, t = {}) {
+      return new tt.Glob(n, t).streamSync();
     }
-    function globStream(pattern, options = {}) {
-      return new glob_js_1.Glob(pattern, options).stream();
+    function Le(n, t = {}) {
+      return new tt.Glob(n, t).stream();
     }
-    function globSync(pattern, options = {}) {
-      return new glob_js_1.Glob(pattern, options).walkSync();
+    function We(n, t = {}) {
+      return new tt.Glob(n, t).walkSync();
     }
-    async function glob_(pattern, options = {}) {
-      return new glob_js_1.Glob(pattern, options).walk();
+    async function Bs(n, t = {}) {
+      return new tt.Glob(n, t).walk();
     }
-    function globIterateSync(pattern, options = {}) {
-      return new glob_js_1.Glob(pattern, options).iterateSync();
+    function Tt(n, t = {}) {
+      return new tt.Glob(n, t).iterateSync();
     }
-    function globIterate(pattern, options = {}) {
-      return new glob_js_1.Glob(pattern, options).iterate();
+    function Be(n, t = {}) {
+      return new tt.Glob(n, t).iterate();
     }
-    exports2.streamSync = globStreamSync;
-    exports2.stream = Object.assign(globStream, { sync: globStreamSync });
-    exports2.iterateSync = globIterateSync;
-    exports2.iterate = Object.assign(globIterate, {
-      sync: globIterateSync
-    });
-    exports2.sync = Object.assign(globSync, {
-      stream: globStreamSync,
-      iterate: globIterateSync
-    });
-    exports2.glob = Object.assign(glob_, {
-      glob: glob_,
-      globSync,
-      sync: exports2.sync,
-      globStream,
-      stream: exports2.stream,
-      globStreamSync,
-      streamSync: exports2.streamSync,
-      globIterate,
-      iterate: exports2.iterate,
-      globIterateSync,
-      iterateSync: exports2.iterateSync,
-      Glob: glob_js_1.Glob,
-      hasMagic: has_magic_js_1.hasMagic,
-      escape: minimatch_1.escape,
-      unescape: minimatch_1.unescape
-    });
+    exports2.streamSync = xt;
+    exports2.stream = Object.assign(Le, { sync: xt });
+    exports2.iterateSync = Tt;
+    exports2.iterate = Object.assign(Be, { sync: Tt });
+    exports2.sync = Object.assign(We, { stream: xt, iterate: Tt });
+    exports2.glob = Object.assign(Bs, { glob: Bs, globSync: We, sync: exports2.sync, globStream: Le, stream: exports2.stream, globStreamSync: xt, streamSync: exports2.streamSync, globIterate: Be, iterate: exports2.iterate, globIterateSync: Tt, iterateSync: exports2.iterateSync, Glob: tt.Glob, hasMagic: Br.hasMagic, escape: Ws.escape, unescape: Ws.unescape });
     exports2.glob.glob = exports2.glob;
   }
 });
@@ -109581,7 +105482,7 @@ var require_file3 = __commonJS({
     var difference = require_difference();
     var union = require_union();
     var isPlainObject4 = require_isPlainObject();
-    var glob2 = require_commonjs24();
+    var glob2 = require_index_min();
     var file = module2.exports = {};
     var pathSeparatorRe = /[\/\\]/g;
     var processPatterns = function(patterns, fn) {
diff --git a/package-lock.json b/package-lock.json
index 95ac61f15c..753eb3dace 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -56,7 +56,7 @@
         "eslint-plugin-import-x": "^4.16.2",
         "eslint-plugin-jsdoc": "^62.9.0",
         "eslint-plugin-no-async-foreach": "^0.1.1",
-        "glob": "^11.1.0",
+        "glob": "^13.0.6",
         "globals": "^17.6.0",
         "nock": "^14.0.15",
         "sinon": "^22.0.0",
@@ -1681,90 +1681,6 @@
         "url": "https://github.com/sponsors/nzakas"
       }
     },
-    "node_modules/@isaacs/cliui": {
-      "version": "8.0.2",
-      "resolved": "https://registry.npmjs.org/@isaacs/cliui/-/cliui-8.0.2.tgz",
-      "integrity": "sha512-O8jcjabXaleOG9DQ0+ARXWZBTfnP4WNAqzuiJK7ll44AmxGKv/J2M4TPjxjY3znBCfvBXFzucm1twdyFybFqEA==",
-      "license": "ISC",
-      "dependencies": {
-        "string-width": "^5.1.2",
-        "string-width-cjs": "npm:string-width@^4.2.0",
-        "strip-ansi": "^7.0.1",
-        "strip-ansi-cjs": "npm:strip-ansi@^6.0.1",
-        "wrap-ansi": "^8.1.0",
-        "wrap-ansi-cjs": "npm:wrap-ansi@^7.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/ansi-regex": {
-      "version": "6.2.0",
-      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.2.0.tgz",
-      "integrity": "sha512-TKY5pyBkHyADOPYlRT9Lx6F544mPl0vS5Ew7BJ45hA08Q+t3GjbueLliBWN3sMICk6+y7HdyxSzC4bWS8baBdg==",
-      "license": "MIT",
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-regex?sponsor=1"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/emoji-regex": {
-      "version": "9.2.2",
-      "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",
-      "integrity": "sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==",
-      "license": "MIT"
-    },
-    "node_modules/@isaacs/cliui/node_modules/string-width": {
-      "version": "5.1.2",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
-      "integrity": "sha512-HnLOCR3vjcY8beoNLtcjZ5/nxn2afmME6lhrDrebokqMap+XbeW8n9TXpPDOqdGK5qcI3oT0GKTW6wC7EMiVqA==",
-      "license": "MIT",
-      "dependencies": {
-        "eastasianwidth": "^0.2.0",
-        "emoji-regex": "^9.2.2",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/strip-ansi": {
-      "version": "7.1.0",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz",
-      "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/strip-ansi?sponsor=1"
-      }
-    },
-    "node_modules/@isaacs/cliui/node_modules/wrap-ansi": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-8.1.0.tgz",
-      "integrity": "sha512-si7QWI6zUMq56bESFvagtmzMdGOtoxfR+Sez11Mobfc7tm+VkUckk9bW2UeffTGVUbOksxmSw0AA2gs8g71NCQ==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^6.1.0",
-        "string-width": "^5.0.1",
-        "strip-ansi": "^7.0.1"
-      },
-      "engines": {
-        "node": ">=12"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
     "node_modules/@isaacs/fs-minipass": {
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
@@ -4618,12 +4534,6 @@
         "node": ">= 0.4"
       }
     },
-    "node_modules/eastasianwidth": {
-      "version": "0.2.0",
-      "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
-      "integrity": "sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==",
-      "license": "MIT"
-    },
     "node_modules/electron-to-chromium": {
       "version": "1.5.68",
       "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.68.tgz",
@@ -5976,22 +5886,6 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/foreground-child": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.3.1.tgz",
-      "integrity": "sha512-gIXjKqtFuWEgzFRJA9WCQeSJLZDjgJUOMCMzxtvFq/37KojM1BFGufqsCy0r4qSQmYLsZYMeyRqzIWOMup03sw==",
-      "license": "ISC",
-      "dependencies": {
-        "cross-spawn": "^7.0.6",
-        "signal-exit": "^4.0.1"
-      },
-      "engines": {
-        "node": ">=14"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/fsevents": {
       "version": "2.3.3",
       "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz",
@@ -6177,23 +6071,18 @@
       }
     },
     "node_modules/glob": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-11.1.0.tgz",
-      "integrity": "sha512-vuNwKSaKiqm7g0THUBu2x7ckSs3XJLXE+2ssL7/MfTGPLLcrJQ/4Uq1CjPTtO5cCIiRxqvN6Twy1qOwhL0Xjcw==",
+      "version": "13.0.6",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz",
+      "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==",
+      "dev": true,
       "license": "BlueOak-1.0.0",
       "dependencies": {
-        "foreground-child": "^3.3.1",
-        "jackspeak": "^4.1.1",
-        "minimatch": "^10.1.1",
-        "minipass": "^7.1.2",
-        "package-json-from-dist": "^1.0.0",
-        "path-scurry": "^2.0.0"
-      },
-      "bin": {
-        "glob": "dist/esm/bin.mjs"
+        "minimatch": "^10.2.2",
+        "minipass": "^7.1.3",
+        "path-scurry": "^2.0.2"
       },
       "engines": {
-        "node": "20 || >=22"
+        "node": "18 || 20 || >=22"
       },
       "funding": {
         "url": "https://github.com/sponsors/isaacs"
@@ -6216,6 +6105,7 @@
       "version": "4.0.4",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
       "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": "18 || 20 || >=22"
@@ -6225,6 +6115,7 @@
       "version": "5.0.6",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
       "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "balanced-match": "^4.0.2"
@@ -6237,6 +6128,7 @@
       "version": "10.2.4",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz",
       "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==",
+      "dev": true,
       "license": "BlueOak-1.0.0",
       "dependencies": {
         "brace-expansion": "^5.0.2"
@@ -7080,21 +6972,6 @@
       "version": "2.0.0",
       "license": "ISC"
     },
-    "node_modules/jackspeak": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/jackspeak/-/jackspeak-4.1.1.tgz",
-      "integrity": "sha512-zptv57P3GpL+O0I7VdMJNBZCu+BPHVQUk55Ft8/QCJjTVxrnJHuVuX/0Bl2A6/+2oyR/ZMEuFKwmzqqZ/U5nPQ==",
-      "license": "BlueOak-1.0.0",
-      "dependencies": {
-        "@isaacs/cliui": "^8.0.2"
-      },
-      "engines": {
-        "node": "20 || >=22"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/isaacs"
-      }
-    },
     "node_modules/js-string-escape": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/js-string-escape/-/js-string-escape-1.0.1.tgz",
@@ -7365,10 +7242,11 @@
       "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA=="
     },
     "node_modules/lru-cache": {
-      "version": "11.1.0",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.1.0.tgz",
-      "integrity": "sha512-QIXZUBJUx+2zHUdQujWejBkcD9+cs94tLn0+YL8UrCh+D5sCXZ4c7LaEH48pNwRY3MLDgqUFyhlCyjJPf1WP0A==",
-      "license": "ISC",
+      "version": "11.5.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.1.tgz",
+      "integrity": "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
       "engines": {
         "node": "20 || >=22"
       }
@@ -7509,10 +7387,10 @@
       }
     },
     "node_modules/minipass": {
-      "version": "7.1.2",
-      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.2.tgz",
-      "integrity": "sha512-qOOzS1cBTWYF4BH8fVePDBOO9iptMnGUEZwNc/cMWnTV2nVLZ7VoNWEPHkYczZA0pdoA7dl6e7FL659nX9S2aw==",
-      "license": "ISC",
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+      "license": "BlueOak-1.0.0",
       "engines": {
         "node": ">=16 || 14 >=14.17"
       }
@@ -7907,12 +7785,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/package-json-from-dist": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.0.tgz",
-      "integrity": "sha512-dATvCeZN/8wQsGywez1mzHtTlP22H8OEfPrVMLNr4/eGa+ijtLn/6M5f0dY8UKNrC2O9UCU6SSoG3qRKnt7STw==",
-      "license": "BlueOak-1.0.0"
-    },
     "node_modules/parent-module": {
       "version": "1.0.1",
       "dev": true,
@@ -7991,16 +7863,17 @@
       "license": "MIT"
     },
     "node_modules/path-scurry": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.0.tgz",
-      "integrity": "sha512-ypGJsmGtdXUOeM5u93TyeIEfEhM6s+ljAhrk5vAvSx8uyY/02OvrZnA0YNGUrPXfpJMgI1ODd3nwz8Npx4O4cg==",
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz",
+      "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==",
+      "dev": true,
       "license": "BlueOak-1.0.0",
       "dependencies": {
         "lru-cache": "^11.0.0",
         "minipass": "^7.1.2"
       },
       "engines": {
-        "node": "20 || >=22"
+        "node": "18 || 20 || >=22"
       },
       "funding": {
         "url": "https://github.com/sponsors/isaacs"
@@ -8859,21 +8732,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/string-width-cjs": {
-      "name": "string-width",
-      "version": "4.2.3",
-      "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
-      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
-      "license": "MIT",
-      "dependencies": {
-        "emoji-regex": "^8.0.0",
-        "is-fullwidth-code-point": "^3.0.0",
-        "strip-ansi": "^6.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/string.prototype.includes": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/string.prototype.includes/-/string.prototype.includes-2.0.1.tgz",
@@ -8957,19 +8815,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/strip-ansi-cjs": {
-      "name": "strip-ansi",
-      "version": "6.0.1",
-      "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
-      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-regex": "^5.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/strip-bom": {
       "version": "3.0.0",
       "dev": true,
@@ -9804,39 +9649,6 @@
         "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
       }
     },
-    "node_modules/wrap-ansi-cjs": {
-      "name": "wrap-ansi",
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
-      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
-      "license": "MIT",
-      "dependencies": {
-        "ansi-styles": "^4.0.0",
-        "string-width": "^4.1.0",
-        "strip-ansi": "^6.0.0"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
-      }
-    },
-    "node_modules/wrap-ansi-cjs/node_modules/ansi-styles": {
-      "version": "4.3.0",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
-      "license": "MIT",
-      "dependencies": {
-        "color-convert": "^2.0.1"
-      },
-      "engines": {
-        "node": ">=8"
-      },
-      "funding": {
-        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
-      }
-    },
     "node_modules/wrap-ansi/node_modules/ansi-styles": {
       "version": "4.3.0",
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
diff --git a/package.json b/package.json
index 1f0dd37a26..d3cd1651f3 100644
--- a/package.json
+++ b/package.json
@@ -64,7 +64,7 @@
     "eslint-plugin-import-x": "^4.16.2",
     "eslint-plugin-jsdoc": "^62.9.0",
     "eslint-plugin-no-async-foreach": "^0.1.1",
-    "glob": "^11.1.0",
+    "glob": "^13.0.6",
     "globals": "^17.6.0",
     "nock": "^14.0.15",
     "sinon": "^22.0.0",
@@ -90,7 +90,7 @@
     "eslint-plugin-jsx-a11y": {
       "semver": ">=6.3.1"
     },
-    "glob": "^11.1.0",
+    "glob": "^13.0.6",
     "undici": "^6.24.0"
   }
 }

From 98470ab04f91cc900521685d788a6d42a84bbe57 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 24 Jun 2026 17:54:37 +0000
Subject: [PATCH 51/65] Bump the npm-minor group across 1 directory with 3
 updates

Bumps the npm-minor group with 3 updates in the / directory: [@actions/cache](https://github.com/actions/toolkit/tree/HEAD/packages/cache), [@types/node](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/HEAD/types/node) and [typescript-eslint](https://github.com/typescript-eslint/typescript-eslint/tree/HEAD/packages/typescript-eslint).


Updates `@actions/cache` from 5.0.5 to 5.1.0
- [Changelog](https://github.com/actions/toolkit/blob/main/packages/cache/RELEASES.md)
- [Commits](https://github.com/actions/toolkit/commits/HEAD/packages/cache)

Updates `@types/node` from 20.19.42 to 20.19.43
- [Release notes](https://github.com/DefinitelyTyped/DefinitelyTyped/releases)
- [Commits](https://github.com/DefinitelyTyped/DefinitelyTyped/commits/HEAD/types/node)

Updates `typescript-eslint` from 8.61.0 to 8.61.1
- [Release notes](https://github.com/typescript-eslint/typescript-eslint/releases)
- [Changelog](https://github.com/typescript-eslint/typescript-eslint/blob/main/packages/typescript-eslint/CHANGELOG.md)
- [Commits](https://github.com/typescript-eslint/typescript-eslint/commits/v8.61.1/packages/typescript-eslint)

---
updated-dependencies:
- dependency-name: "@actions/cache"
  dependency-version: 5.1.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: npm-minor
- dependency-name: "@types/node"
  dependency-version: 20.19.43
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: npm-minor
- dependency-name: typescript-eslint
  dependency-version: 8.61.1
  dependency-type: direct:development
  update-type: version-update:semver-patch
  dependency-group: npm-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 package-lock.json      | 163 ++++++++++++++++++++++-------------------
 package.json           |   6 +-
 pr-checks/package.json |   2 +-
 3 files changed, 90 insertions(+), 81 deletions(-)

diff --git a/package-lock.json b/package-lock.json
index 753eb3dace..f8b8f39b13 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -14,7 +14,7 @@
       "dependencies": {
         "@actions/artifact": "^5.0.3",
         "@actions/artifact-legacy": "npm:@actions/artifact@^1.1.2",
-        "@actions/cache": "^5.0.5",
+        "@actions/cache": "^5.1.0",
         "@actions/core": "^2.0.3",
         "@actions/exec": "^2.0.0",
         "@actions/github": "^8.0.1",
@@ -43,7 +43,7 @@
         "@types/archiver": "^8.0.0",
         "@types/follow-redirects": "^1.14.4",
         "@types/js-yaml": "^4.0.9",
-        "@types/node": "^20.19.42",
+        "@types/node": "^20.19.43",
         "@types/node-forge": "^1.3.14",
         "@types/sarif": "^2.1.7",
         "@types/semver": "^7.7.1",
@@ -61,7 +61,7 @@
         "nock": "^14.0.15",
         "sinon": "^22.0.0",
         "typescript": "^6.0.3",
-        "typescript-eslint": "^8.61.0"
+        "typescript-eslint": "^8.61.1"
       }
     },
     "node_modules/@aashutoshrathi/word-wrap": {
@@ -455,9 +455,9 @@
       }
     },
     "node_modules/@actions/cache": {
-      "version": "5.0.5",
-      "resolved": "https://registry.npmjs.org/@actions/cache/-/cache-5.0.5.tgz",
-      "integrity": "sha512-jiQSg0gfd+C2KPgcmdCOq7dCuCIQQWQ4b1YfGIRaaA9w7PJbRwTOcCz4LiFEUnqZGf0ha/8OKL3BeNwetHzYsQ==",
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@actions/cache/-/cache-5.1.0.tgz",
+      "integrity": "sha512-kTIj4YPrjjRPKSGlj7f8eq+Pijoy/SKBEbJcAwNsQTFGEF29NGqj1mqD02/PmhV6r4bRAixycexAWpmUJ2aCwg==",
       "license": "MIT",
       "dependencies": {
         "@actions/core": "^2.0.0",
@@ -2535,9 +2535,9 @@
       "license": "MIT"
     },
     "node_modules/@types/node": {
-      "version": "20.19.42",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.42.tgz",
-      "integrity": "sha512-5L7SUaFC1RyDraj2yRhyBzHTobyXHmohD100CChNtyPyleoq37Mqab5Gn8XEKI04dfN/oqPdpHk38MgcQWHbZg==",
+      "version": "20.19.43",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.43.tgz",
+      "integrity": "sha512-6oYBAi5ikg4Pl+kGsoYtawUMBT2zZMCvPNF7pVLnHZfd1zf38DRiWn/gT01RYCdUqkv7Fhr+C9ot4/tb+2sVvA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
@@ -2594,17 +2594,17 @@
       "license": "MIT"
     },
     "node_modules/@typescript-eslint/eslint-plugin": {
-      "version": "8.61.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.61.0.tgz",
-      "integrity": "sha512-bFNvl9ZczlVb+wR2Akszf3gHfKVj/8WanXaGJ3UstTA7brNKg0cNdk6X1Psu5V7MZ2oQtzZKOEzIUehaoxbDGw==",
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.61.1.tgz",
+      "integrity": "sha512-ZPlVl3PB3et/59Ne0fv/sci6ZXz4T4Hp4nTJ56i/Y0gR89ARb+KphojTq6j+56E5PIezmOIOOWyY+aWQFd+IkQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/regexpp": "^4.12.2",
-        "@typescript-eslint/scope-manager": "8.61.0",
-        "@typescript-eslint/type-utils": "8.61.0",
-        "@typescript-eslint/utils": "8.61.0",
-        "@typescript-eslint/visitor-keys": "8.61.0",
+        "@typescript-eslint/scope-manager": "8.61.1",
+        "@typescript-eslint/type-utils": "8.61.1",
+        "@typescript-eslint/utils": "8.61.1",
+        "@typescript-eslint/visitor-keys": "8.61.1",
         "ignore": "^7.0.5",
         "natural-compare": "^1.4.0",
         "ts-api-utils": "^2.5.0"
@@ -2617,7 +2617,7 @@
         "url": "https://opencollective.com/typescript-eslint"
       },
       "peerDependencies": {
-        "@typescript-eslint/parser": "^8.61.0",
+        "@typescript-eslint/parser": "^8.61.1",
         "eslint": "^8.57.0 || ^9.0.0 || ^10.0.0",
         "typescript": ">=4.8.4 <6.1.0"
       }
@@ -2633,16 +2633,16 @@
       }
     },
     "node_modules/@typescript-eslint/parser": {
-      "version": "8.61.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.61.0.tgz",
-      "integrity": "sha512-5B7PfA2e1NQGCnDHd/0lW7W3gvp3d59Ryw54FYO8Uswxo9f6ikw3AZV+Xj/TvpImmpsiYyUqAfhC6kJID1jF6w==",
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-8.61.1.tgz",
+      "integrity": "sha512-PJ5vePq5/ognBbrIcoC5+SHO5dfpeLPzP9FpLkzWrguoYQEeeSjlJpVwOpo1JRSTEi7dRcwNy4h4dzV70PqHcg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/scope-manager": "8.61.0",
-        "@typescript-eslint/types": "8.61.0",
-        "@typescript-eslint/typescript-estree": "8.61.0",
-        "@typescript-eslint/visitor-keys": "8.61.0",
+        "@typescript-eslint/scope-manager": "8.61.1",
+        "@typescript-eslint/types": "8.61.1",
+        "@typescript-eslint/typescript-estree": "8.61.1",
+        "@typescript-eslint/visitor-keys": "8.61.1",
         "debug": "^4.4.3"
       },
       "engines": {
@@ -2676,14 +2676,14 @@
       }
     },
     "node_modules/@typescript-eslint/project-service": {
-      "version": "8.61.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.61.0.tgz",
-      "integrity": "sha512-DV42F7MLJO6Rax7SK1yg43tcnEfGUrurSpSxKuVX+a3RCTzBlH3fuxprrOJXKCJGAaw82xXocikJ0uQaqwXgGA==",
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/project-service/-/project-service-8.61.1.tgz",
+      "integrity": "sha512-PrC4JYGmR241lYnfhmKGTXkFqv8+ymbTFgSAY0fVXpY82/QkMw5TZPl+vGzuDDU2QYJk9fIDOBTntF+yDv9LEA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/tsconfig-utils": "^8.61.0",
-        "@typescript-eslint/types": "^8.61.0",
+        "@typescript-eslint/tsconfig-utils": "^8.61.1",
+        "@typescript-eslint/types": "^8.61.1",
         "debug": "^4.4.3"
       },
       "engines": {
@@ -2716,14 +2716,14 @@
       }
     },
     "node_modules/@typescript-eslint/scope-manager": {
-      "version": "8.61.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.61.0.tgz",
-      "integrity": "sha512-IWdXFHFSb6mlC3HPc7QsLDm5zYEbUla6trDEHf32D3/dnuUyXd87plScSNXSbm0/RxMvObpI17sv/EDTGrGZkA==",
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/scope-manager/-/scope-manager-8.61.1.tgz",
+      "integrity": "sha512-L2bdIeoQS8FlKAvONAr20w6OcLXeB+qiDKbAooS9A0Ben+iSIkBef0FxqwKWYqt5sa0i4KJtxVyVmhMylKzF5w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.61.0",
-        "@typescript-eslint/visitor-keys": "8.61.0"
+        "@typescript-eslint/types": "8.61.1",
+        "@typescript-eslint/visitor-keys": "8.61.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2734,9 +2734,9 @@
       }
     },
     "node_modules/@typescript-eslint/tsconfig-utils": {
-      "version": "8.61.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.61.0.tgz",
-      "integrity": "sha512-O5Amvdv9ztMpxpf+vmFULGG78IE6Qwdr3bCGvqwG4nwc9H2qXkOYJJnRbRHyMkQTjv1d03olqwwwzHLMqpFePQ==",
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/tsconfig-utils/-/tsconfig-utils-8.61.1.tgz",
+      "integrity": "sha512-UN/H4di+OO7EWx2ovME+8t31YO+KVnK0RRKEHR3kOt21/Ay8BOq3M1OMvWs5vNiqcFCYGYoxK3MXPZzmMUE+yg==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -2751,15 +2751,15 @@
       }
     },
     "node_modules/@typescript-eslint/type-utils": {
-      "version": "8.61.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.61.0.tgz",
-      "integrity": "sha512-TuBiQYIkd97yBfInHCTKVYMbX4kvEmpOEuixIuzCU9p8BGT1SfyyO0d0IfDMbPIHcjn/hWnusUX5e8v5Xg+X8A==",
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/type-utils/-/type-utils-8.61.1.tgz",
+      "integrity": "sha512-GYRicKmVK0C4fsKgaACaknOUAq9Oa2kwsjnpFhFcS/5p4Ht5IP9OVLbgIgcK4SRk92nVHFluurg1lumD9dBcLw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.61.0",
-        "@typescript-eslint/typescript-estree": "8.61.0",
-        "@typescript-eslint/utils": "8.61.0",
+        "@typescript-eslint/types": "8.61.1",
+        "@typescript-eslint/typescript-estree": "8.61.1",
+        "@typescript-eslint/utils": "8.61.1",
         "debug": "^4.4.3",
         "ts-api-utils": "^2.5.0"
       },
@@ -2794,9 +2794,9 @@
       }
     },
     "node_modules/@typescript-eslint/types": {
-      "version": "8.61.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.61.0.tgz",
-      "integrity": "sha512-9QTQpZ5Iin4CdIodfbDQFSeiSJKidgYJYug1P9CC2xWgUTvlmixViqDZNciMjwLBZyJnG4tGmPl97rVAFb1AJg==",
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/types/-/types-8.61.1.tgz",
+      "integrity": "sha512-G+CRlPqLv7Bz1IZVs03x5K59F1veqL0EJUROAdGhKsEq8qOiRiZbI+HUojPq5l0fEGOKModD9br6lObhB8zkoA==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -2808,16 +2808,16 @@
       }
     },
     "node_modules/@typescript-eslint/typescript-estree": {
-      "version": "8.61.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.61.0.tgz",
-      "integrity": "sha512-42zatd5qSvvcV1JdDBCLxYRznvP4eIHpPoZXdkPFnAmanA4FuZ5dibSnCBggY8hQnqajPpoGjXFdZ7fIJKQnlA==",
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/typescript-estree/-/typescript-estree-8.61.1.tgz",
+      "integrity": "sha512-u+oQD3BqYWPc8YV9Zab4vaJElJuwOLPRc10Jm1o/qS+6Qwen14HCWwx0Seo4LnSn2wxea2Ik8DxPt2/FHmuhrg==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/project-service": "8.61.0",
-        "@typescript-eslint/tsconfig-utils": "8.61.0",
-        "@typescript-eslint/types": "8.61.0",
-        "@typescript-eslint/visitor-keys": "8.61.0",
+        "@typescript-eslint/project-service": "8.61.1",
+        "@typescript-eslint/tsconfig-utils": "8.61.1",
+        "@typescript-eslint/types": "8.61.1",
+        "@typescript-eslint/visitor-keys": "8.61.1",
         "debug": "^4.4.3",
         "minimatch": "^10.2.2",
         "semver": "^7.7.3",
@@ -2893,16 +2893,16 @@
       }
     },
     "node_modules/@typescript-eslint/utils": {
-      "version": "8.61.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.61.0.tgz",
-      "integrity": "sha512-3bzFt7ImFMW/jVYwJamDoe/dMOdFLSC6pom6rRjdh4SZJEYupyMzem8e7vKZLclLfpHjlwSAXOUxtKxGXUiLqA==",
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-8.61.1.tgz",
+      "integrity": "sha512-1+P/3Dj6jvtybE1q0HQ6yBt/gq+oKJyLdEv4HdnqasaEXRSYCAsD59mXEVQnM/ULNdQxbX77tdG4jPRjIS6knA==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.9.1",
-        "@typescript-eslint/scope-manager": "8.61.0",
-        "@typescript-eslint/types": "8.61.0",
-        "@typescript-eslint/typescript-estree": "8.61.0"
+        "@typescript-eslint/scope-manager": "8.61.1",
+        "@typescript-eslint/types": "8.61.1",
+        "@typescript-eslint/typescript-estree": "8.61.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -2917,13 +2917,13 @@
       }
     },
     "node_modules/@typescript-eslint/visitor-keys": {
-      "version": "8.61.0",
-      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.61.0.tgz",
-      "integrity": "sha512-QVLZu3ZPQEE+HICQyAMZ2yLQhxf0meY/wx6Hx14YcTNj13JB3qHlX3lJ02L3fLGHgERRH71kvYDwiXIguT3AjQ==",
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-8.61.1.tgz",
+      "integrity": "sha512-6fJ9MHWtK14C1DSkiMlHUSOmrVebL7150xZJBlJiL62jjhIA4JmOq6flwBgDxIdBKKdoiZRel+dfPD5MLfny3w==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/types": "8.61.0",
+        "@typescript-eslint/types": "8.61.1",
         "eslint-visitor-keys": "^5.0.0"
       },
       "engines": {
@@ -3357,6 +3357,7 @@
     },
     "node_modules/ansi-regex": {
       "version": "5.0.1",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -3366,6 +3367,7 @@
       "version": "6.2.3",
       "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.3.tgz",
       "integrity": "sha512-4Dj6M28JB+oAH8kFkTLUo+a2jwOFkuqb3yucU0CANcRRUbxS0cP0nZYCGjcc3BNXwRIsUVmDGgzawme7zvJHvg==",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=12"
@@ -4215,6 +4217,7 @@
     },
     "node_modules/color-convert": {
       "version": "2.0.1",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "color-name": "~1.1.4"
@@ -4225,6 +4228,7 @@
     },
     "node_modules/color-name": {
       "version": "1.1.4",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/comment-parser": {
@@ -4336,6 +4340,7 @@
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
       "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "dev": true,
       "dependencies": {
         "path-key": "^3.1.0",
         "shebang-command": "^2.0.0",
@@ -4555,6 +4560,7 @@
     },
     "node_modules/emoji-regex": {
       "version": "8.0.0",
+      "dev": true,
       "license": "MIT"
     },
     "node_modules/es-abstract": {
@@ -6074,7 +6080,6 @@
       "version": "13.0.6",
       "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz",
       "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==",
-      "dev": true,
       "license": "BlueOak-1.0.0",
       "dependencies": {
         "minimatch": "^10.2.2",
@@ -6105,7 +6110,6 @@
       "version": "4.0.4",
       "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
       "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": "18 || 20 || >=22"
@@ -6115,7 +6119,6 @@
       "version": "5.0.6",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.6.tgz",
       "integrity": "sha512-kLpxurY4Z4r9sgMsyG0Z9uzsBlgiU/EFKhj/h91/8yHu0edo7XuixOIH3VcJ8kkxs6/jPzoI6U9Vj3WqbMQ94g==",
-      "dev": true,
       "license": "MIT",
       "dependencies": {
         "balanced-match": "^4.0.2"
@@ -6128,7 +6131,6 @@
       "version": "10.2.4",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz",
       "integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==",
-      "dev": true,
       "license": "BlueOak-1.0.0",
       "dependencies": {
         "brace-expansion": "^5.0.2"
@@ -6660,6 +6662,7 @@
     },
     "node_modules/is-fullwidth-code-point": {
       "version": "3.0.0",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -6970,6 +6973,7 @@
     },
     "node_modules/isexe": {
       "version": "2.0.0",
+      "dev": true,
       "license": "ISC"
     },
     "node_modules/js-string-escape": {
@@ -7245,7 +7249,6 @@
       "version": "11.5.1",
       "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.1.tgz",
       "integrity": "sha512-RPimw/7aMdv2oqRrxKwvZXcPfwBrn/JZ2xYcY9Hus/6LaS3VOAKVWKWgNLCFSiOm1ESXinjsDlidVU7JlnCN2A==",
-      "dev": true,
       "license": "BlueOak-1.0.0",
       "engines": {
         "node": "20 || >=22"
@@ -7852,6 +7855,7 @@
     },
     "node_modules/path-key": {
       "version": "3.1.1",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -7866,7 +7870,6 @@
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz",
       "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==",
-      "dev": true,
       "license": "BlueOak-1.0.0",
       "dependencies": {
         "lru-cache": "^11.0.0",
@@ -8452,6 +8455,7 @@
     },
     "node_modules/shebang-command": {
       "version": "2.0.0",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "shebang-regex": "^3.0.0"
@@ -8462,6 +8466,7 @@
     },
     "node_modules/shebang-regex": {
       "version": "3.0.0",
+      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=8"
@@ -8547,6 +8552,7 @@
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz",
       "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==",
+      "dev": true,
       "engines": {
         "node": ">=14"
       },
@@ -8722,6 +8728,7 @@
     },
     "node_modules/string-width": {
       "version": "4.2.3",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "emoji-regex": "^8.0.0",
@@ -8807,6 +8814,7 @@
     },
     "node_modules/strip-ansi": {
       "version": "6.0.1",
+      "dev": true,
       "license": "MIT",
       "dependencies": {
         "ansi-regex": "^5.0.1"
@@ -9317,16 +9325,16 @@
       }
     },
     "node_modules/typescript-eslint": {
-      "version": "8.61.0",
-      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.61.0.tgz",
-      "integrity": "sha512-8y31Rd0eGTrDKqhy6vT0HtzhN+YLjQizwX3aA3hPXP/ynSfnrBXcQY5IzsP9/DM7+klX4IUncZZjkchP0z+rUw==",
+      "version": "8.61.1",
+      "resolved": "https://registry.npmjs.org/typescript-eslint/-/typescript-eslint-8.61.1.tgz",
+      "integrity": "sha512-V7PayAfJokV3pEHgN7/v03D1SpujhRfQtYLbLIiBfDDncdg4PAiRBfoS4cnCANK4jmAPncczi59QO3afiXUlNw==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@typescript-eslint/eslint-plugin": "8.61.0",
-        "@typescript-eslint/parser": "8.61.0",
-        "@typescript-eslint/typescript-estree": "8.61.0",
-        "@typescript-eslint/utils": "8.61.0"
+        "@typescript-eslint/eslint-plugin": "8.61.1",
+        "@typescript-eslint/parser": "8.61.1",
+        "@typescript-eslint/typescript-estree": "8.61.1",
+        "@typescript-eslint/utils": "8.61.1"
       },
       "engines": {
         "node": "^18.18.0 || ^20.9.0 || >=21.1.0"
@@ -9531,6 +9539,7 @@
     },
     "node_modules/which": {
       "version": "2.0.2",
+      "dev": true,
       "license": "ISC",
       "dependencies": {
         "isexe": "^2.0.0"
@@ -9813,7 +9822,7 @@
         "yaml": "^2.9.0"
       },
       "devDependencies": {
-        "@types/node": "^20.19.42",
+        "@types/node": "^20.19.43",
         "tsx": "^4.22.4"
       }
     }
diff --git a/package.json b/package.json
index d3cd1651f3..10d09e81bd 100644
--- a/package.json
+++ b/package.json
@@ -22,7 +22,7 @@
   "dependencies": {
     "@actions/artifact": "^5.0.3",
     "@actions/artifact-legacy": "npm:@actions/artifact@^1.1.2",
-    "@actions/cache": "^5.0.5",
+    "@actions/cache": "^5.1.0",
     "@actions/core": "^2.0.3",
     "@actions/exec": "^2.0.0",
     "@actions/github": "^8.0.1",
@@ -51,7 +51,7 @@
     "@types/archiver": "^8.0.0",
     "@types/follow-redirects": "^1.14.4",
     "@types/js-yaml": "^4.0.9",
-    "@types/node": "^20.19.42",
+    "@types/node": "^20.19.43",
     "@types/node-forge": "^1.3.14",
     "@types/sarif": "^2.1.7",
     "@types/semver": "^7.7.1",
@@ -69,7 +69,7 @@
     "nock": "^14.0.15",
     "sinon": "^22.0.0",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.61.0"
+    "typescript-eslint": "^8.61.1"
   },
   "overrides": {
     "@actions/tool-cache": {
diff --git a/pr-checks/package.json b/pr-checks/package.json
index 649b14795c..eeb63afa87 100644
--- a/pr-checks/package.json
+++ b/pr-checks/package.json
@@ -11,7 +11,7 @@
     "yaml": "^2.9.0"
   },
   "devDependencies": {
-    "@types/node": "^20.19.42",
+    "@types/node": "^20.19.43",
     "tsx": "^4.22.4"
   }
 }

From d8d3457a33576b05837d28ea2b1202c629f290e4 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 24 Jun 2026 17:56:32 +0000
Subject: [PATCH 52/65] Rebuild

---
 lib/entry-points.js | 30 ++++++++++++++++++++++++++----
 1 file changed, 26 insertions(+), 4 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 0cedf0c0fb..d3fbf00eec 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -75356,7 +75356,7 @@ var require_package = __commonJS({
   "node_modules/@actions/cache/package.json"(exports2, module2) {
     module2.exports = {
       name: "@actions/cache",
-      version: "5.0.5",
+      version: "5.1.0",
       preview: true,
       description: "Actions cache lib",
       keywords: [
@@ -81178,7 +81178,7 @@ var require_cache4 = __commonJS({
       });
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.FinalizeCacheError = exports2.ReserveCacheError = exports2.ValidationError = void 0;
+    exports2.FinalizeCacheError = exports2.CacheWriteDeniedError = exports2.CACHE_WRITE_DENIED_PREFIX = exports2.ReserveCacheError = exports2.ValidationError = void 0;
     exports2.isFeatureAvailable = isFeatureAvailable;
     exports2.restoreCache = restoreCache5;
     exports2.saveCache = saveCache5;
@@ -81206,6 +81206,15 @@ var require_cache4 = __commonJS({
       }
     };
     exports2.ReserveCacheError = ReserveCacheError2;
+    exports2.CACHE_WRITE_DENIED_PREFIX = "cache write denied:";
+    var CacheWriteDeniedError = class _CacheWriteDeniedError extends ReserveCacheError2 {
+      constructor(message) {
+        super(message);
+        this.name = "CacheWriteDeniedError";
+        Object.setPrototypeOf(this, _CacheWriteDeniedError.prototype);
+      }
+    };
+    exports2.CacheWriteDeniedError = CacheWriteDeniedError;
     var FinalizeCacheError = class _FinalizeCacheError extends Error {
       constructor(message) {
         super(message);
@@ -81433,7 +81442,11 @@ var require_cache4 = __commonJS({
           } else if ((reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.statusCode) === 400) {
             throw new Error((_d = (_c = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.error) === null || _c === void 0 ? void 0 : _c.message) !== null && _d !== void 0 ? _d : `Cache size of ~${Math.round(archiveFileSize / (1024 * 1024))} MB (${archiveFileSize} B) is over the data cap limit, not saving cache.`);
           } else {
-            throw new ReserveCacheError2(`Unable to reserve cache with key ${key}, another job may be creating this cache. More details: ${(_e = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.error) === null || _e === void 0 ? void 0 : _e.message}`);
+            const detailMessage = (_e = reserveCacheResponse === null || reserveCacheResponse === void 0 ? void 0 : reserveCacheResponse.error) === null || _e === void 0 ? void 0 : _e.message;
+            if (detailMessage === null || detailMessage === void 0 ? void 0 : detailMessage.startsWith(exports2.CACHE_WRITE_DENIED_PREFIX)) {
+              throw new CacheWriteDeniedError(`Unable to reserve cache with key ${key}. More details: ${detailMessage}`);
+            }
+            throw new ReserveCacheError2(`Unable to reserve cache with key ${key}, another job may be creating this cache. More details: ${detailMessage}`);
           }
           core30.debug(`Saving Cache (ID: ${cacheId})`);
           yield cacheHttpClient.saveCache(cacheId, archivePath, "", options);
@@ -81441,6 +81454,8 @@ var require_cache4 = __commonJS({
           const typedError = error3;
           if (typedError.name === ValidationError.name) {
             throw error3;
+          } else if (typedError.name === CacheWriteDeniedError.name) {
+            core30.warning(`Failed to save: ${typedError.message}`);
           } else if (typedError.name === ReserveCacheError2.name) {
             core30.info(`Failed to save: ${typedError.message}`);
           } else {
@@ -81462,6 +81477,7 @@ var require_cache4 = __commonJS({
     }
     function saveCacheV2(paths_1, key_1, options_1) {
       return __awaiter2(this, arguments, void 0, function* (paths, key, options, enableCrossOsArchive = false) {
+        var _a2;
         options = Object.assign(Object.assign({}, options), { uploadChunkSize: 64 * 1024 * 1024, uploadConcurrency: 8, useAzureSdk: true });
         const compressionMethod = yield utils.getCompressionMethod();
         const twirpClient = cacheTwirpClient.internalCacheTwirpClient();
@@ -81493,7 +81509,7 @@ var require_cache4 = __commonJS({
           try {
             const response = yield twirpClient.CreateCacheEntry(request3);
             if (!response.ok) {
-              if (response.message) {
+              if (response.message && !response.message.startsWith(exports2.CACHE_WRITE_DENIED_PREFIX)) {
                 core30.warning(`Cache reservation failed: ${response.message}`);
               }
               throw new Error(response.message || "Response was not ok");
@@ -81501,6 +81517,10 @@ var require_cache4 = __commonJS({
             signedUploadUrl = response.signedUploadUrl;
           } catch (error3) {
             core30.debug(`Failed to reserve cache: ${error3}`);
+            const errorMessage = (_a2 = error3 === null || error3 === void 0 ? void 0 : error3.message) !== null && _a2 !== void 0 ? _a2 : "";
+            if (errorMessage.startsWith(exports2.CACHE_WRITE_DENIED_PREFIX)) {
+              throw new CacheWriteDeniedError(`Unable to reserve cache with key ${key}. More details: ${errorMessage}`);
+            }
             throw new ReserveCacheError2(`Unable to reserve cache with key ${key}, another job may be creating this cache.`);
           }
           core30.debug(`Attempting to upload cache located at: ${archivePath}`);
@@ -81523,6 +81543,8 @@ var require_cache4 = __commonJS({
           const typedError = error3;
           if (typedError.name === ValidationError.name) {
             throw error3;
+          } else if (typedError.name === CacheWriteDeniedError.name) {
+            core30.warning(`Failed to save: ${typedError.message}`);
           } else if (typedError.name === ReserveCacheError2.name) {
             core30.info(`Failed to save: ${typedError.message}`);
           } else if (typedError.name === FinalizeCacheError.name) {

From 1582c0ec80a103998f62bee99a0be313479d2479 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 24 Jun 2026 17:57:04 +0000
Subject: [PATCH 53/65] Bump the actions-minor group across 1 directory with 3
 updates

Bumps the actions-minor group with 3 updates in the /.github/workflows directory: [actions/setup-go](https://github.com/actions/setup-go), [actions/setup-python](https://github.com/actions/setup-python) and [ruby/setup-ruby](https://github.com/ruby/setup-ruby).


Updates `actions/setup-go` from 6.4.0 to 6.5.0
- [Release notes](https://github.com/actions/setup-go/releases)
- [Commits](https://github.com/actions/setup-go/compare/4a3601121dd01d1626a1e23e37211e3254c1c06c...924ae3a1cded613372ab5595356fb5720e22ba16)

Updates `actions/setup-python` from 6.2.0 to 6.3.0
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/a309ff8b426b58ec0e2a45f0f869d46889d02405...ece7cb06caefa5fff74198d8649806c4678c61a1)

Updates `ruby/setup-ruby` from 1.312.0 to 1.313.0
- [Release notes](https://github.com/ruby/setup-ruby/releases)
- [Changelog](https://github.com/ruby/setup-ruby/blob/master/release.rb)
- [Commits](https://github.com/ruby/setup-ruby/compare/12fd324f1d0b43274fdc8130f6980590a667c455...89f90524b88a01fe6e0b732220432cc6142926af)

---
updated-dependencies:
- dependency-name: actions/setup-go
  dependency-version: 6.5.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: actions-minor
- dependency-name: actions/setup-python
  dependency-version: 6.3.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: actions-minor
- dependency-name: ruby/setup-ruby
  dependency-version: 1.313.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: actions-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/__all-platform-bundle.yml                   | 2 +-
 .github/workflows/__analyze-ref-input.yml                     | 2 +-
 .github/workflows/__build-mode-manual.yml                     | 2 +-
 .github/workflows/__export-file-baseline-information.yml      | 2 +-
 .github/workflows/__go-custom-queries.yml                     | 2 +-
 .../workflows/__go-indirect-tracing-workaround-diagnostic.yml | 4 ++--
 .../__go-indirect-tracing-workaround-no-file-program.yml      | 2 +-
 .github/workflows/__go-indirect-tracing-workaround.yml        | 2 +-
 .github/workflows/__go-tracing-autobuilder.yml                | 2 +-
 .github/workflows/__go-tracing-custom-build-steps.yml         | 2 +-
 .github/workflows/__go-tracing-legacy-workflow.yml            | 2 +-
 .github/workflows/__local-bundle.yml                          | 2 +-
 .github/workflows/__multi-language-autodetect.yml             | 4 ++--
 .../workflows/__packaging-codescanning-config-inputs-js.yml   | 2 +-
 .github/workflows/__packaging-config-inputs-js.yml            | 2 +-
 .github/workflows/__packaging-config-js.yml                   | 2 +-
 .github/workflows/__packaging-inputs-js.yml                   | 2 +-
 .github/workflows/__remote-config.yml                         | 2 +-
 .github/workflows/__rubocop-multi-language.yml                | 2 +-
 .github/workflows/__split-workflow.yml                        | 2 +-
 .github/workflows/__swift-custom-build.yml                    | 2 +-
 .github/workflows/__unset-environment.yml                     | 2 +-
 .github/workflows/__upload-ref-sha-input.yml                  | 2 +-
 .github/workflows/__upload-sarif.yml                          | 2 +-
 .github/workflows/__with-checkout-path.yml                    | 2 +-
 .github/workflows/debug-artifacts-failure-safe.yml            | 2 +-
 .github/workflows/debug-artifacts-safe.yml                    | 2 +-
 .github/workflows/post-release-mergeback.yml                  | 2 +-
 .github/workflows/python312-windows.yml                       | 2 +-
 .github/workflows/update-bundle.yml                           | 2 +-
 .../workflows/update-supported-enterprise-server-versions.yml | 2 +-
 31 files changed, 33 insertions(+), 33 deletions(-)

diff --git a/.github/workflows/__all-platform-bundle.yml b/.github/workflows/__all-platform-bundle.yml
index 91843a5523..fc890b7ef6 100644
--- a/.github/workflows/__all-platform-bundle.yml
+++ b/.github/workflows/__all-platform-bundle.yml
@@ -75,7 +75,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__analyze-ref-input.yml b/.github/workflows/__analyze-ref-input.yml
index 1c2ace8a66..0b8c62809b 100644
--- a/.github/workflows/__analyze-ref-input.yml
+++ b/.github/workflows/__analyze-ref-input.yml
@@ -71,7 +71,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__build-mode-manual.yml b/.github/workflows/__build-mode-manual.yml
index 6eedc2e3f7..91e45e3a41 100644
--- a/.github/workflows/__build-mode-manual.yml
+++ b/.github/workflows/__build-mode-manual.yml
@@ -71,7 +71,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__export-file-baseline-information.yml b/.github/workflows/__export-file-baseline-information.yml
index 2297597df0..1485231a6a 100644
--- a/.github/workflows/__export-file-baseline-information.yml
+++ b/.github/workflows/__export-file-baseline-information.yml
@@ -75,7 +75,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__go-custom-queries.yml b/.github/workflows/__go-custom-queries.yml
index 9f24b27202..f8d13632fc 100644
--- a/.github/workflows/__go-custom-queries.yml
+++ b/.github/workflows/__go-custom-queries.yml
@@ -73,7 +73,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__go-indirect-tracing-workaround-diagnostic.yml b/.github/workflows/__go-indirect-tracing-workaround-diagnostic.yml
index d20710d4b4..0e70b29352 100644
--- a/.github/workflows/__go-indirect-tracing-workaround-diagnostic.yml
+++ b/.github/workflows/__go-indirect-tracing-workaround-diagnostic.yml
@@ -57,7 +57,7 @@ jobs:
       - name: Check out repository
         uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
@@ -73,7 +73,7 @@ jobs:
           languages: go
           tools: ${{ steps.prepare-test.outputs.tools-url }}
       # Deliberately change Go after the `init` step
-      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+      - uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: '1.20'
       - name: Build code
diff --git a/.github/workflows/__go-indirect-tracing-workaround-no-file-program.yml b/.github/workflows/__go-indirect-tracing-workaround-no-file-program.yml
index c533573bf0..176f17bc51 100644
--- a/.github/workflows/__go-indirect-tracing-workaround-no-file-program.yml
+++ b/.github/workflows/__go-indirect-tracing-workaround-no-file-program.yml
@@ -57,7 +57,7 @@ jobs:
       - name: Check out repository
         uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__go-indirect-tracing-workaround.yml b/.github/workflows/__go-indirect-tracing-workaround.yml
index 2ba520441f..e7b73e16a4 100644
--- a/.github/workflows/__go-indirect-tracing-workaround.yml
+++ b/.github/workflows/__go-indirect-tracing-workaround.yml
@@ -57,7 +57,7 @@ jobs:
       - name: Check out repository
         uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__go-tracing-autobuilder.yml b/.github/workflows/__go-tracing-autobuilder.yml
index 10ecce6932..fbc2077f0d 100644
--- a/.github/workflows/__go-tracing-autobuilder.yml
+++ b/.github/workflows/__go-tracing-autobuilder.yml
@@ -77,7 +77,7 @@ jobs:
       - name: Check out repository
         uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__go-tracing-custom-build-steps.yml b/.github/workflows/__go-tracing-custom-build-steps.yml
index fa8b04e5e3..0c806751e1 100644
--- a/.github/workflows/__go-tracing-custom-build-steps.yml
+++ b/.github/workflows/__go-tracing-custom-build-steps.yml
@@ -77,7 +77,7 @@ jobs:
       - name: Check out repository
         uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__go-tracing-legacy-workflow.yml b/.github/workflows/__go-tracing-legacy-workflow.yml
index ce6a78678c..f4a02e46eb 100644
--- a/.github/workflows/__go-tracing-legacy-workflow.yml
+++ b/.github/workflows/__go-tracing-legacy-workflow.yml
@@ -77,7 +77,7 @@ jobs:
       - name: Check out repository
         uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__local-bundle.yml b/.github/workflows/__local-bundle.yml
index 9de7f39aee..85bebe7a21 100644
--- a/.github/workflows/__local-bundle.yml
+++ b/.github/workflows/__local-bundle.yml
@@ -71,7 +71,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__multi-language-autodetect.yml b/.github/workflows/__multi-language-autodetect.yml
index f32033e608..42bbec3137 100644
--- a/.github/workflows/__multi-language-autodetect.yml
+++ b/.github/workflows/__multi-language-autodetect.yml
@@ -105,7 +105,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
@@ -120,7 +120,7 @@ jobs:
         # We need Python 3.13 for older CLI versions because they are not compatible with Python 3.14 or newer.
         # See https://github.com/github/codeql-action/pull/3212
         if: matrix.version != 'nightly-latest' && matrix.version != 'linked'
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
         with:
           python-version: '3.13'
 
diff --git a/.github/workflows/__packaging-codescanning-config-inputs-js.yml b/.github/workflows/__packaging-codescanning-config-inputs-js.yml
index 9193791f8f..f187f3aa76 100644
--- a/.github/workflows/__packaging-codescanning-config-inputs-js.yml
+++ b/.github/workflows/__packaging-codescanning-config-inputs-js.yml
@@ -75,7 +75,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__packaging-config-inputs-js.yml b/.github/workflows/__packaging-config-inputs-js.yml
index 4ca70d90e3..122d5d0b20 100644
--- a/.github/workflows/__packaging-config-inputs-js.yml
+++ b/.github/workflows/__packaging-config-inputs-js.yml
@@ -75,7 +75,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__packaging-config-js.yml b/.github/workflows/__packaging-config-js.yml
index 32d59ff8af..9eeb42f6e2 100644
--- a/.github/workflows/__packaging-config-js.yml
+++ b/.github/workflows/__packaging-config-js.yml
@@ -75,7 +75,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__packaging-inputs-js.yml b/.github/workflows/__packaging-inputs-js.yml
index 06356f0f63..09d3fc1266 100644
--- a/.github/workflows/__packaging-inputs-js.yml
+++ b/.github/workflows/__packaging-inputs-js.yml
@@ -75,7 +75,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__remote-config.yml b/.github/workflows/__remote-config.yml
index 4c93775b1d..3dc0dd8dc4 100644
--- a/.github/workflows/__remote-config.yml
+++ b/.github/workflows/__remote-config.yml
@@ -73,7 +73,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__rubocop-multi-language.yml b/.github/workflows/__rubocop-multi-language.yml
index 1752e511e3..80a1349032 100644
--- a/.github/workflows/__rubocop-multi-language.yml
+++ b/.github/workflows/__rubocop-multi-language.yml
@@ -54,7 +54,7 @@ jobs:
           use-all-platform-bundle: 'false'
           setup-kotlin: 'true'
       - name: Set up Ruby
-        uses: ruby/setup-ruby@12fd324f1d0b43274fdc8130f6980590a667c455 # v1.312.0
+        uses: ruby/setup-ruby@89f90524b88a01fe6e0b732220432cc6142926af # v1.313.0
         with:
           ruby-version: 2.6
       - name: Install Code Scanning integration
diff --git a/.github/workflows/__split-workflow.yml b/.github/workflows/__split-workflow.yml
index c7dbc1b522..7d2310ed5a 100644
--- a/.github/workflows/__split-workflow.yml
+++ b/.github/workflows/__split-workflow.yml
@@ -81,7 +81,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__swift-custom-build.yml b/.github/workflows/__swift-custom-build.yml
index 55b293e182..0451f4125e 100644
--- a/.github/workflows/__swift-custom-build.yml
+++ b/.github/workflows/__swift-custom-build.yml
@@ -75,7 +75,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__unset-environment.yml b/.github/workflows/__unset-environment.yml
index 0c39c82227..93c4f4d791 100644
--- a/.github/workflows/__unset-environment.yml
+++ b/.github/workflows/__unset-environment.yml
@@ -73,7 +73,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__upload-ref-sha-input.yml b/.github/workflows/__upload-ref-sha-input.yml
index 8ccca4f405..5c1d88ce07 100644
--- a/.github/workflows/__upload-ref-sha-input.yml
+++ b/.github/workflows/__upload-ref-sha-input.yml
@@ -71,7 +71,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__upload-sarif.yml b/.github/workflows/__upload-sarif.yml
index c6e877562d..08c260cd6b 100644
--- a/.github/workflows/__upload-sarif.yml
+++ b/.github/workflows/__upload-sarif.yml
@@ -78,7 +78,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/__with-checkout-path.yml b/.github/workflows/__with-checkout-path.yml
index c075883426..93cd269f84 100644
--- a/.github/workflows/__with-checkout-path.yml
+++ b/.github/workflows/__with-checkout-path.yml
@@ -72,7 +72,7 @@ jobs:
         with:
           dotnet-version: ${{ inputs.dotnet-version || '9.x' }}
       - name: Install Go
-        uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+        uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ${{ inputs.go-version || '>=1.21.0' }}
           cache: false
diff --git a/.github/workflows/debug-artifacts-failure-safe.yml b/.github/workflows/debug-artifacts-failure-safe.yml
index fbddc54608..2267626508 100644
--- a/.github/workflows/debug-artifacts-failure-safe.yml
+++ b/.github/workflows/debug-artifacts-failure-safe.yml
@@ -54,7 +54,7 @@ jobs:
         uses: ./.github/actions/prepare-test
         with:
           version: ${{ matrix.version }}
-      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+      - uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ^1.13.1
       - name: Install .NET
diff --git a/.github/workflows/debug-artifacts-safe.yml b/.github/workflows/debug-artifacts-safe.yml
index 15cb0b9890..c6df381f93 100644
--- a/.github/workflows/debug-artifacts-safe.yml
+++ b/.github/workflows/debug-artifacts-safe.yml
@@ -50,7 +50,7 @@ jobs:
         uses: ./.github/actions/prepare-test
         with:
           version: ${{ matrix.version }}
-      - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+      - uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
         with:
           go-version: ^1.13.1
       - name: Install .NET
diff --git a/.github/workflows/post-release-mergeback.yml b/.github/workflows/post-release-mergeback.yml
index 313a1e3558..772ae4fce5 100644
--- a/.github/workflows/post-release-mergeback.yml
+++ b/.github/workflows/post-release-mergeback.yml
@@ -51,7 +51,7 @@ jobs:
         with:
           node-version: 24
           cache: 'npm'
-      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+      - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
         with:
           python-version: '3.12'
 
diff --git a/.github/workflows/python312-windows.yml b/.github/workflows/python312-windows.yml
index 2e2f3a6f81..4fb3054363 100644
--- a/.github/workflows/python312-windows.yml
+++ b/.github/workflows/python312-windows.yml
@@ -32,7 +32,7 @@ jobs:
     runs-on: windows-latest
 
     steps:
-    - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+    - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
       with:
         python-version: 3.12
 
diff --git a/.github/workflows/update-bundle.yml b/.github/workflows/update-bundle.yml
index 6b15d1932d..8885d4997e 100644
--- a/.github/workflows/update-bundle.yml
+++ b/.github/workflows/update-bundle.yml
@@ -41,7 +41,7 @@ jobs:
           git config --global user.name "github-actions[bot]"
 
       - name: Set up Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
         with:
           python-version: '3.12'
 
diff --git a/.github/workflows/update-supported-enterprise-server-versions.yml b/.github/workflows/update-supported-enterprise-server-versions.yml
index 2271ee2ac6..41cbbad3a2 100644
--- a/.github/workflows/update-supported-enterprise-server-versions.yml
+++ b/.github/workflows/update-supported-enterprise-server-versions.yml
@@ -23,7 +23,7 @@ jobs:
 
     steps:
       - name: Setup Python
-        uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+        uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
         with:
           python-version: "3.13"
 

From 490a5f655cbf861cbe0c4f395fdfa16b2d9a7727 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 24 Jun 2026 17:58:21 +0000
Subject: [PATCH 54/65] Bump actions/checkout from 6.0.3 to 7.0.0 in
 /.github/workflows

Bumps [actions/checkout](https://github.com/actions/checkout) from 6.0.3 to 7.0.0.
- [Release notes](https://github.com/actions/checkout/releases)
- [Changelog](https://github.com/actions/checkout/blob/main/CHANGELOG.md)
- [Commits](https://github.com/actions/checkout/compare/df4cb1c069e1874edd31b4311f1884172cec0e10...9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0)

---
updated-dependencies:
- dependency-name: actions/checkout
  dependency-version: 7.0.0
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 .github/workflows/__all-platform-bundle.yml                 | 2 +-
 .github/workflows/__analysis-kinds.yml                      | 2 +-
 .github/workflows/__analyze-ref-input.yml                   | 2 +-
 .github/workflows/__autobuild-action.yml                    | 2 +-
 .../__autobuild-direct-tracing-with-working-dir.yml         | 2 +-
 .github/workflows/__autobuild-working-dir.yml               | 2 +-
 .github/workflows/__build-mode-autobuild.yml                | 2 +-
 .github/workflows/__build-mode-manual.yml                   | 2 +-
 .github/workflows/__build-mode-none.yml                     | 2 +-
 .github/workflows/__build-mode-rollback.yml                 | 2 +-
 .github/workflows/__bundle-from-nightly.yml                 | 2 +-
 .github/workflows/__bundle-from-toolcache.yml               | 2 +-
 .github/workflows/__bundle-toolcache.yml                    | 2 +-
 .github/workflows/__bundle-zstd.yml                         | 2 +-
 .github/workflows/__cleanup-db-cluster-dir.yml              | 2 +-
 .github/workflows/__config-export.yml                       | 2 +-
 .github/workflows/__config-input.yml                        | 2 +-
 .github/workflows/__cpp-deptrace-disabled.yml               | 2 +-
 .github/workflows/__cpp-deptrace-enabled-on-macos.yml       | 2 +-
 .github/workflows/__cpp-deptrace-enabled.yml                | 2 +-
 .github/workflows/__diagnostics-export.yml                  | 2 +-
 .github/workflows/__export-file-baseline-information.yml    | 2 +-
 .github/workflows/__extractor-ram-threads.yml               | 2 +-
 .github/workflows/__global-proxy.yml                        | 2 +-
 .github/workflows/__go-custom-queries.yml                   | 2 +-
 .../__go-indirect-tracing-workaround-diagnostic.yml         | 2 +-
 .../__go-indirect-tracing-workaround-no-file-program.yml    | 2 +-
 .github/workflows/__go-indirect-tracing-workaround.yml      | 2 +-
 .github/workflows/__go-tracing-autobuilder.yml              | 2 +-
 .github/workflows/__go-tracing-custom-build-steps.yml       | 2 +-
 .github/workflows/__go-tracing-legacy-workflow.yml          | 2 +-
 .github/workflows/__init-with-registries.yml                | 2 +-
 .github/workflows/__javascript-source-root.yml              | 2 +-
 .github/workflows/__job-run-uuid-sarif.yml                  | 2 +-
 .github/workflows/__language-aliases.yml                    | 2 +-
 .github/workflows/__local-bundle.yml                        | 2 +-
 .github/workflows/__multi-language-autodetect.yml           | 2 +-
 .github/workflows/__overlay-init-fallback.yml               | 2 +-
 .../workflows/__packaging-codescanning-config-inputs-js.yml | 2 +-
 .github/workflows/__packaging-config-inputs-js.yml          | 2 +-
 .github/workflows/__packaging-config-js.yml                 | 2 +-
 .github/workflows/__packaging-inputs-js.yml                 | 2 +-
 .github/workflows/__remote-config.yml                       | 2 +-
 .github/workflows/__resolve-environment-action.yml          | 2 +-
 .github/workflows/__rubocop-multi-language.yml              | 2 +-
 .github/workflows/__ruby.yml                                | 2 +-
 .github/workflows/__rust.yml                                | 2 +-
 .github/workflows/__split-workflow.yml                      | 2 +-
 .github/workflows/__start-proxy.yml                         | 2 +-
 .github/workflows/__submit-sarif-failure.yml                | 4 ++--
 .github/workflows/__swift-autobuild.yml                     | 2 +-
 .github/workflows/__swift-custom-build.yml                  | 2 +-
 .github/workflows/__unset-environment.yml                   | 2 +-
 .github/workflows/__upload-ref-sha-input.yml                | 2 +-
 .github/workflows/__upload-sarif.yml                        | 2 +-
 .github/workflows/__with-checkout-path.yml                  | 4 ++--
 .github/workflows/check-expected-release-files.yml          | 2 +-
 .github/workflows/codeql.yml                                | 6 +++---
 .github/workflows/codescanning-config-cli.yml               | 2 +-
 .github/workflows/debug-artifacts-failure-safe.yml          | 2 +-
 .github/workflows/debug-artifacts-safe.yml                  | 2 +-
 .github/workflows/post-release-mergeback.yml                | 2 +-
 .github/workflows/pr-checks.yml                             | 6 +++---
 .github/workflows/prepare-release.yml                       | 2 +-
 .github/workflows/publish-immutable-action.yml              | 2 +-
 .github/workflows/python312-windows.yml                     | 2 +-
 .github/workflows/query-filters.yml                         | 2 +-
 .github/workflows/rebuild.yml                               | 2 +-
 .github/workflows/rollback-release.yml                      | 2 +-
 .github/workflows/test-codeql-bundle-all.yml                | 2 +-
 .github/workflows/update-bundle.yml                         | 2 +-
 .github/workflows/update-release-branch.yml                 | 4 ++--
 .../update-supported-enterprise-server-versions.yml         | 4 ++--
 73 files changed, 81 insertions(+), 81 deletions(-)

diff --git a/.github/workflows/__all-platform-bundle.yml b/.github/workflows/__all-platform-bundle.yml
index 91843a5523..4a0044a53b 100644
--- a/.github/workflows/__all-platform-bundle.yml
+++ b/.github/workflows/__all-platform-bundle.yml
@@ -69,7 +69,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__analysis-kinds.yml b/.github/workflows/__analysis-kinds.yml
index 66443d6382..53c8834eea 100644
--- a/.github/workflows/__analysis-kinds.yml
+++ b/.github/workflows/__analysis-kinds.yml
@@ -67,7 +67,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__analyze-ref-input.yml b/.github/workflows/__analyze-ref-input.yml
index 1c2ace8a66..b696876f20 100644
--- a/.github/workflows/__analyze-ref-input.yml
+++ b/.github/workflows/__analyze-ref-input.yml
@@ -65,7 +65,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__autobuild-action.yml b/.github/workflows/__autobuild-action.yml
index 2eb8d5be8a..e79c4994c4 100644
--- a/.github/workflows/__autobuild-action.yml
+++ b/.github/workflows/__autobuild-action.yml
@@ -59,7 +59,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__autobuild-direct-tracing-with-working-dir.yml b/.github/workflows/__autobuild-direct-tracing-with-working-dir.yml
index 2e2658297c..2b771914e6 100644
--- a/.github/workflows/__autobuild-direct-tracing-with-working-dir.yml
+++ b/.github/workflows/__autobuild-direct-tracing-with-working-dir.yml
@@ -61,7 +61,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install Java
         uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5.3.0
         with:
diff --git a/.github/workflows/__autobuild-working-dir.yml b/.github/workflows/__autobuild-working-dir.yml
index d82f24de51..71dd9d1df8 100644
--- a/.github/workflows/__autobuild-working-dir.yml
+++ b/.github/workflows/__autobuild-working-dir.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__build-mode-autobuild.yml b/.github/workflows/__build-mode-autobuild.yml
index 8e1789135c..2ba8ca76dc 100644
--- a/.github/workflows/__build-mode-autobuild.yml
+++ b/.github/workflows/__build-mode-autobuild.yml
@@ -61,7 +61,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install Java
         uses: actions/setup-java@ad2b38190b15e4d6bdf0c97fb4fca8412226d287 # v5.3.0
         with:
diff --git a/.github/workflows/__build-mode-manual.yml b/.github/workflows/__build-mode-manual.yml
index 6eedc2e3f7..1f29e11c80 100644
--- a/.github/workflows/__build-mode-manual.yml
+++ b/.github/workflows/__build-mode-manual.yml
@@ -65,7 +65,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__build-mode-none.yml b/.github/workflows/__build-mode-none.yml
index 8af5952fb5..dc97aa3d99 100644
--- a/.github/workflows/__build-mode-none.yml
+++ b/.github/workflows/__build-mode-none.yml
@@ -47,7 +47,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__build-mode-rollback.yml b/.github/workflows/__build-mode-rollback.yml
index c2ceee4da5..4383024f3b 100644
--- a/.github/workflows/__build-mode-rollback.yml
+++ b/.github/workflows/__build-mode-rollback.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__bundle-from-nightly.yml b/.github/workflows/__bundle-from-nightly.yml
index 5f220e6c40..9ccb507866 100644
--- a/.github/workflows/__bundle-from-nightly.yml
+++ b/.github/workflows/__bundle-from-nightly.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__bundle-from-toolcache.yml b/.github/workflows/__bundle-from-toolcache.yml
index 63612d1dbe..036262395e 100644
--- a/.github/workflows/__bundle-from-toolcache.yml
+++ b/.github/workflows/__bundle-from-toolcache.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__bundle-toolcache.yml b/.github/workflows/__bundle-toolcache.yml
index 017640730b..0bdfd45082 100644
--- a/.github/workflows/__bundle-toolcache.yml
+++ b/.github/workflows/__bundle-toolcache.yml
@@ -49,7 +49,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__bundle-zstd.yml b/.github/workflows/__bundle-zstd.yml
index adae450548..7c1f89cfbd 100644
--- a/.github/workflows/__bundle-zstd.yml
+++ b/.github/workflows/__bundle-zstd.yml
@@ -49,7 +49,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__cleanup-db-cluster-dir.yml b/.github/workflows/__cleanup-db-cluster-dir.yml
index 22bd3563fe..921228910e 100644
--- a/.github/workflows/__cleanup-db-cluster-dir.yml
+++ b/.github/workflows/__cleanup-db-cluster-dir.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__config-export.yml b/.github/workflows/__config-export.yml
index 408a871f34..dedf559719 100644
--- a/.github/workflows/__config-export.yml
+++ b/.github/workflows/__config-export.yml
@@ -47,7 +47,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__config-input.yml b/.github/workflows/__config-input.yml
index bc5d782b53..a5da2050ad 100644
--- a/.github/workflows/__config-input.yml
+++ b/.github/workflows/__config-input.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install Node.js
         uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
         with:
diff --git a/.github/workflows/__cpp-deptrace-disabled.yml b/.github/workflows/__cpp-deptrace-disabled.yml
index a6117be2ce..5eba27ed63 100644
--- a/.github/workflows/__cpp-deptrace-disabled.yml
+++ b/.github/workflows/__cpp-deptrace-disabled.yml
@@ -49,7 +49,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__cpp-deptrace-enabled-on-macos.yml b/.github/workflows/__cpp-deptrace-enabled-on-macos.yml
index c4a5e5df92..d26cd7dca7 100644
--- a/.github/workflows/__cpp-deptrace-enabled-on-macos.yml
+++ b/.github/workflows/__cpp-deptrace-enabled-on-macos.yml
@@ -47,7 +47,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__cpp-deptrace-enabled.yml b/.github/workflows/__cpp-deptrace-enabled.yml
index a4775d8ad5..d3b04db26d 100644
--- a/.github/workflows/__cpp-deptrace-enabled.yml
+++ b/.github/workflows/__cpp-deptrace-enabled.yml
@@ -49,7 +49,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__diagnostics-export.yml b/.github/workflows/__diagnostics-export.yml
index fbc3d189b6..7f788ef0a2 100644
--- a/.github/workflows/__diagnostics-export.yml
+++ b/.github/workflows/__diagnostics-export.yml
@@ -47,7 +47,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__export-file-baseline-information.yml b/.github/workflows/__export-file-baseline-information.yml
index 2297597df0..2b35a28779 100644
--- a/.github/workflows/__export-file-baseline-information.yml
+++ b/.github/workflows/__export-file-baseline-information.yml
@@ -69,7 +69,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__extractor-ram-threads.yml b/.github/workflows/__extractor-ram-threads.yml
index 4783be96c7..28487388df 100644
--- a/.github/workflows/__extractor-ram-threads.yml
+++ b/.github/workflows/__extractor-ram-threads.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__global-proxy.yml b/.github/workflows/__global-proxy.yml
index 3f09901dba..e3ba6ff101 100644
--- a/.github/workflows/__global-proxy.yml
+++ b/.github/workflows/__global-proxy.yml
@@ -47,7 +47,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__go-custom-queries.yml b/.github/workflows/__go-custom-queries.yml
index 9f24b27202..421daf1c12 100644
--- a/.github/workflows/__go-custom-queries.yml
+++ b/.github/workflows/__go-custom-queries.yml
@@ -67,7 +67,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__go-indirect-tracing-workaround-diagnostic.yml b/.github/workflows/__go-indirect-tracing-workaround-diagnostic.yml
index d20710d4b4..d29969ef56 100644
--- a/.github/workflows/__go-indirect-tracing-workaround-diagnostic.yml
+++ b/.github/workflows/__go-indirect-tracing-workaround-diagnostic.yml
@@ -55,7 +55,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install Go
         uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
diff --git a/.github/workflows/__go-indirect-tracing-workaround-no-file-program.yml b/.github/workflows/__go-indirect-tracing-workaround-no-file-program.yml
index c533573bf0..8dbd0a1375 100644
--- a/.github/workflows/__go-indirect-tracing-workaround-no-file-program.yml
+++ b/.github/workflows/__go-indirect-tracing-workaround-no-file-program.yml
@@ -55,7 +55,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install Go
         uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
diff --git a/.github/workflows/__go-indirect-tracing-workaround.yml b/.github/workflows/__go-indirect-tracing-workaround.yml
index 2ba520441f..a7c60852af 100644
--- a/.github/workflows/__go-indirect-tracing-workaround.yml
+++ b/.github/workflows/__go-indirect-tracing-workaround.yml
@@ -55,7 +55,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install Go
         uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
diff --git a/.github/workflows/__go-tracing-autobuilder.yml b/.github/workflows/__go-tracing-autobuilder.yml
index 10ecce6932..a52951edc8 100644
--- a/.github/workflows/__go-tracing-autobuilder.yml
+++ b/.github/workflows/__go-tracing-autobuilder.yml
@@ -75,7 +75,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install Go
         uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
diff --git a/.github/workflows/__go-tracing-custom-build-steps.yml b/.github/workflows/__go-tracing-custom-build-steps.yml
index fa8b04e5e3..d550bb3605 100644
--- a/.github/workflows/__go-tracing-custom-build-steps.yml
+++ b/.github/workflows/__go-tracing-custom-build-steps.yml
@@ -75,7 +75,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install Go
         uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
diff --git a/.github/workflows/__go-tracing-legacy-workflow.yml b/.github/workflows/__go-tracing-legacy-workflow.yml
index ce6a78678c..e75b26c18c 100644
--- a/.github/workflows/__go-tracing-legacy-workflow.yml
+++ b/.github/workflows/__go-tracing-legacy-workflow.yml
@@ -75,7 +75,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install Go
         uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
         with:
diff --git a/.github/workflows/__init-with-registries.yml b/.github/workflows/__init-with-registries.yml
index bec944b568..623afdee97 100644
--- a/.github/workflows/__init-with-registries.yml
+++ b/.github/workflows/__init-with-registries.yml
@@ -49,7 +49,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__javascript-source-root.yml b/.github/workflows/__javascript-source-root.yml
index c27f3633a2..622156ce4d 100644
--- a/.github/workflows/__javascript-source-root.yml
+++ b/.github/workflows/__javascript-source-root.yml
@@ -49,7 +49,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__job-run-uuid-sarif.yml b/.github/workflows/__job-run-uuid-sarif.yml
index 4f503b9a42..989b28fc53 100644
--- a/.github/workflows/__job-run-uuid-sarif.yml
+++ b/.github/workflows/__job-run-uuid-sarif.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__language-aliases.yml b/.github/workflows/__language-aliases.yml
index 91da90b496..3a1656eef7 100644
--- a/.github/workflows/__language-aliases.yml
+++ b/.github/workflows/__language-aliases.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__local-bundle.yml b/.github/workflows/__local-bundle.yml
index 9de7f39aee..3a14967037 100644
--- a/.github/workflows/__local-bundle.yml
+++ b/.github/workflows/__local-bundle.yml
@@ -65,7 +65,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__multi-language-autodetect.yml b/.github/workflows/__multi-language-autodetect.yml
index f32033e608..00e23053c1 100644
--- a/.github/workflows/__multi-language-autodetect.yml
+++ b/.github/workflows/__multi-language-autodetect.yml
@@ -99,7 +99,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__overlay-init-fallback.yml b/.github/workflows/__overlay-init-fallback.yml
index ec0856ccf9..9a4ffa71f2 100644
--- a/.github/workflows/__overlay-init-fallback.yml
+++ b/.github/workflows/__overlay-init-fallback.yml
@@ -47,7 +47,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__packaging-codescanning-config-inputs-js.yml b/.github/workflows/__packaging-codescanning-config-inputs-js.yml
index 9193791f8f..dfe8e02d23 100644
--- a/.github/workflows/__packaging-codescanning-config-inputs-js.yml
+++ b/.github/workflows/__packaging-codescanning-config-inputs-js.yml
@@ -69,7 +69,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__packaging-config-inputs-js.yml b/.github/workflows/__packaging-config-inputs-js.yml
index 4ca70d90e3..8e09844c30 100644
--- a/.github/workflows/__packaging-config-inputs-js.yml
+++ b/.github/workflows/__packaging-config-inputs-js.yml
@@ -69,7 +69,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__packaging-config-js.yml b/.github/workflows/__packaging-config-js.yml
index 32d59ff8af..7ebe27a427 100644
--- a/.github/workflows/__packaging-config-js.yml
+++ b/.github/workflows/__packaging-config-js.yml
@@ -69,7 +69,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__packaging-inputs-js.yml b/.github/workflows/__packaging-inputs-js.yml
index 06356f0f63..a69c6c062c 100644
--- a/.github/workflows/__packaging-inputs-js.yml
+++ b/.github/workflows/__packaging-inputs-js.yml
@@ -69,7 +69,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__remote-config.yml b/.github/workflows/__remote-config.yml
index 4c93775b1d..4e5aae0451 100644
--- a/.github/workflows/__remote-config.yml
+++ b/.github/workflows/__remote-config.yml
@@ -67,7 +67,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__resolve-environment-action.yml b/.github/workflows/__resolve-environment-action.yml
index 923b670622..29a042ae2b 100644
--- a/.github/workflows/__resolve-environment-action.yml
+++ b/.github/workflows/__resolve-environment-action.yml
@@ -49,7 +49,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__rubocop-multi-language.yml b/.github/workflows/__rubocop-multi-language.yml
index 1752e511e3..c00aaaab7b 100644
--- a/.github/workflows/__rubocop-multi-language.yml
+++ b/.github/workflows/__rubocop-multi-language.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__ruby.yml b/.github/workflows/__ruby.yml
index adeb014fa7..3558be85e4 100644
--- a/.github/workflows/__ruby.yml
+++ b/.github/workflows/__ruby.yml
@@ -55,7 +55,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__rust.yml b/.github/workflows/__rust.yml
index 8f89acb6b0..e74daa4e4a 100644
--- a/.github/workflows/__rust.yml
+++ b/.github/workflows/__rust.yml
@@ -53,7 +53,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__split-workflow.yml b/.github/workflows/__split-workflow.yml
index c7dbc1b522..6011ab079b 100644
--- a/.github/workflows/__split-workflow.yml
+++ b/.github/workflows/__split-workflow.yml
@@ -75,7 +75,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__start-proxy.yml b/.github/workflows/__start-proxy.yml
index 3330c5ecff..7ac2dede30 100644
--- a/.github/workflows/__start-proxy.yml
+++ b/.github/workflows/__start-proxy.yml
@@ -49,7 +49,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__submit-sarif-failure.yml b/.github/workflows/__submit-sarif-failure.yml
index 136c8a5313..339d6a07cb 100644
--- a/.github/workflows/__submit-sarif-failure.yml
+++ b/.github/workflows/__submit-sarif-failure.yml
@@ -49,7 +49,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
@@ -57,7 +57,7 @@ jobs:
           version: ${{ matrix.version }}
           use-all-platform-bundle: 'false'
           setup-kotlin: 'true'
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - uses: ./init
         with:
           languages: javascript
diff --git a/.github/workflows/__swift-autobuild.yml b/.github/workflows/__swift-autobuild.yml
index 7c9ae25b06..e59a87e3aa 100644
--- a/.github/workflows/__swift-autobuild.yml
+++ b/.github/workflows/__swift-autobuild.yml
@@ -45,7 +45,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/__swift-custom-build.yml b/.github/workflows/__swift-custom-build.yml
index 55b293e182..3cec4614b3 100644
--- a/.github/workflows/__swift-custom-build.yml
+++ b/.github/workflows/__swift-custom-build.yml
@@ -69,7 +69,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__unset-environment.yml b/.github/workflows/__unset-environment.yml
index 0c39c82227..e0c772bb8b 100644
--- a/.github/workflows/__unset-environment.yml
+++ b/.github/workflows/__unset-environment.yml
@@ -67,7 +67,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__upload-ref-sha-input.yml b/.github/workflows/__upload-ref-sha-input.yml
index 8ccca4f405..d2746b6444 100644
--- a/.github/workflows/__upload-ref-sha-input.yml
+++ b/.github/workflows/__upload-ref-sha-input.yml
@@ -65,7 +65,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__upload-sarif.yml b/.github/workflows/__upload-sarif.yml
index c6e877562d..3999569a40 100644
--- a/.github/workflows/__upload-sarif.yml
+++ b/.github/workflows/__upload-sarif.yml
@@ -72,7 +72,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
diff --git a/.github/workflows/__with-checkout-path.yml b/.github/workflows/__with-checkout-path.yml
index c075883426..eafbb2d32c 100644
--- a/.github/workflows/__with-checkout-path.yml
+++ b/.github/workflows/__with-checkout-path.yml
@@ -66,7 +66,7 @@ jobs:
     steps:
       # This ensures we don't accidentally use the original checkout for any part of the test.
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Install .NET
         uses: actions/setup-dotnet@9a946fdbd5fb07b82b2f5a4466058b876ab72bb2 # v5.3.0
         with:
@@ -91,7 +91,7 @@ jobs:
           rm -rf ./* .github .git
       # Check out the actions repo again, but at a different location.
       # choose an arbitrary SHA so that we can later test that the commit_oid is not from main
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           ref: 474bbf07f9247ffe1856c6a0f94aeeb10e7afee6
           path: x/y/z/some-path
diff --git a/.github/workflows/check-expected-release-files.yml b/.github/workflows/check-expected-release-files.yml
index 9459e879ab..670f146566 100644
--- a/.github/workflows/check-expected-release-files.yml
+++ b/.github/workflows/check-expected-release-files.yml
@@ -23,7 +23,7 @@ jobs:
 
     steps:
       - name: Checkout CodeQL Action
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Check Expected Release Files
         run: |
           bundle_version="$(cat "./src/defaults.json" | jq -r ".bundleVersion")"
diff --git a/.github/workflows/codeql.yml b/.github/workflows/codeql.yml
index 7a5b81d9fa..c5efa1731a 100644
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -32,7 +32,7 @@ jobs:
       security-events: read
 
     steps:
-    - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+    - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
     - name: Set up default CodeQL bundle
       id: setup-default
       uses: ./setup-codeql
@@ -84,7 +84,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
     - name: Initialize CodeQL
       uses: ./init
       id: init
@@ -121,7 +121,7 @@ jobs:
 
     steps:
     - name: Checkout
-      uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
     - name: Initialize CodeQL
       uses: ./init
       with:
diff --git a/.github/workflows/codescanning-config-cli.yml b/.github/workflows/codescanning-config-cli.yml
index eeb4eefa3f..693be12392 100644
--- a/.github/workflows/codescanning-config-cli.yml
+++ b/.github/workflows/codescanning-config-cli.yml
@@ -54,7 +54,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
     - name: Check out repository
-      uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
     - name: Set up Node.js
       uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
diff --git a/.github/workflows/debug-artifacts-failure-safe.yml b/.github/workflows/debug-artifacts-failure-safe.yml
index fbddc54608..46c7d4268d 100644
--- a/.github/workflows/debug-artifacts-failure-safe.yml
+++ b/.github/workflows/debug-artifacts-failure-safe.yml
@@ -48,7 +48,7 @@ jobs:
       - name: Dump GitHub event
         run: cat "${GITHUB_EVENT_PATH}"
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/debug-artifacts-safe.yml b/.github/workflows/debug-artifacts-safe.yml
index 15cb0b9890..76a0e17552 100644
--- a/.github/workflows/debug-artifacts-safe.yml
+++ b/.github/workflows/debug-artifacts-safe.yml
@@ -44,7 +44,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Prepare test
         id: prepare-test
         uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/post-release-mergeback.yml b/.github/workflows/post-release-mergeback.yml
index 313a1e3558..60a5f616e9 100644
--- a/.github/workflows/post-release-mergeback.yml
+++ b/.github/workflows/post-release-mergeback.yml
@@ -44,7 +44,7 @@ jobs:
           GITHUB_CONTEXT: '${{ toJson(github) }}'
         run: echo "${GITHUB_CONTEXT}"
 
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           fetch-depth: 0  # ensure we have all tags and can push commits
       - uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
diff --git a/.github/workflows/pr-checks.yml b/.github/workflows/pr-checks.yml
index b971cae363..45d38d3459 100644
--- a/.github/workflows/pr-checks.yml
+++ b/.github/workflows/pr-checks.yml
@@ -39,7 +39,7 @@ jobs:
         if: runner.os == 'Windows'
         run: git config --global core.autocrlf false
 
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Set up Node.js
         uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
@@ -88,7 +88,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Set up Node.js
         uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
@@ -161,7 +161,7 @@ jobs:
       - name: 'Backport: Check out base ref'
         id: checkout-base
         if: ${{ startsWith(github.head_ref, 'backport-') }}
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           ref: ${{ github.base_ref }}
 
diff --git a/.github/workflows/prepare-release.yml b/.github/workflows/prepare-release.yml
index 915148e277..8bab54557a 100644
--- a/.github/workflows/prepare-release.yml
+++ b/.github/workflows/prepare-release.yml
@@ -44,7 +44,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           fetch-depth: 0 # Need full history for calculation of diffs
 
diff --git a/.github/workflows/publish-immutable-action.yml b/.github/workflows/publish-immutable-action.yml
index 3944a81e6d..ec9a6518aa 100644
--- a/.github/workflows/publish-immutable-action.yml
+++ b/.github/workflows/publish-immutable-action.yml
@@ -20,7 +20,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Publish immutable release
         id: publish
diff --git a/.github/workflows/python312-windows.yml b/.github/workflows/python312-windows.yml
index 2e2f3a6f81..7b10d41b00 100644
--- a/.github/workflows/python312-windows.yml
+++ b/.github/workflows/python312-windows.yml
@@ -36,7 +36,7 @@ jobs:
       with:
         python-version: 3.12
 
-    - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+    - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
     - name: Prepare test
       uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/query-filters.yml b/.github/workflows/query-filters.yml
index 1b1054627d..0343ce2e69 100644
--- a/.github/workflows/query-filters.yml
+++ b/.github/workflows/query-filters.yml
@@ -30,7 +30,7 @@ jobs:
       contents: read # This permission is needed to allow the GitHub Actions workflow to read the contents of the repository.
     steps:
     - name: Check out repository
-      uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
     - name: Install Node.js
       uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
diff --git a/.github/workflows/rebuild.yml b/.github/workflows/rebuild.yml
index 26acd867fb..39b42d8a02 100644
--- a/.github/workflows/rebuild.yml
+++ b/.github/workflows/rebuild.yml
@@ -24,7 +24,7 @@ jobs:
       pull-requests: write # needed to comment on the PR
     steps:
       - name: Checkout
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           fetch-depth: 0
           ref: ${{ env.HEAD_REF }}
diff --git a/.github/workflows/rollback-release.yml b/.github/workflows/rollback-release.yml
index e6a9da61f9..b830a827dd 100644
--- a/.github/workflows/rollback-release.yml
+++ b/.github/workflows/rollback-release.yml
@@ -52,7 +52,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           fetch-depth: 0 # Need full history for calculation of diffs
 
diff --git a/.github/workflows/test-codeql-bundle-all.yml b/.github/workflows/test-codeql-bundle-all.yml
index 6462973588..a44d3137cd 100644
--- a/.github/workflows/test-codeql-bundle-all.yml
+++ b/.github/workflows/test-codeql-bundle-all.yml
@@ -38,7 +38,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
     - name: Check out repository
-      uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
     - name: Prepare test
       id: prepare-test
       uses: ./.github/actions/prepare-test
diff --git a/.github/workflows/update-bundle.yml b/.github/workflows/update-bundle.yml
index 6b15d1932d..3b3110781f 100644
--- a/.github/workflows/update-bundle.yml
+++ b/.github/workflows/update-bundle.yml
@@ -33,7 +33,7 @@ jobs:
           GITHUB_CONTEXT: '${{ toJson(github) }}'
         run: echo "$GITHUB_CONTEXT"
 
-      - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Update git config
         run: |
diff --git a/.github/workflows/update-release-branch.yml b/.github/workflows/update-release-branch.yml
index bef7965742..11e97eeca0 100644
--- a/.github/workflows/update-release-branch.yml
+++ b/.github/workflows/update-release-branch.yml
@@ -38,7 +38,7 @@ jobs:
       contents: write # needed to push commits
       pull-requests: write # needed to create pull request
     steps:
-    - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+    - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       with:
         fetch-depth: 0  # Need full history for calculation of diffs
     - uses: ./.github/actions/release-initialise
@@ -101,7 +101,7 @@ jobs:
         private-key: ${{ secrets.AUTOMATION_PRIVATE_KEY }}
 
     - name: Checkout
-      uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+      uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       with:
         fetch-depth: 0  # Need full history for calculation of diffs
         token: ${{ steps.app-token.outputs.token }}
diff --git a/.github/workflows/update-supported-enterprise-server-versions.yml b/.github/workflows/update-supported-enterprise-server-versions.yml
index 2271ee2ac6..1990560dbd 100644
--- a/.github/workflows/update-supported-enterprise-server-versions.yml
+++ b/.github/workflows/update-supported-enterprise-server-versions.yml
@@ -28,7 +28,7 @@ jobs:
           python-version: "3.13"
 
       - name: Checkout CodeQL Action
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
 
       - name: Set up Node.js
         uses: actions/setup-node@48b55a011bda9f5d6aeb4c2d9c7362e8dae4041e # v6.4.0
@@ -40,7 +40,7 @@ jobs:
         run: npm ci
 
       - name: Checkout Enterprise Releases
-        uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
         with:
           repository: github/enterprise-releases
           token: ${{ secrets.ENTERPRISE_RELEASE_TOKEN }}

From dca26a3927c5f2a09e79a9aa9f02b37c3adfc236 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 24 Jun 2026 17:59:01 +0000
Subject: [PATCH 55/65] Rebuild

---
 .../checks/go-indirect-tracing-workaround-diagnostic.yml  | 2 +-
 pr-checks/checks/multi-language-autodetect.yml            | 2 +-
 pr-checks/checks/rubocop-multi-language.yml               | 2 +-
 pr-checks/sync.ts                                         | 8 ++++----
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/pr-checks/checks/go-indirect-tracing-workaround-diagnostic.yml b/pr-checks/checks/go-indirect-tracing-workaround-diagnostic.yml
index 69f9b47621..895dba2b6c 100644
--- a/pr-checks/checks/go-indirect-tracing-workaround-diagnostic.yml
+++ b/pr-checks/checks/go-indirect-tracing-workaround-diagnostic.yml
@@ -12,7 +12,7 @@ steps:
       languages: go
       tools: ${{ steps.prepare-test.outputs.tools-url }}
   # Deliberately change Go after the `init` step
-  - uses: actions/setup-go@4a3601121dd01d1626a1e23e37211e3254c1c06c # v6.4.0
+  - uses: actions/setup-go@924ae3a1cded613372ab5595356fb5720e22ba16 # v6.5.0
     with:
       go-version: "1.20"
   - name: Build code
diff --git a/pr-checks/checks/multi-language-autodetect.yml b/pr-checks/checks/multi-language-autodetect.yml
index 1608fcc6b7..801f4521a4 100644
--- a/pr-checks/checks/multi-language-autodetect.yml
+++ b/pr-checks/checks/multi-language-autodetect.yml
@@ -23,7 +23,7 @@ steps:
     # We need Python 3.13 for older CLI versions because they are not compatible with Python 3.14 or newer.
     # See https://github.com/github/codeql-action/pull/3212
     if: matrix.version != 'nightly-latest' && matrix.version != 'linked'
-    uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+    uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6.3.0
     with:
       python-version: "3.13"
 
diff --git a/pr-checks/checks/rubocop-multi-language.yml b/pr-checks/checks/rubocop-multi-language.yml
index 182816cb35..5ae18526af 100644
--- a/pr-checks/checks/rubocop-multi-language.yml
+++ b/pr-checks/checks/rubocop-multi-language.yml
@@ -5,7 +5,7 @@ versions:
   - default
 steps:
   - name: Set up Ruby
-    uses: ruby/setup-ruby@12fd324f1d0b43274fdc8130f6980590a667c455 # v1.312.0
+    uses: ruby/setup-ruby@89f90524b88a01fe6e0b732220432cc6142926af # v1.313.0
     with:
       ruby-version: 2.6
   - name: Install Code Scanning integration
diff --git a/pr-checks/sync.ts b/pr-checks/sync.ts
index e2e350a069..dcfde695ca 100755
--- a/pr-checks/sync.ts
+++ b/pr-checks/sync.ts
@@ -233,8 +233,8 @@ const languageSetups: LanguageSetups = {
         name: "Install Go",
         uses: pinnedUses(
           "actions/setup-go",
-          "4a3601121dd01d1626a1e23e37211e3254c1c06c",
-          "v6.4.0",
+          "924ae3a1cded613372ab5595356fb5720e22ba16",
+          "v6.5.0",
         ),
         with: {
           "go-version": `\${{ inputs.go-version || '${defaultLanguageVersions.go}' }}`,
@@ -271,8 +271,8 @@ const languageSetups: LanguageSetups = {
         name: "Install Python",
         uses: pinnedUses(
           "actions/setup-python",
-          "a309ff8b426b58ec0e2a45f0f869d46889d02405",
-          "v6.2.0",
+          "ece7cb06caefa5fff74198d8649806c4678c61a1",
+          "v6.3.0",
         ),
         with: {
           "python-version": `\${{ inputs.python-version || '${defaultLanguageVersions.python}' }}`,

From d56b7d789e0b64b7d2ea94405ad7a296abce7347 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 24 Jun 2026 18:00:15 +0000
Subject: [PATCH 56/65] Rebuild

---
 pr-checks/checks/submit-sarif-failure.yml | 2 +-
 pr-checks/checks/with-checkout-path.yml   | 2 +-
 pr-checks/sync.ts                         | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/pr-checks/checks/submit-sarif-failure.yml b/pr-checks/checks/submit-sarif-failure.yml
index 2bba971d72..9212a5dc79 100644
--- a/pr-checks/checks/submit-sarif-failure.yml
+++ b/pr-checks/checks/submit-sarif-failure.yml
@@ -21,7 +21,7 @@ permissions:
   security-events: write # needed to upload the SARIF file
 
 steps:
-  - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+  - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
   - uses: ./init
     with:
       languages: javascript
diff --git a/pr-checks/checks/with-checkout-path.yml b/pr-checks/checks/with-checkout-path.yml
index e91066e18e..7a5866b783 100644
--- a/pr-checks/checks/with-checkout-path.yml
+++ b/pr-checks/checks/with-checkout-path.yml
@@ -14,7 +14,7 @@ steps:
       rm -rf ./* .github .git
   # Check out the actions repo again, but at a different location.
   # choose an arbitrary SHA so that we can later test that the commit_oid is not from main
-  - uses: actions/checkout@df4cb1c069e1874edd31b4311f1884172cec0e10 # v6.0.3
+  - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
     with:
       ref: 474bbf07f9247ffe1856c6a0f94aeeb10e7afee6
       path: x/y/z/some-path
diff --git a/pr-checks/sync.ts b/pr-checks/sync.ts
index e2e350a069..60779ce010 100755
--- a/pr-checks/sync.ts
+++ b/pr-checks/sync.ts
@@ -529,8 +529,8 @@ function generateJob(
       name: "Check out repository",
       uses: pinnedUses(
         "actions/checkout",
-        "df4cb1c069e1874edd31b4311f1884172cec0e10",
-        "v6.0.3",
+        "9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0",
+        "v7.0.0",
       ),
     },
     ...setupInfo.steps,

From ad159d34f6e136f6707597f40995d27df951d565 Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Fri, 26 Jun 2026 17:37:37 +0100
Subject: [PATCH 57/65] Measure overlay-base database size at the clear cleanup
 level

This lets us compare the storage cost of overlay-base and trimmed databases for the same commit.
---
 lib/entry-points.js    | 43 ++++++++++++++++++++
 src/database-upload.ts | 90 ++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 133 insertions(+)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index d3fbf00eec..8aba6ba39a 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -151828,8 +151828,51 @@ async function cleanupAndUploadDatabases(repositoryNwo, codeql, config, apiDetai
       });
     }
   }
+  if (shouldUploadOverlayBase && !config.debugMode) {
+    await withGroupAsync(
+      "Measuring database size at the clear cleanup level",
+      () => recordClearCleanupSizes(codeql, config, reports, logger)
+    );
+  }
   return reports;
 }
+async function recordClearCleanupSizes(codeql, config, reports, logger) {
+  const startTime = performance.now();
+  try {
+    try {
+      await codeql.databaseCleanupCluster(config, "clear" /* Clear */);
+    } catch (e) {
+      logger.warning(
+        `Failed to clean up databases at the '${"clear" /* Clear */}' level for size measurement: ${getErrorMessage(e)}`
+      );
+      return;
+    }
+    for (const language of config.languages) {
+      const report = reports.find((r) => r.language === language);
+      if (report === void 0) {
+        continue;
+      }
+      try {
+        const bundledDb = await bundleDb(config, language, codeql, language, {
+          includeDiagnostics: false
+        });
+        report.clear_cleanup_zipped_size_bytes = fs17.statSync(bundledDb).size;
+        logger.debug(
+          `Database for ${language} is ${report.clear_cleanup_zipped_size_bytes} bytes zipped at the '${"clear" /* Clear */}' cleanup level (vs. ${report.zipped_upload_size_bytes} bytes at the '${"overlay" /* Overlay */}' level).`
+        );
+      } catch (e) {
+        logger.warning(
+          `Failed to measure the '${"clear" /* Clear */}' cleanup database size for ${language}: ${getErrorMessage(e)}`
+        );
+      }
+    }
+  } finally {
+    const durationMs = performance.now() - startTime;
+    for (const report of reports) {
+      report.clear_cleanup_measurement_duration_ms = durationMs;
+    }
+  }
+}
 async function uploadBundledDatabase(repositoryNwo, language, commitOid, bundledDb, bundledDbSize, apiDetails) {
   const client = getApiClient();
   const uploadsUrl = new URL(parseGitHubUrl(apiDetails.url));
diff --git a/src/database-upload.ts b/src/database-upload.ts
index 9869f38034..41aee8fe25 100644
--- a/src/database-upload.ts
+++ b/src/database-upload.ts
@@ -25,6 +25,19 @@ export interface DatabaseUploadResult {
   zipped_upload_size_bytes?: number;
   /** Whether the uploaded database is an overlay base. */
   is_overlay_base?: boolean;
+  /**
+   * For overlay-base uploads only: the size in bytes that the zipped database
+   * would have been if it had been cleaned at the `clear` cleanup level instead
+   * of the `overlay` level.
+   */
+  clear_cleanup_zipped_size_bytes?: number;
+  /**
+   * For overlay-base uploads only: the time in milliseconds spent measuring the
+   * `clear` cleanup size (cleaning up the cluster at the `clear` level and
+   * bundling each database). This is a cluster-wide measurement, so it is the
+   * same for every language in a run.
+   */
+  clear_cleanup_measurement_duration_ms?: number;
   /** Time taken to upload database in milliseconds. */
   upload_duration_ms?: number;
   /** If there was an error during database upload, this is its message. */
@@ -156,9 +169,86 @@ export async function cleanupAndUploadDatabases(
       });
     }
   }
+
+  // When we upload an overlay-base database, we cleaned the databases at the `overlay` level, which
+  // retains more data than the `clear` level used for regular uploads. Measure what the zipped size
+  // would have been at the `clear` level too, so we can compare the storage cost of overlay-base
+  // databases against regular databases for the same repository.
+  //
+  // We skip this in debug mode, where the databases are preserved and uploaded as debug artifacts,
+  // since cleaning them up at the `clear` level would discard data that is useful for debugging.
+  if (shouldUploadOverlayBase && !config.debugMode) {
+    await withGroupAsync(
+      "Measuring database size at the clear cleanup level",
+      () => recordClearCleanupSizes(codeql, config, reports, logger),
+    );
+  }
+
   return reports;
 }
 
+/**
+ * Cleans up the databases at the `clear` cleanup level and records the resulting zipped size for
+ * each language in `clear_cleanup_zipped_size_bytes`, along with the time spent taking the
+ * measurement in `clear_cleanup_measurement_duration_ms`.
+ *
+ * This mutates the entries of `reports` in place. It must run only after all overlay-base uploads
+ * have completed, since the `clear` cleanup discards overlay data that the uploaded database
+ * depends on.
+ *
+ * Failures here are non-fatal: this is telemetry-only, so we log and move on rather than failing
+ * the workflow.
+ */
+async function recordClearCleanupSizes(
+  codeql: CodeQL,
+  config: Config,
+  reports: DatabaseUploadResult[],
+  logger: Logger,
+): Promise<void> {
+  const startTime = performance.now();
+  try {
+    try {
+      await codeql.databaseCleanupCluster(config, CleanupLevel.Clear);
+    } catch (e) {
+      logger.warning(
+        `Failed to clean up databases at the '${CleanupLevel.Clear}' level for ` +
+          `size measurement: ${util.getErrorMessage(e)}`,
+      );
+      return;
+    }
+
+    for (const language of config.languages) {
+      const report = reports.find((r) => r.language === language);
+      if (report === undefined) {
+        continue;
+      }
+      try {
+        const bundledDb = await bundleDb(config, language, codeql, language, {
+          includeDiagnostics: false,
+        });
+        report.clear_cleanup_zipped_size_bytes = fs.statSync(bundledDb).size;
+        logger.debug(
+          `Database for ${language} is ` +
+            `${report.clear_cleanup_zipped_size_bytes} bytes zipped at the ` +
+            `'${CleanupLevel.Clear}' cleanup level ` +
+            `(vs. ${report.zipped_upload_size_bytes} bytes at the ` +
+            `'${CleanupLevel.Overlay}' level).`,
+        );
+      } catch (e) {
+        logger.warning(
+          `Failed to measure the '${CleanupLevel.Clear}' cleanup database size ` +
+            `for ${language}: ${util.getErrorMessage(e)}`,
+        );
+      }
+    }
+  } finally {
+    const durationMs = performance.now() - startTime;
+    for (const report of reports) {
+      report.clear_cleanup_measurement_duration_ms = durationMs;
+    }
+  }
+}
+
 /**
  * Uploads a bundled database to the GitHub API.
  *

From e90a71aaea341c9deecb8a254ab1a8a3892f9fa4 Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Fri, 26 Jun 2026 17:37:38 +0100
Subject: [PATCH 58/65] Add tests for clear cleanup size telemetry

---
 src/database-upload.test.ts | 146 ++++++++++++++++++++++++++++++++++++
 1 file changed, 146 insertions(+)

diff --git a/src/database-upload.test.ts b/src/database-upload.test.ts
index 1cfbaecad6..26041fc0e4 100644
--- a/src/database-upload.test.ts
+++ b/src/database-upload.test.ts
@@ -11,8 +11,10 @@ import * as apiClient from "./api-client";
 import { createStubCodeQL } from "./codeql";
 import { Config } from "./config-utils";
 import { cleanupAndUploadDatabases } from "./database-upload";
+import { Feature } from "./feature-flags";
 import * as gitUtils from "./git-utils";
 import { BuiltInLanguage } from "./languages";
+import { OverlayDatabaseMode } from "./overlay/overlay-database-mode";
 import { RepositoryNwo } from "./repository";
 import {
   checkExpectedLogMessages,
@@ -24,6 +26,7 @@ import {
   setupTests,
 } from "./testing-utils";
 import {
+  CleanupLevel,
   GitHubVariant,
   HTTPError,
   initializeEnvironment,
@@ -335,3 +338,146 @@ test.serial("Successfully uploading a database to GHEC-DR", async (t) => {
     );
   });
 });
+
+test.serial(
+  "Records overlay and clear cleanup sizes when uploading an overlay-base database",
+  async (t) => {
+    await withTmpDir(async (tmpDir) => {
+      setupActionsVars(tmpDir, tmpDir);
+      sinon
+        .stub(actionsUtil, "getRequiredInput")
+        .withArgs("upload-database")
+        .returns("true");
+      sinon.stub(gitUtils, "isAnalyzingDefaultBranch").resolves(true);
+
+      await mockHttpRequests(201);
+
+      // Track the cleanup level passed to each cleanup so that the database
+      // bundle stub can write a differently-sized bundle for each level.
+      const cleanupLevels: CleanupLevel[] = [];
+      let lastCleanupLevel: CleanupLevel | undefined;
+      const overlaySizeBytes = 100;
+      const clearSizeBytes = 50;
+      const codeql = createStubCodeQL({
+        async databaseCleanupCluster(_config, cleanupLevel) {
+          cleanupLevels.push(cleanupLevel);
+          lastCleanupLevel = cleanupLevel;
+        },
+        async databaseBundle(_databasePath, outputFilePath) {
+          const sizeBytes =
+            lastCleanupLevel === CleanupLevel.Overlay
+              ? overlaySizeBytes
+              : clearSizeBytes;
+          fs.writeFileSync(outputFilePath, "x".repeat(sizeBytes));
+        },
+      });
+
+      const config = getTestConfig(tmpDir);
+      config.overlayDatabaseMode = OverlayDatabaseMode.OverlayBase;
+
+      const loggedMessages: LoggedMessage[] = [];
+      const results = await cleanupAndUploadDatabases(
+        testRepoName,
+        codeql,
+        config,
+        testApiDetails,
+        createFeatures([Feature.UploadOverlayDbToApi]),
+        getRecordingLogger(loggedMessages),
+      );
+
+      // The database should be cleaned up at the `overlay` level for the upload
+      // and then re-cleaned at the `clear` level to measure its size.
+      t.deepEqual(cleanupLevels, [CleanupLevel.Overlay, CleanupLevel.Clear]);
+
+      t.is(results.length, 1);
+      t.is(results[0].is_overlay_base, true);
+      t.is(results[0].zipped_upload_size_bytes, overlaySizeBytes);
+      t.is(results[0].clear_cleanup_zipped_size_bytes, clearSizeBytes);
+      t.is(typeof results[0].clear_cleanup_measurement_duration_ms, "number");
+    });
+  },
+);
+
+test.serial(
+  "Does not measure clear cleanup size for a regular (non-overlay-base) upload",
+  async (t) => {
+    await withTmpDir(async (tmpDir) => {
+      setupActionsVars(tmpDir, tmpDir);
+      sinon
+        .stub(actionsUtil, "getRequiredInput")
+        .withArgs("upload-database")
+        .returns("true");
+      sinon.stub(gitUtils, "isAnalyzingDefaultBranch").resolves(true);
+
+      await mockHttpRequests(201);
+
+      const cleanupLevels: CleanupLevel[] = [];
+      const codeql = createStubCodeQL({
+        async databaseCleanupCluster(_config, cleanupLevel) {
+          cleanupLevels.push(cleanupLevel);
+        },
+        async databaseBundle(_databasePath, outputFilePath) {
+          fs.writeFileSync(outputFilePath, "");
+        },
+      });
+
+      const results = await cleanupAndUploadDatabases(
+        testRepoName,
+        codeql,
+        getTestConfig(tmpDir),
+        testApiDetails,
+        createFeatures([Feature.UploadOverlayDbToApi]),
+        getRecordingLogger([]),
+      );
+
+      // A regular upload is cleaned only once, at the `clear` level.
+      t.deepEqual(cleanupLevels, [CleanupLevel.Clear]);
+      t.is(results[0].is_overlay_base, false);
+      t.is(results[0].clear_cleanup_zipped_size_bytes, undefined);
+      t.is(results[0].clear_cleanup_measurement_duration_ms, undefined);
+    });
+  },
+);
+
+test.serial("Does not measure clear cleanup size in debug mode", async (t) => {
+  await withTmpDir(async (tmpDir) => {
+    setupActionsVars(tmpDir, tmpDir);
+    sinon
+      .stub(actionsUtil, "getRequiredInput")
+      .withArgs("upload-database")
+      .returns("true");
+    sinon.stub(gitUtils, "isAnalyzingDefaultBranch").resolves(true);
+
+    await mockHttpRequests(201);
+
+    const cleanupLevels: CleanupLevel[] = [];
+    const codeql = createStubCodeQL({
+      async databaseCleanupCluster(_config, cleanupLevel) {
+        cleanupLevels.push(cleanupLevel);
+      },
+      async databaseBundle(_databasePath, outputFilePath) {
+        fs.writeFileSync(outputFilePath, "");
+      },
+    });
+
+    const config = getTestConfig(tmpDir);
+    config.overlayDatabaseMode = OverlayDatabaseMode.OverlayBase;
+    config.debugMode = true;
+
+    const results = await cleanupAndUploadDatabases(
+      testRepoName,
+      codeql,
+      config,
+      testApiDetails,
+      createFeatures([Feature.UploadOverlayDbToApi]),
+      getRecordingLogger([]),
+    );
+
+    // In debug mode we clean up at the `overlay` level for the upload but skip
+    // the additional `clear` cleanup, to preserve the database for debugging.
+    t.deepEqual(cleanupLevels, [CleanupLevel.Overlay]);
+    t.is(results[0].is_overlay_base, true);
+    t.is(results[0].clear_cleanup_zipped_size_bytes, undefined);
+    t.is(results[0].clear_cleanup_measurement_duration_ms, undefined);
+  });
+});

From 6f8864c8b0fdaa2810bf2e549f9a9994006b6548 Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Fri, 26 Jun 2026 18:43:09 +0100
Subject: [PATCH 59/65] Address review comments

---
 lib/entry-points.js         | 51 +++++++++++++-------------
 src/database-upload.test.ts | 45 +++++++++++++++++++++++
 src/database-upload.ts      | 71 +++++++++++++++++++------------------
 3 files changed, 105 insertions(+), 62 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 8aba6ba39a..93a4d0ed58 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -151839,39 +151839,36 @@ async function cleanupAndUploadDatabases(repositoryNwo, codeql, config, apiDetai
 async function recordClearCleanupSizes(codeql, config, reports, logger) {
   const startTime = performance.now();
   try {
+    await codeql.databaseCleanupCluster(config, "clear" /* Clear */);
+  } catch (e) {
+    logger.warning(
+      `Failed to clean up databases at the '${"clear" /* Clear */}' level for size measurement: ${getErrorMessage(e)}`
+    );
+    return;
+  }
+  for (const language of config.languages) {
+    const report = reports.find((r) => r.language === language);
+    if (report === void 0) {
+      continue;
+    }
     try {
-      await codeql.databaseCleanupCluster(config, "clear" /* Clear */);
+      const bundledDb = await bundleDb(config, language, codeql, language, {
+        includeDiagnostics: false
+      });
+      report.clear_cleanup_zipped_size_bytes = fs17.statSync(bundledDb).size;
+      logger.debug(
+        `Database for ${language} is ${report.clear_cleanup_zipped_size_bytes} bytes zipped at the '${"clear" /* Clear */}' cleanup level (vs. ${report.zipped_upload_size_bytes ?? "unknown"} bytes at the '${"overlay" /* Overlay */}' level).`
+      );
     } catch (e) {
       logger.warning(
-        `Failed to clean up databases at the '${"clear" /* Clear */}' level for size measurement: ${getErrorMessage(e)}`
+        `Failed to measure the '${"clear" /* Clear */}' cleanup database size for ${language}: ${getErrorMessage(e)}`
       );
-      return;
-    }
-    for (const language of config.languages) {
-      const report = reports.find((r) => r.language === language);
-      if (report === void 0) {
-        continue;
-      }
-      try {
-        const bundledDb = await bundleDb(config, language, codeql, language, {
-          includeDiagnostics: false
-        });
-        report.clear_cleanup_zipped_size_bytes = fs17.statSync(bundledDb).size;
-        logger.debug(
-          `Database for ${language} is ${report.clear_cleanup_zipped_size_bytes} bytes zipped at the '${"clear" /* Clear */}' cleanup level (vs. ${report.zipped_upload_size_bytes} bytes at the '${"overlay" /* Overlay */}' level).`
-        );
-      } catch (e) {
-        logger.warning(
-          `Failed to measure the '${"clear" /* Clear */}' cleanup database size for ${language}: ${getErrorMessage(e)}`
-        );
-      }
-    }
-  } finally {
-    const durationMs = performance.now() - startTime;
-    for (const report of reports) {
-      report.clear_cleanup_measurement_duration_ms = durationMs;
     }
   }
+  const durationMs = performance.now() - startTime;
+  for (const report of reports) {
+    report.clear_cleanup_measurement_duration_ms = durationMs;
+  }
 }
 async function uploadBundledDatabase(repositoryNwo, language, commitOid, bundledDb, bundledDbSize, apiDetails) {
   const client = getApiClient();
diff --git a/src/database-upload.test.ts b/src/database-upload.test.ts
index 26041fc0e4..bcaf9f1c9e 100644
--- a/src/database-upload.test.ts
+++ b/src/database-upload.test.ts
@@ -481,3 +481,48 @@ test.serial("Does not measure clear cleanup size in debug mode", async (t) => {
     t.is(results[0].clear_cleanup_measurement_duration_ms, undefined);
   });
 });
+
+test.serial(
+  "Does not record a clear cleanup duration when the clear cleanup fails",
+  async (t) => {
+    await withTmpDir(async (tmpDir) => {
+      setupActionsVars(tmpDir, tmpDir);
+      sinon
+        .stub(actionsUtil, "getRequiredInput")
+        .withArgs("upload-database")
+        .returns("true");
+      sinon.stub(gitUtils, "isAnalyzingDefaultBranch").resolves(true);
+
+      await mockHttpRequests(201);
+
+      const codeql = createStubCodeQL({
+        async databaseCleanupCluster(_config, cleanupLevel) {
+          if (cleanupLevel === CleanupLevel.Clear) {
+            throw new Error("clear cleanup failed");
+          }
+        },
+        async databaseBundle(_databasePath, outputFilePath) {
+          fs.writeFileSync(outputFilePath, "x".repeat(100));
+        },
+      });
+
+      const config = getTestConfig(tmpDir);
+      config.overlayDatabaseMode = OverlayDatabaseMode.OverlayBase;
+
+      const results = await cleanupAndUploadDatabases(
+        testRepoName,
+        codeql,
+        config,
+        testApiDetails,
+        createFeatures([Feature.UploadOverlayDbToApi]),
+        getRecordingLogger([]),
+      );
+
+      // When the `clear` cleanup fails, no size is measured, so we should not
+      // report a measurement duration either.
+      t.is(results[0].is_overlay_base, true);
+      t.is(results[0].clear_cleanup_zipped_size_bytes, undefined);
+      t.is(results[0].clear_cleanup_measurement_duration_ms, undefined);
+    });
+  },
+);
diff --git a/src/database-upload.ts b/src/database-upload.ts
index 41aee8fe25..0bd99422a0 100644
--- a/src/database-upload.ts
+++ b/src/database-upload.ts
@@ -189,8 +189,8 @@ export async function cleanupAndUploadDatabases(
 
 /**
  * Cleans up the databases at the `clear` cleanup level and records the resulting zipped size for
- * each language in `clear_cleanup_zipped_size_bytes`, along with the time spent taking the
- * measurement in `clear_cleanup_measurement_duration_ms`.
+ * each language in `clear_cleanup_zipped_size_bytes`. If the cleanup succeeds, also records the
+ * time spent taking the measurement in `clear_cleanup_measurement_duration_ms`.
  *
  * This mutates the entries of `reports` in place. It must run only after all overlay-base uploads
  * have completed, since the `clear` cleanup discards overlay data that the uploaded database
@@ -206,46 +206,47 @@ async function recordClearCleanupSizes(
   logger: Logger,
 ): Promise<void> {
   const startTime = performance.now();
+
   try {
+    await codeql.databaseCleanupCluster(config, CleanupLevel.Clear);
+  } catch (e) {
+    // The cleanup didn't run, so there are no sizes to measure. Return without recording a
+    // duration, so that we don't report a measurement duration with no accompanying sizes.
+    logger.warning(
+      `Failed to clean up databases at the '${CleanupLevel.Clear}' level for ` +
+        `size measurement: ${util.getErrorMessage(e)}`,
+    );
+    return;
+  }
+
+  for (const language of config.languages) {
+    const report = reports.find((r) => r.language === language);
+    if (report === undefined) {
+      continue;
+    }
     try {
-      await codeql.databaseCleanupCluster(config, CleanupLevel.Clear);
+      const bundledDb = await bundleDb(config, language, codeql, language, {
+        includeDiagnostics: false,
+      });
+      report.clear_cleanup_zipped_size_bytes = fs.statSync(bundledDb).size;
+      logger.debug(
+        `Database for ${language} is ` +
+          `${report.clear_cleanup_zipped_size_bytes} bytes zipped at the ` +
+          `'${CleanupLevel.Clear}' cleanup level ` +
+          `(vs. ${report.zipped_upload_size_bytes ?? "unknown"} bytes at the ` +
+          `'${CleanupLevel.Overlay}' level).`,
+      );
     } catch (e) {
       logger.warning(
-        `Failed to clean up databases at the '${CleanupLevel.Clear}' level for ` +
-          `size measurement: ${util.getErrorMessage(e)}`,
+        `Failed to measure the '${CleanupLevel.Clear}' cleanup database size ` +
+          `for ${language}: ${util.getErrorMessage(e)}`,
       );
-      return;
     }
+  }
 
-    for (const language of config.languages) {
-      const report = reports.find((r) => r.language === language);
-      if (report === undefined) {
-        continue;
-      }
-      try {
-        const bundledDb = await bundleDb(config, language, codeql, language, {
-          includeDiagnostics: false,
-        });
-        report.clear_cleanup_zipped_size_bytes = fs.statSync(bundledDb).size;
-        logger.debug(
-          `Database for ${language} is ` +
-            `${report.clear_cleanup_zipped_size_bytes} bytes zipped at the ` +
-            `'${CleanupLevel.Clear}' cleanup level ` +
-            `(vs. ${report.zipped_upload_size_bytes} bytes at the ` +
-            `'${CleanupLevel.Overlay}' level).`,
-        );
-      } catch (e) {
-        logger.warning(
-          `Failed to measure the '${CleanupLevel.Clear}' cleanup database size ` +
-            `for ${language}: ${util.getErrorMessage(e)}`,
-        );
-      }
-    }
-  } finally {
-    const durationMs = performance.now() - startTime;
-    for (const report of reports) {
-      report.clear_cleanup_measurement_duration_ms = durationMs;
-    }
+  const durationMs = performance.now() - startTime;
+  for (const report of reports) {
+    report.clear_cleanup_measurement_duration_ms = durationMs;
   }
 }
 

From 9cfb67bab9b32441237f92d4ba29a7f3ccff259f Mon Sep 17 00:00:00 2001
From: Henry Mercer <henrymercer@github.com>
Date: Tue, 30 Jun 2026 16:49:24 +0100
Subject: [PATCH 60/65] Add clarifying comments

---
 src/database-upload.ts | 2 ++
 src/util.ts            | 8 +++++++-
 2 files changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/database-upload.ts b/src/database-upload.ts
index 0bd99422a0..0189bef1e6 100644
--- a/src/database-upload.ts
+++ b/src/database-upload.ts
@@ -205,6 +205,8 @@ async function recordClearCleanupSizes(
   reports: DatabaseUploadResult[],
   logger: Logger,
 ): Promise<void> {
+  // Include both the cleanup and the re-bundling to record how much time taking this measurement adds
+  // to the run.
   const startTime = performance.now();
 
   try {
diff --git a/src/util.ts b/src/util.ts
index 200d68d2c2..fc0553b1b7 100644
--- a/src/util.ts
+++ b/src/util.ts
@@ -712,7 +712,13 @@ export function getBaseDatabaseOidsFilePath(config: Config): string {
   return path.join(config.dbLocation, BASE_DATABASE_OIDS_FILE_NAME);
 }
 
-// Create a bundle for the given DB, if it doesn't already exist
+/**
+ * Bundles the database for the given language into a `.zip` file, returning the path to it.
+ *
+ * If a bundle for `dbName` already exists (e.g. from an earlier call), it is deleted and
+ * re-created, so each call produces a fresh bundle reflecting the current database contents and the
+ * given `includeDiagnostics` value.
+ */
 export async function bundleDb(
   config: Config,
   language: Language,

From f7fa18f05d107ff6735857c3510fbff190c9a1eb Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Wed, 1 Jul 2026 15:51:37 +0100
Subject: [PATCH 61/65] Add FF for config file repo property

---
 lib/entry-points.js  | 5 +++++
 src/feature-flags.ts | 7 +++++++
 2 files changed, 12 insertions(+)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 93a4d0ed58..27cf79298a 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -145942,6 +145942,11 @@ var featureConfig = {
     envVar: "CODEQL_ACTION_CLEANUP_TRAP_CACHES",
     minimumVersion: void 0
   },
+  ["config_file_repository_property" /* ConfigFileRepositoryProperty */]: {
+    defaultValue: false,
+    envVar: "CODEQL_ACTION_CONFIG_FILE_REPOSITORY_PROPERTY",
+    minimumVersion: void 0
+  },
   ["cpp_dependency_installation_enabled" /* CppDependencyInstallation */]: {
     defaultValue: false,
     envVar: "CODEQL_EXTRACTOR_CPP_AUTOINSTALL_DEPENDENCIES",
diff --git a/src/feature-flags.ts b/src/feature-flags.ts
index a796982242..f71ecab57b 100644
--- a/src/feature-flags.ts
+++ b/src/feature-flags.ts
@@ -74,6 +74,8 @@ export enum Feature {
   AllowMultipleAnalysisKinds = "allow_multiple_analysis_kinds",
   AllowToolcacheInput = "allow_toolcache_input",
   CleanupTrapCaches = "cleanup_trap_caches",
+  /** Whether to allow the `config-file` input to be specified via a repository property. */
+  ConfigFileRepositoryProperty = "config_file_repository_property",
   CppDependencyInstallation = "cpp_dependency_installation_enabled",
   CsharpCacheBuildModeNone = "csharp_cache_bmn",
   CsharpNewCacheKey = "csharp_new_cache_key",
@@ -184,6 +186,11 @@ export const featureConfig = {
     envVar: "CODEQL_ACTION_CLEANUP_TRAP_CACHES",
     minimumVersion: undefined,
   },
+  [Feature.ConfigFileRepositoryProperty]: {
+    defaultValue: false,
+    envVar: "CODEQL_ACTION_CONFIG_FILE_REPOSITORY_PROPERTY",
+    minimumVersion: undefined,
+  },
   [Feature.CppDependencyInstallation]: {
     defaultValue: false,
     envVar: "CODEQL_EXTRACTOR_CPP_AUTOINSTALL_DEPENDENCIES",

From 0025d0f2b5676fde748a0be9725dcce18dd9f986 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Wed, 1 Jul 2026 15:54:22 +0100
Subject: [PATCH 62/65] Use FF

---
 lib/entry-points.js     | 15 +++++++++++++--
 src/config/file.test.ts | 27 +++++++++++++++++++++------
 src/config/file.ts      |  6 ++++++
 src/init-action.ts      | 10 +++++++++-
 4 files changed, 49 insertions(+), 9 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index 27cf79298a..dcbb94c2f5 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -159652,12 +159652,15 @@ var io7 = __toESM(require_io());
 var semver10 = __toESM(require_semver2());
 
 // src/config/file.ts
-function getConfigFileInput(logger, actions, repositoryProperties) {
+function getConfigFileInput(logger, actions, repositoryProperties, useRepositoryProperty) {
   const input = actions.getOptionalInput("config-file");
   if (input !== void 0) {
     logger.info(`Using configuration file input from workflow: ${input}`);
     return input;
   }
+  if (!useRepositoryProperty) {
+    return void 0;
+  }
   const propertyValue = repositoryProperties["github-codeql-config-file" /* CONFIG_FILE */];
   if (propertyValue !== void 0 && propertyValue.trim().length > 0) {
     logger.info(
@@ -160048,7 +160051,15 @@ async function run3(startedAt) {
     logger.info(`Job run UUID is ${jobRunUuid}.`);
     core20.exportVariable("JOB_RUN_UUID" /* JOB_RUN_UUID */, jobRunUuid);
     core20.exportVariable("CODEQL_ACTION_INIT_HAS_RUN" /* INIT_ACTION_HAS_RUN */, "true");
-    configFile = getConfigFileInput(logger, actionsEnv, repositoryProperties);
+    const useConfigFileProperty = await features.getValue(
+      "config_file_repository_property" /* ConfigFileRepositoryProperty */
+    );
+    configFile = getConfigFileInput(
+      logger,
+      actionsEnv,
+      repositoryProperties,
+      useConfigFileProperty
+    );
     sourceRoot = path24.resolve(
       getRequiredEnvParam("GITHUB_WORKSPACE"),
       getOptionalInput("source-root") || ""
diff --git a/src/config/file.test.ts b/src/config/file.test.ts
index 4c511c1a70..1a4e7b4f5d 100644
--- a/src/config/file.test.ts
+++ b/src/config/file.test.ts
@@ -15,7 +15,7 @@ setupTests(test);
 test("getConfigFileInput returns undefined by default", async (t) => {
   const logger = new RecordingLogger();
   const actionsEnv = getTestActionsEnv();
-  const result = getConfigFileInput(logger, actionsEnv, {});
+  const result = getConfigFileInput(logger, actionsEnv, {}, true);
   t.is(result, undefined);
 });
 
@@ -34,7 +34,12 @@ test("getConfigFileInput returns input value", async (t) => {
 
   // Even though both an input and repository property are configured,
   // we prefer the direct input to the Action.
-  const result = getConfigFileInput(logger, actionsEnv, repositoryProperties);
+  const result = getConfigFileInput(
+    logger,
+    actionsEnv,
+    repositoryProperties,
+    true,
+  );
   t.is(result, testInput);
 
   // Check for the expected log message.
@@ -46,7 +51,12 @@ test("getConfigFileInput returns repository property value", async (t) => {
   const actionsEnv = getTestActionsEnv();
 
   // Since there is no direct input, we should use the repository property.
-  const result = getConfigFileInput(logger, actionsEnv, repositoryProperties);
+  const result = getConfigFileInput(
+    logger,
+    actionsEnv,
+    repositoryProperties,
+    true,
+  );
   t.is(result, repositoryProperties[RepositoryPropertyName.CONFIG_FILE]);
 
   // Check for the expected log message.
@@ -62,8 +72,13 @@ test("getConfigFileInput ignores empty repository property value", async (t) =>
   const actionsEnv = getTestActionsEnv();
 
   // Since the repository property value is an empty/whitespace string, we should ignore it.
-  const result = getConfigFileInput(logger, actionsEnv, {
-    [RepositoryPropertyName.CONFIG_FILE]: "   ",
-  });
+  const result = getConfigFileInput(
+    logger,
+    actionsEnv,
+    {
+      [RepositoryPropertyName.CONFIG_FILE]: "   ",
+    },
+    true,
+  );
   t.is(result, undefined);
 });
diff --git a/src/config/file.ts b/src/config/file.ts
index 24613dc557..9df95cc01f 100644
--- a/src/config/file.ts
+++ b/src/config/file.ts
@@ -12,6 +12,7 @@ export function getConfigFileInput(
   logger: Logger,
   actions: ActionsEnv,
   repositoryProperties: Partial<RepositoryProperties>,
+  useRepositoryProperty: boolean,
 ): string | undefined {
   const input = actions.getOptionalInput("config-file");
 
@@ -20,6 +21,11 @@ export function getConfigFileInput(
     return input;
   }
 
+  // Don't take the repository property into consideration if the FF is not enabled.
+  if (!useRepositoryProperty) {
+    return undefined;
+  }
+
   const propertyValue =
     repositoryProperties[RepositoryPropertyName.CONFIG_FILE];
 
diff --git a/src/init-action.ts b/src/init-action.ts
index 9c9b45556b..ec711cdf0b 100644
--- a/src/init-action.ts
+++ b/src/init-action.ts
@@ -263,7 +263,15 @@ async function run(startedAt: Date) {
 
     core.exportVariable(EnvVar.INIT_ACTION_HAS_RUN, "true");
 
-    configFile = getConfigFileInput(logger, actionsEnv, repositoryProperties);
+    const useConfigFileProperty = await features.getValue(
+      Feature.ConfigFileRepositoryProperty,
+    );
+    configFile = getConfigFileInput(
+      logger,
+      actionsEnv,
+      repositoryProperties,
+      useConfigFileProperty,
+    );
 
     // path.resolve() respects the intended semantics of source-root. If
     // source-root is relative, it is relative to the GITHUB_WORKSPACE. If

From f27f56386a3c745af8d7bbfb806098c714a5e32a Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Wed, 1 Jul 2026 15:55:57 +0100
Subject: [PATCH 63/65] Add test for when the FF is off

---
 src/config/file.test.ts | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/src/config/file.test.ts b/src/config/file.test.ts
index 1a4e7b4f5d..442d74e854 100644
--- a/src/config/file.test.ts
+++ b/src/config/file.test.ts
@@ -82,3 +82,23 @@ test("getConfigFileInput ignores empty repository property value", async (t) =>
   );
   t.is(result, undefined);
 });
+
+test("getConfigFileInput ignores repository property value when FF is off", async (t) => {
+  const logger = new RecordingLogger();
+  const actionsEnv = getTestActionsEnv();
+
+  // Since the FF is off, we should ignore the repository property value.
+  const result = getConfigFileInput(
+    logger,
+    actionsEnv,
+    repositoryProperties,
+    false,
+  );
+  t.is(result, undefined);
+
+  t.false(
+    logger.hasMessage(
+      "Using configuration file input from repository property",
+    ),
+  );
+});

From d5f0145480025b49d8b08c3f6b36e6ad41a68c90 Mon Sep 17 00:00:00 2001
From: "Michael B. Gale" <mbg@github.com>
Date: Wed, 1 Jul 2026 16:22:48 +0100
Subject: [PATCH 64/65] Log when repository property has a value but is ignored

---
 lib/entry-points.js     | 17 ++++++++++-------
 src/config/file.test.ts |  5 +++++
 src/config/file.ts      | 20 +++++++++++---------
 3 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/lib/entry-points.js b/lib/entry-points.js
index dcbb94c2f5..cdbd6ab82b 100644
--- a/lib/entry-points.js
+++ b/lib/entry-points.js
@@ -159658,15 +159658,18 @@ function getConfigFileInput(logger, actions, repositoryProperties, useRepository
     logger.info(`Using configuration file input from workflow: ${input}`);
     return input;
   }
-  if (!useRepositoryProperty) {
-    return void 0;
-  }
   const propertyValue = repositoryProperties["github-codeql-config-file" /* CONFIG_FILE */];
   if (propertyValue !== void 0 && propertyValue.trim().length > 0) {
-    logger.info(
-      `Using configuration file input from repository property: ${propertyValue}`
-    );
-    return propertyValue;
+    if (useRepositoryProperty) {
+      logger.info(
+        `Using configuration file input from repository property: ${propertyValue}`
+      );
+      return propertyValue;
+    } else {
+      logger.info(
+        "Ignoring configuration file input from repository property, because the corresponding feature flag is disabled."
+      );
+    }
   }
   return void 0;
 }
diff --git a/src/config/file.test.ts b/src/config/file.test.ts
index 442d74e854..fef6088297 100644
--- a/src/config/file.test.ts
+++ b/src/config/file.test.ts
@@ -101,4 +101,9 @@ test("getConfigFileInput ignores repository property value when FF is off", asyn
       "Using configuration file input from repository property",
     ),
   );
+  t.true(
+    logger.hasMessage(
+      "Ignoring configuration file input from repository property, because the corresponding feature flag is disabled.",
+    ),
+  );
 });
diff --git a/src/config/file.ts b/src/config/file.ts
index 9df95cc01f..6b8dfdcdcb 100644
--- a/src/config/file.ts
+++ b/src/config/file.ts
@@ -21,19 +21,21 @@ export function getConfigFileInput(
     return input;
   }
 
-  // Don't take the repository property into consideration if the FF is not enabled.
-  if (!useRepositoryProperty) {
-    return undefined;
-  }
-
   const propertyValue =
     repositoryProperties[RepositoryPropertyName.CONFIG_FILE];
 
   if (propertyValue !== undefined && propertyValue.trim().length > 0) {
-    logger.info(
-      `Using configuration file input from repository property: ${propertyValue}`,
-    );
-    return propertyValue;
+    // Only use the repository property value if the FF is enabled.
+    if (useRepositoryProperty) {
+      logger.info(
+        `Using configuration file input from repository property: ${propertyValue}`,
+      );
+      return propertyValue;
+    } else {
+      logger.info(
+        "Ignoring configuration file input from repository property, because the corresponding feature flag is disabled.",
+      );
+    }
   }
 
   return undefined;

From 2c9d3d63eb4941734e2d29468953529a56f5ff1c Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Wed, 1 Jul 2026 15:58:40 +0000
Subject: [PATCH 65/65] Update changelog for v4.36.3

---
 CHANGELOG.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1c0d6f84ea..cc4d169933 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,7 +2,7 @@
 
 See the [releases page](https://github.com/github/codeql-action/releases) for the relevant changes to the CodeQL CLI and language packs.
 
-## [UNRELEASED]
+## 4.36.3 - 01 Jul 2026
 
 No user facing changes.