@prosopo/client-example-server 2.7.11 → 2.7.13

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @prosopo/client-example-server
 
+## 2.7.13
+### Patch Changes
+
+  - @prosopo/server@2.9.9
+
+## 2.7.12
+### Patch Changes
+
+- Updated dependencies [b0d7207]
+  - @prosopo/types@3.0.3
+  - @prosopo/server@2.9.8
+
 ## 2.7.11
 ### Patch Changes
 

package/dist/bundle/prosopo_client_example_server.app.bundle.js

@@ -29426,7 +29426,7 @@ function A1() {
       const S = h(g), E = a++;
       i(m, E, g), u[m] = E, c[E] = g, f[E] = S, o[E] = new RegExp(g, b ? "g" : void 0), l[E] = new RegExp(S, b ? "g" : void 0);
     };
-    y("NUMERICIDENTIFIER", "0|[1-9]\\d*"), y("NUMERICIDENTIFIERLOOSE", "\\d+"), y("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${d}*`), y("MAINVERSION", `(${c[u.NUMERICIDENTIFIER]})\\.(${c[u.NUMERICIDENTIFIER]})\\.(${c[u.NUMERICIDENTIFIER]})`), y("MAINVERSIONLOOSE", `(${c[u.NUMERICIDENTIFIERLOOSE]})\\.(${c[u.NUMERICIDENTIFIERLOOSE]})\\.(${c[u.NUMERICIDENTIFIERLOOSE]})`), y("PRERELEASEIDENTIFIER", `(?:${c[u.NONNUMERICIDENTIFIER]}|${c[u.NUMERICIDENTIFIER]})`), y("PRERELEASEIDENTIFIERLOOSE", `(?:${c[u.NONNUMERICIDENTIFIER]}|${c[u.NUMERICIDENTIFIERLOOSE]})`), y("PRERELEASE", `(?:-(${c[u.PRERELEASEIDENTIFIER]}(?:\\.${c[u.PRERELEASEIDENTIFIER]})*))`), y("PRERELEASELOOSE", `(?:-?(${c[u.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${c[u.PRERELEASEIDENTIFIERLOOSE]})*))`), y("BUILDIDENTIFIER", `${d}+`), y("BUILD", `(?:\\+(${c[u.BUILDIDENTIFIER]}(?:\\.${c[u.BUILDIDENTIFIER]})*))`), y("FULLPLAIN", `v?${c[u.MAINVERSION]}${c[u.PRERELEASE]}?${c[u.BUILD]}?`), y("FULL", `^${c[u.FULLPLAIN]}$`), y("LOOSEPLAIN", `[v=\\s]*${c[u.MAINVERSIONLOOSE]}${c[u.PRERELEASELOOSE]}?${c[u.BUILD]}?`), y("LOOSE", `^${c[u.LOOSEPLAIN]}$`), y("GTLT", "((?:<|>)?=?)"), y("XRANGEIDENTIFIERLOOSE", `${c[u.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), y("XRANGEIDENTIFIER", `${c[u.NUMERICIDENTIFIER]}|x|X|\\*`), y("XRANGEPLAIN", `[v=\\s]*(${c[u.XRANGEIDENTIFIER]})(?:\\.(${c[u.XRANGEIDENTIFIER]})(?:\\.(${c[u.XRANGEIDENTIFIER]})(?:${c[u.PRERELEASE]})?${c[u.BUILD]}?)?)?`), y("XRANGEPLAINLOOSE", `[v=\\s]*(${c[u.XRANGEIDENTIFIERLOOSE]})(?:\\.(${c[u.XRANGEIDENTIFIERLOOSE]})(?:\\.(${c[u.XRANGEIDENTIFIERLOOSE]})(?:${c[u.PRERELEASELOOSE]})?${c[u.BUILD]}?)?)?`), y("XRANGE", `^${c[u.GTLT]}\\s*${c[u.XRANGEPLAIN]}$`), y("XRANGELOOSE", `^${c[u.GTLT]}\\s*${c[u.XRANGEPLAINLOOSE]}$`), y("COERCEPLAIN", `(^|[^\\d])(\\d{1,${r}})(?:\\.(\\d{1,${r}}))?(?:\\.(\\d{1,${r}}))?`), y("COERCE", `${c[u.COERCEPLAIN]}(?:$|[^\\d])`), y("COERCEFULL", c[u.COERCEPLAIN] + `(?:${c[u.PRERELEASE]})?(?:${c[u.BUILD]})?(?:$|[^\\d])`), y("COERCERTL", c[u.COERCE], !0), y("COERCERTLFULL", c[u.COERCEFULL], !0), y("LONETILDE", "(?:~>?)"), y("TILDETRIM", `(\\s*)${c[u.LONETILDE]}\\s+`, !0), t.tildeTrimReplace = "$1~", y("TILDE", `^${c[u.LONETILDE]}${c[u.XRANGEPLAIN]}$`), y("TILDELOOSE", `^${c[u.LONETILDE]}${c[u.XRANGEPLAINLOOSE]}$`), y("LONECARET", "(?:\\^)"), y("CARETTRIM", `(\\s*)${c[u.LONECARET]}\\s+`, !0), t.caretTrimReplace = "$1^", y("CARET", `^${c[u.LONECARET]}${c[u.XRANGEPLAIN]}$`), y("CARETLOOSE", `^${c[u.LONECARET]}${c[u.XRANGEPLAINLOOSE]}$`), y("COMPARATORLOOSE", `^${c[u.GTLT]}\\s*(${c[u.LOOSEPLAIN]})$|^$`), y("COMPARATOR", `^${c[u.GTLT]}\\s*(${c[u.FULLPLAIN]})$|^$`), y("COMPARATORTRIM", `(\\s*)${c[u.GTLT]}\\s*(${c[u.LOOSEPLAIN]}|${c[u.XRANGEPLAIN]})`, !0), t.comparatorTrimReplace = "$1$2$3", y("HYPHENRANGE", `^\\s*(${c[u.XRANGEPLAIN]})\\s+-\\s+(${c[u.XRANGEPLAIN]})\\s*$`), y("HYPHENRANGELOOSE", `^\\s*(${c[u.XRANGEPLAINLOOSE]})\\s+-\\s+(${c[u.XRANGEPLAINLOOSE]})\\s*$`), y("STAR", "(<|>)?=?\\s*\\*"), y("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), y("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+    y("NUMERICIDENTIFIER", "0|[1-9]\\d*"), y("NUMERICIDENTIFIERLOOSE", "\\d+"), y("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${d}*`), y("MAINVERSION", `(${c[u.NUMERICIDENTIFIER]})\\.(${c[u.NUMERICIDENTIFIER]})\\.(${c[u.NUMERICIDENTIFIER]})`), y("MAINVERSIONLOOSE", `(${c[u.NUMERICIDENTIFIERLOOSE]})\\.(${c[u.NUMERICIDENTIFIERLOOSE]})\\.(${c[u.NUMERICIDENTIFIERLOOSE]})`), y("PRERELEASEIDENTIFIER", `(?:${c[u.NUMERICIDENTIFIER]}|${c[u.NONNUMERICIDENTIFIER]})`), y("PRERELEASEIDENTIFIERLOOSE", `(?:${c[u.NUMERICIDENTIFIERLOOSE]}|${c[u.NONNUMERICIDENTIFIER]})`), y("PRERELEASE", `(?:-(${c[u.PRERELEASEIDENTIFIER]}(?:\\.${c[u.PRERELEASEIDENTIFIER]})*))`), y("PRERELEASELOOSE", `(?:-?(${c[u.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${c[u.PRERELEASEIDENTIFIERLOOSE]})*))`), y("BUILDIDENTIFIER", `${d}+`), y("BUILD", `(?:\\+(${c[u.BUILDIDENTIFIER]}(?:\\.${c[u.BUILDIDENTIFIER]})*))`), y("FULLPLAIN", `v?${c[u.MAINVERSION]}${c[u.PRERELEASE]}?${c[u.BUILD]}?`), y("FULL", `^${c[u.FULLPLAIN]}$`), y("LOOSEPLAIN", `[v=\\s]*${c[u.MAINVERSIONLOOSE]}${c[u.PRERELEASELOOSE]}?${c[u.BUILD]}?`), y("LOOSE", `^${c[u.LOOSEPLAIN]}$`), y("GTLT", "((?:<|>)?=?)"), y("XRANGEIDENTIFIERLOOSE", `${c[u.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`), y("XRANGEIDENTIFIER", `${c[u.NUMERICIDENTIFIER]}|x|X|\\*`), y("XRANGEPLAIN", `[v=\\s]*(${c[u.XRANGEIDENTIFIER]})(?:\\.(${c[u.XRANGEIDENTIFIER]})(?:\\.(${c[u.XRANGEIDENTIFIER]})(?:${c[u.PRERELEASE]})?${c[u.BUILD]}?)?)?`), y("XRANGEPLAINLOOSE", `[v=\\s]*(${c[u.XRANGEIDENTIFIERLOOSE]})(?:\\.(${c[u.XRANGEIDENTIFIERLOOSE]})(?:\\.(${c[u.XRANGEIDENTIFIERLOOSE]})(?:${c[u.PRERELEASELOOSE]})?${c[u.BUILD]}?)?)?`), y("XRANGE", `^${c[u.GTLT]}\\s*${c[u.XRANGEPLAIN]}$`), y("XRANGELOOSE", `^${c[u.GTLT]}\\s*${c[u.XRANGEPLAINLOOSE]}$`), y("COERCEPLAIN", `(^|[^\\d])(\\d{1,${r}})(?:\\.(\\d{1,${r}}))?(?:\\.(\\d{1,${r}}))?`), y("COERCE", `${c[u.COERCEPLAIN]}(?:$|[^\\d])`), y("COERCEFULL", c[u.COERCEPLAIN] + `(?:${c[u.PRERELEASE]})?(?:${c[u.BUILD]})?(?:$|[^\\d])`), y("COERCERTL", c[u.COERCE], !0), y("COERCERTLFULL", c[u.COERCEFULL], !0), y("LONETILDE", "(?:~>?)"), y("TILDETRIM", `(\\s*)${c[u.LONETILDE]}\\s+`, !0), t.tildeTrimReplace = "$1~", y("TILDE", `^${c[u.LONETILDE]}${c[u.XRANGEPLAIN]}$`), y("TILDELOOSE", `^${c[u.LONETILDE]}${c[u.XRANGEPLAINLOOSE]}$`), y("LONECARET", "(?:\\^)"), y("CARETTRIM", `(\\s*)${c[u.LONECARET]}\\s+`, !0), t.caretTrimReplace = "$1^", y("CARET", `^${c[u.LONECARET]}${c[u.XRANGEPLAIN]}$`), y("CARETLOOSE", `^${c[u.LONECARET]}${c[u.XRANGEPLAINLOOSE]}$`), y("COMPARATORLOOSE", `^${c[u.GTLT]}\\s*(${c[u.LOOSEPLAIN]})$|^$`), y("COMPARATOR", `^${c[u.GTLT]}\\s*(${c[u.FULLPLAIN]})$|^$`), y("COMPARATORTRIM", `(\\s*)${c[u.GTLT]}\\s*(${c[u.LOOSEPLAIN]}|${c[u.XRANGEPLAIN]})`, !0), t.comparatorTrimReplace = "$1$2$3", y("HYPHENRANGE", `^\\s*(${c[u.XRANGEPLAIN]})\\s+-\\s+(${c[u.XRANGEPLAIN]})\\s*$`), y("HYPHENRANGELOOSE", `^\\s*(${c[u.XRANGEPLAINLOOSE]})\\s+-\\s+(${c[u.XRANGEPLAINLOOSE]})\\s*$`), y("STAR", "(<|>)?=?\\s*\\*"), y("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$"), y("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
   }(Jy, Jy.exports)), Jy.exports;
 }
 var ww, p5;
@@ -29453,37 +29453,37 @@ var Ow, y5;
 function Ci() {
   if (y5) return Ow;
   y5 = 1;
-  const e = /* @__PURE__ */ I_(), { MAX_LENGTH: t, MAX_SAFE_INTEGER: r } = /* @__PURE__ */ R_(), { safeRe: n, t: s } = /* @__PURE__ */ A1(), i = /* @__PURE__ */ MP(), { compareIdentifiers: o } = /* @__PURE__ */ Kie();
-  class l {
-    constructor(f, u) {
-      if (u = i(u), f instanceof l) {
-        if (f.loose === !!u.loose && f.includePrerelease === !!u.includePrerelease)
-          return f;
-        f = f.version;
-      } else if (typeof f != "string")
-        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof f}".`);
-      if (f.length > t)
+  const e = /* @__PURE__ */ I_(), { MAX_LENGTH: t, MAX_SAFE_INTEGER: r } = /* @__PURE__ */ R_(), { safeRe: n, safeSrc: s, t: i } = /* @__PURE__ */ A1(), o = /* @__PURE__ */ MP(), { compareIdentifiers: l } = /* @__PURE__ */ Kie();
+  class c {
+    constructor(u, a) {
+      if (a = o(a), u instanceof c) {
+        if (u.loose === !!a.loose && u.includePrerelease === !!a.includePrerelease)
+          return u;
+        u = u.version;
+      } else if (typeof u != "string")
+        throw new TypeError(`Invalid version. Must be a string. Got type "${typeof u}".`);
+      if (u.length > t)
         throw new TypeError(
           `version is longer than ${t} characters`
         );
-      e("SemVer", f, u), this.options = u, this.loose = !!u.loose, this.includePrerelease = !!u.includePrerelease;
-      const a = f.trim().match(u.loose ? n[s.LOOSE] : n[s.FULL]);
-      if (!a)
-        throw new TypeError(`Invalid Version: ${f}`);
-      if (this.raw = f, this.major = +a[1], this.minor = +a[2], this.patch = +a[3], this.major > r || this.major < 0)
+      e("SemVer", u, a), this.options = a, this.loose = !!a.loose, this.includePrerelease = !!a.includePrerelease;
+      const d = u.trim().match(a.loose ? n[i.LOOSE] : n[i.FULL]);
+      if (!d)
+        throw new TypeError(`Invalid Version: ${u}`);
+      if (this.raw = u, this.major = +d[1], this.minor = +d[2], this.patch = +d[3], this.major > r || this.major < 0)
         throw new TypeError("Invalid major version");
       if (this.minor > r || this.minor < 0)
         throw new TypeError("Invalid minor version");
       if (this.patch > r || this.patch < 0)
         throw new TypeError("Invalid patch version");
-      a[4] ? this.prerelease = a[4].split(".").map((d) => {
-        if (/^[0-9]+$/.test(d)) {
-          const p = +d;
-          if (p >= 0 && p < r)
-            return p;
+      d[4] ? this.prerelease = d[4].split(".").map((p) => {
+        if (/^[0-9]+$/.test(p)) {
+          const h = +p;
+          if (h >= 0 && h < r)
+            return h;
         }
-        return d;
-      }) : this.prerelease = [], this.build = a[5] ? a[5].split(".") : [], this.format();
+        return p;
+      }) : this.prerelease = [], this.build = d[5] ? d[5].split(".") : [], this.format();
     }
     format() {
       return this.version = `${this.major}.${this.minor}.${this.patch}`, this.prerelease.length && (this.version += `-${this.prerelease.join(".")}`), this.version;
@@ -29491,80 +29491,80 @@ function Ci() {
     toString() {
       return this.version;
     }
-    compare(f) {
-      if (e("SemVer.compare", this.version, this.options, f), !(f instanceof l)) {
-        if (typeof f == "string" && f === this.version)
+    compare(u) {
+      if (e("SemVer.compare", this.version, this.options, u), !(u instanceof c)) {
+        if (typeof u == "string" && u === this.version)
           return 0;
-        f = new l(f, this.options);
+        u = new c(u, this.options);
       }
-      return f.version === this.version ? 0 : this.compareMain(f) || this.comparePre(f);
+      return u.version === this.version ? 0 : this.compareMain(u) || this.comparePre(u);
     }
-    compareMain(f) {
-      return f instanceof l || (f = new l(f, this.options)), o(this.major, f.major) || o(this.minor, f.minor) || o(this.patch, f.patch);
+    compareMain(u) {
+      return u instanceof c || (u = new c(u, this.options)), l(this.major, u.major) || l(this.minor, u.minor) || l(this.patch, u.patch);
     }
-    comparePre(f) {
-      if (f instanceof l || (f = new l(f, this.options)), this.prerelease.length && !f.prerelease.length)
+    comparePre(u) {
+      if (u instanceof c || (u = new c(u, this.options)), this.prerelease.length && !u.prerelease.length)
         return -1;
-      if (!this.prerelease.length && f.prerelease.length)
+      if (!this.prerelease.length && u.prerelease.length)
         return 1;
-      if (!this.prerelease.length && !f.prerelease.length)
+      if (!this.prerelease.length && !u.prerelease.length)
         return 0;
-      let u = 0;
+      let a = 0;
       do {
-        const a = this.prerelease[u], d = f.prerelease[u];
-        if (e("prerelease compare", u, a, d), a === void 0 && d === void 0)
+        const d = this.prerelease[a], p = u.prerelease[a];
+        if (e("prerelease compare", a, d, p), d === void 0 && p === void 0)
           return 0;
-        if (d === void 0)
+        if (p === void 0)
           return 1;
-        if (a === void 0)
+        if (d === void 0)
           return -1;
-        if (a === d)
+        if (d === p)
           continue;
-        return o(a, d);
-      } while (++u);
+        return l(d, p);
+      } while (++a);
     }
-    compareBuild(f) {
-      f instanceof l || (f = new l(f, this.options));
-      let u = 0;
+    compareBuild(u) {
+      u instanceof c || (u = new c(u, this.options));
+      let a = 0;
       do {
-        const a = this.build[u], d = f.build[u];
-        if (e("build compare", u, a, d), a === void 0 && d === void 0)
+        const d = this.build[a], p = u.build[a];
+        if (e("build compare", a, d, p), d === void 0 && p === void 0)
           return 0;
-        if (d === void 0)
+        if (p === void 0)
           return 1;
-        if (a === void 0)
+        if (d === void 0)
           return -1;
-        if (a === d)
+        if (d === p)
           continue;
-        return o(a, d);
-      } while (++u);
+        return l(d, p);
+      } while (++a);
     }
     // 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(f, u, a) {
-      if (f.startsWith("pre")) {
-        if (!u && a === !1)
+    inc(u, a, d) {
+      if (u.startsWith("pre")) {
+        if (!a && d === !1)
           throw new Error("invalid increment argument: identifier is empty");
-        if (u) {
-          const d = `-${u}`.match(this.options.loose ? n[s.PRERELEASELOOSE] : n[s.PRERELEASE]);
-          if (!d || d[1] !== u)
-            throw new Error(`invalid identifier: ${u}`);
+        if (a) {
+          const p = new RegExp(`^${this.options.loose ? s[i.PRERELEASELOOSE] : s[i.PRERELEASE]}$`), h = `-${a}`.match(p);
+          if (!h || h[1] !== a)
+            throw new Error(`invalid identifier: ${a}`);
         }
       }
-      switch (f) {
+      switch (u) {
         case "premajor":
-          this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", u, a);
+          this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", a, d);
           break;
         case "preminor":
-          this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", u, a);
+          this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", a, d);
           break;
         case "prepatch":
-          this.prerelease.length = 0, this.inc("patch", u, a), this.inc("pre", u, a);
+          this.prerelease.length = 0, this.inc("patch", a, d), this.inc("pre", a, d);
           break;
         // If the input is a non-prerelease version, this acts the same as
         // prepatch.
         case "prerelease":
-          this.prerelease.length === 0 && this.inc("patch", u, a), this.inc("pre", u, a);
+          this.prerelease.length === 0 && this.inc("patch", a, d), this.inc("pre", a, d);
           break;
         case "release":
           if (this.prerelease.length === 0)
@@ -29583,32 +29583,32 @@ function Ci() {
         // This probably shouldn't be used publicly.
         // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
         case "pre": {
-          const d = Number(a) ? 1 : 0;
+          const p = Number(d) ? 1 : 0;
           if (this.prerelease.length === 0)
-            this.prerelease = [d];
+            this.prerelease = [p];
           else {
-            let p = this.prerelease.length;
-            for (; --p >= 0; )
-              typeof this.prerelease[p] == "number" && (this.prerelease[p]++, p = -2);
-            if (p === -1) {
-              if (u === this.prerelease.join(".") && a === !1)
+            let h = this.prerelease.length;
+            for (; --h >= 0; )
+              typeof this.prerelease[h] == "number" && (this.prerelease[h]++, h = -2);
+            if (h === -1) {
+              if (a === this.prerelease.join(".") && d === !1)
                 throw new Error("invalid increment argument: identifier already exists");
-              this.prerelease.push(d);
+              this.prerelease.push(p);
             }
           }
-          if (u) {
-            let p = [u, d];
-            a === !1 && (p = [u]), o(this.prerelease[0], u) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = p) : this.prerelease = p;
+          if (a) {
+            let h = [a, p];
+            d === !1 && (h = [a]), l(this.prerelease[0], a) === 0 ? isNaN(this.prerelease[1]) && (this.prerelease = h) : this.prerelease = h;
           }
           break;
         }
         default:
-          throw new Error(`invalid increment argument: ${f}`);
+          throw new Error(`invalid increment argument: ${u}`);
       }
       return this.raw = this.format(), this.build.length && (this.raw += `+${this.build.join(".")}`), this;
     }
   }
-  return Ow = l, Ow;
+  return Ow = c, Ow;
 }
 var Cw, g5;
 function Jl() {
@@ -70242,7 +70242,7 @@ function Bae() {
   if (DV) return cT;
   DV = 1;
   function e(t) {
-    n.debug = n, n.default = n, n.coerce = f, n.disable = l, n.enable = i, n.enabled = c, n.humanize = /* @__PURE__ */ C1(), n.destroy = u, Object.keys(t).forEach((a) => {
+    n.debug = n, n.default = n, n.coerce = f, n.disable = o, n.enable = i, n.enabled = l, n.humanize = /* @__PURE__ */ C1(), n.destroy = u, Object.keys(t).forEach((a) => {
       n[a] = t[a];
     }), n.names = [], n.skips = [], n.formatters = {};
     function r(a) {
@@ -70287,39 +70287,33 @@ function Bae() {
     }
     function i(a) {
       n.save(a), n.namespaces = a, n.names = [], n.skips = [];
-      const d = (typeof a == "string" ? a : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
-      for (const p of d)
-        p[0] === "-" ? n.skips.push(p.slice(1)) : n.names.push(p);
-    }
-    function o(a, d) {
-      let p = 0, h = 0, y = -1, m = 0;
-      for (; p < a.length; )
-        if (h < d.length && (d[h] === a[p] || d[h] === "*"))
-          d[h] === "*" ? (y = h, m = p, h++) : (p++, h++);
-        else if (y !== -1)
-          h = y + 1, m++, p = m;
-        else
-          return !1;
-      for (; h < d.length && d[h] === "*"; )
-        h++;
-      return h === d.length;
+      let d;
+      const p = (typeof a == "string" ? a : "").split(/[\s,]+/), h = p.length;
+      for (d = 0; d < h; d++)
+        p[d] && (a = p[d].replace(/\*/g, ".*?"), a[0] === "-" ? n.skips.push(new RegExp("^" + a.slice(1) + "$")) : n.names.push(new RegExp("^" + a + "$")));
     }
-    function l() {
+    function o() {
       const a = [
-        ...n.names,
-        ...n.skips.map((d) => "-" + d)
+        ...n.names.map(c),
+        ...n.skips.map(c).map((d) => "-" + d)
       ].join(",");
       return n.enable(""), a;
     }
-    function c(a) {
-      for (const d of n.skips)
-        if (o(a, d))
+    function l(a) {
+      if (a[a.length - 1] === "*")
+        return !0;
+      let d, p;
+      for (d = 0, p = n.skips.length; d < p; d++)
+        if (n.skips[d].test(a))
           return !1;
-      for (const d of n.names)
-        if (o(a, d))
+      for (d = 0, p = n.names.length; d < p; d++)
+        if (n.names[d].test(a))
           return !0;
       return !1;
     }
+    function c(a) {
+      return a.toString().substring(2, a.toString().length - 2).replace(/\.\*\?$/, "*");
+    }
     function f(a) {
       return a instanceof Error ? a.stack || a.message : a;
     }
@@ -70449,7 +70443,7 @@ function eOe() {
     function i() {
       let c;
       try {
-        c = t.storage.getItem("debug") || t.storage.getItem("DEBUG");
+        c = t.storage.getItem("debug");
       } catch {
       }
       return !c && typeof process < "u" && "env" in process && (c = process.env.DEBUG), c;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prosopo/client-example-server",
-	"version": "2.7.11",
+	"version": "2.7.13",
 	"description": "Backend for client-example",
 	"main": "dist/app.js",
 	"type": "module",
@@ -34,8 +34,8 @@
 		"@polkadot/util-crypto": "12.6.2",
 		"@prosopo/common": "3.0.2",
 		"@prosopo/dotenv": "3.0.4",
-		"@prosopo/server": "2.9.7",
-		"@prosopo/types": "3.0.2",
+		"@prosopo/server": "2.9.9",
+		"@prosopo/types": "3.0.3",
 		"@prosopo/util": "3.0.2",
 		"@typegoose/auto-increment": "4.13.0",
 		"axios": "1.10.0",