@platforma-sdk/block-tools 2.2.0 → 2.3.0

package/dist/config-YukCegnp.mjs

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