strapi-plugin-firebase-authentication 1.2.1 → 1.2.3

package/dist/server/index.mjs

@@ -13,7 +13,7 @@ import require$$0$8 from "constants";
 import "node:stream";
 import admin$1 from "firebase-admin";
 import CryptoJS from "crypto-js";
-import * as fs$6 from "fs/promises";
+import * as fs$8 from "fs/promises";
 async function migrateFirebaseUserData(strapi2, dryRun = false) {
   strapi2.log.info("=== Firebase User Data Migration ===");
   strapi2.log.info(`Mode: ${dryRun ? "DRY RUN (no changes)" : "LIVE (will modify database)"}`);
@@ -982,9 +982,9 @@ lodash.exports;
     function hasUnicodeWord2(string2) {
       return reHasUnicodeWord2.test(string2);
     }
-    function iteratorToArray(iterator) {
+    function iteratorToArray(iterator2) {
       var data, result = [];
-      while (!(data = iterator.next()).done) {
+      while (!(data = iterator2.next()).done) {
         result.push(data.value);
       }
       return result;
@@ -9567,7 +9567,7 @@ var _mapping = {};
 })(_mapping);
 var placeholder = {};
 var mapping = _mapping, fallbackHolder = placeholder;
-var push = Array.prototype.push;
+var push$1 = Array.prototype.push;
 function baseArity(func, n) {
   return n == 2 ? function(a, b) {
     return func.apply(void 0, arguments);
@@ -9602,10 +9602,10 @@ function flatSpread(func, start) {
     }
     var array2 = args[start], otherArgs = args.slice(0, start);
     if (array2) {
-      push.apply(otherArgs, array2);
+      push$1.apply(otherArgs, array2);
     }
     if (start != lastIndex) {
-      push.apply(otherArgs, args.slice(start + 1));
+      push$1.apply(otherArgs, args.slice(start + 1));
     }
     return func.apply(this, otherArgs);
   };
@@ -12213,11 +12213,11 @@ function baseGet$2(object2, path2) {
 }
 var _baseGet = baseGet$2;
 var baseGet$1 = _baseGet;
-function get$1(object2, path2, defaultValue) {
+function get$2(object2, path2, defaultValue) {
   var result = object2 == null ? void 0 : baseGet$1(object2, path2);
   return result === void 0 ? defaultValue : result;
 }
-var get_1 = get$1;
+var get_1 = get$2;
 function baseHasIn$1(object2, key) {
   return object2 != null && key in Object(object2);
 }
@@ -12227,14 +12227,14 @@ function hasIn$1(object2, path2) {
   return object2 != null && hasPath(object2, path2, baseHasIn);
 }
 var hasIn_1 = hasIn$1;
-var baseIsEqual = _baseIsEqual, get = get_1, hasIn = hasIn_1, isKey$1 = _isKey, isStrictComparable = _isStrictComparable, matchesStrictComparable = _matchesStrictComparable, toKey$1 = _toKey;
+var baseIsEqual = _baseIsEqual, get$1 = get_1, hasIn = hasIn_1, isKey$1 = _isKey, isStrictComparable = _isStrictComparable, matchesStrictComparable = _matchesStrictComparable, toKey$1 = _toKey;
 var COMPARE_PARTIAL_FLAG = 1, COMPARE_UNORDERED_FLAG = 2;
 function baseMatchesProperty$1(path2, srcValue) {
   if (isKey$1(path2) && isStrictComparable(srcValue)) {
     return matchesStrictComparable(toKey$1(path2), srcValue);
   }
   return function(object2) {
-    var objValue = get(object2, path2);
+    var objValue = get$1(object2, path2);
     return objValue === void 0 && objValue === srcValue ? hasIn(object2, path2) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
   };
 }
@@ -12530,7 +12530,7 @@ function createValidation(config2) {
   validate2.OPTIONS = config2;
   return validate2;
 }
-let trim = (part) => part.substr(0, part.length - 1).substr(1);
+let trim$1 = (part) => part.substr(0, part.length - 1).substr(1);
 function getIn(schema2, path2, value, context = value) {
   let parent, lastPart, lastPartDebug;
   if (!path2) return {
@@ -12539,7 +12539,7 @@ function getIn(schema2, path2, value, context = value) {
     schema: schema2
   };
   propertyExpr.forEach(path2, (_part, isBracket, isArray2) => {
-    let part = isBracket ? trim(_part) : _part;
+    let part = isBracket ? trim$1(_part) : _part;
     schema2 = schema2.resolve({
       context,
       parent,
@@ -14926,7 +14926,7 @@ var pMap = async (iterable, mapper, {
     }
     const result = [];
     const errors2 = [];
-    const iterator = iterable[Symbol.iterator]();
+    const iterator2 = iterable[Symbol.iterator]();
     let isRejected = false;
     let isIterableDone = false;
     let resolvingCount = 0;
@@ -14935,7 +14935,7 @@ var pMap = async (iterable, mapper, {
       if (isRejected) {
         return;
       }
-      const nextItem = iterator.next();
+      const nextItem = iterator2.next();
       const index2 = currentIndex;
       currentIndex++;
       if (nextItem.done) {
@@ -16145,16 +16145,16 @@ var shebangCommand$1 = (string2 = "") => {
   }
   return argument ? `${binary2} ${argument}` : binary2;
 };
-const fs$5 = require$$0$4;
+const fs$7 = require$$0$4;
 const shebangCommand = shebangCommand$1;
 function readShebang$1(command2) {
   const size = 150;
   const buffer = Buffer.alloc(size);
   let fd;
   try {
-    fd = fs$5.openSync(command2, "r");
-    fs$5.readSync(fd, buffer, 0, size, 0);
-    fs$5.closeSync(fd);
+    fd = fs$7.openSync(command2, "r");
+    fs$7.readSync(fd, buffer, 0, size, 0);
+    fs$7.closeSync(fd);
   } catch (e) {
   }
   return shebangCommand(buffer.toString());
@@ -17165,9 +17165,9 @@ var bufferStream$1 = (options2) => {
 };
 const { constants: BufferConstants } = require$$0$7;
 const stream$1 = require$$0$6;
-const { promisify: promisify$3 } = require$$2$1;
+const { promisify: promisify$5 } = require$$2$1;
 const bufferStream = bufferStream$1;
-const streamPipelinePromisified = promisify$3(stream$1.pipeline);
+const streamPipelinePromisified = promisify$5(stream$1.pipeline);
 class MaxBufferError extends Error {
   constructor() {
     super("maxBuffer exceeded");
@@ -17703,11 +17703,11 @@ pLocate$4.exports = pLocate$3;
 pLocate$4.exports.default = pLocate$3;
 var pLocateExports = pLocate$4.exports;
 const path$4 = require$$0__default;
-const fs$4 = require$$0$4;
-const { promisify: promisify$2 } = require$$2$1;
+const fs$6 = require$$0$4;
+const { promisify: promisify$4 } = require$$2$1;
 const pLocate$2 = pLocateExports;
-const fsStat$1 = promisify$2(fs$4.stat);
-const fsLStat$1 = promisify$2(fs$4.lstat);
+const fsStat$1 = promisify$4(fs$6.stat);
+const fsLStat$1 = promisify$4(fs$6.lstat);
 const typeMappings$1 = {
   directory: "isDirectory",
   file: "isFile"
@@ -17745,7 +17745,7 @@ locatePath$1.exports.sync = (paths, options2) => {
     ...options2
   };
   checkType$1(options2);
-  const statFn = options2.allowSymlinks ? fs$4.statSync : fs$4.lstatSync;
+  const statFn = options2.allowSymlinks ? fs$6.statSync : fs$6.lstatSync;
   for (const path_ of paths) {
     try {
       const stat = statFn(path$4.resolve(options2.cwd, path_));
@@ -17757,31 +17757,31 @@ locatePath$1.exports.sync = (paths, options2) => {
   }
 };
 var locatePathExports$1 = locatePath$1.exports;
-var pathExists = { exports: {} };
-const fs$3 = require$$0$4;
-const { promisify: promisify$1 } = require$$2$1;
-const pAccess = promisify$1(fs$3.access);
-pathExists.exports = async (path2) => {
+var pathExists$2 = { exports: {} };
+const fs$5 = require$$0$4;
+const { promisify: promisify$3 } = require$$2$1;
+const pAccess$2 = promisify$3(fs$5.access);
+pathExists$2.exports = async (path2) => {
   try {
-    await pAccess(path2);
+    await pAccess$2(path2);
     return true;
   } catch (_2) {
     return false;
   }
 };
-pathExists.exports.sync = (path2) => {
+pathExists$2.exports.sync = (path2) => {
   try {
-    fs$3.accessSync(path2);
+    fs$5.accessSync(path2);
     return true;
   } catch (_2) {
     return false;
   }
 };
-var pathExistsExports = pathExists.exports;
+var pathExistsExports$1 = pathExists$2.exports;
 (function(module) {
   const path2 = require$$0__default;
   const locatePath2 = locatePathExports$1;
-  const pathExists2 = pathExistsExports;
+  const pathExists2 = pathExistsExports$1;
   const stop = Symbol("findUp.stop");
   module.exports = async (name, options2 = {}) => {
     let directory = path2.resolve(options2.cwd || "");
@@ -20535,14 +20535,14 @@ const core_1 = core$1;
 core_1.findWorkspaceRoot;
 var findUp = { exports: {} };
 var locatePath = { exports: {} };
-class Node {
+let Node$1 = class Node {
   /// value;
   /// next;
   constructor(value) {
     this.value = value;
     this.next = void 0;
   }
-}
+};
 let Queue$1 = class Queue {
   // TODO: Use private class fields when targeting Node.js 12.
   // #_head;
@@ -20552,7 +20552,7 @@ let Queue$1 = class Queue {
     this.clear();
   }
   enqueue(value) {
-    const node = new Node(value);
+    const node = new Node$1(value);
     if (this._head) {
       this._tail.next = node;
       this._tail = node;
@@ -20674,11 +20674,11 @@ const pLocate$1 = async (iterable, tester, options2) => {
 };
 var pLocate_1 = pLocate$1;
 const path = require$$0__default;
-const fs$2 = require$$0$4;
-const { promisify } = require$$2$1;
+const fs$4 = require$$0$4;
+const { promisify: promisify$2 } = require$$2$1;
 const pLocate = pLocate_1;
-const fsStat = promisify(fs$2.stat);
-const fsLStat = promisify(fs$2.lstat);
+const fsStat = promisify$2(fs$4.stat);
+const fsLStat = promisify$2(fs$4.lstat);
 const typeMappings = {
   directory: "isDirectory",
   file: "isFile"
@@ -20716,7 +20716,7 @@ locatePath.exports.sync = (paths, options2) => {
     ...options2
   };
   checkType(options2);
-  const statFn = options2.allowSymlinks ? fs$2.statSync : fs$2.lstatSync;
+  const statFn = options2.allowSymlinks ? fs$4.statSync : fs$4.lstatSync;
   for (const path_ of paths) {
     try {
       const stat = statFn(path.resolve(options2.cwd, path_));
@@ -20728,6 +20728,27 @@ locatePath.exports.sync = (paths, options2) => {
   }
 };
 var locatePathExports = locatePath.exports;
+var pathExists$1 = { exports: {} };
+const fs$3 = require$$0$4;
+const { promisify: promisify$1 } = require$$2$1;
+const pAccess$1 = promisify$1(fs$3.access);
+pathExists$1.exports = async (path2) => {
+  try {
+    await pAccess$1(path2);
+    return true;
+  } catch (_2) {
+    return false;
+  }
+};
+pathExists$1.exports.sync = (path2) => {
+  try {
+    fs$3.accessSync(path2);
+    return true;
+  } catch (_2) {
+    return false;
+  }
+};
+var pathExistsExports = pathExists$1.exports;
 (function(module) {
   const path2 = require$$0__default;
   const locatePath2 = locatePathExports;
@@ -20793,6 +20814,26 @@ var locatePathExports = locatePath.exports;
   module.exports.sync.exists = pathExists2.sync;
   module.exports.stop = stop;
 })(findUp);
+var pathExists = { exports: {} };
+const fs$2 = require$$0$4;
+const { promisify } = require$$2$1;
+const pAccess = promisify(fs$2.access);
+pathExists.exports = async (path2) => {
+  try {
+    await pAccess(path2);
+    return true;
+  } catch (_2) {
+    return false;
+  }
+};
+pathExists.exports.sync = (path2) => {
+  try {
+    fs$2.accessSync(path2);
+    return true;
+  } catch (_2) {
+    return false;
+  }
+};
 var loadYamlFile = { exports: {} };
 var constants$2 = require$$0$8;
 var origCwd = process.cwd;
@@ -23620,17 +23661,17 @@ function loadDocuments(input, options2) {
   }
   return state.documents;
 }
-function loadAll(input, iterator, options2) {
-  if (iterator !== null && typeof iterator === "object" && typeof options2 === "undefined") {
-    options2 = iterator;
-    iterator = null;
+function loadAll(input, iterator2, options2) {
+  if (iterator2 !== null && typeof iterator2 === "object" && typeof options2 === "undefined") {
+    options2 = iterator2;
+    iterator2 = null;
   }
   var documents = loadDocuments(input, options2);
-  if (typeof iterator !== "function") {
+  if (typeof iterator2 !== "function") {
     return documents;
   }
   for (var index2 = 0, length = documents.length; index2 < length; index2 += 1) {
-    iterator(documents[index2]);
+    iterator2(documents[index2]);
   }
 }
 function load(input, options2) {
@@ -23642,12 +23683,12 @@ function load(input, options2) {
   }
   throw new YAMLException$1("expected a single document in the stream, but found more");
 }
-function safeLoadAll(input, iterator, options2) {
-  if (typeof iterator === "object" && iterator !== null && typeof options2 === "undefined") {
-    options2 = iterator;
-    iterator = null;
+function safeLoadAll(input, iterator2, options2) {
+  if (typeof iterator2 === "object" && iterator2 !== null && typeof options2 === "undefined") {
+    options2 = iterator2;
+    iterator2 = null;
   }
-  return loadAll(input, iterator, common$1.extend({ schema: DEFAULT_SAFE_SCHEMA$1 }, options2));
+  return loadAll(input, iterator2, common$1.extend({ schema: DEFAULT_SAFE_SCHEMA$1 }, options2));
 }
 function safeLoad(input, options2) {
   return load(input, common$1.extend({ schema: DEFAULT_SAFE_SCHEMA$1 }, options2));
@@ -28910,12 +28951,15 @@ const firebaseController = {
     try {
       const { token } = ctx.request.body || {};
       if (!token) {
-        throw new ValidationError$1("Token is required");
+        return ctx.badRequest("Token is required");
       }
       const result = await strapi.plugin(pluginName).service("firebaseService").verifyEmail(token);
       ctx.body = result;
     } catch (error2) {
       strapi.log.error("verifyEmail controller error:", error2);
+      if (error2.name === "ValidationError") {
+        return ctx.badRequest(error2.message);
+      }
       throw error2;
     }
   }
@@ -31111,6 +31155,22 @@ const firebaseService = ({ strapi: strapi2 }) => ({
     const tokenService2 = strapi2.plugin("firebase-authentication").service("tokenService");
     const validationResult = await tokenService2.validateVerificationToken(token);
     if (!validationResult.valid) {
+      if (validationResult.code === "TOKEN_ALREADY_USED" && validationResult.firebaseUID) {
+        try {
+          const firebaseUser = await strapi2.firebase.auth().getUser(validationResult.firebaseUID);
+          if (firebaseUser.emailVerified) {
+            strapi2.log.info(
+              `[verifyEmail] Token already used but email is verified for: ${firebaseUser.email}`
+            );
+            return {
+              success: true,
+              message: "This email has already been verified."
+            };
+          }
+        } catch (checkError) {
+          strapi2.log.warn(`[verifyEmail] Could not verify Firebase user status: ${checkError.message}`);
+        }
+      }
       strapi2.log.warn(`[verifyEmail] Token validation failed: ${validationResult.error}`);
       throw new ValidationError$1(validationResult.error || "Invalid verification link");
     }
@@ -31709,7 +31769,7 @@ class TemplateService {
     if (userTemplate.htmlFile) {
       try {
         const htmlPath = require$$0$1.resolve(userTemplate.htmlFile);
-        mergedTemplate.html = await fs$6.readFile(htmlPath, "utf-8");
+        mergedTemplate.html = await fs$8.readFile(htmlPath, "utf-8");
       } catch (error2) {
         strapi.log.warn(
           `Failed to load HTML template from ${userTemplate.htmlFile}: ${error2.message}. Using default template.`
@@ -31721,7 +31781,7 @@ class TemplateService {
     if (userTemplate.textFile) {
       try {
         const textPath = require$$0$1.resolve(userTemplate.textFile);
-        mergedTemplate.text = await fs$6.readFile(textPath, "utf-8");
+        mergedTemplate.text = await fs$8.readFile(textPath, "utf-8");
       } catch (error2) {
         strapi.log.warn(
           `Failed to load text template from ${userTemplate.textFile}: ${error2.message}. Using default template.`
@@ -33467,7 +33527,6 @@ var debug_1 = debug$1;
   const re2 = exports$1.re = [];
   const safeRe = exports$1.safeRe = [];
   const src = exports$1.src = [];
-  const safeSrc = exports$1.safeSrc = [];
   const t2 = exports$1.t = {};
   let R = 0;
   const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
@@ -33488,7 +33547,6 @@ var debug_1 = debug$1;
     debug2(name, index2, value);
     t2[name] = index2;
     src[index2] = value;
-    safeSrc[index2] = safe;
     re2[index2] = new RegExp(value, isGlobal ? "g" : void 0);
     safeRe[index2] = new RegExp(safe, isGlobal ? "g" : void 0);
   };
@@ -33497,8 +33555,8 @@ var debug_1 = debug$1;
   createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
   createToken("MAINVERSION", `(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})\\.(${src[t2.NUMERICIDENTIFIER]})`);
   createToken("MAINVERSIONLOOSE", `(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})\\.(${src[t2.NUMERICIDENTIFIERLOOSE]})`);
-  createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NONNUMERICIDENTIFIER]}|${src[t2.NUMERICIDENTIFIER]})`);
-  createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NONNUMERICIDENTIFIER]}|${src[t2.NUMERICIDENTIFIERLOOSE]})`);
+  createToken("PRERELEASEIDENTIFIER", `(?:${src[t2.NUMERICIDENTIFIER]}|${src[t2.NONNUMERICIDENTIFIER]})`);
+  createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t2.NUMERICIDENTIFIERLOOSE]}|${src[t2.NONNUMERICIDENTIFIER]})`);
   createToken("PRERELEASE", `(?:-(${src[t2.PRERELEASEIDENTIFIER]}(?:\\.${src[t2.PRERELEASEIDENTIFIER]})*))`);
   createToken("PRERELEASELOOSE", `(?:-?(${src[t2.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t2.PRERELEASEIDENTIFIERLOOSE]})*))`);
   createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
@@ -33514,11 +33572,8 @@ var debug_1 = debug$1;
   createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t2.XRANGEIDENTIFIERLOOSE]})(?:${src[t2.PRERELEASELOOSE]})?${src[t2.BUILD]}?)?)?`);
   createToken("XRANGE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAIN]}$`);
   createToken("XRANGELOOSE", `^${src[t2.GTLT]}\\s*${src[t2.XRANGEPLAINLOOSE]}$`);
-  createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH2}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?`);
-  createToken("COERCE", `${src[t2.COERCEPLAIN]}(?:$|[^\\d])`);
-  createToken("COERCEFULL", src[t2.COERCEPLAIN] + `(?:${src[t2.PRERELEASE]})?(?:${src[t2.BUILD]})?(?:$|[^\\d])`);
+  createToken("COERCE", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH2}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH2}}))?(?:$|[^\\d])`);
   createToken("COERCERTL", src[t2.COERCE], true);
-  createToken("COERCERTLFULL", src[t2.COERCEFULL], true);
   createToken("LONETILDE", "(?:~>?)");
   createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true);
   exports$1.tildeTrimReplace = "$1~";
@@ -33554,9 +33609,6 @@ const parseOptions$1 = (options2) => {
 var parseOptions_1 = parseOptions$1;
 const numeric = /^[0-9]+$/;
 const compareIdentifiers$1 = (a, b) => {
-  if (typeof a === "number" && typeof b === "number") {
-    return a === b ? 0 : a < b ? -1 : 1;
-  }
   const anum = numeric.test(a);
   const bnum = numeric.test(b);
   if (anum && bnum) {
@@ -33656,25 +33708,7 @@ let SemVer$d = class SemVer {
     if (!(other instanceof SemVer)) {
       other = new SemVer(other, this.options);
     }
-    if (this.major < other.major) {
-      return -1;
-    }
-    if (this.major > other.major) {
-      return 1;
-    }
-    if (this.minor < other.minor) {
-      return -1;
-    }
-    if (this.minor > other.minor) {
-      return 1;
-    }
-    if (this.patch < other.patch) {
-      return -1;
-    }
-    if (this.patch > other.patch) {
-      return 1;
-    }
-    return 0;
+    return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
   }
   comparePre(other) {
     if (!(other instanceof SemVer)) {
@@ -33713,7 +33747,7 @@ let SemVer$d = class SemVer {
     do {
       const a = this.build[i];
       const b = other.build[i];
-      debug("build compare", i, a, b);
+      debug("prerelease compare", i, a, b);
       if (a === void 0 && b === void 0) {
         return 0;
       } else if (b === void 0) {
@@ -33730,17 +33764,6 @@ let SemVer$d = class SemVer {
   // 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(release, identifier, identifierBase) {
-    if (release.startsWith("pre")) {
-      if (!identifier && identifierBase === false) {
-        throw new Error("invalid increment argument: identifier is empty");
-      }
-      if (identifier) {
-        const match = `-${identifier}`.match(this.options.loose ? re$1[t$1.PRERELEASELOOSE] : re$1[t$1.PRERELEASE]);
-        if (!match || match[1] !== identifier) {
-          throw new Error(`invalid identifier: ${identifier}`);
-        }
-      }
-    }
     switch (release) {
       case "premajor":
         this.prerelease.length = 0;
@@ -33766,12 +33789,6 @@ let SemVer$d = class SemVer {
         }
         this.inc("pre", identifier, identifierBase);
         break;
-      case "release":
-        if (this.prerelease.length === 0) {
-          throw new Error(`version ${this.raw} is not a prerelease`);
-        }
-        this.prerelease.length = 0;
-        break;
       case "major":
         if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
           this.major++;
@@ -33795,6 +33812,9 @@ let SemVer$d = class SemVer {
         break;
       case "pre": {
         const base = Number(identifierBase) ? 1 : 0;
+        if (!identifier && identifierBase === false) {
+          throw new Error("invalid increment argument: identifier is empty");
+        }
         if (this.prerelease.length === 0) {
           this.prerelease = [base];
         } else {
@@ -33899,12 +33919,13 @@ const diff$1 = (version1, version2) => {
     if (!lowVersion.patch && !lowVersion.minor) {
       return "major";
     }
-    if (lowVersion.compareMain(highVersion) === 0) {
-      if (lowVersion.minor && !lowVersion.patch) {
-        return "minor";
-      }
+    if (highVersion.patch) {
       return "patch";
     }
+    if (highVersion.minor) {
+      return "minor";
+    }
+    return "major";
   }
   const prefix = highHasPre ? "pre" : "";
   if (v1.major !== v2.major) {
@@ -34033,66 +34054,666 @@ const coerce$1 = (version2, options2) => {
   options2 = options2 || {};
   let match = null;
   if (!options2.rtl) {
-    match = version2.match(options2.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+    match = version2.match(re[t.COERCE]);
   } else {
-    const coerceRtlRegex = options2.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
     let next;
-    while ((next = coerceRtlRegex.exec(version2)) && (!match || match.index + match[0].length !== version2.length)) {
+    while ((next = re[t.COERCERTL].exec(version2)) && (!match || match.index + match[0].length !== version2.length)) {
       if (!match || next.index + next[0].length !== match.index + match[0].length) {
         match = next;
       }
-      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
     }
-    coerceRtlRegex.lastIndex = -1;
+    re[t.COERCERTL].lastIndex = -1;
   }
   if (match === null) {
     return null;
   }
-  const major2 = match[2];
-  const minor2 = match[3] || "0";
-  const patch2 = match[4] || "0";
-  const prerelease2 = options2.includePrerelease && match[5] ? `-${match[5]}` : "";
-  const build = options2.includePrerelease && match[6] ? `+${match[6]}` : "";
-  return parse$1(`${major2}.${minor2}.${patch2}${prerelease2}${build}`, options2);
+  return parse$1(`${match[2]}.${match[3] || "0"}.${match[4] || "0"}`, options2);
 };
 var coerce_1 = coerce$1;
+var iterator;
+var hasRequiredIterator;
+function requireIterator() {
+  if (hasRequiredIterator) return iterator;
+  hasRequiredIterator = 1;
+  iterator = function(Yallist2) {
+    Yallist2.prototype[Symbol.iterator] = function* () {
+      for (let walker = this.head; walker; walker = walker.next) {
+        yield walker.value;
+      }
+    };
+  };
+  return iterator;
+}
+var yallist = Yallist$1;
+Yallist$1.Node = Node2;
+Yallist$1.create = Yallist$1;
+function Yallist$1(list) {
+  var self2 = this;
+  if (!(self2 instanceof Yallist$1)) {
+    self2 = new Yallist$1();
+  }
+  self2.tail = null;
+  self2.head = null;
+  self2.length = 0;
+  if (list && typeof list.forEach === "function") {
+    list.forEach(function(item) {
+      self2.push(item);
+    });
+  } else if (arguments.length > 0) {
+    for (var i = 0, l = arguments.length; i < l; i++) {
+      self2.push(arguments[i]);
+    }
+  }
+  return self2;
+}
+Yallist$1.prototype.removeNode = function(node) {
+  if (node.list !== this) {
+    throw new Error("removing node which does not belong to this list");
+  }
+  var next = node.next;
+  var prev = node.prev;
+  if (next) {
+    next.prev = prev;
+  }
+  if (prev) {
+    prev.next = next;
+  }
+  if (node === this.head) {
+    this.head = next;
+  }
+  if (node === this.tail) {
+    this.tail = prev;
+  }
+  node.list.length--;
+  node.next = null;
+  node.prev = null;
+  node.list = null;
+  return next;
+};
+Yallist$1.prototype.unshiftNode = function(node) {
+  if (node === this.head) {
+    return;
+  }
+  if (node.list) {
+    node.list.removeNode(node);
+  }
+  var head = this.head;
+  node.list = this;
+  node.next = head;
+  if (head) {
+    head.prev = node;
+  }
+  this.head = node;
+  if (!this.tail) {
+    this.tail = node;
+  }
+  this.length++;
+};
+Yallist$1.prototype.pushNode = function(node) {
+  if (node === this.tail) {
+    return;
+  }
+  if (node.list) {
+    node.list.removeNode(node);
+  }
+  var tail = this.tail;
+  node.list = this;
+  node.prev = tail;
+  if (tail) {
+    tail.next = node;
+  }
+  this.tail = node;
+  if (!this.head) {
+    this.head = node;
+  }
+  this.length++;
+};
+Yallist$1.prototype.push = function() {
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    push(this, arguments[i]);
+  }
+  return this.length;
+};
+Yallist$1.prototype.unshift = function() {
+  for (var i = 0, l = arguments.length; i < l; i++) {
+    unshift(this, arguments[i]);
+  }
+  return this.length;
+};
+Yallist$1.prototype.pop = function() {
+  if (!this.tail) {
+    return void 0;
+  }
+  var res = this.tail.value;
+  this.tail = this.tail.prev;
+  if (this.tail) {
+    this.tail.next = null;
+  } else {
+    this.head = null;
+  }
+  this.length--;
+  return res;
+};
+Yallist$1.prototype.shift = function() {
+  if (!this.head) {
+    return void 0;
+  }
+  var res = this.head.value;
+  this.head = this.head.next;
+  if (this.head) {
+    this.head.prev = null;
+  } else {
+    this.tail = null;
+  }
+  this.length--;
+  return res;
+};
+Yallist$1.prototype.forEach = function(fn, thisp) {
+  thisp = thisp || this;
+  for (var walker = this.head, i = 0; walker !== null; i++) {
+    fn.call(thisp, walker.value, i, this);
+    walker = walker.next;
+  }
+};
+Yallist$1.prototype.forEachReverse = function(fn, thisp) {
+  thisp = thisp || this;
+  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+    fn.call(thisp, walker.value, i, this);
+    walker = walker.prev;
+  }
+};
+Yallist$1.prototype.get = function(n) {
+  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+    walker = walker.next;
+  }
+  if (i === n && walker !== null) {
+    return walker.value;
+  }
+};
+Yallist$1.prototype.getReverse = function(n) {
+  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+    walker = walker.prev;
+  }
+  if (i === n && walker !== null) {
+    return walker.value;
+  }
+};
+Yallist$1.prototype.map = function(fn, thisp) {
+  thisp = thisp || this;
+  var res = new Yallist$1();
+  for (var walker = this.head; walker !== null; ) {
+    res.push(fn.call(thisp, walker.value, this));
+    walker = walker.next;
+  }
+  return res;
+};
+Yallist$1.prototype.mapReverse = function(fn, thisp) {
+  thisp = thisp || this;
+  var res = new Yallist$1();
+  for (var walker = this.tail; walker !== null; ) {
+    res.push(fn.call(thisp, walker.value, this));
+    walker = walker.prev;
+  }
+  return res;
+};
+Yallist$1.prototype.reduce = function(fn, initial) {
+  var acc;
+  var walker = this.head;
+  if (arguments.length > 1) {
+    acc = initial;
+  } else if (this.head) {
+    walker = this.head.next;
+    acc = this.head.value;
+  } else {
+    throw new TypeError("Reduce of empty list with no initial value");
+  }
+  for (var i = 0; walker !== null; i++) {
+    acc = fn(acc, walker.value, i);
+    walker = walker.next;
+  }
+  return acc;
+};
+Yallist$1.prototype.reduceReverse = function(fn, initial) {
+  var acc;
+  var walker = this.tail;
+  if (arguments.length > 1) {
+    acc = initial;
+  } else if (this.tail) {
+    walker = this.tail.prev;
+    acc = this.tail.value;
+  } else {
+    throw new TypeError("Reduce of empty list with no initial value");
+  }
+  for (var i = this.length - 1; walker !== null; i--) {
+    acc = fn(acc, walker.value, i);
+    walker = walker.prev;
+  }
+  return acc;
+};
+Yallist$1.prototype.toArray = function() {
+  var arr = new Array(this.length);
+  for (var i = 0, walker = this.head; walker !== null; i++) {
+    arr[i] = walker.value;
+    walker = walker.next;
+  }
+  return arr;
+};
+Yallist$1.prototype.toArrayReverse = function() {
+  var arr = new Array(this.length);
+  for (var i = 0, walker = this.tail; walker !== null; i++) {
+    arr[i] = walker.value;
+    walker = walker.prev;
+  }
+  return arr;
+};
+Yallist$1.prototype.slice = function(from, to) {
+  to = to || this.length;
+  if (to < 0) {
+    to += this.length;
+  }
+  from = from || 0;
+  if (from < 0) {
+    from += this.length;
+  }
+  var ret = new Yallist$1();
+  if (to < from || to < 0) {
+    return ret;
+  }
+  if (from < 0) {
+    from = 0;
+  }
+  if (to > this.length) {
+    to = this.length;
+  }
+  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+    walker = walker.next;
+  }
+  for (; walker !== null && i < to; i++, walker = walker.next) {
+    ret.push(walker.value);
+  }
+  return ret;
+};
+Yallist$1.prototype.sliceReverse = function(from, to) {
+  to = to || this.length;
+  if (to < 0) {
+    to += this.length;
+  }
+  from = from || 0;
+  if (from < 0) {
+    from += this.length;
+  }
+  var ret = new Yallist$1();
+  if (to < from || to < 0) {
+    return ret;
+  }
+  if (from < 0) {
+    from = 0;
+  }
+  if (to > this.length) {
+    to = this.length;
+  }
+  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+    walker = walker.prev;
+  }
+  for (; walker !== null && i > from; i--, walker = walker.prev) {
+    ret.push(walker.value);
+  }
+  return ret;
+};
+Yallist$1.prototype.splice = function(start, deleteCount, ...nodes) {
+  if (start > this.length) {
+    start = this.length - 1;
+  }
+  if (start < 0) {
+    start = this.length + start;
+  }
+  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
+    walker = walker.next;
+  }
+  var ret = [];
+  for (var i = 0; walker && i < deleteCount; i++) {
+    ret.push(walker.value);
+    walker = this.removeNode(walker);
+  }
+  if (walker === null) {
+    walker = this.tail;
+  }
+  if (walker !== this.head && walker !== this.tail) {
+    walker = walker.prev;
+  }
+  for (var i = 0; i < nodes.length; i++) {
+    walker = insert(this, walker, nodes[i]);
+  }
+  return ret;
+};
+Yallist$1.prototype.reverse = function() {
+  var head = this.head;
+  var tail = this.tail;
+  for (var walker = head; walker !== null; walker = walker.prev) {
+    var p = walker.prev;
+    walker.prev = walker.next;
+    walker.next = p;
+  }
+  this.head = tail;
+  this.tail = head;
+  return this;
+};
+function insert(self2, node, value) {
+  var inserted = node === self2.head ? new Node2(value, null, node, self2) : new Node2(value, node, node.next, self2);
+  if (inserted.next === null) {
+    self2.tail = inserted;
+  }
+  if (inserted.prev === null) {
+    self2.head = inserted;
+  }
+  self2.length++;
+  return inserted;
+}
+function push(self2, item) {
+  self2.tail = new Node2(item, self2.tail, null, self2);
+  if (!self2.head) {
+    self2.head = self2.tail;
+  }
+  self2.length++;
+}
+function unshift(self2, item) {
+  self2.head = new Node2(item, null, self2.head, self2);
+  if (!self2.tail) {
+    self2.tail = self2.head;
+  }
+  self2.length++;
+}
+function Node2(value, prev, next, list) {
+  if (!(this instanceof Node2)) {
+    return new Node2(value, prev, next, list);
+  }
+  this.list = list;
+  this.value = value;
+  if (prev) {
+    prev.next = this;
+    this.prev = prev;
+  } else {
+    this.prev = null;
+  }
+  if (next) {
+    next.prev = this;
+    this.next = next;
+  } else {
+    this.next = null;
+  }
+}
+try {
+  requireIterator()(Yallist$1);
+} catch (er) {
+}
+const Yallist = yallist;
+const MAX = Symbol("max");
+const LENGTH = Symbol("length");
+const LENGTH_CALCULATOR = Symbol("lengthCalculator");
+const ALLOW_STALE = Symbol("allowStale");
+const MAX_AGE = Symbol("maxAge");
+const DISPOSE = Symbol("dispose");
+const NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
+const LRU_LIST = Symbol("lruList");
+const CACHE = Symbol("cache");
+const UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
+const naiveLength = () => 1;
 class LRUCache {
-  constructor() {
-    this.max = 1e3;
-    this.map = /* @__PURE__ */ new Map();
+  constructor(options2) {
+    if (typeof options2 === "number")
+      options2 = { max: options2 };
+    if (!options2)
+      options2 = {};
+    if (options2.max && (typeof options2.max !== "number" || options2.max < 0))
+      throw new TypeError("max must be a non-negative number");
+    this[MAX] = options2.max || Infinity;
+    const lc = options2.length || naiveLength;
+    this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
+    this[ALLOW_STALE] = options2.stale || false;
+    if (options2.maxAge && typeof options2.maxAge !== "number")
+      throw new TypeError("maxAge must be a number");
+    this[MAX_AGE] = options2.maxAge || 0;
+    this[DISPOSE] = options2.dispose;
+    this[NO_DISPOSE_ON_SET] = options2.noDisposeOnSet || false;
+    this[UPDATE_AGE_ON_GET] = options2.updateAgeOnGet || false;
+    this.reset();
+  }
+  // resize the cache when the max changes.
+  set max(mL) {
+    if (typeof mL !== "number" || mL < 0)
+      throw new TypeError("max must be a non-negative number");
+    this[MAX] = mL || Infinity;
+    trim(this);
+  }
+  get max() {
+    return this[MAX];
+  }
+  set allowStale(allowStale) {
+    this[ALLOW_STALE] = !!allowStale;
+  }
+  get allowStale() {
+    return this[ALLOW_STALE];
+  }
+  set maxAge(mA) {
+    if (typeof mA !== "number")
+      throw new TypeError("maxAge must be a non-negative number");
+    this[MAX_AGE] = mA;
+    trim(this);
+  }
+  get maxAge() {
+    return this[MAX_AGE];
+  }
+  // resize the cache when the lengthCalculator changes.
+  set lengthCalculator(lC) {
+    if (typeof lC !== "function")
+      lC = naiveLength;
+    if (lC !== this[LENGTH_CALCULATOR]) {
+      this[LENGTH_CALCULATOR] = lC;
+      this[LENGTH] = 0;
+      this[LRU_LIST].forEach((hit) => {
+        hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
+        this[LENGTH] += hit.length;
+      });
+    }
+    trim(this);
+  }
+  get lengthCalculator() {
+    return this[LENGTH_CALCULATOR];
+  }
+  get length() {
+    return this[LENGTH];
+  }
+  get itemCount() {
+    return this[LRU_LIST].length;
+  }
+  rforEach(fn, thisp) {
+    thisp = thisp || this;
+    for (let walker = this[LRU_LIST].tail; walker !== null; ) {
+      const prev = walker.prev;
+      forEachStep(this, fn, walker, thisp);
+      walker = prev;
+    }
+  }
+  forEach(fn, thisp) {
+    thisp = thisp || this;
+    for (let walker = this[LRU_LIST].head; walker !== null; ) {
+      const next = walker.next;
+      forEachStep(this, fn, walker, thisp);
+      walker = next;
+    }
+  }
+  keys() {
+    return this[LRU_LIST].toArray().map((k) => k.key);
+  }
+  values() {
+    return this[LRU_LIST].toArray().map((k) => k.value);
+  }
+  reset() {
+    if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
+      this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value));
+    }
+    this[CACHE] = /* @__PURE__ */ new Map();
+    this[LRU_LIST] = new Yallist();
+    this[LENGTH] = 0;
+  }
+  dump() {
+    return this[LRU_LIST].map((hit) => isStale(this, hit) ? false : {
+      k: hit.key,
+      v: hit.value,
+      e: hit.now + (hit.maxAge || 0)
+    }).toArray().filter((h2) => h2);
+  }
+  dumpLru() {
+    return this[LRU_LIST];
+  }
+  set(key, value, maxAge) {
+    maxAge = maxAge || this[MAX_AGE];
+    if (maxAge && typeof maxAge !== "number")
+      throw new TypeError("maxAge must be a number");
+    const now = maxAge ? Date.now() : 0;
+    const len = this[LENGTH_CALCULATOR](value, key);
+    if (this[CACHE].has(key)) {
+      if (len > this[MAX]) {
+        del(this, this[CACHE].get(key));
+        return false;
+      }
+      const node = this[CACHE].get(key);
+      const item = node.value;
+      if (this[DISPOSE]) {
+        if (!this[NO_DISPOSE_ON_SET])
+          this[DISPOSE](key, item.value);
+      }
+      item.now = now;
+      item.maxAge = maxAge;
+      item.value = value;
+      this[LENGTH] += len - item.length;
+      item.length = len;
+      this.get(key);
+      trim(this);
+      return true;
+    }
+    const hit = new Entry(key, value, len, now, maxAge);
+    if (hit.length > this[MAX]) {
+      if (this[DISPOSE])
+        this[DISPOSE](key, value);
+      return false;
+    }
+    this[LENGTH] += hit.length;
+    this[LRU_LIST].unshift(hit);
+    this[CACHE].set(key, this[LRU_LIST].head);
+    trim(this);
+    return true;
+  }
+  has(key) {
+    if (!this[CACHE].has(key)) return false;
+    const hit = this[CACHE].get(key).value;
+    return !isStale(this, hit);
   }
   get(key) {
-    const value = this.map.get(key);
-    if (value === void 0) {
-      return void 0;
-    } else {
-      this.map.delete(key);
-      this.map.set(key, value);
-      return value;
+    return get(this, key, true);
+  }
+  peek(key) {
+    return get(this, key, false);
+  }
+  pop() {
+    const node = this[LRU_LIST].tail;
+    if (!node)
+      return null;
+    del(this, node);
+    return node.value;
+  }
+  del(key) {
+    del(this, this[CACHE].get(key));
+  }
+  load(arr) {
+    this.reset();
+    const now = Date.now();
+    for (let l = arr.length - 1; l >= 0; l--) {
+      const hit = arr[l];
+      const expiresAt = hit.e || 0;
+      if (expiresAt === 0)
+        this.set(hit.k, hit.v);
+      else {
+        const maxAge = expiresAt - now;
+        if (maxAge > 0) {
+          this.set(hit.k, hit.v, maxAge);
+        }
+      }
     }
   }
-  delete(key) {
-    return this.map.delete(key);
+  prune() {
+    this[CACHE].forEach((value, key) => get(this, key, false));
   }
-  set(key, value) {
-    const deleted = this.delete(key);
-    if (!deleted && value !== void 0) {
-      if (this.map.size >= this.max) {
-        const firstKey = this.map.keys().next().value;
-        this.delete(firstKey);
+}
+const get = (self2, key, doUse) => {
+  const node = self2[CACHE].get(key);
+  if (node) {
+    const hit = node.value;
+    if (isStale(self2, hit)) {
+      del(self2, node);
+      if (!self2[ALLOW_STALE])
+        return void 0;
+    } else {
+      if (doUse) {
+        if (self2[UPDATE_AGE_ON_GET])
+          node.value.now = Date.now();
+        self2[LRU_LIST].unshiftNode(node);
       }
-      this.map.set(key, value);
     }
-    return this;
+    return hit.value;
+  }
+};
+const isStale = (self2, hit) => {
+  if (!hit || !hit.maxAge && !self2[MAX_AGE])
+    return false;
+  const diff2 = Date.now() - hit.now;
+  return hit.maxAge ? diff2 > hit.maxAge : self2[MAX_AGE] && diff2 > self2[MAX_AGE];
+};
+const trim = (self2) => {
+  if (self2[LENGTH] > self2[MAX]) {
+    for (let walker = self2[LRU_LIST].tail; self2[LENGTH] > self2[MAX] && walker !== null; ) {
+      const prev = walker.prev;
+      del(self2, walker);
+      walker = prev;
+    }
+  }
+};
+const del = (self2, node) => {
+  if (node) {
+    const hit = node.value;
+    if (self2[DISPOSE])
+      self2[DISPOSE](hit.key, hit.value);
+    self2[LENGTH] -= hit.length;
+    self2[CACHE].delete(hit.key);
+    self2[LRU_LIST].removeNode(node);
+  }
+};
+class Entry {
+  constructor(key, value, length, now, maxAge) {
+    this.key = key;
+    this.value = value;
+    this.length = length;
+    this.now = now;
+    this.maxAge = maxAge || 0;
   }
 }
-var lrucache = LRUCache;
+const forEachStep = (self2, fn, node, thisp) => {
+  let hit = node.value;
+  if (isStale(self2, hit)) {
+    del(self2, node);
+    if (!self2[ALLOW_STALE])
+      hit = void 0;
+  }
+  if (hit)
+    fn.call(thisp, hit.value, hit.key, self2);
+};
+var lruCache = LRUCache;
 var range;
 var hasRequiredRange;
 function requireRange() {
   if (hasRequiredRange) return range;
   hasRequiredRange = 1;
-  const SPACE_CHARACTERS = /\s+/g;
   class Range2 {
     constructor(range2, options2) {
       options2 = parseOptions2(options2);
@@ -34106,13 +34727,13 @@ function requireRange() {
       if (range2 instanceof Comparator2) {
         this.raw = range2.value;
         this.set = [[range2]];
-        this.formatted = void 0;
+        this.format();
         return this;
       }
       this.options = options2;
       this.loose = !!options2.loose;
       this.includePrerelease = !!options2.includePrerelease;
-      this.raw = range2.trim().replace(SPACE_CHARACTERS, " ");
+      this.raw = range2.trim().split(/\s+/).join(" ");
       this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
       if (!this.set.length) {
         throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
@@ -34131,27 +34752,10 @@ function requireRange() {
           }
         }
       }
-      this.formatted = void 0;
-    }
-    get range() {
-      if (this.formatted === void 0) {
-        this.formatted = "";
-        for (let i = 0; i < this.set.length; i++) {
-          if (i > 0) {
-            this.formatted += "||";
-          }
-          const comps = this.set[i];
-          for (let k = 0; k < comps.length; k++) {
-            if (k > 0) {
-              this.formatted += " ";
-            }
-            this.formatted += comps[k].toString().trim();
-          }
-        }
-      }
-      return this.formatted;
+      this.format();
     }
     format() {
+      this.range = this.set.map((comps) => comps.join(" ").trim()).join("||").trim();
       return this.range;
     }
     toString() {
@@ -34232,8 +34836,8 @@ function requireRange() {
     }
   }
   range = Range2;
-  const LRU = lrucache;
-  const cache = new LRU();
+  const LRU = lruCache;
+  const cache = new LRU({ max: 1e3 });
   const parseOptions2 = parseOptions_1;
   const Comparator2 = requireComparator();
   const debug2 = debug_1;
@@ -34261,7 +34865,6 @@ function requireRange() {
     return result;
   };
   const parseComparator = (comp, options2) => {
-    comp = comp.replace(re2[t2.BUILD], "");
     debug2("comp", comp, options2);
     comp = replaceCarets(comp, options2);
     debug2("caret", comp);
@@ -34412,7 +35015,7 @@ function requireRange() {
     debug2("replaceGTE0", comp, options2);
     return comp.trim().replace(re2[options2.includePrerelease ? t2.GTE0PRE : t2.GTE0], "");
   };
-  const hyphenReplace = (incPr) => ($0, from, fM, fm, fp2, fpr, fb, to, tM, tm, tp, tpr) => {
+  const hyphenReplace = (incPr) => ($0, from, fM, fm, fp2, fpr, fb, to, tM, tm, tp, tpr, tb) => {
     if (isX(fM)) {
       from = "";
     } else if (isX(fm)) {
@@ -35735,9 +36338,10 @@ const tokenService = ({ strapi: strapi2 }) => {
         if (firebaseUserData2.verificationTokenHash !== tokenHash) {
           return {
             valid: false,
-            firebaseUserDataDocumentId: "",
-            firebaseUID: "",
-            error: "Verification link has already been used or is invalid"
+            firebaseUserDataDocumentId: firebaseUserData2.documentId,
+            firebaseUID: firebaseUserData2.firebaseUserID,
+            error: "Verification link has already been used or is invalid",
+            code: "TOKEN_ALREADY_USED"
           };
         }
         if (firebaseUserData2.verificationTokenExpiresAt) {