@platforma-sdk/block-tools 2.5.91 → 2.6.0

package/dist/config-XBQ2O39y.mjs

@@ -0,0 +1,2020 @@
+var fs = Object.defineProperty;
+var us = (t, e, r) => e in t ? fs(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var X = (t, e, r) => us(t, typeof e != "symbol" ? e + "" : e, r);
+import { BlockPackMeta as V, ContentAbsoluteTextLocal as Ct, ContentAbsoluteBinaryLocal as le, BlockPackMetaEmbeddedBase64 as hs, BlockPackMetaEmbeddedBytes as Vr, DescriptionContentText as ps, DescriptionContentBinary as gs, ContentRelativeText as ee, ContentRelativeBinary as te, BlockComponents as fe, ContentAbsoluteFolder as ds, BlockComponentsManifest as ue, ContentRelative as oe, mapRemoteToAbsolute as zt, addPrefixToRelative as ms, BlockPackDescriptionManifest as J, CreateBlockPackDescriptionSchema as W, BlockPackManifest as Mr, BlockPackManifestFile as vs, SemVer as Tt, BlockPackDescriptionFromPackageJsonRaw as Xr, Sha256Schema as St, BlockPackIdNoVersion as Es, VersionWithChannels as $s, AnyChannel as ce, blockPackIdToString as Oe } from "@milaboratories/pl-model-middle-layer";
+import { z as L } from "zod";
+import B from "node:path";
+import z from "node:fs/promises";
+import * as he from "mime-types";
+import * as ws from "tar";
+import { tryResolve as Jr } from "@milaboratories/resolve-helper";
+import { notEmpty as Wr, ConsoleLoggerAdapter as Rs } from "@milaboratories/ts-helpers";
+import { gzip as Ss, gunzip as ys } from "node:zlib";
+import { promisify as Ut } from "node:util";
+import { extractConfigGeneric as Os } from "@milaboratories/pl-model-common";
+import { randomUUID as Hr } from "node:crypto";
+import Ps from "yaml";
+import * as Vt from "node:os";
+import U from "node:path/posix";
+import { S3 as Is, paginateListObjectsV2 as Ns } from "@aws-sdk/client-s3";
+import * as Q from "node:fs";
+function ks(t) {
+  return L.string().transform((e, r) => {
+    const s = Jr(t, e);
+    return s === void 0 ? (r.addIssue({
+      code: L.ZodIssueCode.custom,
+      message: `Can't resolve ${e} against ${t}`
+    }), L.NEVER) : {
+      type: "absolute-file",
+      file: s
+    };
+  });
+}
+function Ls(t, ...e) {
+  return L.string().transform((r, s) => {
+    const i = r.endsWith("/") ? r : `${r}/`;
+    for (const l of e) {
+      const a = Jr(t, i + l);
+      if (a !== void 0) {
+        if (!a.endsWith(l))
+          throw new Error(`Unexpected resolve result ${a} with index file ${l}`);
+        return {
+          type: "absolute-folder",
+          folder: a.slice(0, a.length - l.length)
+        };
+      }
+    }
+    return s.addIssue({
+      code: L.ZodIssueCode.custom,
+      message: `Can't resolve ${r} folder against ${t}, no index file found (${e.join(", ")})`
+    }), L.NEVER;
+  });
+}
+function Mt(t) {
+  return (e) => e.type === "relative" ? { type: "absolute-file", file: B.resolve(t, e.path) } : e;
+}
+function Yr() {
+  return async (t) => t.type === "absolute-file" ? await z.readFile(t.file, { encoding: "utf-8" }) : t.content;
+}
+function Cs() {
+  return async (t) => {
+    if (t.type === "absolute-file") {
+      const e = he.lookup(t.file);
+      if (!e) throw new Error(`Can't recognize mime type of the file: ${t.file}.`);
+      return {
+        type: "explicit-base64",
+        mimeType: e,
+        content: await z.readFile(t.file, { encoding: "base64" })
+      };
+    } else return t;
+  };
+}
+function Ts() {
+  return async (t) => {
+    if (t.type === "absolute-file") {
+      const e = he.lookup(t.file);
+      if (!e) throw new Error(`Can't recognize mime type of the file: ${t.file}.`);
+      return {
+        type: "explicit-bytes",
+        mimeType: e,
+        content: Buffer.from(await z.readFile(t.file))
+      };
+    } else return t.type === "explicit-base64" ? {
+      type: "explicit-bytes",
+      mimeType: t.mimeType,
+      content: Buffer.from(t.content, "base64")
+    } : t;
+  };
+}
+function yt(t, e) {
+  return async (r) => {
+    if (r.type === "absolute-file") {
+      const s = B.basename(r.file), i = B.resolve(t, s);
+      return e == null || e.push(s), await z.cp(r.file, i), { type: "relative", path: s };
+    } else return r;
+  };
+}
+function As(t, e, r) {
+  if (!e.endsWith(".tgz")) throw new Error(`Unexpected tgz file name: ${e}`);
+  return async (s) => {
+    const i = B.resolve(t, e);
+    return await ws.create(
+      {
+        gzip: !0,
+        file: i,
+        cwd: s.folder
+      },
+      ["."]
+    ), r == null || r.push(e), { type: "relative", path: e };
+  };
+}
+function At(t) {
+  return async (e) => e.type === "explicit-string" ? e : { type: "explicit-string", content: (await t(e.path)).toString("utf8") };
+}
+function Fs(t) {
+  return async (e) => e.type === "explicit-string" ? e.content : (await t(e.path)).toString("utf8");
+}
+function si(t) {
+  return async (e) => {
+    if (e.type === "explicit-base64") return e;
+    const r = he.lookup(e.path);
+    if (!r) throw new Error(`Can't recognize mime type of the file: ${e.path}.`);
+    return {
+      type: "explicit-base64",
+      mimeType: r,
+      content: (await t(e.path)).toString("base64")
+    };
+  };
+}
+function pe(t) {
+  return async (e) => {
+    if (e.type === "explicit-base64")
+      return {
+        type: "explicit-bytes",
+        mimeType: e.mimeType,
+        content: Buffer.from(e.content, "base64")
+      };
+    const r = he.lookup(e.path);
+    if (!r) throw new Error(`Can't recognize mime type of the file: ${e.path}.`);
+    return {
+      type: "explicit-bytes",
+      mimeType: r,
+      content: await t(e.path)
+    };
+  };
+}
+function bs(t) {
+  return V(
+    ps.transform(Mt(t)),
+    gs.transform(Mt(t))
+  );
+}
+function qs(t, e) {
+  return V(
+    Ct.transform(yt(t, e)),
+    le.transform(yt(t, e))
+  );
+}
+const ni = V(
+  Ct.transform(Yr()),
+  le.transform(Cs())
+).pipe(hs), ii = V(
+  Ct.transform(Yr()),
+  le.transform(Ts())
+).pipe(Vr);
+function ai(t) {
+  return V(
+    ee.transform(Fs(t)),
+    te.transform(pe(t))
+  ).pipe(Vr);
+}
+function Ds(t) {
+  return fe(
+    ks(t),
+    Ls(t, "index.html")
+  );
+}
+function Bs(t, e) {
+  return fe(
+    le.transform(yt(t, e)),
+    ds.transform(As(t, "ui.tgz", e))
+  ).pipe(ue);
+}
+function oi(t) {
+  return fe(
+    oe.transform(zt(t)),
+    oe.transform(zt(t))
+  );
+}
+function Zr(t) {
+  return W(
+    Ds(t),
+    bs(t)
+  ).transform(async (e, r) => {
+    const i = Os(JSON.parse(await z.readFile(e.components.model.file, "utf-8"))).featureFlags;
+    return {
+      ...e,
+      featureFlags: i
+    };
+  });
+}
+function Gs(t, e) {
+  return W(
+    Bs(t, e),
+    qs(t, e)
+  ).pipe(J);
+}
+function Xt(t) {
+  const e = ms(t);
+  return J.pipe(
+    W(
+      fe(
+        oe.transform(e),
+        oe.transform(e)
+      ),
+      V(
+        ee.transform(e),
+        te.transform(e)
+      )
+    )
+  ).pipe(J);
+}
+async function Ft(t, e) {
+  try {
+    return e(await z.readFile(t));
+  } catch (r) {
+    if (r.code == "ENOENT") return;
+    throw new Error("", { cause: r });
+  }
+}
+async function Ot(t) {
+  return Buffer.from(await crypto.subtle.digest("sha-256", t)).toString("hex").toUpperCase();
+}
+async function ci(t, e) {
+  await z.mkdir(e, { recursive: !0 });
+  const r = [], s = await Gs(e, r).parseAsync(t), i = await Promise.all(
+    r.map(async (a) => {
+      const h = await z.readFile(B.resolve(e, a)), c = await Ot(h);
+      return { name: a, size: h.length, sha256: c };
+    })
+  ), l = Mr.parse({
+    schema: "v2",
+    description: {
+      ...s
+    },
+    files: i,
+    timestamp: Date.now()
+  });
+  return await z.writeFile(B.resolve(e, vs), JSON.stringify(l)), l;
+}
+const Pt = "block", _s = /(?:@[a-zA-Z0-9-.]+\/)?(?<organization>[a-zA-Z0-9-]+)\.(?<name>[a-zA-Z0-9-]+)/;
+function Kr(t) {
+  const e = t.match(_s);
+  if (!e)
+    throw new Error(
+      `Malformed package name (${t}), can't infer organization and block pack name.`
+    );
+  const { name: r, organization: s } = e.groups;
+  return { name: r, organization: s };
+}
+async function li(t, e) {
+  const r = B.resolve(t, "package.json");
+  try {
+    const s = await Ft(
+      r,
+      (h) => JSON.parse(h.toString("utf-8"))
+    );
+    if (s === void 0) return;
+    const i = s[Pt];
+    if (i === void 0) return;
+    const l = {
+      ...Xr.parse(i),
+      id: {
+        ...Kr(
+          Wr(s.name, `"name" not found in ${r}`)
+        ),
+        version: Tt.parse(s.version)
+      }
+    }, a = await Zr(t).safeParseAsync(l);
+    if (a.success) return a.data;
+    e == null || e.warn(a.error);
+    return;
+  } catch (s) {
+    e == null || e.warn(s);
+    return;
+  }
+}
+async function js(t) {
+  const e = B.resolve(t, "package.json"), r = JSON.parse(await z.readFile(e, { encoding: "utf-8" })), s = r[Pt];
+  if (s === void 0)
+    throw new Error(
+      `Block description (field ${Pt}) not found in ${e}.`
+    );
+  return {
+    ...Xr.parse(s),
+    id: {
+      ...Kr(
+        Wr(r.name, `"name" not found in ${e}`)
+      ),
+      version: Tt.parse(r.version)
+    },
+    featureFlags: {}
+  };
+}
+async function fi(t) {
+  const e = await js(t);
+  return await Zr(t).parseAsync(e);
+}
+function xs(t) {
+  return t && t.__esModule && Object.prototype.hasOwnProperty.call(t, "default") ? t.default : t;
+}
+var se = { exports: {} }, Pe, Jt;
+function ge() {
+  if (Jt) return Pe;
+  Jt = 1;
+  const t = "2.0.0", e = 256, r = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+  9007199254740991, s = 16, i = e - 6;
+  return Pe = {
+    MAX_LENGTH: e,
+    MAX_SAFE_COMPONENT_LENGTH: s,
+    MAX_SAFE_BUILD_LENGTH: i,
+    MAX_SAFE_INTEGER: r,
+    RELEASE_TYPES: [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ],
+    SEMVER_SPEC_VERSION: t,
+    FLAG_INCLUDE_PRERELEASE: 1,
+    FLAG_LOOSE: 2
+  }, Pe;
+}
+var Ie, Wt;
+function de() {
+  return Wt || (Wt = 1, Ie = typeof process == "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...e) => console.error("SEMVER", ...e) : () => {
+  }), Ie;
+}
+var Ht;
+function re() {
+  return Ht || (Ht = 1, function(t, e) {
+    const {
+      MAX_SAFE_COMPONENT_LENGTH: r,
+      MAX_SAFE_BUILD_LENGTH: s,
+      MAX_LENGTH: i
+    } = ge(), l = de();
+    e = t.exports = {};
+    const a = e.re = [], h = e.safeRe = [], c = e.src = [], o = e.safeSrc = [], n = e.t = {};
+    let f = 0;
+    const u = "[a-zA-Z0-9-]", g = [
+      ["\\s", 1],
+      ["\\d", i],
+      [u, s]
+    ], m = (S) => {
+      for (const [P, w] of g)
+        S = S.split(`${P}*`).join(`${P}{0,${w}}`).split(`${P}+`).join(`${P}{1,${w}}`);
+      return S;
+    }, p = (S, P, w) => {
+      const R = m(P), T = f++;
+      l(S, T, P), n[S] = T, c[T] = P, o[T] = R, a[T] = new RegExp(P, w ? "g" : void 0), h[T] = new RegExp(R, w ? "g" : void 0);
+    };
+    p("NUMERICIDENTIFIER", "0|[1-9]\\d*"), p("NUMERICIDENTIFIERLOOSE", "\\d+"), p("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${u}*`), p("MAINVERSION", `(${c[n.NUMERICIDENTIFIER]})\\.(${c[n.NUMERICIDENTIFIER]})\\.(${c[n.NUMERICIDENTIFIER]})`), p("MAINVERSIONLOOSE", `(${c[n.NUMERICIDENTIFIERLOOSE]})\\.(${c[n.NUMERICIDENTIFIERLOOSE]})\\.(${c[n.NUMERICIDENTIFIERLOOSE]})`), p("PRERELEASEIDENTIFIER", `(?:${c[n.NONNUMERICIDENTIFIER]}|${c[n.NUMERICIDENTIFIER]})`), p("PRERELEASEIDENTIFIERLOOSE", `(?:${c[n.NONNUMERICIDENTIFIER]}|${c[n.NUMERICIDENTIFIERLOOSE]})`), p("PRERELEASE", `(?:-(${c[n.PRERELEASEIDENTIFIER]}(?:\\.${c[n.PRERELEASEIDENTIFIER]})*))`), p("PRERELEASELOOSE", `(?:-?(${c[n.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${c[n.PRERELEASEIDENTIFIERLOOSE]})*))`), p("BUILDIDENTIFIER", `${u}+`), p("BUILD", `(?:\\+(${c[n.BUILDIDENTIFIER]}(?:\\.${c[n.BUILDIDENTIFIER]})*))`), p("FULLPLAIN", `v?${c[n.MAINVERSION]}${c[n.PRERELEASE]}?${c[n.BUILD]}?`), p("FULL", `^${c[n.FULLPLAIN]}$`), p("LOOSEPLAIN", `[v=\\s]*${c[n.MAINVERSIONLOOSE]}${c[n.PRERELEASELOOSE]}?${c[n.BUILD]}?`), p("LOOSE", `^${c[n.LOOSEPLAIN]}$`), p("GTLT", "((?:<|>)?=?)"), p("XRANGEIDENTIFIERLOOSE", `${c[n.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), p("XRANGEIDENTIFIER", `${c[n.NUMERICIDENTIFIER]}|x|X|\\*`), p("XRANGEPLAIN", `[v=\\s]*(${c[n.XRANGEIDENTIFIER]})(?:\\.(${c[n.XRANGEIDENTIFIER]})(?:\\.(${c[n.XRANGEIDENTIFIER]})(?:${c[n.PRERELEASE]})?${c[n.BUILD]}?)?)?`), p("XRANGEPLAINLOOSE", `[v=\\s]*(${c[n.XRANGEIDENTIFIERLOOSE]})(?:\\.(${c[n.XRANGEIDENTIFIERLOOSE]})(?:\\.(${c[n.XRANGEIDENTIFIERLOOSE]})(?:${c[n.PRERELEASELOOSE]})?${c[n.BUILD]}?)?)?`), p("XRANGE", `^${c[n.GTLT]}\\s*${c[n.XRANGEPLAIN]}$`), p("XRANGELOOSE", `^${c[n.GTLT]}\\s*${c[n.XRANGEPLAINLOOSE]}$`), p("COERCEPLAIN", `(^|[^\\d])(\\d{1,${r}})(?:\\.(\\d{1,${r}}))?(?:\\.(\\d{1,${r}}))?`), p("COERCE", `${c[n.COERCEPLAIN]}(?:$|[^\\d])`), p("COERCEFULL", c[n.COERCEPLAIN] + `(?:${c[n.PRERELEASE]})?(?:${c[n.BUILD]})?(?:$|[^\\d])`), p("COERCERTL", c[n.COERCE], !0), p("COERCERTLFULL", c[n.COERCEFULL], !0), p("LONETILDE", "(?:~>?)"), p("TILDETRIM", `(\\s*)${c[n.LONETILDE]}\\s+`, !0), e.tildeTrimReplace = "$1~", p("TILDE", `^${c[n.LONETILDE]}${c[n.XRANGEPLAIN]}$`), p("TILDELOOSE", `^${c[n.LONETILDE]}${c[n.XRANGEPLAINLOOSE]}$`), p("LONECARET", "(?:\\^)"), p("CARETTRIM", `(\\s*)${c[n.LONECARET]}\\s+`, !0), e.caretTrimReplace = "$1^", p("CARET", `^${c[n.LONECARET]}${c[n.XRANGEPLAIN]}$`), p("CARETLOOSE", `^${c[n.LONECARET]}${c[n.XRANGEPLAINLOOSE]}$`), p("COMPARATORLOOSE", `^${c[n.GTLT]}\\s*(${c[n.LOOSEPLAIN]})$|^$`), p("COMPARATOR", `^${c[n.GTLT]}\\s*(${c[n.FULLPLAIN]})$|^$`), p("COMPARATORTRIM", `(\\s*)${c[n.GTLT]}\\s*(${c[n.LOOSEPLAIN]}|${c[n.XRANGEPLAIN]})`, !0), e.comparatorTrimReplace = "$1$2$3", p("HYPHENRANGE", `^\\s*(${c[n.XRANGEPLAIN]})\\s+-\\s+(${c[n.XRANGEPLAIN]})\\s*$`), p("HYPHENRANGELOOSE", `^\\s*(${c[n.XRANGEPLAINLOOSE]})\\s+-\\s+(${c[n.XRANGEPLAINLOOSE]})\\s*$`), p("STAR", "(<|>)?=?\\s*\\*"), p("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), p("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  }(se, se.exports)), se.exports;
+}
+var Ne, Yt;
+function bt() {
+  if (Yt) return Ne;
+  Yt = 1;
+  const t = Object.freeze({ loose: !0 }), e = Object.freeze({});
+  return Ne = (s) => s ? typeof s != "object" ? t : s : e, Ne;
+}
+var ke, Zt;
+function Qr() {
+  if (Zt) return ke;
+  Zt = 1;
+  const t = /^[0-9]+$/, e = (s, i) => {
+    const l = t.test(s), a = t.test(i);
+    return l && a && (s = +s, i = +i), s === i ? 0 : l && !a ? -1 : a && !l ? 1 : s < i ? -1 : 1;
+  };
+  return ke = {
+    compareIdentifiers: e,
+    rcompareIdentifiers: (s, i) => e(i, s)
+  }, ke;
+}
+var Le, Kt;
+function _() {
+  if (Kt) return Le;
+  Kt = 1;
+  const t = de(), { MAX_LENGTH: e, MAX_SAFE_INTEGER: r } = ge(), { safeRe: s, t: i } = re(), l = bt(), { compareIdentifiers: a } = Qr();
+  class h {
+    constructor(o, n) {
+      if (n = l(n), o instanceof h) {
+        if (o.loose === !!n.loose && o.includePrerelease === !!n.includePrerelease)
+          return o;
+        o = o.version;
+      } else if (typeof o != "string")
+        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof o}".`);
+      if (o.length > e)
+        throw new TypeError(
+          `version is longer than ${e} characters`
+        );
+      t("SemVer", o, n), this.options = n, this.loose = !!n.loose, this.includePrerelease = !!n.includePrerelease;
+      const f = o.trim().match(n.loose ? s[i.LOOSE] : s[i.FULL]);
+      if (!f)
+        throw new TypeError(`Invalid Version: ${o}`);
+      if (this.raw = o, this.major = +f[1], this.minor = +f[2], this.patch = +f[3], this.major > r || this.major < 0)
+        throw new TypeError("Invalid major version");
+      if (this.minor > r || this.minor < 0)
+        throw new TypeError("Invalid minor version");
+      if (this.patch > r || this.patch < 0)
+        throw new TypeError("Invalid patch version");
+      f[4] ? this.prerelease = f[4].split(".").map((u) => {
+        if (/^[0-9]+$/.test(u)) {
+          const g = +u;
+          if (g >= 0 && g < r)
+            return g;
+        }
+        return u;
+      }) : this.prerelease = [], this.build = f[5] ? f[5].split(".") : [], this.format();
+    }
+    format() {
+      return this.version = `${this.major}.${this.minor}.${this.patch}`, this.prerelease.length && (this.version += `-${this.prerelease.join(".")}`), this.version;
+    }
+    toString() {
+      return this.version;
+    }
+    compare(o) {
+      if (t("SemVer.compare", this.version, this.options, o), !(o instanceof h)) {
+        if (typeof o == "string" && o === this.version)
+          return 0;
+        o = new h(o, this.options);
+      }
+      return o.version === this.version ? 0 : this.compareMain(o) || this.comparePre(o);
+    }
+    compareMain(o) {
+      return o instanceof h || (o = new h(o, this.options)), a(this.major, o.major) || a(this.minor, o.minor) || a(this.patch, o.patch);
+    }
+    comparePre(o) {
+      if (o instanceof h || (o = new h(o, this.options)), this.prerelease.length && !o.prerelease.length)
+        return -1;
+      if (!this.prerelease.length && o.prerelease.length)
+        return 1;
+      if (!this.prerelease.length && !o.prerelease.length)
+        return 0;
+      let n = 0;
+      do {
+        const f = this.prerelease[n], u = o.prerelease[n];
+        if (t("prerelease compare", n, f, u), f === void 0 && u === void 0)
+          return 0;
+        if (u === void 0)
+          return 1;
+        if (f === void 0)
+          return -1;
+        if (f === u)
+          continue;
+        return a(f, u);
+      } while (++n);
+    }
+    compareBuild(o) {
+      o instanceof h || (o = new h(o, this.options));
+      let n = 0;
+      do {
+        const f = this.build[n], u = o.build[n];
+        if (t("build compare", n, f, u), f === void 0 && u === void 0)
+          return 0;
+        if (u === void 0)
+          return 1;
+        if (f === void 0)
+          return -1;
+        if (f === u)
+          continue;
+        return a(f, u);
+      } while (++n);
+    }
+    // preminor will bump the version up to the next minor release, and immediately
+    // down to pre-release. premajor and prepatch work the same way.
+    inc(o, n, f) {
+      if (o.startsWith("pre")) {
+        if (!n && f === !1)
+          throw new Error("invalid increment argument: identifier is empty");
+        if (n) {
+          const u = `-${n}`.match(this.options.loose ? s[i.PRERELEASELOOSE] : s[i.PRERELEASE]);
+          if (!u || u[1] !== n)
+            throw new Error(`invalid identifier: ${n}`);
+        }
+      }
+      switch (o) {
+        case "premajor":
+          this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", n, f);
+          break;
+        case "preminor":
+          this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", n, f);
+          break;
+        case "prepatch":
+          this.prerelease.length = 0, this.inc("patch", n, f), this.inc("pre", n, f);
+          break;
+        // If the input is a non-prerelease version, this acts the same as
+        // prepatch.
+        case "prerelease":
+          this.prerelease.length === 0 && this.inc("patch", n, f), this.inc("pre", n, f);
+          break;
+        case "release":
+          if (this.prerelease.length === 0)
+            throw new Error(`version ${this.raw} is not a prerelease`);
+          this.prerelease.length = 0;
+          break;
+        case "major":
+          (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) && this.major++, this.minor = 0, this.patch = 0, this.prerelease = [];
+          break;
+        case "minor":
+          (this.patch !== 0 || this.prerelease.length === 0) && this.minor++, this.patch = 0, this.prerelease = [];
+          break;
+        case "patch":
+          this.prerelease.length === 0 && this.patch++, this.prerelease = [];
+          break;
+        // This probably shouldn't be used publicly.
+        // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+        case "pre": {
+          const u = Number(f) ? 1 : 0;
+          if (this.prerelease.length === 0)
+            this.prerelease = [u];
+          else {
+            let g = this.prerelease.length;
+            for (; --g >= 0; )
+              typeof this.prerelease[g] == "number" && (this.prerelease[g]++, g = -2);
+            if (g === -1) {
+              if (n === this.prerelease.join(".") && f === !1)
+                throw new Error("invalid increment argument: identifier already exists");
+              this.prerelease.push(u);
+            }
+          }
+          if (n) {
+            let g = [n, u];
+            f === !1 && (g = [n]), a(this.prerelease[0], n) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = g) : this.prerelease = g;
+          }
+          break;
+        }
+        default:
+          throw new Error(`invalid increment argument: ${o}`);
+      }
+      return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), this;
+    }
+  }
+  return Le = h, Le;
+}
+var Ce, Qt;
+function H() {
+  if (Qt) return Ce;
+  Qt = 1;
+  const t = _();
+  return Ce = (r, s, i = !1) => {
+    if (r instanceof t)
+      return r;
+    try {
+      return new t(r, s);
+    } catch (l) {
+      if (!i)
+        return null;
+      throw l;
+    }
+  }, Ce;
+}
+var Te, er;
+function zs() {
+  if (er) return Te;
+  er = 1;
+  const t = H();
+  return Te = (r, s) => {
+    const i = t(r, s);
+    return i ? i.version : null;
+  }, Te;
+}
+var Ae, tr;
+function Us() {
+  if (tr) return Ae;
+  tr = 1;
+  const t = H();
+  return Ae = (r, s) => {
+    const i = t(r.trim().replace(/^[=v]+/, ""), s);
+    return i ? i.version : null;
+  }, Ae;
+}
+var Fe, rr;
+function Vs() {
+  if (rr) return Fe;
+  rr = 1;
+  const t = _();
+  return Fe = (r, s, i, l, a) => {
+    typeof i == "string" && (a = l, l = i, i = void 0);
+    try {
+      return new t(
+        r instanceof t ? r.version : r,
+        i
+      ).inc(s, l, a).version;
+    } catch {
+      return null;
+    }
+  }, Fe;
+}
+var be, sr;
+function Ms() {
+  if (sr) return be;
+  sr = 1;
+  const t = H();
+  return be = (r, s) => {
+    const i = t(r, null, !0), l = t(s, null, !0), a = i.compare(l);
+    if (a === 0)
+      return null;
+    const h = a > 0, c = h ? i : l, o = h ? l : i, n = !!c.prerelease.length;
+    if (!!o.prerelease.length && !n) {
+      if (!o.patch && !o.minor)
+        return "major";
+      if (o.compareMain(c) === 0)
+        return o.minor && !o.patch ? "minor" : "patch";
+    }
+    const u = n ? "pre" : "";
+    return i.major !== l.major ? u + "major" : i.minor !== l.minor ? u + "minor" : i.patch !== l.patch ? u + "patch" : "prerelease";
+  }, be;
+}
+var qe, nr;
+function Xs() {
+  if (nr) return qe;
+  nr = 1;
+  const t = _();
+  return qe = (r, s) => new t(r, s).major, qe;
+}
+var De, ir;
+function Js() {
+  if (ir) return De;
+  ir = 1;
+  const t = _();
+  return De = (r, s) => new t(r, s).minor, De;
+}
+var Be, ar;
+function Ws() {
+  if (ar) return Be;
+  ar = 1;
+  const t = _();
+  return Be = (r, s) => new t(r, s).patch, Be;
+}
+var Ge, or;
+function Hs() {
+  if (or) return Ge;
+  or = 1;
+  const t = H();
+  return Ge = (r, s) => {
+    const i = t(r, s);
+    return i && i.prerelease.length ? i.prerelease : null;
+  }, Ge;
+}
+var _e, cr;
+function j() {
+  if (cr) return _e;
+  cr = 1;
+  const t = _();
+  return _e = (r, s, i) => new t(r, i).compare(new t(s, i)), _e;
+}
+var je, lr;
+function Ys() {
+  if (lr) return je;
+  lr = 1;
+  const t = j();
+  return je = (r, s, i) => t(s, r, i), je;
+}
+var xe, fr;
+function Zs() {
+  if (fr) return xe;
+  fr = 1;
+  const t = j();
+  return xe = (r, s) => t(r, s, !0), xe;
+}
+var ze, ur;
+function qt() {
+  if (ur) return ze;
+  ur = 1;
+  const t = _();
+  return ze = (r, s, i) => {
+    const l = new t(r, i), a = new t(s, i);
+    return l.compare(a) || l.compareBuild(a);
+  }, ze;
+}
+var Ue, hr;
+function Ks() {
+  if (hr) return Ue;
+  hr = 1;
+  const t = qt();
+  return Ue = (r, s) => r.sort((i, l) => t(i, l, s)), Ue;
+}
+var Ve, pr;
+function Qs() {
+  if (pr) return Ve;
+  pr = 1;
+  const t = qt();
+  return Ve = (r, s) => r.sort((i, l) => t(l, i, s)), Ve;
+}
+var Me, gr;
+function me() {
+  if (gr) return Me;
+  gr = 1;
+  const t = j();
+  return Me = (r, s, i) => t(r, s, i) > 0, Me;
+}
+var Xe, dr;
+function Dt() {
+  if (dr) return Xe;
+  dr = 1;
+  const t = j();
+  return Xe = (r, s, i) => t(r, s, i) < 0, Xe;
+}
+var Je, mr;
+function es() {
+  if (mr) return Je;
+  mr = 1;
+  const t = j();
+  return Je = (r, s, i) => t(r, s, i) === 0, Je;
+}
+var We, vr;
+function ts() {
+  if (vr) return We;
+  vr = 1;
+  const t = j();
+  return We = (r, s, i) => t(r, s, i) !== 0, We;
+}
+var He, Er;
+function Bt() {
+  if (Er) return He;
+  Er = 1;
+  const t = j();
+  return He = (r, s, i) => t(r, s, i) >= 0, He;
+}
+var Ye, $r;
+function Gt() {
+  if ($r) return Ye;
+  $r = 1;
+  const t = j();
+  return Ye = (r, s, i) => t(r, s, i) <= 0, Ye;
+}
+var Ze, wr;
+function rs() {
+  if (wr) return Ze;
+  wr = 1;
+  const t = es(), e = ts(), r = me(), s = Bt(), i = Dt(), l = Gt();
+  return Ze = (h, c, o, n) => {
+    switch (c) {
+      case "===":
+        return typeof h == "object" && (h = h.version), typeof o == "object" && (o = o.version), h === o;
+      case "!==":
+        return typeof h == "object" && (h = h.version), typeof o == "object" && (o = o.version), h !== o;
+      case "":
+      case "=":
+      case "==":
+        return t(h, o, n);
+      case "!=":
+        return e(h, o, n);
+      case ">":
+        return r(h, o, n);
+      case ">=":
+        return s(h, o, n);
+      case "<":
+        return i(h, o, n);
+      case "<=":
+        return l(h, o, n);
+      default:
+        throw new TypeError(`Invalid operator: ${c}`);
+    }
+  }, Ze;
+}
+var Ke, Rr;
+function en() {
+  if (Rr) return Ke;
+  Rr = 1;
+  const t = _(), e = H(), { safeRe: r, t: s } = re();
+  return Ke = (l, a) => {
+    if (l instanceof t)
+      return l;
+    if (typeof l == "number" && (l = String(l)), typeof l != "string")
+      return null;
+    a = a || {};
+    let h = null;
+    if (!a.rtl)
+      h = l.match(a.includePrerelease ? r[s.COERCEFULL] : r[s.COERCE]);
+    else {
+      const g = a.includePrerelease ? r[s.COERCERTLFULL] : r[s.COERCERTL];
+      let m;
+      for (; (m = g.exec(l)) && (!h || h.index + h[0].length !== l.length); )
+        (!h || m.index + m[0].length !== h.index + h[0].length) && (h = m), g.lastIndex = m.index + m[1].length + m[2].length;
+      g.lastIndex = -1;
+    }
+    if (h === null)
+      return null;
+    const c = h[2], o = h[3] || "0", n = h[4] || "0", f = a.includePrerelease && h[5] ? `-${h[5]}` : "", u = a.includePrerelease && h[6] ? `+${h[6]}` : "";
+    return e(`${c}.${o}.${n}${f}${u}`, a);
+  }, Ke;
+}
+var Qe, Sr;
+function tn() {
+  if (Sr) return Qe;
+  Sr = 1;
+  class t {
+    constructor() {
+      this.max = 1e3, this.map = /* @__PURE__ */ new Map();
+    }
+    get(r) {
+      const s = this.map.get(r);
+      if (s !== void 0)
+        return this.map.delete(r), this.map.set(r, s), s;
+    }
+    delete(r) {
+      return this.map.delete(r);
+    }
+    set(r, s) {
+      if (!this.delete(r) && s !== void 0) {
+        if (this.map.size >= this.max) {
+          const l = this.map.keys().next().value;
+          this.delete(l);
+        }
+        this.map.set(r, s);
+      }
+      return this;
+    }
+  }
+  return Qe = t, Qe;
+}
+var et, yr;
+function x() {
+  if (yr) return et;
+  yr = 1;
+  const t = /\s+/g;
+  class e {
+    constructor(d, y) {
+      if (y = i(y), d instanceof e)
+        return d.loose === !!y.loose && d.includePrerelease === !!y.includePrerelease ? d : new e(d.raw, y);
+      if (d instanceof l)
+        return this.raw = d.value, this.set = [[d]], this.formatted = void 0, this;
+      if (this.options = y, this.loose = !!y.loose, this.includePrerelease = !!y.includePrerelease, this.raw = d.trim().replace(t, " "), this.set = this.raw.split("||").map((E) => this.parseRange(E.trim())).filter((E) => E.length), !this.set.length)
+        throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+      if (this.set.length > 1) {
+        const E = this.set[0];
+        if (this.set = this.set.filter((O) => !p(O[0])), this.set.length === 0)
+          this.set = [E];
+        else if (this.set.length > 1) {
+          for (const O of this.set)
+            if (O.length === 1 && S(O[0])) {
+              this.set = [O];
+              break;
+            }
+        }
+      }
+      this.formatted = void 0;
+    }
+    get range() {
+      if (this.formatted === void 0) {
+        this.formatted = "";
+        for (let d = 0; d < this.set.length; d++) {
+          d > 0 && (this.formatted += "||");
+          const y = this.set[d];
+          for (let E = 0; E < y.length; E++)
+            E > 0 && (this.formatted += " "), this.formatted += y[E].toString().trim();
+        }
+      }
+      return this.formatted;
+    }
+    format() {
+      return this.range;
+    }
+    toString() {
+      return this.range;
+    }
+    parseRange(d) {
+      const E = ((this.options.includePrerelease && g) | (this.options.loose && m)) + ":" + d, O = s.get(E);
+      if (O)
+        return O;
+      const $ = this.options.loose, N = $ ? c[o.HYPHENRANGELOOSE] : c[o.HYPHENRANGE];
+      d = d.replace(N, Se(this.options.includePrerelease)), a("hyphen replace", d), d = d.replace(c[o.COMPARATORTRIM], n), a("comparator trim", d), d = d.replace(c[o.TILDETRIM], f), a("tilde trim", d), d = d.replace(c[o.CARETTRIM], u), a("caret trim", d);
+      let C = d.split(" ").map((D) => w(D, this.options)).join(" ").split(/\s+/).map((D) => Re(D, this.options));
+      $ && (C = C.filter((D) => (a("loose invalid filter", D, this.options), !!D.match(c[o.COMPARATORLOOSE])))), a("range list", C);
+      const k = /* @__PURE__ */ new Map(), F = C.map((D) => new l(D, this.options));
+      for (const D of F) {
+        if (p(D))
+          return [D];
+        k.set(D.value, D);
+      }
+      k.size > 1 && k.has("") && k.delete("");
+      const G = [...k.values()];
+      return s.set(E, G), G;
+    }
+    intersects(d, y) {
+      if (!(d instanceof e))
+        throw new TypeError("a Range is required");
+      return this.set.some((E) => P(E, y) && d.set.some((O) => P(O, y) && E.every(($) => O.every((N) => $.intersects(N, y)))));
+    }
+    // if ANY of the sets match ALL of its comparators, then pass
+    test(d) {
+      if (!d)
+        return !1;
+      if (typeof d == "string")
+        try {
+          d = new h(d, this.options);
+        } catch {
+          return !1;
+        }
+      for (let y = 0; y < this.set.length; y++)
+        if (ye(this.set[y], d, this.options))
+          return !0;
+      return !1;
+    }
+  }
+  et = e;
+  const r = tn(), s = new r(), i = bt(), l = ve(), a = de(), h = _(), {
+    safeRe: c,
+    t: o,
+    comparatorTrimReplace: n,
+    tildeTrimReplace: f,
+    caretTrimReplace: u
+  } = re(), { FLAG_INCLUDE_PRERELEASE: g, FLAG_LOOSE: m } = ge(), p = (v) => v.value === "<0.0.0-0", S = (v) => v.value === "", P = (v, d) => {
+    let y = !0;
+    const E = v.slice();
+    let O = E.pop();
+    for (; y && E.length; )
+      y = E.every(($) => O.intersects($, d)), O = E.pop();
+    return y;
+  }, w = (v, d) => (a("comp", v, d), v = A(v, d), a("caret", v), v = T(v, d), a("tildes", v), v = I(v, d), a("xrange", v), v = we(v, d), a("stars", v), v), R = (v) => !v || v.toLowerCase() === "x" || v === "*", T = (v, d) => v.trim().split(/\s+/).map((y) => b(y, d)).join(" "), b = (v, d) => {
+    const y = d.loose ? c[o.TILDELOOSE] : c[o.TILDE];
+    return v.replace(y, (E, O, $, N, C) => {
+      a("tilde", v, E, O, $, N, C);
+      let k;
+      return R(O) ? k = "" : R($) ? k = `>=${O}.0.0 <${+O + 1}.0.0-0` : R(N) ? k = `>=${O}.${$}.0 <${O}.${+$ + 1}.0-0` : C ? (a("replaceTilde pr", C), k = `>=${O}.${$}.${N}-${C} <${O}.${+$ + 1}.0-0`) : k = `>=${O}.${$}.${N} <${O}.${+$ + 1}.0-0`, a("tilde return", k), k;
+    });
+  }, A = (v, d) => v.trim().split(/\s+/).map((y) => q(y, d)).join(" "), q = (v, d) => {
+    a("caret", v, d);
+    const y = d.loose ? c[o.CARETLOOSE] : c[o.CARET], E = d.includePrerelease ? "-0" : "";
+    return v.replace(y, (O, $, N, C, k) => {
+      a("caret", v, O, $, N, C, k);
+      let F;
+      return R($) ? F = "" : R(N) ? F = `>=${$}.0.0${E} <${+$ + 1}.0.0-0` : R(C) ? $ === "0" ? F = `>=${$}.${N}.0${E} <${$}.${+N + 1}.0-0` : F = `>=${$}.${N}.0${E} <${+$ + 1}.0.0-0` : k ? (a("replaceCaret pr", k), $ === "0" ? N === "0" ? F = `>=${$}.${N}.${C}-${k} <${$}.${N}.${+C + 1}-0` : F = `>=${$}.${N}.${C}-${k} <${$}.${+N + 1}.0-0` : F = `>=${$}.${N}.${C}-${k} <${+$ + 1}.0.0-0`) : (a("no pr"), $ === "0" ? N === "0" ? F = `>=${$}.${N}.${C}${E} <${$}.${N}.${+C + 1}-0` : F = `>=${$}.${N}.${C}${E} <${$}.${+N + 1}.0-0` : F = `>=${$}.${N}.${C} <${+$ + 1}.0.0-0`), a("caret return", F), F;
+    });
+  }, I = (v, d) => (a("replaceXRanges", v, d), v.split(/\s+/).map((y) => Z(y, d)).join(" ")), Z = (v, d) => {
+    v = v.trim();
+    const y = d.loose ? c[o.XRANGELOOSE] : c[o.XRANGE];
+    return v.replace(y, (E, O, $, N, C, k) => {
+      a("xRange", v, E, O, $, N, C, k);
+      const F = R($), G = F || R(N), D = G || R(C), K = D;
+      return O === "=" && K && (O = ""), k = d.includePrerelease ? "-0" : "", F ? O === ">" || O === "<" ? E = "<0.0.0-0" : E = "*" : O && K ? (G && (N = 0), C = 0, O === ">" ? (O = ">=", G ? ($ = +$ + 1, N = 0, C = 0) : (N = +N + 1, C = 0)) : O === "<=" && (O = "<", G ? $ = +$ + 1 : N = +N + 1), O === "<" && (k = "-0"), E = `${O + $}.${N}.${C}${k}`) : G ? E = `>=${$}.0.0${k} <${+$ + 1}.0.0-0` : D && (E = `>=${$}.${N}.0${k} <${$}.${+N + 1}.0-0`), a("xRange return", E), E;
+    });
+  }, we = (v, d) => (a("replaceStars", v, d), v.trim().replace(c[o.STAR], "")), Re = (v, d) => (a("replaceGTE0", v, d), v.trim().replace(c[d.includePrerelease ? o.GTE0PRE : o.GTE0], "")), Se = (v) => (d, y, E, O, $, N, C, k, F, G, D, K) => (R(E) ? y = "" : R(O) ? y = `>=${E}.0.0${v ? "-0" : ""}` : R($) ? y = `>=${E}.${O}.0${v ? "-0" : ""}` : N ? y = `>=${y}` : y = `>=${y}${v ? "-0" : ""}`, R(F) ? k = "" : R(G) ? k = `<${+F + 1}.0.0-0` : R(D) ? k = `<${F}.${+G + 1}.0-0` : K ? k = `<=${F}.${G}.${D}-${K}` : v ? k = `<${F}.${G}.${+D + 1}-0` : k = `<=${k}`, `${y} ${k}`.trim()), ye = (v, d, y) => {
+    for (let E = 0; E < v.length; E++)
+      if (!v[E].test(d))
+        return !1;
+    if (d.prerelease.length && !y.includePrerelease) {
+      for (let E = 0; E < v.length; E++)
+        if (a(v[E].semver), v[E].semver !== l.ANY && v[E].semver.prerelease.length > 0) {
+          const O = v[E].semver;
+          if (O.major === d.major && O.minor === d.minor && O.patch === d.patch)
+            return !0;
+        }
+      return !1;
+    }
+    return !0;
+  };
+  return et;
+}
+var tt, Or;
+function ve() {
+  if (Or) return tt;
+  Or = 1;
+  const t = Symbol("SemVer ANY");
+  class e {
+    static get ANY() {
+      return t;
+    }
+    constructor(n, f) {
+      if (f = r(f), n instanceof e) {
+        if (n.loose === !!f.loose)
+          return n;
+        n = n.value;
+      }
+      n = n.trim().split(/\s+/).join(" "), a("comparator", n, f), this.options = f, this.loose = !!f.loose, this.parse(n), this.semver === t ? this.value = "" : this.value = this.operator + this.semver.version, a("comp", this);
+    }
+    parse(n) {
+      const f = this.options.loose ? s[i.COMPARATORLOOSE] : s[i.COMPARATOR], u = n.match(f);
+      if (!u)
+        throw new TypeError(`Invalid comparator: ${n}`);
+      this.operator = u[1] !== void 0 ? u[1] : "", this.operator === "=" && (this.operator = ""), u[2] ? this.semver = new h(u[2], this.options.loose) : this.semver = t;
+    }
+    toString() {
+      return this.value;
+    }
+    test(n) {
+      if (a("Comparator.test", n, this.options.loose), this.semver === t || n === t)
+        return !0;
+      if (typeof n == "string")
+        try {
+          n = new h(n, this.options);
+        } catch {
+          return !1;
+        }
+      return l(n, this.operator, this.semver, this.options);
+    }
+    intersects(n, f) {
+      if (!(n instanceof e))
+        throw new TypeError("a Comparator is required");
+      return this.operator === "" ? this.value === "" ? !0 : new c(n.value, f).test(this.value) : n.operator === "" ? n.value === "" ? !0 : new c(this.value, f).test(n.semver) : (f = r(f), f.includePrerelease && (this.value === "<0.0.0-0" || n.value === "<0.0.0-0") || !f.includePrerelease && (this.value.startsWith("<0.0.0") || n.value.startsWith("<0.0.0")) ? !1 : !!(this.operator.startsWith(">") && n.operator.startsWith(">") || this.operator.startsWith("<") && n.operator.startsWith("<") || this.semver.version === n.semver.version && this.operator.includes("=") && n.operator.includes("=") || l(this.semver, "<", n.semver, f) && this.operator.startsWith(">") && n.operator.startsWith("<") || l(this.semver, ">", n.semver, f) && this.operator.startsWith("<") && n.operator.startsWith(">")));
+    }
+  }
+  tt = e;
+  const r = bt(), { safeRe: s, t: i } = re(), l = rs(), a = de(), h = _(), c = x();
+  return tt;
+}
+var rt, Pr;
+function Ee() {
+  if (Pr) return rt;
+  Pr = 1;
+  const t = x();
+  return rt = (r, s, i) => {
+    try {
+      s = new t(s, i);
+    } catch {
+      return !1;
+    }
+    return s.test(r);
+  }, rt;
+}
+var st, Ir;
+function rn() {
+  if (Ir) return st;
+  Ir = 1;
+  const t = x();
+  return st = (r, s) => new t(r, s).set.map((i) => i.map((l) => l.value).join(" ").trim().split(" ")), st;
+}
+var nt, Nr;
+function sn() {
+  if (Nr) return nt;
+  Nr = 1;
+  const t = _(), e = x();
+  return nt = (s, i, l) => {
+    let a = null, h = null, c = null;
+    try {
+      c = new e(i, l);
+    } catch {
+      return null;
+    }
+    return s.forEach((o) => {
+      c.test(o) && (!a || h.compare(o) === -1) && (a = o, h = new t(a, l));
+    }), a;
+  }, nt;
+}
+var it, kr;
+function nn() {
+  if (kr) return it;
+  kr = 1;
+  const t = _(), e = x();
+  return it = (s, i, l) => {
+    let a = null, h = null, c = null;
+    try {
+      c = new e(i, l);
+    } catch {
+      return null;
+    }
+    return s.forEach((o) => {
+      c.test(o) && (!a || h.compare(o) === 1) && (a = o, h = new t(a, l));
+    }), a;
+  }, it;
+}
+var at, Lr;
+function an() {
+  if (Lr) return at;
+  Lr = 1;
+  const t = _(), e = x(), r = me();
+  return at = (i, l) => {
+    i = new e(i, l);
+    let a = new t("0.0.0");
+    if (i.test(a) || (a = new t("0.0.0-0"), i.test(a)))
+      return a;
+    a = null;
+    for (let h = 0; h < i.set.length; ++h) {
+      const c = i.set[h];
+      let o = null;
+      c.forEach((n) => {
+        const f = new t(n.semver.version);
+        switch (n.operator) {
+          case ">":
+            f.prerelease.length === 0 ? f.patch++ : f.prerelease.push(0), f.raw = f.format();
+          /* fallthrough */
+          case "":
+          case ">=":
+            (!o || r(f, o)) && (o = f);
+            break;
+          case "<":
+          case "<=":
+            break;
+          /* istanbul ignore next */
+          default:
+            throw new Error(`Unexpected operation: ${n.operator}`);
+        }
+      }), o && (!a || r(a, o)) && (a = o);
+    }
+    return a && i.test(a) ? a : null;
+  }, at;
+}
+var ot, Cr;
+function on() {
+  if (Cr) return ot;
+  Cr = 1;
+  const t = x();
+  return ot = (r, s) => {
+    try {
+      return new t(r, s).range || "*";
+    } catch {
+      return null;
+    }
+  }, ot;
+}
+var ct, Tr;
+function _t() {
+  if (Tr) return ct;
+  Tr = 1;
+  const t = _(), e = ve(), { ANY: r } = e, s = x(), i = Ee(), l = me(), a = Dt(), h = Gt(), c = Bt();
+  return ct = (n, f, u, g) => {
+    n = new t(n, g), f = new s(f, g);
+    let m, p, S, P, w;
+    switch (u) {
+      case ">":
+        m = l, p = h, S = a, P = ">", w = ">=";
+        break;
+      case "<":
+        m = a, p = c, S = l, P = "<", w = "<=";
+        break;
+      default:
+        throw new TypeError('Must provide a hilo val of "<" or ">"');
+    }
+    if (i(n, f, g))
+      return !1;
+    for (let R = 0; R < f.set.length; ++R) {
+      const T = f.set[R];
+      let b = null, A = null;
+      if (T.forEach((q) => {
+        q.semver === r && (q = new e(">=0.0.0")), b = b || q, A = A || q, m(q.semver, b.semver, g) ? b = q : S(q.semver, A.semver, g) && (A = q);
+      }), b.operator === P || b.operator === w || (!A.operator || A.operator === P) && p(n, A.semver))
+        return !1;
+      if (A.operator === w && S(n, A.semver))
+        return !1;
+    }
+    return !0;
+  }, ct;
+}
+var lt, Ar;
+function cn() {
+  if (Ar) return lt;
+  Ar = 1;
+  const t = _t();
+  return lt = (r, s, i) => t(r, s, ">", i), lt;
+}
+var ft, Fr;
+function ln() {
+  if (Fr) return ft;
+  Fr = 1;
+  const t = _t();
+  return ft = (r, s, i) => t(r, s, "<", i), ft;
+}
+var ut, br;
+function fn() {
+  if (br) return ut;
+  br = 1;
+  const t = x();
+  return ut = (r, s, i) => (r = new t(r, i), s = new t(s, i), r.intersects(s, i)), ut;
+}
+var ht, qr;
+function un() {
+  if (qr) return ht;
+  qr = 1;
+  const t = Ee(), e = j();
+  return ht = (r, s, i) => {
+    const l = [];
+    let a = null, h = null;
+    const c = r.sort((u, g) => e(u, g, i));
+    for (const u of c)
+      t(u, s, i) ? (h = u, a || (a = u)) : (h && l.push([a, h]), h = null, a = null);
+    a && l.push([a, null]);
+    const o = [];
+    for (const [u, g] of l)
+      u === g ? o.push(u) : !g && u === c[0] ? o.push("*") : g ? u === c[0] ? o.push(`<=${g}`) : o.push(`${u} - ${g}`) : o.push(`>=${u}`);
+    const n = o.join(" || "), f = typeof s.raw == "string" ? s.raw : String(s);
+    return n.length < f.length ? n : s;
+  }, ht;
+}
+var pt, Dr;
+function hn() {
+  if (Dr) return pt;
+  Dr = 1;
+  const t = x(), e = ve(), { ANY: r } = e, s = Ee(), i = j(), l = (f, u, g = {}) => {
+    if (f === u)
+      return !0;
+    f = new t(f, g), u = new t(u, g);
+    let m = !1;
+    e: for (const p of f.set) {
+      for (const S of u.set) {
+        const P = c(p, S, g);
+        if (m = m || P !== null, P)
+          continue e;
+      }
+      if (m)
+        return !1;
+    }
+    return !0;
+  }, a = [new e(">=0.0.0-0")], h = [new e(">=0.0.0")], c = (f, u, g) => {
+    if (f === u)
+      return !0;
+    if (f.length === 1 && f[0].semver === r) {
+      if (u.length === 1 && u[0].semver === r)
+        return !0;
+      g.includePrerelease ? f = a : f = h;
+    }
+    if (u.length === 1 && u[0].semver === r) {
+      if (g.includePrerelease)
+        return !0;
+      u = h;
+    }
+    const m = /* @__PURE__ */ new Set();
+    let p, S;
+    for (const I of f)
+      I.operator === ">" || I.operator === ">=" ? p = o(p, I, g) : I.operator === "<" || I.operator === "<=" ? S = n(S, I, g) : m.add(I.semver);
+    if (m.size > 1)
+      return null;
+    let P;
+    if (p && S) {
+      if (P = i(p.semver, S.semver, g), P > 0)
+        return null;
+      if (P === 0 && (p.operator !== ">=" || S.operator !== "<="))
+        return null;
+    }
+    for (const I of m) {
+      if (p && !s(I, String(p), g) || S && !s(I, String(S), g))
+        return null;
+      for (const Z of u)
+        if (!s(I, String(Z), g))
+          return !1;
+      return !0;
+    }
+    let w, R, T, b, A = S && !g.includePrerelease && S.semver.prerelease.length ? S.semver : !1, q = p && !g.includePrerelease && p.semver.prerelease.length ? p.semver : !1;
+    A && A.prerelease.length === 1 && S.operator === "<" && A.prerelease[0] === 0 && (A = !1);
+    for (const I of u) {
+      if (b = b || I.operator === ">" || I.operator === ">=", T = T || I.operator === "<" || I.operator === "<=", p) {
+        if (q && I.semver.prerelease && I.semver.prerelease.length && I.semver.major === q.major && I.semver.minor === q.minor && I.semver.patch === q.patch && (q = !1), I.operator === ">" || I.operator === ">=") {
+          if (w = o(p, I, g), w === I && w !== p)
+            return !1;
+        } else if (p.operator === ">=" && !s(p.semver, String(I), g))
+          return !1;
+      }
+      if (S) {
+        if (A && I.semver.prerelease && I.semver.prerelease.length && I.semver.major === A.major && I.semver.minor === A.minor && I.semver.patch === A.patch && (A = !1), I.operator === "<" || I.operator === "<=") {
+          if (R = n(S, I, g), R === I && R !== S)
+            return !1;
+        } else if (S.operator === "<=" && !s(S.semver, String(I), g))
+          return !1;
+      }
+      if (!I.operator && (S || p) && P !== 0)
+        return !1;
+    }
+    return !(p && T && !S && P !== 0 || S && b && !p && P !== 0 || q || A);
+  }, o = (f, u, g) => {
+    if (!f)
+      return u;
+    const m = i(f.semver, u.semver, g);
+    return m > 0 ? f : m < 0 || u.operator === ">" && f.operator === ">=" ? u : f;
+  }, n = (f, u, g) => {
+    if (!f)
+      return u;
+    const m = i(f.semver, u.semver, g);
+    return m < 0 ? f : m > 0 || u.operator === "<" && f.operator === "<=" ? u : f;
+  };
+  return pt = l, pt;
+}
+var gt, Br;
+function pn() {
+  if (Br) return gt;
+  Br = 1;
+  const t = re(), e = ge(), r = _(), s = Qr(), i = H(), l = zs(), a = Us(), h = Vs(), c = Ms(), o = Xs(), n = Js(), f = Ws(), u = Hs(), g = j(), m = Ys(), p = Zs(), S = qt(), P = Ks(), w = Qs(), R = me(), T = Dt(), b = es(), A = ts(), q = Bt(), I = Gt(), Z = rs(), we = en(), Re = ve(), Se = x(), ye = Ee(), v = rn(), d = sn(), y = nn(), E = an(), O = on(), $ = _t(), N = cn(), C = ln(), k = fn(), F = un(), G = hn();
+  return gt = {
+    parse: i,
+    valid: l,
+    clean: a,
+    inc: h,
+    diff: c,
+    major: o,
+    minor: n,
+    patch: f,
+    prerelease: u,
+    compare: g,
+    rcompare: m,
+    compareLoose: p,
+    compareBuild: S,
+    sort: P,
+    rsort: w,
+    gt: R,
+    lt: T,
+    eq: b,
+    neq: A,
+    gte: q,
+    lte: I,
+    cmp: Z,
+    coerce: we,
+    Comparator: Re,
+    Range: Se,
+    satisfies: ye,
+    toComparators: v,
+    maxSatisfying: d,
+    minSatisfying: y,
+    minVersion: E,
+    validRange: O,
+    outside: $,
+    gtr: N,
+    ltr: C,
+    intersects: k,
+    simplifyRange: F,
+    subset: G,
+    SemVer: r,
+    re: t.re,
+    src: t.src,
+    tokens: t.t,
+    SEMVER_SPEC_VERSION: e.SEMVER_SPEC_VERSION,
+    RELEASE_TYPES: e.RELEASE_TYPES,
+    compareIdentifiers: s.compareIdentifiers,
+    rcompareIdentifiers: s.rcompareIdentifiers
+  }, gt;
+}
+var ss = pn();
+const gn = /* @__PURE__ */ xs(ss), It = "_updates_v2/per_package_version/";
+function dn(t, e) {
+  return `${It}${t.organization}/${t.name}/${t.version}/${e}`;
+}
+const mn = /(?<packageKeyWithoutVersion>(?<organization>[^\/]+)\/(?<name>[^\/]+))\/(?<version>[^\/]+)\/(?<seed>[^\/]+)$/, dt = "_updates_v2/_global_update_in", Gr = "_updates_v2/_global_update_out", Nt = "_overview_snapshots_v2/global/", vn = "_overview_snapshots_v2/per_package/", En = /^(?<timestamp>\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.\d{3}Z-[a-z0-9]+)\.json\.gz$/;
+function _r(t) {
+  return `${Nt}${t}.json.gz`;
+}
+function $n(t, e) {
+  return `${vn}${t.organization}/${t.name}/${e}.json.gz`;
+}
+const Y = "v2/", wn = "overview.json", Rn = "overview.json.gz", Sn = "overview.json", ae = "manifest.json", kt = "channels", mt = /^[-a-z0-9]+$/;
+function ns(t) {
+  return `${t.organization}/${t.name}/${t.version}`;
+}
+function ne(t) {
+  return `${Y}${ns(t)}`;
+}
+const yn = "/" + ae, On = L.object({
+  description: J,
+  channels: L.array(L.string()).default(() => []),
+  manifestSha256: St
+}).passthrough(), vt = L.object({
+  schema: L.literal("v2"),
+  versions: L.array(On)
+}).passthrough();
+function Pn(t) {
+  return `${t.organization}/${t.name}/${Sn}`;
+}
+function jr(t) {
+  return `${Y}${Pn(t)}`;
+}
+function In(t) {
+  return `${ns(t)}/${kt}/`;
+}
+function Nn(t) {
+  return `${Y}${In(t)}`;
+}
+const kn = /(?<packageKeyWithoutVersion>(?<organization>[^\/]+)\/(?<name>[^\/]+))\/(?<version>[^\/]+)\/manifest\.json$/, ie = `${Y}${wn}`, xr = `${Y}${Rn}`;
+function is(t) {
+  const e = L.object({
+    id: Es,
+    /** @deprecated to be removed at some point, not used, left for compatibility with older versions */
+    allVersions: L.array(L.string()).optional(),
+    allVersionsWithChannels: L.array($s).optional(),
+    /** @deprecated to be removed at some point, not used, left for compatibility with older versions */
+    latest: t,
+    /** @deprecated to be removed at some point, not used, left for compatibility with older versions */
+    latestManifestSha256: St,
+    latestByChannel: L.record(
+      L.string(),
+      L.object({
+        description: t,
+        manifestSha256: St
+      }).passthrough()
+    ).default({})
+  }).passthrough();
+  return e.transform((r) => r.allVersionsWithChannels ? r : {
+    ...r,
+    allVersionsWithChannels: r.allVersions.map((s) => ({ version: s, channels: [] }))
+  }).transform(
+    (r) => r.latestByChannel[ce] ? r : {
+      ...r,
+      latestByChannel: {
+        ...r.latestByChannel,
+        [ce]: { description: r.latest, manifestSha256: r.latestManifestSha256 }
+      }
+    }
+  ).pipe(e.required({ allVersionsWithChannels: !0 }));
+}
+const ui = is(J);
+function jt(t) {
+  return L.object({
+    schema: L.literal("v2"),
+    packages: L.array(is(t))
+  }).passthrough();
+}
+const Et = jt(J);
+function hi(t) {
+  return W(
+    ue,
+    V(
+      ee.transform(At(t)),
+      te.transform(pe(t))
+    )
+  );
+}
+function pi(t) {
+  return jt(
+    W(
+      ue,
+      V(
+        ee.transform(At(t)),
+        te.transform(pe(t))
+      )
+    )
+  );
+}
+function gi(t) {
+  return jt(
+    W(
+      ue,
+      V(
+        ee.transform(At(t)),
+        te.transform(pe(t))
+      )
+    )
+  );
+}
+class di {
+  constructor(e, r = new Rs(), s = {}) {
+    X(this, "gzipAsync", Ut(Ss));
+    X(this, "gunzipAsync", Ut(ys));
+    this.storage = e, this.logger = r, this.settings = s;
+  }
+  generateTimestamp() {
+    const e = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").replace(/\.(\d{3})Z$/, ".$1Z"), r = Math.random().toString(36).substring(2, 6);
+    return `${e}-${r}`;
+  }
+  generatePreWriteTimestamp() {
+    const e = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-").replace(/\.(\d{3})Z$/, ".$1Z"), r = Math.random().toString(36).substring(2, 6);
+    return `${e}-prewrite-${r}`;
+  }
+  async createGlobalOverviewSnapshot(e, r) {
+    if (!this.settings.skipSnapshotCreation)
+      try {
+        const s = await this.gzipAsync(e), i = _r(r);
+        await this.storage.putFile(i, Buffer.from(s)), this.logger.info(`Global overview snapshot created at ${i}`);
+      } catch (s) {
+        this.logger.warn(`Failed to create global overview snapshot: ${s}`);
+      }
+  }
+  async createPackageOverviewSnapshot(e, r, s) {
+    if (!this.settings.skipSnapshotCreation)
+      try {
+        const i = JSON.stringify(r), l = await this.gzipAsync(i), a = $n(e, s);
+        await this.storage.putFile(a, Buffer.from(l)), this.logger.info(`Package overview snapshot created at ${a} for ${e.organization}:${e.name}`);
+      } catch (i) {
+        this.logger.warn(`Failed to create package overview snapshot for ${e.organization}:${e.name}: ${i}`);
+      }
+  }
+  async updateRegistry(e = "normal") {
+    this.logger.info("Initiating registry refresh...");
+    const r = this.generateTimestamp(), s = /* @__PURE__ */ new Map(), i = [], l = await this.storage.listFiles(It), a = ({ organization: n, name: f, version: u }) => {
+      const g = `${n}:${f}`;
+      let m = s.get(g);
+      if (m) {
+        if (!m.versions.has(u))
+          return m.versions.add(u), !0;
+      } else return s.set(g, {
+        package: { organization: n, name: f },
+        versions: /* @__PURE__ */ new Set([u])
+      }), !0;
+      return !1;
+    };
+    this.logger.info("Packages to be updated:");
+    for (const n of l) {
+      const f = n.match(mn);
+      if (!f) continue;
+      i.push(n);
+      const { organization: u, name: g, version: m, seed: p } = f.groups, S = a({ organization: u, name: g, version: m });
+      this.logger.info(`  - ${u}:${g}:${m} added:${S}`);
+    }
+    if (e === "force") {
+      const n = await this.storage.listFiles(Y);
+      for (const f of n) {
+        const u = f.match(kn);
+        if (!u) continue;
+        const { organization: g, name: m, version: p } = u.groups, S = a({ organization: g, name: m, version: p });
+        this.logger.info(`  - ${g}:${m}:${p} force_added:${S}`);
+      }
+    }
+    const h = await this.storage.getFile(ie);
+    if (e === "force" && h !== void 0) {
+      const n = this.generatePreWriteTimestamp();
+      await this.createGlobalOverviewSnapshot(h.toString(), n);
+    }
+    let o = (e === "force" ? { packages: [] } : h === void 0 ? { packages: [] } : Et.parse(JSON.parse(h.toString()))).packages;
+    this.logger.info(`Global overview ${e === "force" ? "starting empty (force mode)" : "loaded"}, ${o.length} records`);
+    for (const [, n] of s.entries()) {
+      const f = jr(n.package), u = await this.storage.getFile(f);
+      if (e === "force" && u !== void 0) {
+        const w = this.generatePreWriteTimestamp(), R = vt.parse(JSON.parse(u.toString()));
+        await this.createPackageOverviewSnapshot(n.package, R, w);
+      }
+      const g = e === "force" ? { versions: [] } : u === void 0 ? { versions: [] } : vt.parse(JSON.parse(u.toString()));
+      this.logger.info(
+        `Updating ${n.package.organization}:${n.package.name} overview${e === "force" ? " (starting empty in force mode)" : ""}, ${g.versions.length} records`
+      );
+      const m = g.versions.filter(
+        (w) => !n.versions.has(w.description.id.version)
+      );
+      for (const [w] of n.versions.entries()) {
+        const R = w.toString(), T = {
+          ...n.package,
+          version: R
+        }, b = await this.storage.getFile(
+          ne(T) + yn
+        );
+        if (!b) continue;
+        const A = await Ot(b), q = (await this.storage.listFiles(Nn(T))).filter((I) => I.match(mt) ? !0 : (this.logger.warn(`Unexpected channel in ${Oe(T)}: ${I}`), !1));
+        m.push({
+          description: Xt(R).parse(
+            Mr.parse(JSON.parse(b.toString("utf8"))).description
+          ),
+          manifestSha256: A,
+          channels: q
+        });
+      }
+      m.sort(
+        (w, R) => ss.compare(R.description.id.version, w.description.id.version)
+      );
+      const p = { schema: "v2", versions: m };
+      e !== "dry-run" && (await this.storage.putFile(
+        f,
+        Buffer.from(JSON.stringify(p))
+      ), await this.createPackageOverviewSnapshot(n.package, p, r)), this.logger.info(`Done (${m.length} records)`);
+      const S = /* @__PURE__ */ new Set();
+      for (const w of m) for (const R of w.channels) S.add(R);
+      o = o.filter(
+        (w) => w.id.organization !== n.package.organization || w.id.name !== n.package.name
+      );
+      const P = Xt(
+        `${n.package.organization}/${n.package.name}`
+      );
+      o.push({
+        id: {
+          organization: n.package.organization,
+          name: n.package.name
+        },
+        // left for backward compatibility
+        allVersions: m.map((w) => w.description.id.version).reverse(),
+        allVersionsWithChannels: m.map((w) => ({ version: w.description.id.version, channels: w.channels })).reverse(),
+        // left for backward compatibility
+        latest: P.parse(m[0].description),
+        // left for backward compatibility
+        latestManifestSha256: m[0].manifestSha256,
+        latestByChannel: Object.fromEntries(
+          [...S, ce].map((w) => {
+            const R = m.find((T) => w === ce || T.channels.indexOf(w) !== -1);
+            if (!R) throw new Error("Assertion error");
+            return [
+              w,
+              {
+                description: P.parse(R.description),
+                manifestSha256: R == null ? void 0 : R.manifestSha256
+              }
+            ];
+          })
+        )
+      });
+    }
+    if (e !== "dry-run") {
+      const n = JSON.stringify({ schema: "v2", packages: o }), f = Buffer.from(n);
+      await this.storage.putFile(ie, f);
+      const u = await this.gzipAsync(n);
+      await this.storage.putFile(xr, Buffer.from(u)), await this.createGlobalOverviewSnapshot(n, r);
+    }
+    this.logger.info(`Global overview updated (${o.length} records)`), e !== "dry-run" && await this.storage.deleteFiles(...i.map((n) => `${It}${n}`)), this.logger.info("Version update requests cleared");
+  }
+  async updateIfNeeded(e = "normal") {
+    this.logger.info("Checking if registry requires refresh...");
+    const r = await this.storage.getFile(dt), s = await this.storage.getFile(Gr);
+    if (e !== "force" && r === void 0 && s === void 0) {
+      this.logger.info("No global seed files found, update not needed.");
+      return;
+    }
+    if (e !== "force" && r !== void 0 && s !== void 0 && r.equals(s)) {
+      this.logger.info("Registry is up to date.");
+      return;
+    }
+    await this.updateRegistry(e), r && (e !== "dry-run" && await this.storage.putFile(Gr, r), this.logger.info("Refresh finished."));
+  }
+  async getPackageOverview(e) {
+    const r = await this.storage.getFile(jr(e));
+    if (r !== void 0)
+      return vt.parse(JSON.parse(r.toString()));
+  }
+  async getGlobalOverview() {
+    const e = await this.storage.getFile(ie);
+    if (e !== void 0)
+      return Et.parse(JSON.parse(e.toString()));
+  }
+  async marchChanged(e) {
+    const r = Hr(), s = dn(e, r);
+    this.logger.info(`Creating update seed at ${s} ...`), await this.storage.putFile(s, Buffer.from(r)), this.logger.info(`Touching global update seed ${dt} ...`), await this.storage.putFile(dt, Buffer.from(r));
+  }
+  async addPackageToChannel(e, r) {
+    if (!r.match(mt))
+      throw new Error(`Illegal characters in channel name: ${r}`);
+    const s = ne(e);
+    if (await this.storage.getFile(`${s}/${ae}`) === void 0)
+      throw new Error(`Package ${Oe(e)} not found in the registry.`);
+    await this.storage.putFile(`${s}/${kt}/${r}`, Buffer.from(r)), await this.marchChanged(e);
+  }
+  async removePackageFromChannel(e, r) {
+    if (!r.match(mt))
+      throw new Error(`Illegal characters in channel name: ${r}`);
+    const s = ne(e);
+    if (await this.storage.getFile(`${s}/${ae}`) === void 0)
+      throw new Error(`Package ${Oe(e)} not found in the registry.`);
+    await this.storage.deleteFiles(`${s}/${kt}/${r}`), await this.marchChanged(e);
+  }
+  async listGlobalOverviewSnapshots() {
+    const e = await this.storage.listFiles(Nt), r = [];
+    for (const s of e) {
+      const i = s.indexOf("/") === -1 ? s : s.substring(s.lastIndexOf("/") + 1), l = i.match(En);
+      l && r.push({
+        timestamp: l.groups.timestamp,
+        path: Nt + i
+      });
+    }
+    return r.sort((s, i) => i.timestamp.localeCompare(s.timestamp)), r;
+  }
+  async restoreGlobalOverviewFromSnapshot(e) {
+    const r = _r(e), s = await this.storage.getFile(r);
+    if (!s)
+      throw new Error(`Snapshot ${e} not found at ${r}`);
+    const l = (await this.gunzipAsync(s)).toString("utf8");
+    try {
+      Et.parse(JSON.parse(l));
+    } catch (c) {
+      throw new Error(`Invalid snapshot data in ${e}: ${c}`);
+    }
+    const a = Buffer.from(l);
+    await this.storage.putFile(ie, a);
+    const h = await this.gzipAsync(l);
+    await this.storage.putFile(xr, Buffer.from(h)), this.logger.info(`Global overview restored from snapshot ${e}`);
+  }
+  async publishPackage(e, r) {
+    const s = ne(e.description.id);
+    for (const l of e.files) {
+      const a = await r(l.name);
+      if (a.length !== l.size)
+        throw new Error(
+          `Actual file size don't match file size from the manifest file for ${l.name} (actual = ${a.length}; manifest = ${l.size})`
+        );
+      const h = await Ot(a);
+      if (h !== l.sha256.toUpperCase())
+        throw new Error(
+          `Actual file SHA-256 don't match the checksum from the manifest file for ${l.name} (actual = ${h}; manifest = ${l.sha256.toUpperCase()})`
+        );
+      const c = s + "/" + l.name;
+      this.logger.info(`Uploading ${l.name} -> ${c} ...`), await this.storage.putFile(c, a);
+    }
+    const i = s + "/" + ae;
+    this.logger.info(`Uploading manifest to ${i} ...`), await this.storage.putFile(i, Buffer.from(JSON.stringify(e))), await this.marchChanged(e.description.id);
+  }
+}
+class Ln {
+  constructor(e, r, s) {
+    this.client = e, this.bucket = r, this.root = s;
+  }
+  async getFile(e) {
+    try {
+      return Buffer.from(
+        await (await this.client.getObject({
+          Bucket: this.bucket,
+          Key: U.join(this.root, e)
+        })).Body.transformToByteArray()
+      );
+    } catch (r) {
+      if (r.name === "NoSuchKey") return;
+      throw r;
+    }
+  }
+  async listFiles(e) {
+    const r = U.join(this.root, e), s = Ns(
+      { client: this.client },
+      {
+        Bucket: this.bucket,
+        Prefix: r
+      }
+    ), i = [];
+    for await (const l of s)
+      i.push(...(l.Contents ?? []).map((a) => U.relative(r, a.Key)));
+    return i;
+  }
+  async putFile(e, r) {
+    await this.client.putObject({
+      Bucket: this.bucket,
+      Key: U.join(this.root, e),
+      Body: r
+    });
+  }
+  async deleteFiles(...e) {
+    const r = await this.client.deleteObjects({
+      Bucket: this.bucket,
+      Delete: {
+        Objects: e.map((s) => ({
+          Key: U.join(this.root, s)
+        }))
+      }
+    });
+    if (r.Errors !== void 0 && r.Errors.length > 0)
+      throw new Error(`Errors encountered while deleting files: ${r.Errors.join(`
+`)}`);
+  }
+}
+class Cn {
+  constructor(e) {
+    /** Absolute path */
+    X(this, "root");
+    this.root = B.resolve(e);
+  }
+  toAbsolutePath(e) {
+    if (U.isAbsolute(e)) throw new Error("absolute path");
+    return B.resolve(this.root, e.split(U.sep).join(B.sep));
+  }
+  async getFile(e) {
+    try {
+      return await Q.promises.readFile(this.toAbsolutePath(e));
+    } catch (r) {
+      if (r.code == "ENOENT") return;
+      throw new Error("", { cause: r });
+    }
+  }
+  async listFiles(e) {
+    try {
+      const r = this.toAbsolutePath(e);
+      return (await Q.promises.readdir(r, { recursive: !0, withFileTypes: !0 })).filter((s) => s.isFile()).map(
+        (s) => B.relative(r, B.resolve(s.parentPath, s.name)).split(B.sep).join(U.sep)
+      );
+    } catch (r) {
+      if (r.code == "ENOENT") return [];
+      throw new Error("", { cause: r });
+    }
+  }
+  async putFile(e, r) {
+    const s = this.toAbsolutePath(e);
+    await Q.promises.mkdir(B.dirname(s), { recursive: !0 }), await Q.promises.writeFile(s, r);
+  }
+  async deleteFiles(...e) {
+    for (const r of e) await Q.promises.rm(this.toAbsolutePath(r));
+  }
+}
+function Tn(t) {
+  const e = new URL(t, `file:${B.resolve(".").split(B.sep).join(U.sep)}/`);
+  switch (e.protocol) {
+    case "file:":
+      const r = B.resolve(e.pathname);
+      return new Cn(r);
+    case "s3:":
+      const s = {}, i = e.searchParams.get("region");
+      i && (s.region = i);
+      const l = e.hostname;
+      return new Ln(new Is(s), l, e.pathname.replace(/^\//, ""));
+    default:
+      throw new Error(`Unknown protocol: ${e.protocol}`);
+  }
+}
+const An = L.string().regex(/^(?:s3:|file:)/), Fn = L.object({
+  organization: L.string(),
+  package: L.string(),
+  version: Tt.optional(),
+  files: L.record(L.string().regex(/^[^\/]+$/), L.string()).default({}),
+  meta: L.object({}).passthrough()
+}), bn = L.object({
+  registries: L.record(L.string(), An).default({}),
+  registry: L.string().optional()
+}), as = bn.merge(Fn).required(
+  { registry: !0, version: !0 }
+), xt = as.partial().required({
+  registries: !0,
+  files: !0
+}), qn = "pl.package.json", Dn = "pl.package.yaml", $e = "v1/";
+function mi(t) {
+  return `${$e}${t.organization}/${t.package}/${t.version}`;
+}
+function os(t, e) {
+  return `${$e}${t.organization}/${t.package}/${t.version}/${e}`;
+}
+function zr(t) {
+  return `${$e}${t.organization}/${t.package}/overview.json`;
+}
+const $t = `${$e}overview.json`, cs = "meta.json", Lt = "_updates_v1/per_package_version/";
+function Bn(t, e) {
+  return `${Lt}${t.organization}/${t.package}/${t.version}/${e}`;
+}
+const Gn = /(?<packageKeyWithoutVersion>(?<organization>[^\/]+)\/(?<pkg>[^\/]+))\/(?<version>[^\/]+)\/(?<seed>[^\/]+)$/, ls = "_updates_v1/_global_update_in", Ur = "_updates_v1/_global_update_out";
+class _n {
+  constructor(e, r) {
+    this.storage = e, this.logger = r;
+  }
+  constructNewPackage(e) {
+    return new jn(this.storage, e);
+  }
+  async updateRegistry() {
+    var a, h, c, o, n, f, u, g;
+    (a = this.logger) == null || a.info("Initiating registry refresh...");
+    const e = /* @__PURE__ */ new Map(), r = [], s = await this.storage.listFiles(Lt);
+    (h = this.logger) == null || h.info("Packages to be updated:");
+    for (const m of s) {
+      const p = m.match(Gn);
+      if (!p) continue;
+      r.push(m);
+      const { packageKeyWithoutVersion: S, organization: P, pkg: w, version: R, seed: T } = p.groups;
+      let b = e.get(S);
+      b ? b.versions.has(R) || b.versions.add(R) : e.set(S, {
+        package: { organization: P, package: w },
+        versions: /* @__PURE__ */ new Set([R])
+      }), (c = this.logger) == null || c.info(`  - ${P}:${w}:${R}`);
+    }
+    const i = await this.storage.getFile($t);
+    let l = i === void 0 ? [] : JSON.parse(i.toString());
+    (o = this.logger) == null || o.info(`Global overview loaded, ${l.length} records`);
+    for (const [, m] of e.entries()) {
+      const p = zr(m.package), S = await this.storage.getFile(p);
+      let P = S === void 0 ? [] : JSON.parse(S.toString());
+      (n = this.logger) == null || n.info(
+        `Updating ${m.package.organization}:${m.package.package} overview, ${P.length} records`
+      ), P = P.filter((w) => !m.versions.has(w.version));
+      for (const [w] of m.versions.entries()) {
+        const R = w.toString(), T = await this.storage.getFile(
+          os(
+            {
+              ...m.package,
+              version: R
+            },
+            cs
+          )
+        );
+        T && P.push({ version: R, meta: JSON.parse(T.toString()) });
+      }
+      P.sort((w, R) => gn.compare(R.version, w.version)), await this.storage.putFile(p, Buffer.from(JSON.stringify(P))), (f = this.logger) == null || f.info(`Done (${P.length} records)`), l = l.filter(
+        (w) => w.organization !== m.package.organization || w.package !== m.package.package
+      ), l.push({
+        organization: m.package.organization,
+        package: m.package.package,
+        allVersions: P.map((w) => w.version).reverse(),
+        latestVersion: P[0].version,
+        latestMeta: P[0].meta
+      });
+    }
+    await this.storage.putFile($t, Buffer.from(JSON.stringify(l))), (u = this.logger) == null || u.info(`Global overview updated (${l.length} records)`), await this.storage.deleteFiles(...r.map((m) => `${Lt}${m}`)), (g = this.logger) == null || g.info("Version update requests cleared");
+  }
+  async updateIfNeeded(e = !1) {
+    var i, l;
+    (i = this.logger) == null || i.info("Checking if registry requires refresh...");
+    const r = await this.storage.getFile(ls), s = await this.storage.getFile(Ur);
+    !e && r === void 0 && s === void 0 || !e && r !== void 0 && s !== void 0 && r.equals(s) || (await this.updateRegistry(), r && (await this.storage.putFile(Ur, r), (l = this.logger) == null || l.info("Refresh finished")));
+  }
+  async getPackageOverview(e) {
+    const r = await this.storage.getFile(zr(e));
+    if (r !== void 0)
+      return JSON.parse(r.toString());
+  }
+  async getGlobalOverview() {
+    const e = await this.storage.getFile($t);
+    if (e !== void 0)
+      return JSON.parse(e.toString());
+  }
+}
+class jn {
+  constructor(e, r) {
+    X(this, "metaAdded", !1);
+    X(this, "seed", Hr());
+    this.storage = e, this.name = r;
+  }
+  async addFile(e, r) {
+    await this.storage.putFile(os(this.name, e), r);
+  }
+  async writeMeta(e) {
+    await this.addFile(cs, Buffer.from(JSON.stringify(e))), this.metaAdded = !0;
+  }
+  async finish() {
+    if (!this.metaAdded) throw new Error("meta not added");
+    await this.storage.putFile(Bn(this.name, this.seed), Buffer.of(0)), await this.storage.putFile(ls, Buffer.from(this.seed));
+  }
+}
+function M(t, e) {
+  return e === void 0 ? t : {
+    ...t,
+    ...e,
+    registries: { ...t.registries, ...e.registries },
+    files: { ...t.files, ...e.files }
+  };
+}
+async function wt(t) {
+  return Ft(t, (e) => xt.parse(JSON.parse(e.toString())));
+}
+async function Rt(t) {
+  return Ft(t, (e) => xt.parse(Ps.parse(e.toString())));
+}
+async function xn() {
+  let t = xt.parse({});
+  return t = M(t, await wt("./.pl.reg.json")), t = M(t, await Rt("./.pl.reg.yaml")), t = M(t, await wt(`${Vt.homedir()}/.pl.reg.json`)), t = M(t, await Rt(`${Vt.homedir()}/.pl.reg.yaml`)), t = M(t, await wt(qn)), t = M(t, await Rt(Dn)), t;
+}
+class zn {
+  constructor(e) {
+    this.conf = e;
+  }
+  createRegistry(e) {
+    let r = this.conf.registry;
+    if (!r.startsWith("file:") && !r.startsWith("s3:")) {
+      const s = this.conf.registries[r];
+      if (!s) throw new Error(`Registry with alias "${r}" not found`);
+      r = s;
+    }
+    return new _n(Tn(r), e);
+  }
+  get fullPackageName() {
+    return {
+      organization: this.conf.organization,
+      package: this.conf.package,
+      version: this.conf.version
+    };
+  }
+}
+async function vi(t) {
+  const e = await xn();
+  return new zn(
+    as.parse(M(e, t))
+  );
+}
+export {
+  li as $,
+  Ls as A,
+  ni as B,
+  Mt as C,
+  Yr as D,
+  Cs as E,
+  Cn as F,
+  Et as G,
+  Ts as H,
+  yt as I,
+  As as J,
+  At as K,
+  Fs as L,
+  ae as M,
+  si as N,
+  pe as O,
+  xt as P,
+  qs as Q,
+  ks as R,
+  Ln as S,
+  ii as T,
+  Ds as U,
+  Bs as V,
+  Zr as W,
+  Gs as X,
+  Xt as Y,
+  Pt as Z,
+  Kr as _,
+  bs as a,
+  Rn as a0,
+  Sn as a1,
+  kt as a2,
+  mt as a3,
+  ne as a4,
+  On as a5,
+  vt as a6,
+  Pn as a7,
+  jr as a8,
+  In as a9,
+  Nn as aa,
+  kn as ab,
+  ie as ac,
+  xr as ad,
+  is as ae,
+  ui as af,
+  jt as ag,
+  hi as ah,
+  pi as ai,
+  gi as aj,
+  di as b,
+  fi as c,
+  ci as d,
+  gn as e,
+  Y as f,
+  vi as g,
+  ai as h,
+  wn as i,
+  yn as j,
+  Ot as k,
+  js as l,
+  oi as m,
+  $t as n,
+  cs as o,
+  ns as p,
+  Fn as q,
+  qn as r,
+  Tn as s,
+  Dn as t,
+  bn as u,
+  as as v,
+  zn as w,
+  mi as x,
+  zr as y,
+  os as z
+};
+//# sourceMappingURL=config-XBQ2O39y.mjs.map