html-validate-vue 4.1.0 → 4.2.2

package/dist/index.js

@@ -21,21 +21,18 @@ var __spreadValues = (a, b) => {
   return a;
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-var __reExport = (target, module2, copyDefault, desc) => {
-  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
-    for (let key of __getOwnPropNames(module2))
-      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
-        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return target;
-};
-var __toESM = (module2, isNodeMode) => {
-  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", !isNodeMode && module2 && module2.__esModule ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+  return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
 
 // node_modules/semver/internal/constants.js
 var require_constants = __commonJS({
@@ -74,7 +71,7 @@ var require_re = __commonJS({
     var R = 0;
     var createToken = (name, value, isGlobal) => {
       const index = R++;
-      debug(index, value);
+      debug(name, index, value);
       t[name] = index;
       src[index] = value;
       re[index] = new RegExp(value, isGlobal ? "g" : void 0);
@@ -120,8 +117,8 @@ var require_re = __commonJS({
     createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
     createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
     createToken("STAR", "(<|>)?=?\\s*\\*");
-    createToken("GTE0", "^\\s*>=\\s*0.0.0\\s*$");
-    createToken("GTE0PRE", "^\\s*>=\\s*0.0.0-0\\s*$");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
   }
 });
 
@@ -129,9 +126,9 @@ var require_re = __commonJS({
 var require_parse_options = __commonJS({
   "node_modules/semver/internal/parse-options.js"(exports2, module2) {
     var opts = ["includePrerelease", "loose", "rtl"];
-    var parseOptions = (options) => !options ? {} : typeof options !== "object" ? { loose: true } : opts.filter((k) => options[k]).reduce((options2, k) => {
-      options2[k] = true;
-      return options2;
+    var parseOptions = (options) => !options ? {} : typeof options !== "object" ? { loose: true } : opts.filter((k) => options[k]).reduce((o, k) => {
+      o[k] = true;
+      return o;
     }, {});
     module2.exports = parseOptions;
   }
@@ -487,12 +484,12 @@ var require_diff = __commonJS({
         const v1 = parse(version1);
         const v2 = parse(version2);
         const hasPre = v1.prerelease.length || v2.prerelease.length;
-        const prefix = hasPre ? "pre" : "";
+        const prefix2 = hasPre ? "pre" : "";
         const defaultResult = hasPre ? "prerelease" : "";
         for (const key in v1) {
           if (key === "major" || key === "minor" || key === "patch") {
             if (v1[key] !== v2[key]) {
-              return prefix + key;
+              return prefix2 + key;
             }
           }
         }
@@ -648,16 +645,20 @@ var require_cmp = __commonJS({
     var cmp = (a, op, b, loose) => {
       switch (op) {
         case "===":
-          if (typeof a === "object")
+          if (typeof a === "object") {
             a = a.version;
-          if (typeof b === "object")
+          }
+          if (typeof b === "object") {
             b = b.version;
+          }
           return a === b;
         case "!==":
-          if (typeof a === "object")
+          if (typeof a === "object") {
             a = a.version;
-          if (typeof b === "object")
+          }
+          if (typeof b === "object") {
             b = b.version;
+          }
           return a !== b;
         case "":
         case "=":
@@ -711,661 +712,724 @@ var require_coerce = __commonJS({
         }
         re[t.COERCERTL].lastIndex = -1;
       }
-      if (match === null)
+      if (match === null) {
         return null;
+      }
       return parse(`${match[2]}.${match[3] || "0"}.${match[4] || "0"}`, options);
     };
     module2.exports = coerce;
   }
 });
 
-// node_modules/yallist/iterator.js
-var require_iterator = __commonJS({
-  "node_modules/yallist/iterator.js"(exports2, module2) {
-    "use strict";
-    module2.exports = function(Yallist) {
-      Yallist.prototype[Symbol.iterator] = function* () {
-        for (let walker = this.head; walker; walker = walker.next) {
-          yield walker.value;
-        }
-      };
-    };
-  }
-});
-
-// node_modules/yallist/yallist.js
-var require_yallist = __commonJS({
-  "node_modules/yallist/yallist.js"(exports2, module2) {
-    "use strict";
-    module2.exports = Yallist;
-    Yallist.Node = Node;
-    Yallist.create = Yallist;
-    function Yallist(list) {
-      var self = this;
-      if (!(self instanceof Yallist)) {
-        self = new Yallist();
-      }
-      self.tail = null;
-      self.head = null;
-      self.length = 0;
-      if (list && typeof list.forEach === "function") {
-        list.forEach(function(item) {
-          self.push(item);
-        });
-      } else if (arguments.length > 0) {
-        for (var i = 0, l = arguments.length; i < l; i++) {
-          self.push(arguments[i]);
-        }
-      }
-      return self;
-    }
-    Yallist.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.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.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.prototype.push = function() {
-      for (var i = 0, l = arguments.length; i < l; i++) {
-        push(this, arguments[i]);
-      }
-      return this.length;
-    };
-    Yallist.prototype.unshift = function() {
-      for (var i = 0, l = arguments.length; i < l; i++) {
-        unshift(this, arguments[i]);
-      }
-      return this.length;
-    };
-    Yallist.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.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.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.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.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.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.prototype.map = function(fn, thisp) {
-      thisp = thisp || this;
-      var res = new Yallist();
-      for (var walker = this.head; walker !== null; ) {
-        res.push(fn.call(thisp, walker.value, this));
-        walker = walker.next;
-      }
-      return res;
-    };
-    Yallist.prototype.mapReverse = function(fn, thisp) {
-      thisp = thisp || this;
-      var res = new Yallist();
-      for (var walker = this.tail; walker !== null; ) {
-        res.push(fn.call(thisp, walker.value, this));
-        walker = walker.prev;
-      }
-      return res;
-    };
-    Yallist.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.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.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.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.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();
-      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;
+// node_modules/semver/node_modules/lru-cache/index.js
+var require_lru_cache = __commonJS({
+  "node_modules/semver/node_modules/lru-cache/index.js"(exports2, module2) {
+    var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
+    var hasAbortController = typeof AbortController !== "undefined";
+    var AC = hasAbortController ? AbortController : Object.assign(class AbortController {
+      constructor() {
+        this.signal = new AC.AbortSignal();
+      }
+      abort() {
+        this.signal.aborted = true;
+      }
+    }, { AbortSignal: class AbortSignal {
+      constructor() {
+        this.aborted = false;
+      }
+    } });
+    var warned = /* @__PURE__ */ new Set();
+    var deprecatedOption = (opt, instead) => {
+      const code = `LRU_CACHE_OPTION_${opt}`;
+      if (shouldWarn(code)) {
+        warn(code, `${opt} option`, `options.${instead}`, LRUCache);
+      }
+    };
+    var deprecatedMethod = (method, instead) => {
+      const code = `LRU_CACHE_METHOD_${method}`;
+      if (shouldWarn(code)) {
+        const { prototype } = LRUCache;
+        const { get } = Object.getOwnPropertyDescriptor(prototype, method);
+        warn(code, `${method} method`, `cache.${instead}()`, get);
+      }
+    };
+    var deprecatedProperty = (field, instead) => {
+      const code = `LRU_CACHE_PROPERTY_${field}`;
+      if (shouldWarn(code)) {
+        const { prototype } = LRUCache;
+        const { get } = Object.getOwnPropertyDescriptor(prototype, field);
+        warn(code, `${field} property`, `cache.${instead}`, get);
+      }
+    };
+    var emitWarning = (...a) => {
+      typeof process === "object" && process && typeof process.emitWarning === "function" ? process.emitWarning(...a) : console.error(...a);
+    };
+    var shouldWarn = (code) => !warned.has(code);
+    var warn = (code, what, instead, fn) => {
+      warned.add(code);
+      const msg = `The ${what} is deprecated. Please use ${instead} instead.`;
+      emitWarning(msg, "DeprecationWarning", code, fn);
+    };
+    var isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
+    var getUintArray = (max) => !isPosInt(max) ? null : max <= Math.pow(2, 8) ? Uint8Array : max <= Math.pow(2, 16) ? Uint16Array : max <= Math.pow(2, 32) ? Uint32Array : max <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
+    var ZeroArray = class extends Array {
+      constructor(size) {
+        super(size);
+        this.fill(0);
+      }
+    };
+    var Stack = class {
+      constructor(max) {
+        const UintArray = max ? getUintArray(max) : Array;
+        this.heap = new UintArray(max);
+        this.length = 0;
+      }
+      push(n) {
+        this.heap[this.length++] = n;
       }
-      for (; walker !== null && i < to; i++, walker = walker.next) {
-        ret.push(walker.value);
+      pop() {
+        return this.heap[--this.length];
       }
-      return ret;
     };
-    Yallist.prototype.sliceReverse = function(from, to) {
-      to = to || this.length;
-      if (to < 0) {
-        to += this.length;
+    var LRUCache = class {
+      constructor(options = {}) {
+        const {
+          max = 0,
+          ttl,
+          ttlResolution = 1,
+          ttlAutopurge,
+          updateAgeOnGet,
+          updateAgeOnHas,
+          allowStale,
+          dispose,
+          disposeAfter,
+          noDisposeOnSet,
+          noUpdateTTL,
+          maxSize = 0,
+          sizeCalculation,
+          fetchMethod
+        } = options;
+        const {
+          length,
+          maxAge,
+          stale
+        } = options instanceof LRUCache ? {} : options;
+        if (max !== 0 && !isPosInt(max)) {
+          throw new TypeError("max option must be a nonnegative integer");
+        }
+        const UintArray = max ? getUintArray(max) : Array;
+        if (!UintArray) {
+          throw new Error("invalid max value: " + max);
+        }
+        this.max = max;
+        this.maxSize = maxSize;
+        this.sizeCalculation = sizeCalculation || length;
+        if (this.sizeCalculation) {
+          if (!this.maxSize) {
+            throw new TypeError("cannot set sizeCalculation without setting maxSize");
+          }
+          if (typeof this.sizeCalculation !== "function") {
+            throw new TypeError("sizeCalculation set to non-function");
+          }
+        }
+        this.fetchMethod = fetchMethod || null;
+        if (this.fetchMethod && typeof this.fetchMethod !== "function") {
+          throw new TypeError("fetchMethod must be a function if specified");
+        }
+        this.keyMap = /* @__PURE__ */ new Map();
+        this.keyList = new Array(max).fill(null);
+        this.valList = new Array(max).fill(null);
+        this.next = new UintArray(max);
+        this.prev = new UintArray(max);
+        this.head = 0;
+        this.tail = 0;
+        this.free = new Stack(max);
+        this.initialFill = 1;
+        this.size = 0;
+        if (typeof dispose === "function") {
+          this.dispose = dispose;
+        }
+        if (typeof disposeAfter === "function") {
+          this.disposeAfter = disposeAfter;
+          this.disposed = [];
+        } else {
+          this.disposeAfter = null;
+          this.disposed = null;
+        }
+        this.noDisposeOnSet = !!noDisposeOnSet;
+        this.noUpdateTTL = !!noUpdateTTL;
+        if (this.maxSize !== 0) {
+          if (!isPosInt(this.maxSize)) {
+            throw new TypeError("maxSize must be a positive integer if specified");
+          }
+          this.initializeSizeTracking();
+        }
+        this.allowStale = !!allowStale || !!stale;
+        this.updateAgeOnGet = !!updateAgeOnGet;
+        this.updateAgeOnHas = !!updateAgeOnHas;
+        this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
+        this.ttlAutopurge = !!ttlAutopurge;
+        this.ttl = ttl || maxAge || 0;
+        if (this.ttl) {
+          if (!isPosInt(this.ttl)) {
+            throw new TypeError("ttl must be a positive integer if specified");
+          }
+          this.initializeTTLTracking();
+        }
+        if (this.max === 0 && this.ttl === 0 && this.maxSize === 0) {
+          throw new TypeError("At least one of max, maxSize, or ttl is required");
+        }
+        if (!this.ttlAutopurge && !this.max && !this.maxSize) {
+          const code = "LRU_CACHE_UNBOUNDED";
+          if (shouldWarn(code)) {
+            warned.add(code);
+            const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";
+            emitWarning(msg, "UnboundedCacheWarning", code, LRUCache);
+          }
+        }
+        if (stale) {
+          deprecatedOption("stale", "allowStale");
+        }
+        if (maxAge) {
+          deprecatedOption("maxAge", "ttl");
+        }
+        if (length) {
+          deprecatedOption("length", "sizeCalculation");
+        }
       }
-      from = from || 0;
-      if (from < 0) {
-        from += this.length;
+      getRemainingTTL(key) {
+        return this.has(key, { updateAgeOnHas: false }) ? Infinity : 0;
+      }
+      initializeTTLTracking() {
+        this.ttls = new ZeroArray(this.max);
+        this.starts = new ZeroArray(this.max);
+        this.setItemTTL = (index, ttl) => {
+          this.starts[index] = ttl !== 0 ? perf.now() : 0;
+          this.ttls[index] = ttl;
+          if (ttl !== 0 && this.ttlAutopurge) {
+            const t = setTimeout(() => {
+              if (this.isStale(index)) {
+                this.delete(this.keyList[index]);
+              }
+            }, ttl + 1);
+            if (t.unref) {
+              t.unref();
+            }
+          }
+        };
+        this.updateItemAge = (index) => {
+          this.starts[index] = this.ttls[index] !== 0 ? perf.now() : 0;
+        };
+        let cachedNow = 0;
+        const getNow = () => {
+          const n = perf.now();
+          if (this.ttlResolution > 0) {
+            cachedNow = n;
+            const t = setTimeout(() => cachedNow = 0, this.ttlResolution);
+            if (t.unref) {
+              t.unref();
+            }
+          }
+          return n;
+        };
+        this.getRemainingTTL = (key) => {
+          const index = this.keyMap.get(key);
+          if (index === void 0) {
+            return 0;
+          }
+          return this.ttls[index] === 0 || this.starts[index] === 0 ? Infinity : this.starts[index] + this.ttls[index] - (cachedNow || getNow());
+        };
+        this.isStale = (index) => {
+          return this.ttls[index] !== 0 && this.starts[index] !== 0 && (cachedNow || getNow()) - this.starts[index] > this.ttls[index];
+        };
       }
-      var ret = new Yallist();
-      if (to < from || to < 0) {
-        return ret;
+      updateItemAge(index) {
       }
-      if (from < 0) {
-        from = 0;
+      setItemTTL(index, ttl) {
       }
-      if (to > this.length) {
-        to = this.length;
+      isStale(index) {
+        return false;
       }
-      for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
-        walker = walker.prev;
+      initializeSizeTracking() {
+        this.calculatedSize = 0;
+        this.sizes = new ZeroArray(this.max);
+        this.removeItemSize = (index) => this.calculatedSize -= this.sizes[index];
+        this.requireSize = (k, v, size, sizeCalculation) => {
+          if (!isPosInt(size)) {
+            if (sizeCalculation) {
+              if (typeof sizeCalculation !== "function") {
+                throw new TypeError("sizeCalculation must be a function");
+              }
+              size = sizeCalculation(v, k);
+              if (!isPosInt(size)) {
+                throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+              }
+            } else {
+              throw new TypeError("invalid size value (must be positive integer)");
+            }
+          }
+          return size;
+        };
+        this.addItemSize = (index, v, k, size) => {
+          this.sizes[index] = size;
+          const maxSize = this.maxSize - this.sizes[index];
+          while (this.calculatedSize > maxSize) {
+            this.evict();
+          }
+          this.calculatedSize += this.sizes[index];
+        };
+        this.delete = (k) => {
+          if (this.size !== 0) {
+            const index = this.keyMap.get(k);
+            if (index !== void 0) {
+              this.calculatedSize -= this.sizes[index];
+            }
+          }
+          return LRUCache.prototype.delete.call(this, k);
+        };
       }
-      for (; walker !== null && i > from; i--, walker = walker.prev) {
-        ret.push(walker.value);
+      removeItemSize(index) {
       }
-      return ret;
-    };
-    Yallist.prototype.splice = function(start, deleteCount, ...nodes) {
-      if (start > this.length) {
-        start = this.length - 1;
+      addItemSize(index, v, k, size) {
       }
-      if (start < 0) {
-        start = this.length + start;
+      requireSize(k, v, size, sizeCalculation) {
+        if (size || sizeCalculation) {
+          throw new TypeError("cannot set size without setting maxSize on cache");
+        }
       }
-      for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
-        walker = walker.next;
+      *indexes({ allowStale = this.allowStale } = {}) {
+        if (this.size) {
+          for (let i = this.tail; true; ) {
+            if (!this.isValidIndex(i)) {
+              break;
+            }
+            if (allowStale || !this.isStale(i)) {
+              yield i;
+            }
+            if (i === this.head) {
+              break;
+            } else {
+              i = this.prev[i];
+            }
+          }
+        }
       }
-      var ret = [];
-      for (var i = 0; walker && i < deleteCount; i++) {
-        ret.push(walker.value);
-        walker = this.removeNode(walker);
+      *rindexes({ allowStale = this.allowStale } = {}) {
+        if (this.size) {
+          for (let i = this.head; true; ) {
+            if (!this.isValidIndex(i)) {
+              break;
+            }
+            if (allowStale || !this.isStale(i)) {
+              yield i;
+            }
+            if (i === this.tail) {
+              break;
+            } else {
+              i = this.next[i];
+            }
+          }
+        }
       }
-      if (walker === null) {
-        walker = this.tail;
+      isValidIndex(index) {
+        return this.keyMap.get(this.keyList[index]) === index;
       }
-      if (walker !== this.head && walker !== this.tail) {
-        walker = walker.prev;
+      *entries() {
+        for (const i of this.indexes()) {
+          yield [this.keyList[i], this.valList[i]];
+        }
       }
-      for (var i = 0; i < nodes.length; i++) {
-        walker = insert(this, walker, nodes[i]);
+      *rentries() {
+        for (const i of this.rindexes()) {
+          yield [this.keyList[i], this.valList[i]];
+        }
       }
-      return ret;
-    };
-    Yallist.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(self, node, value) {
-      var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
-      if (inserted.next === null) {
-        self.tail = inserted;
+      *keys() {
+        for (const i of this.indexes()) {
+          yield this.keyList[i];
+        }
       }
-      if (inserted.prev === null) {
-        self.head = inserted;
+      *rkeys() {
+        for (const i of this.rindexes()) {
+          yield this.keyList[i];
+        }
       }
-      self.length++;
-      return inserted;
-    }
-    function push(self, item) {
-      self.tail = new Node(item, self.tail, null, self);
-      if (!self.head) {
-        self.head = self.tail;
+      *values() {
+        for (const i of this.indexes()) {
+          yield this.valList[i];
+        }
       }
-      self.length++;
-    }
-    function unshift(self, item) {
-      self.head = new Node(item, null, self.head, self);
-      if (!self.tail) {
-        self.tail = self.head;
+      *rvalues() {
+        for (const i of this.rindexes()) {
+          yield this.valList[i];
+        }
       }
-      self.length++;
-    }
-    function Node(value, prev, next, list) {
-      if (!(this instanceof Node)) {
-        return new Node(value, prev, next, list);
-      }
-      this.list = list;
-      this.value = value;
-      if (prev) {
-        prev.next = this;
-        this.prev = prev;
-      } else {
-        this.prev = null;
+      [Symbol.iterator]() {
+        return this.entries();
       }
-      if (next) {
-        next.prev = this;
-        this.next = next;
-      } else {
-        this.next = null;
+      find(fn, getOptions = {}) {
+        for (const i of this.indexes()) {
+          if (fn(this.valList[i], this.keyList[i], this)) {
+            return this.get(this.keyList[i], getOptions);
+          }
+        }
       }
-    }
-    try {
-      require_iterator()(Yallist);
-    } catch (er) {
-    }
-  }
-});
-
-// node_modules/lru-cache/index.js
-var require_lru_cache = __commonJS({
-  "node_modules/lru-cache/index.js"(exports2, module2) {
-    "use strict";
-    var Yallist = require_yallist();
-    var MAX = Symbol("max");
-    var LENGTH = Symbol("length");
-    var LENGTH_CALCULATOR = Symbol("lengthCalculator");
-    var ALLOW_STALE = Symbol("allowStale");
-    var MAX_AGE = Symbol("maxAge");
-    var DISPOSE = Symbol("dispose");
-    var NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
-    var LRU_LIST = Symbol("lruList");
-    var CACHE = Symbol("cache");
-    var UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
-    var naiveLength = () => 1;
-    var LRUCache = class {
-      constructor(options) {
-        if (typeof options === "number")
-          options = { max: options };
-        if (!options)
-          options = {};
-        if (options.max && (typeof options.max !== "number" || options.max < 0))
-          throw new TypeError("max must be a non-negative number");
-        const max = this[MAX] = options.max || Infinity;
-        const lc = options.length || naiveLength;
-        this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
-        this[ALLOW_STALE] = options.stale || false;
-        if (options.maxAge && typeof options.maxAge !== "number")
-          throw new TypeError("maxAge must be a number");
-        this[MAX_AGE] = options.maxAge || 0;
-        this[DISPOSE] = options.dispose;
-        this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
-        this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
-        this.reset();
-      }
-      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];
-      }
-      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;
-          });
+      forEach(fn, thisp = this) {
+        for (const i of this.indexes()) {
+          fn.call(thisp, this.valList[i], this.keyList[i], this);
         }
-        trim(this);
       }
-      get lengthCalculator() {
-        return this[LENGTH_CALCULATOR];
+      rforEach(fn, thisp = this) {
+        for (const i of this.rindexes()) {
+          fn.call(thisp, this.valList[i], this.keyList[i], this);
+        }
       }
-      get length() {
-        return this[LENGTH];
+      get prune() {
+        deprecatedMethod("prune", "purgeStale");
+        return this.purgeStale;
       }
-      get itemCount() {
-        return this[LRU_LIST].length;
+      purgeStale() {
+        let deleted = false;
+        for (const i of this.rindexes({ allowStale: true })) {
+          if (this.isStale(i)) {
+            this.delete(this.keyList[i]);
+            deleted = true;
+          }
+        }
+        return deleted;
       }
-      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;
+      dump() {
+        const arr = [];
+        for (const i of this.indexes()) {
+          const key = this.keyList[i];
+          const value = this.valList[i];
+          const entry = { value };
+          if (this.ttls) {
+            entry.ttl = this.ttls[i];
+          }
+          if (this.sizes) {
+            entry.size = this.sizes[i];
+          }
+          arr.unshift([key, entry]);
         }
+        return arr;
       }
-      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;
+      load(arr) {
+        this.clear();
+        for (const [key, entry] of arr) {
+          this.set(key, entry.value, entry);
         }
       }
-      keys() {
-        return this[LRU_LIST].toArray().map((k) => k.key);
+      dispose(v, k, reason) {
+      }
+      set(k, v, {
+        ttl = this.ttl,
+        noDisposeOnSet = this.noDisposeOnSet,
+        size = 0,
+        sizeCalculation = this.sizeCalculation,
+        noUpdateTTL = this.noUpdateTTL
+      } = {}) {
+        size = this.requireSize(k, v, size, sizeCalculation);
+        let index = this.size === 0 ? void 0 : this.keyMap.get(k);
+        if (index === void 0) {
+          index = this.newIndex();
+          this.keyList[index] = k;
+          this.valList[index] = v;
+          this.keyMap.set(k, index);
+          this.next[this.tail] = index;
+          this.prev[index] = this.tail;
+          this.tail = index;
+          this.size++;
+          this.addItemSize(index, v, k, size);
+          noUpdateTTL = false;
+        } else {
+          const oldVal = this.valList[index];
+          if (v !== oldVal) {
+            if (this.isBackgroundFetch(oldVal)) {
+              oldVal.__abortController.abort();
+            } else {
+              if (!noDisposeOnSet) {
+                this.dispose(oldVal, k, "set");
+                if (this.disposeAfter) {
+                  this.disposed.push([oldVal, k, "set"]);
+                }
+              }
+            }
+            this.removeItemSize(index);
+            this.valList[index] = v;
+            this.addItemSize(index, v, k, size);
+          }
+          this.moveToTail(index);
+        }
+        if (ttl !== 0 && this.ttl === 0 && !this.ttls) {
+          this.initializeTTLTracking();
+        }
+        if (!noUpdateTTL) {
+          this.setItemTTL(index, ttl);
+        }
+        if (this.disposeAfter) {
+          while (this.disposed.length) {
+            this.disposeAfter(...this.disposed.shift());
+          }
+        }
+        return this;
       }
-      values() {
-        return this[LRU_LIST].toArray().map((k) => k.value);
+      newIndex() {
+        if (this.size === 0) {
+          return this.tail;
+        }
+        if (this.size === this.max) {
+          return this.evict();
+        }
+        if (this.free.length !== 0) {
+          return this.free.pop();
+        }
+        return this.initialFill++;
       }
-      reset() {
-        if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
-          this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value));
+      pop() {
+        if (this.size) {
+          const val = this.valList[this.head];
+          this.evict();
+          return val;
         }
-        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((h) => h);
-      }
-      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;
+      evict() {
+        const head = this.head;
+        const k = this.keyList[head];
+        const v = this.valList[head];
+        if (this.isBackgroundFetch(v)) {
+          v.__abortController.abort();
+        } else {
+          this.dispose(v, k, "evict");
+          if (this.disposeAfter) {
+            this.disposed.push([v, k, "evict"]);
           }
-          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.removeItemSize(head);
+        this.head = this.next[head];
+        this.keyMap.delete(k);
+        this.size--;
+        return head;
+      }
+      has(k, { updateAgeOnHas = this.updateAgeOnHas } = {}) {
+        const index = this.keyMap.get(k);
+        if (index !== void 0) {
+          if (!this.isStale(index)) {
+            if (updateAgeOnHas) {
+              this.updateItemAge(index);
+            }
+            return true;
+          }
         }
-        this[LENGTH] += hit.length;
-        this[LRU_LIST].unshift(hit);
-        this[CACHE].set(key, this[LRU_LIST].head);
-        trim(this);
-        return true;
+        return false;
       }
-      has(key) {
-        if (!this[CACHE].has(key))
-          return false;
-        const hit = this[CACHE].get(key).value;
-        return !isStale(this, hit);
+      peek(k, { allowStale = this.allowStale } = {}) {
+        const index = this.keyMap.get(k);
+        if (index !== void 0 && (allowStale || !this.isStale(index))) {
+          return this.valList[index];
+        }
       }
-      get(key) {
-        return get(this, key, true);
+      backgroundFetch(k, index, options) {
+        const v = index === void 0 ? void 0 : this.valList[index];
+        if (this.isBackgroundFetch(v)) {
+          return v;
+        }
+        const ac = new AC();
+        const fetchOpts = {
+          signal: ac.signal,
+          options
+        };
+        const p = Promise.resolve(this.fetchMethod(k, v, fetchOpts)).then((v2) => {
+          if (!ac.signal.aborted) {
+            this.set(k, v2, fetchOpts.options);
+          }
+          return v2;
+        });
+        p.__abortController = ac;
+        p.__staleWhileFetching = v;
+        if (index === void 0) {
+          this.set(k, p, fetchOpts.options);
+          index = this.keyMap.get(k);
+        } else {
+          this.valList[index] = p;
+        }
+        return p;
+      }
+      isBackgroundFetch(p) {
+        return p && typeof p === "object" && typeof p.then === "function" && Object.prototype.hasOwnProperty.call(p, "__staleWhileFetching");
+      }
+      async fetch(k, {
+        allowStale = this.allowStale,
+        updateAgeOnGet = this.updateAgeOnGet,
+        ttl = this.ttl,
+        noDisposeOnSet = this.noDisposeOnSet,
+        size = 0,
+        sizeCalculation = this.sizeCalculation,
+        noUpdateTTL = this.noUpdateTTL
+      } = {}) {
+        if (!this.fetchMethod) {
+          return this.get(k, { allowStale, updateAgeOnGet });
+        }
+        const options = {
+          allowStale,
+          updateAgeOnGet,
+          ttl,
+          noDisposeOnSet,
+          size,
+          sizeCalculation,
+          noUpdateTTL
+        };
+        let index = this.keyMap.get(k);
+        if (index === void 0) {
+          return this.backgroundFetch(k, index, options);
+        } else {
+          const v = this.valList[index];
+          if (this.isBackgroundFetch(v)) {
+            return allowStale && v.__staleWhileFetching !== void 0 ? v.__staleWhileFetching : v;
+          }
+          if (!this.isStale(index)) {
+            this.moveToTail(index);
+            if (updateAgeOnGet) {
+              this.updateItemAge(index);
+            }
+            return v;
+          }
+          const p = this.backgroundFetch(k, index, options);
+          return allowStale && p.__staleWhileFetching !== void 0 ? p.__staleWhileFetching : p;
+        }
       }
-      peek(key) {
-        return get(this, key, false);
+      get(k, {
+        allowStale = this.allowStale,
+        updateAgeOnGet = this.updateAgeOnGet
+      } = {}) {
+        const index = this.keyMap.get(k);
+        if (index !== void 0) {
+          const value = this.valList[index];
+          const fetching = this.isBackgroundFetch(value);
+          if (this.isStale(index)) {
+            if (!fetching) {
+              this.delete(k);
+              return allowStale ? value : void 0;
+            } else {
+              return allowStale ? value.__staleWhileFetching : void 0;
+            }
+          } else {
+            if (fetching) {
+              return void 0;
+            }
+            this.moveToTail(index);
+            if (updateAgeOnGet) {
+              this.updateItemAge(index);
+            }
+            return value;
+          }
+        }
       }
-      pop() {
-        const node = this[LRU_LIST].tail;
-        if (!node)
-          return null;
-        del(this, node);
-        return node.value;
+      connect(p, n) {
+        this.prev[n] = p;
+        this.next[p] = n;
       }
-      del(key) {
-        del(this, this[CACHE].get(key));
+      moveToTail(index) {
+        if (index !== this.tail) {
+          if (index === this.head) {
+            this.head = this.next[index];
+          } else {
+            this.connect(this.prev[index], this.next[index]);
+          }
+          this.connect(this.tail, index);
+          this.tail = index;
+        }
       }
-      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);
+      get del() {
+        deprecatedMethod("del", "delete");
+        return this.delete;
+      }
+      delete(k) {
+        let deleted = false;
+        if (this.size !== 0) {
+          const index = this.keyMap.get(k);
+          if (index !== void 0) {
+            deleted = true;
+            if (this.size === 1) {
+              this.clear();
+            } else {
+              this.removeItemSize(index);
+              const v = this.valList[index];
+              if (this.isBackgroundFetch(v)) {
+                v.__abortController.abort();
+              } else {
+                this.dispose(v, k, "delete");
+                if (this.disposeAfter) {
+                  this.disposed.push([v, k, "delete"]);
+                }
+              }
+              this.keyMap.delete(k);
+              this.keyList[index] = null;
+              this.valList[index] = null;
+              if (index === this.tail) {
+                this.tail = this.prev[index];
+              } else if (index === this.head) {
+                this.head = this.next[index];
+              } else {
+                this.next[this.prev[index]] = this.next[index];
+                this.prev[this.next[index]] = this.prev[index];
+              }
+              this.size--;
+              this.free.push(index);
             }
           }
         }
-      }
-      prune() {
-        this[CACHE].forEach((value, key) => get(this, key, false));
-      }
-    };
-    var get = (self, key, doUse) => {
-      const node = self[CACHE].get(key);
-      if (node) {
-        const hit = node.value;
-        if (isStale(self, hit)) {
-          del(self, node);
-          if (!self[ALLOW_STALE])
-            return void 0;
-        } else {
-          if (doUse) {
-            if (self[UPDATE_AGE_ON_GET])
-              node.value.now = Date.now();
-            self[LRU_LIST].unshiftNode(node);
+        if (this.disposed) {
+          while (this.disposed.length) {
+            this.disposeAfter(...this.disposed.shift());
           }
         }
-        return hit.value;
+        return deleted;
       }
-    };
-    var isStale = (self, hit) => {
-      if (!hit || !hit.maxAge && !self[MAX_AGE])
-        return false;
-      const diff = Date.now() - hit.now;
-      return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
-    };
-    var trim = (self) => {
-      if (self[LENGTH] > self[MAX]) {
-        for (let walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null; ) {
-          const prev = walker.prev;
-          del(self, walker);
-          walker = prev;
+      clear() {
+        for (const index of this.rindexes({ allowStale: true })) {
+          const v = this.valList[index];
+          if (this.isBackgroundFetch(v)) {
+            v.__abortController.abort();
+          } else {
+            const k = this.keyList[index];
+            this.dispose(v, k, "delete");
+            if (this.disposeAfter) {
+              this.disposed.push([v, k, "delete"]);
+            }
+          }
+        }
+        this.keyMap.clear();
+        this.valList.fill(null);
+        this.keyList.fill(null);
+        if (this.ttls) {
+          this.ttls.fill(0);
+          this.starts.fill(0);
+        }
+        if (this.sizes) {
+          this.sizes.fill(0);
+        }
+        this.head = 0;
+        this.tail = 0;
+        this.initialFill = 1;
+        this.free.length = 0;
+        this.calculatedSize = 0;
+        this.size = 0;
+        if (this.disposed) {
+          while (this.disposed.length) {
+            this.disposeAfter(...this.disposed.shift());
+          }
         }
       }
-    };
-    var del = (self, node) => {
-      if (node) {
-        const hit = node.value;
-        if (self[DISPOSE])
-          self[DISPOSE](hit.key, hit.value);
-        self[LENGTH] -= hit.length;
-        self[CACHE].delete(hit.key);
-        self[LRU_LIST].removeNode(node);
+      get reset() {
+        deprecatedMethod("reset", "clear");
+        return this.clear;
       }
-    };
-    var Entry = class {
-      constructor(key, value, length, now, maxAge) {
-        this.key = key;
-        this.value = value;
-        this.length = length;
-        this.now = now;
-        this.maxAge = maxAge || 0;
+      get length() {
+        deprecatedProperty("length", "size");
+        return this.size;
       }
     };
-    var forEachStep = (self, fn, node, thisp) => {
-      let hit = node.value;
-      if (isStale(self, hit)) {
-        del(self, node);
-        if (!self[ALLOW_STALE])
-          hit = void 0;
-      }
-      if (hit)
-        fn.call(thisp, hit.value, hit.key, self);
-    };
     module2.exports = LRUCache;
   }
 });
@@ -1393,16 +1457,16 @@ var require_range = __commonJS({
         this.loose = !!options.loose;
         this.includePrerelease = !!options.includePrerelease;
         this.raw = range;
-        this.set = range.split(/\s*\|\|\s*/).map((range2) => this.parseRange(range2.trim())).filter((c) => c.length);
+        this.set = range.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
         if (!this.set.length) {
           throw new TypeError(`Invalid SemVer Range: ${range}`);
         }
         if (this.set.length > 1) {
           const first = this.set[0];
           this.set = this.set.filter((c) => !isNullSet(c[0]));
-          if (this.set.length === 0)
+          if (this.set.length === 0) {
             this.set = [first];
-          else if (this.set.length > 1) {
+          } else if (this.set.length > 1) {
             for (const c of this.set) {
               if (c.length === 1 && isAny(c[0])) {
                 this.set = [c];
@@ -1427,28 +1491,37 @@ var require_range = __commonJS({
         const memoOpts = Object.keys(this.options).join(",");
         const memoKey = `parseRange:${memoOpts}:${range}`;
         const cached = cache.get(memoKey);
-        if (cached)
+        if (cached) {
           return cached;
+        }
         const loose = this.options.loose;
         const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
         range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
         debug("hyphen replace", range);
         range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
-        debug("comparator trim", range, re[t.COMPARATORTRIM]);
+        debug("comparator trim", range);
         range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
         range = range.replace(re[t.CARETTRIM], caretTrimReplace);
         range = range.split(/\s+/).join(" ");
-        const compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
-        const rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options)).filter(this.options.loose ? (comp) => !!comp.match(compRe) : () => true).map((comp) => new Comparator(comp, this.options));
-        const l = rangeList.length;
+        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        if (loose) {
+          rangeList = rangeList.filter((comp) => {
+            debug("loose invalid filter", comp, this.options);
+            return !!comp.match(re[t.COMPARATORLOOSE]);
+          });
+        }
+        debug("range list", rangeList);
         const rangeMap = /* @__PURE__ */ new Map();
-        for (const comp of rangeList) {
-          if (isNullSet(comp))
+        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+        for (const comp of comparators) {
+          if (isNullSet(comp)) {
             return [comp];
+          }
           rangeMap.set(comp.value, comp);
         }
-        if (rangeMap.size > 1 && rangeMap.has(""))
+        if (rangeMap.size > 1 && rangeMap.has("")) {
           rangeMap.delete("");
+        }
         const result = [...rangeMap.values()];
         cache.set(memoKey, result);
         return result;
@@ -1527,8 +1600,8 @@ var require_range = __commonJS({
       return comp;
     };
     var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
-    var replaceTildes = (comp, options) => comp.trim().split(/\s+/).map((comp2) => {
-      return replaceTilde(comp2, options);
+    var replaceTildes = (comp, options) => comp.trim().split(/\s+/).map((c) => {
+      return replaceTilde(c, options);
     }).join(" ");
     var replaceTilde = (comp, options) => {
       const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
@@ -1551,8 +1624,8 @@ var require_range = __commonJS({
         return ret;
       });
     };
-    var replaceCarets = (comp, options) => comp.trim().split(/\s+/).map((comp2) => {
-      return replaceCaret(comp2, options);
+    var replaceCarets = (comp, options) => comp.trim().split(/\s+/).map((c) => {
+      return replaceCaret(c, options);
     }).join(" ");
     var replaceCaret = (comp, options) => {
       debug("caret", comp, options);
@@ -1600,8 +1673,8 @@ var require_range = __commonJS({
     };
     var replaceXRanges = (comp, options) => {
       debug("replaceXRanges", comp, options);
-      return comp.split(/\s+/).map((comp2) => {
-        return replaceXRange(comp2, options);
+      return comp.split(/\s+/).map((c) => {
+        return replaceXRange(c, options);
       }).join(" ");
     };
     var replaceXRange = (comp, options) => {
@@ -1646,8 +1719,9 @@ var require_range = __commonJS({
               m = +m + 1;
             }
           }
-          if (gtlt === "<")
+          if (gtlt === "<") {
             pr = "-0";
+          }
           ret = `${gtlt + M}.${m}.${p}${pr}`;
         } else if (xm) {
           ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
@@ -1944,8 +2018,9 @@ var require_min_version = __commonJS({
               throw new Error(`Unexpected operation: ${comparator.operator}`);
           }
         });
-        if (setMin && (!minver || gt(minver, setMin)))
+        if (setMin && (!minver || gt(minver, setMin))) {
           minver = setMin;
+        }
       }
       if (minver && range.test(minver)) {
         return minver;
@@ -2077,37 +2152,40 @@ var require_simplify = __commonJS({
     var compare = require_compare();
     module2.exports = (versions, range, options) => {
       const set = [];
-      let min = null;
+      let first = null;
       let prev = null;
       const v = versions.sort((a, b) => compare(a, b, options));
       for (const version of v) {
         const included = satisfies2(version, range, options);
         if (included) {
           prev = version;
-          if (!min)
-            min = version;
+          if (!first) {
+            first = version;
+          }
         } else {
           if (prev) {
-            set.push([min, prev]);
+            set.push([first, prev]);
           }
           prev = null;
-          min = null;
+          first = null;
         }
       }
-      if (min)
-        set.push([min, null]);
+      if (first) {
+        set.push([first, null]);
+      }
       const ranges = [];
-      for (const [min2, max] of set) {
-        if (min2 === max)
-          ranges.push(min2);
-        else if (!max && min2 === v[0])
+      for (const [min, max] of set) {
+        if (min === max) {
+          ranges.push(min);
+        } else if (!max && min === v[0]) {
           ranges.push("*");
-        else if (!max)
-          ranges.push(`>=${min2}`);
-        else if (min2 === v[0])
+        } else if (!max) {
+          ranges.push(`>=${min}`);
+        } else if (min === v[0]) {
           ranges.push(`<=${max}`);
-        else
-          ranges.push(`${min2} - ${max}`);
+        } else {
+          ranges.push(`${min} - ${max}`);
+        }
       }
       const simplified = ranges.join(" || ");
       const original = typeof range.raw === "string" ? range.raw : String(range);
@@ -2125,8 +2203,9 @@ var require_subset = __commonJS({
     var satisfies2 = require_satisfies();
     var compare = require_compare();
     var subset = (sub, dom, options = {}) => {
-      if (sub === dom)
+      if (sub === dom) {
         return true;
+      }
       sub = new Range(sub, options);
       dom = new Range(dom, options);
       let sawNonNull = false;
@@ -2135,59 +2214,70 @@ var require_subset = __commonJS({
           for (const simpleDom of dom.set) {
             const isSub = simpleSubset(simpleSub, simpleDom, options);
             sawNonNull = sawNonNull || isSub !== null;
-            if (isSub)
+            if (isSub) {
               continue OUTER;
+            }
           }
-          if (sawNonNull)
+          if (sawNonNull) {
             return false;
+          }
         }
       return true;
     };
     var simpleSubset = (sub, dom, options) => {
-      if (sub === dom)
+      if (sub === dom) {
         return true;
+      }
       if (sub.length === 1 && sub[0].semver === ANY) {
-        if (dom.length === 1 && dom[0].semver === ANY)
+        if (dom.length === 1 && dom[0].semver === ANY) {
           return true;
-        else if (options.includePrerelease)
+        } else if (options.includePrerelease) {
           sub = [new Comparator(">=0.0.0-0")];
-        else
+        } else {
           sub = [new Comparator(">=0.0.0")];
+        }
       }
       if (dom.length === 1 && dom[0].semver === ANY) {
-        if (options.includePrerelease)
+        if (options.includePrerelease) {
           return true;
-        else
+        } else {
           dom = [new Comparator(">=0.0.0")];
+        }
       }
       const eqSet = /* @__PURE__ */ new Set();
       let gt, lt;
       for (const c of sub) {
-        if (c.operator === ">" || c.operator === ">=")
+        if (c.operator === ">" || c.operator === ">=") {
           gt = higherGT(gt, c, options);
-        else if (c.operator === "<" || c.operator === "<=")
+        } else if (c.operator === "<" || c.operator === "<=") {
           lt = lowerLT(lt, c, options);
-        else
+        } else {
           eqSet.add(c.semver);
+        }
       }
-      if (eqSet.size > 1)
+      if (eqSet.size > 1) {
         return null;
+      }
       let gtltComp;
       if (gt && lt) {
         gtltComp = compare(gt.semver, lt.semver, options);
-        if (gtltComp > 0)
+        if (gtltComp > 0) {
           return null;
-        else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<="))
+        } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
           return null;
+        }
       }
       for (const eq of eqSet) {
-        if (gt && !satisfies2(eq, String(gt), options))
+        if (gt && !satisfies2(eq, String(gt), options)) {
           return null;
-        if (lt && !satisfies2(eq, String(lt), options))
+        }
+        if (lt && !satisfies2(eq, String(lt), options)) {
           return null;
+        }
         for (const c of dom) {
-          if (!satisfies2(eq, String(c), options))
+          if (!satisfies2(eq, String(c), options)) {
             return false;
+          }
         }
         return true;
       }
@@ -2209,10 +2299,12 @@ var require_subset = __commonJS({
           }
           if (c.operator === ">" || c.operator === ">=") {
             higher = higherGT(gt, c, options);
-            if (higher === c && higher !== gt)
+            if (higher === c && higher !== gt) {
               return false;
-          } else if (gt.operator === ">=" && !satisfies2(gt.semver, String(c), options))
+            }
+          } else if (gt.operator === ">=" && !satisfies2(gt.semver, String(c), options)) {
             return false;
+          }
         }
         if (lt) {
           if (needDomLTPre) {
@@ -2222,31 +2314,39 @@ var require_subset = __commonJS({
           }
           if (c.operator === "<" || c.operator === "<=") {
             lower = lowerLT(lt, c, options);
-            if (lower === c && lower !== lt)
+            if (lower === c && lower !== lt) {
               return false;
-          } else if (lt.operator === "<=" && !satisfies2(lt.semver, String(c), options))
+            }
+          } else if (lt.operator === "<=" && !satisfies2(lt.semver, String(c), options)) {
             return false;
+          }
         }
-        if (!c.operator && (lt || gt) && gtltComp !== 0)
+        if (!c.operator && (lt || gt) && gtltComp !== 0) {
           return false;
+        }
       }
-      if (gt && hasDomLT && !lt && gtltComp !== 0)
+      if (gt && hasDomLT && !lt && gtltComp !== 0) {
         return false;
-      if (lt && hasDomGT && !gt && gtltComp !== 0)
+      }
+      if (lt && hasDomGT && !gt && gtltComp !== 0) {
         return false;
-      if (needDomGTPre || needDomLTPre)
+      }
+      if (needDomGTPre || needDomLTPre) {
         return false;
+      }
       return true;
     };
     var higherGT = (a, b, options) => {
-      if (!a)
+      if (!a) {
         return b;
+      }
       const comp = compare(a.semver, b.semver, options);
       return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
     };
     var lowerLT = (a, b, options) => {
-      if (!a)
+      if (!a) {
         return b;
+      }
       const comp = compare(a.semver, b.semver, options);
       return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
     };
@@ -2319,6 +2419,7 @@ function createConfig(options) {
       "void-style": ["error", { style: "selfclose" }],
       "no-self-closing": "off",
       "vue/available-slots": "error",
+      "vue/prefer-slot-shorthand": "error",
       "vue/required-slots": "error"
     }
   };
@@ -2436,8 +2537,66 @@ var AvailableSlots = class extends import_html_validate2.Rule {
   }
 };
 
-// src/rules/required-slots.ts
+// src/rules/prefer-slot-shorthand.ts
 var import_html_validate3 = require("html-validate");
+var prefix = "v-slot:";
+function isVSlot(attr) {
+  if (!attr.startsWith(prefix)) {
+    return null;
+  }
+  if (attr.length <= prefix.length) {
+    return null;
+  }
+  const slot = attr.slice(prefix.length);
+  if (slot.match(/^\[.*\]$/)) {
+    return null;
+  }
+  return slot;
+}
+function isDeprecatedSlot(attr, value) {
+  if (attr !== "slot") {
+    return null;
+  }
+  if (value instanceof import_html_validate3.DynamicValue) {
+    return null;
+  }
+  if (value === null || value === "") {
+    return null;
+  }
+  return value.toString();
+}
+var PreferSlotShorthand = class extends import_html_validate3.Rule {
+  documentation(context) {
+    var _a;
+    const slot = (_a = context == null ? void 0 : context.slot) != null ? _a : "my-slot";
+    return {
+      description: [
+        `Prefer to use \`#${slot}\` over \`v-slot:${slot}\`.`,
+        "",
+        "Vue.js supports a shorthand syntax for slots using `#` instead of `v-slot:` or the deprecated `slot` attribute, e.g. using `#header` instead of `v-slot:header`."
+      ].join("\n")
+    };
+  }
+  setup() {
+    this.on("attr", (event) => {
+      const { key: attr, value, target, keyLocation: location } = event;
+      let slot;
+      if (slot = isVSlot(attr)) {
+        const context = { slot };
+        const message = `Prefer to use #${slot} over ${attr}`;
+        this.report(target, message, location, context);
+      }
+      if (slot = isDeprecatedSlot(attr, value)) {
+        const context = { slot };
+        const message = `Prefer to use #${slot} over ${attr}="${value.toString()}"`;
+        this.report(target, message, location, context);
+      }
+    });
+  }
+};
+
+// src/rules/required-slots.ts
+var import_html_validate4 = require("html-validate");
 function difference2(a, b) {
   const result = new Set(a);
   for (const elem of b) {
@@ -2445,7 +2604,7 @@ function difference2(a, b) {
   }
   return result;
 }
-var RequiredSlots = class extends import_html_validate3.Rule {
+var RequiredSlots = class extends import_html_validate4.Rule {
   documentation(context) {
     if (context) {
       return {
@@ -2492,12 +2651,13 @@ var RequiredSlots = class extends import_html_validate3.Rule {
 // src/rules/index.ts
 var rules = {
   "vue/available-slots": AvailableSlots,
+  "vue/prefer-slot-shorthand": PreferSlotShorthand,
   "vue/required-slots": RequiredSlots
 };
 var rules_default = rules;
 
 // src/hooks/attribute.ts
-var import_html_validate4 = require("html-validate");
+var import_html_validate5 = require("html-validate");
 function* processAttribute(attr) {
   yield attr;
   if (!attr.value) {
@@ -2507,14 +2667,14 @@ function* processAttribute(attr) {
   if (bind) {
     yield Object.assign({}, attr, {
       key: bind[1],
-      value: new import_html_validate4.DynamicValue(attr.value),
+      value: new import_html_validate5.DynamicValue(attr.value),
       originalAttribute: attr.key
     });
   }
 }
 
 // src/hooks/element.ts
-var import_html_validate5 = require("html-validate");
+var import_html_validate6 = require("html-validate");
 function isBound(node) {
   return node.hasAttribute("v-html");
 }
@@ -2575,7 +2735,7 @@ function processElement(node) {
     loadComponentMeta(this, node);
   }
   if (isBound(node) || isSlot(node)) {
-    node.appendText(new import_html_validate5.DynamicValue(""), node.location);
+    node.appendText(new import_html_validate6.DynamicValue(""), node.location);
   }
 }
 
@@ -2591,9 +2751,9 @@ function* transformHTML(source) {
 transformHTML.api = 1;
 
 // src/transform/js.transform.ts
-var import_html_validate6 = require("html-validate");
+var import_html_validate7 = require("html-validate");
 function transformJS(source) {
-  const te = import_html_validate6.TemplateExtractor.fromString(source.data, source.filename);
+  const te = import_html_validate7.TemplateExtractor.fromString(source.data, source.filename);
   return Array.from(te.extractObjectProperty("template"), (cur) => {
     cur.originalData = source.originalData || source.data;
     cur.hooks = {
@@ -2697,7 +2857,7 @@ var schema_default = {
 
 // src/version-check.ts
 var import_semver = __toESM(require_semver2());
-var import_html_validate7 = require("html-validate");
+var import_html_validate8 = require("html-validate");
 var pkg = require("../package.json");
 function doVersionCheck(peerDependency, version) {
   const printVersion = version || "< 1.16.0";
@@ -2712,10 +2872,10 @@ function doVersionCheck(peerDependency, version) {
 }
 function versionCheck() {
   const range = pkg.peerDependencies["html-validate"];
-  if (import_html_validate7.compatibilityCheck) {
-    (0, import_html_validate7.compatibilityCheck)(pkg.name, range);
+  if (import_html_validate8.compatibilityCheck) {
+    (0, import_html_validate8.compatibilityCheck)(pkg.name, range);
   } else {
-    const version = import_html_validate7.version;
+    const version = import_html_validate8.version;
     doVersionCheck(range, version);
   }
 }