@platforma-sdk/block-tools 2.3.30 → 2.4.0

package/dist/config-DJEjRJs6.mjs

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