@platforma-sdk/block-tools 2.1.6 → 2.1.8

package/dist/config-jteHItEq.mjs

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