@platforma-sdk/block-tools 2.5.51 → 2.5.52

package/dist/config-DrI3vxIZ.mjs

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