@forsakringskassan/vite-lib-config 4.0.2 → 4.1.0

package/dist/vite.config.mjs

@@ -1046,214 +1046,6 @@ var require_supports_color = __commonJS({
   }
 });
 
-// node_modules/balanced-match/index.js
-var require_balanced_match = __commonJS({
-  "node_modules/balanced-match/index.js"(exports, module) {
-    "use strict";
-    module.exports = balanced;
-    function balanced(a, b, str) {
-      if (a instanceof RegExp) a = maybeMatch(a, str);
-      if (b instanceof RegExp) b = maybeMatch(b, str);
-      var r = range(a, b, str);
-      return r && {
-        start: r[0],
-        end: r[1],
-        pre: str.slice(0, r[0]),
-        body: str.slice(r[0] + a.length, r[1]),
-        post: str.slice(r[1] + b.length)
-      };
-    }
-    function maybeMatch(reg, str) {
-      var m = str.match(reg);
-      return m ? m[0] : null;
-    }
-    balanced.range = range;
-    function range(a, b, str) {
-      var begs, beg, left, right, result;
-      var ai = str.indexOf(a);
-      var bi = str.indexOf(b, ai + 1);
-      var i = ai;
-      if (ai >= 0 && bi > 0) {
-        if (a === b) {
-          return [ai, bi];
-        }
-        begs = [];
-        left = str.length;
-        while (i >= 0 && !result) {
-          if (i == ai) {
-            begs.push(i);
-            ai = str.indexOf(a, i + 1);
-          } else if (begs.length == 1) {
-            result = [begs.pop(), bi];
-          } else {
-            beg = begs.pop();
-            if (beg < left) {
-              left = beg;
-              right = bi;
-            }
-            bi = str.indexOf(b, i + 1);
-          }
-          i = ai < bi && ai >= 0 ? ai : bi;
-        }
-        if (begs.length) {
-          result = [left, right];
-        }
-      }
-      return result;
-    }
-  }
-});
-
-// node_modules/glob/node_modules/brace-expansion/index.js
-var require_brace_expansion = __commonJS({
-  "node_modules/glob/node_modules/brace-expansion/index.js"(exports, module) {
-    var balanced = require_balanced_match();
-    module.exports = expandTop;
-    var escSlash = "\0SLASH" + Math.random() + "\0";
-    var escOpen = "\0OPEN" + Math.random() + "\0";
-    var escClose = "\0CLOSE" + Math.random() + "\0";
-    var escComma = "\0COMMA" + Math.random() + "\0";
-    var escPeriod = "\0PERIOD" + Math.random() + "\0";
-    function numeric(str) {
-      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
-    }
-    function escapeBraces(str) {
-      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
-    }
-    function unescapeBraces(str) {
-      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
-    }
-    function parseCommaParts(str) {
-      if (!str)
-        return [""];
-      var parts = [];
-      var m = balanced("{", "}", str);
-      if (!m)
-        return str.split(",");
-      var pre = m.pre;
-      var body = m.body;
-      var post = m.post;
-      var p = pre.split(",");
-      p[p.length - 1] += "{" + body + "}";
-      var postParts = parseCommaParts(post);
-      if (post.length) {
-        p[p.length - 1] += postParts.shift();
-        p.push.apply(p, postParts);
-      }
-      parts.push.apply(parts, p);
-      return parts;
-    }
-    function expandTop(str) {
-      if (!str)
-        return [];
-      if (str.substr(0, 2) === "{}") {
-        str = "\\{\\}" + str.substr(2);
-      }
-      return expand2(escapeBraces(str), true).map(unescapeBraces);
-    }
-    function embrace(str) {
-      return "{" + str + "}";
-    }
-    function isPadded(el) {
-      return /^-?0\d/.test(el);
-    }
-    function lte(i, y) {
-      return i <= y;
-    }
-    function gte(i, y) {
-      return i >= y;
-    }
-    function expand2(str, isTop) {
-      var expansions = [];
-      var m = balanced("{", "}", str);
-      if (!m) return [str];
-      var pre = m.pre;
-      var post = m.post.length ? expand2(m.post, false) : [""];
-      if (/\$$/.test(m.pre)) {
-        for (var k = 0; k < post.length; k++) {
-          var expansion = pre + "{" + m.body + "}" + post[k];
-          expansions.push(expansion);
-        }
-      } else {
-        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-        var isSequence = isNumericSequence || isAlphaSequence;
-        var isOptions = m.body.indexOf(",") >= 0;
-        if (!isSequence && !isOptions) {
-          if (m.post.match(/,.*\}/)) {
-            str = m.pre + "{" + m.body + escClose + m.post;
-            return expand2(str);
-          }
-          return [str];
-        }
-        var n;
-        if (isSequence) {
-          n = m.body.split(/\.\./);
-        } else {
-          n = parseCommaParts(m.body);
-          if (n.length === 1) {
-            n = expand2(n[0], false).map(embrace);
-            if (n.length === 1) {
-              return post.map(function(p) {
-                return m.pre + n[0] + p;
-              });
-            }
-          }
-        }
-        var N;
-        if (isSequence) {
-          var x = numeric(n[0]);
-          var y = numeric(n[1]);
-          var width = Math.max(n[0].length, n[1].length);
-          var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
-          var test = lte;
-          var reverse = y < x;
-          if (reverse) {
-            incr *= -1;
-            test = gte;
-          }
-          var pad = n.some(isPadded);
-          N = [];
-          for (var i = x; test(i, y); i += incr) {
-            var c;
-            if (isAlphaSequence) {
-              c = String.fromCharCode(i);
-              if (c === "\\")
-                c = "";
-            } else {
-              c = String(i);
-              if (pad) {
-                var need = width - c.length;
-                if (need > 0) {
-                  var z = new Array(need + 1).join("0");
-                  if (i < 0)
-                    c = "-" + z + c.slice(1);
-                  else
-                    c = z + c;
-                }
-              }
-            }
-            N.push(c);
-          }
-        } else {
-          N = [];
-          for (var j = 0; j < n.length; j++) {
-            N.push.apply(N, expand2(n[j], false));
-          }
-        }
-        for (var j = 0; j < N.length; j++) {
-          for (var k = 0; k < post.length; k++) {
-            var expansion = pre + N[j] + post[k];
-            if (!isTop || isSequence || expansion)
-              expansions.push(expansion);
-          }
-        }
-      }
-      return expansions;
-    }
-  }
-});
-
 // node_modules/semver/internal/constants.js
 var require_constants = __commonJS({
   "node_modules/semver/internal/constants.js"(exports, module) {
@@ -1407,10 +1199,10 @@ var require_parse_options = __commonJS({
 var require_identifiers = __commonJS({
   "node_modules/semver/internal/identifiers.js"(exports, module) {
     "use strict";
-    var numeric = /^[0-9]+$/;
+    var numeric2 = /^[0-9]+$/;
     var compareIdentifiers = (a, b) => {
-      const anum = numeric.test(a);
-      const bnum = numeric.test(b);
+      const anum = numeric2.test(a);
+      const bnum = numeric2.test(b);
       if (anum && bnum) {
         a = +a;
         b = +b;
@@ -1954,8 +1746,8 @@ var require_gte = __commonJS({
   "node_modules/semver/functions/gte.js"(exports, module) {
     "use strict";
     var compare = require_compare();
-    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
-    module.exports = gte;
+    var gte2 = (a, b, loose) => compare(a, b, loose) >= 0;
+    module.exports = gte2;
   }
 });
 
@@ -1964,8 +1756,8 @@ var require_lte = __commonJS({
   "node_modules/semver/functions/lte.js"(exports, module) {
     "use strict";
     var compare = require_compare();
-    var lte = (a, b, loose) => compare(a, b, loose) <= 0;
-    module.exports = lte;
+    var lte2 = (a, b, loose) => compare(a, b, loose) <= 0;
+    module.exports = lte2;
   }
 });
 
@@ -1976,9 +1768,9 @@ var require_cmp = __commonJS({
     var eq = require_eq();
     var neq = require_neq();
     var gt = require_gt();
-    var gte = require_gte();
+    var gte2 = require_gte();
     var lt = require_lt();
-    var lte = require_lte();
+    var lte2 = require_lte();
     var cmp = (a, op, b, loose) => {
       switch (op) {
         case "===":
@@ -2006,11 +1798,11 @@ var require_cmp = __commonJS({
         case ">":
           return gt(a, b, loose);
         case ">=":
-          return gte(a, b, loose);
+          return gte2(a, b, loose);
         case "<":
           return lt(a, b, loose);
         case "<=":
-          return lte(a, b, loose);
+          return lte2(a, b, loose);
         default:
           throw new TypeError(`Invalid operator: ${op}`);
       }
@@ -2109,25 +1901,25 @@ var require_range = __commonJS({
     "use strict";
     var SPACE_CHARACTERS = /\s+/g;
     var Range = class _Range {
-      constructor(range, options) {
+      constructor(range2, options) {
         options = parseOptions(options);
-        if (range instanceof _Range) {
-          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
-            return range;
+        if (range2 instanceof _Range) {
+          if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) {
+            return range2;
           } else {
-            return new _Range(range.raw, options);
+            return new _Range(range2.raw, options);
           }
         }
-        if (range instanceof Comparator) {
-          this.raw = range.value;
-          this.set = [[range]];
+        if (range2 instanceof Comparator) {
+          this.raw = range2.value;
+          this.set = [[range2]];
           this.formatted = void 0;
           return this;
         }
         this.options = options;
         this.loose = !!options.loose;
         this.includePrerelease = !!options.includePrerelease;
-        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.raw = range2.trim().replace(SPACE_CHARACTERS, " ");
         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}`);
@@ -2172,24 +1964,24 @@ var require_range = __commonJS({
       toString() {
         return this.range;
       }
-      parseRange(range) {
+      parseRange(range2) {
         const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
-        const memoKey = memoOpts + ":" + range;
+        const memoKey = memoOpts + ":" + range2;
         const cached = cache2.get(memoKey);
         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));
-        debug2("hyphen replace", range);
-        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
-        debug2("comparator trim", range);
-        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
-        debug2("tilde trim", range);
-        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
-        debug2("caret trim", range);
-        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        range2 = range2.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug2("hyphen replace", range2);
+        range2 = range2.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+        debug2("comparator trim", range2);
+        range2 = range2.replace(re[t.TILDETRIM], tildeTrimReplace);
+        debug2("tilde trim", range2);
+        range2 = range2.replace(re[t.CARETTRIM], caretTrimReplace);
+        debug2("caret trim", range2);
+        let rangeList = range2.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
         if (loose) {
           rangeList = rangeList.filter((comp) => {
             debug2("loose invalid filter", comp, this.options);
@@ -2212,12 +2004,12 @@ var require_range = __commonJS({
         cache2.set(memoKey, result);
         return result;
       }
-      intersects(range, options) {
-        if (!(range instanceof _Range)) {
+      intersects(range2, options) {
+        if (!(range2 instanceof _Range)) {
           throw new TypeError("a Range is required");
         }
         return this.set.some((thisComparators) => {
-          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+          return isSatisfiable(thisComparators, options) && range2.set.some((rangeComparators) => {
             return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
               return rangeComparators.every((rangeComparator) => {
                 return thisComparator.intersects(rangeComparator, options);
@@ -2597,13 +2389,13 @@ var require_satisfies = __commonJS({
   "node_modules/semver/functions/satisfies.js"(exports, module) {
     "use strict";
     var Range = require_range();
-    var satisfies = (version3, range, options) => {
+    var satisfies = (version3, range2, options) => {
       try {
-        range = new Range(range, options);
+        range2 = new Range(range2, options);
       } catch (er) {
         return false;
       }
-      return range.test(version3);
+      return range2.test(version3);
     };
     module.exports = satisfies;
   }
@@ -2614,7 +2406,7 @@ var require_to_comparators = __commonJS({
   "node_modules/semver/ranges/to-comparators.js"(exports, module) {
     "use strict";
     var Range = require_range();
-    var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+    var toComparators = (range2, options) => new Range(range2, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
     module.exports = toComparators;
   }
 });
@@ -2625,12 +2417,12 @@ var require_max_satisfying = __commonJS({
     "use strict";
     var SemVer = require_semver();
     var Range = require_range();
-    var maxSatisfying = (versions, range, options) => {
+    var maxSatisfying = (versions, range2, options) => {
       let max = null;
       let maxSV = null;
       let rangeObj = null;
       try {
-        rangeObj = new Range(range, options);
+        rangeObj = new Range(range2, options);
       } catch (er) {
         return null;
       }
@@ -2654,12 +2446,12 @@ var require_min_satisfying = __commonJS({
     "use strict";
     var SemVer = require_semver();
     var Range = require_range();
-    var minSatisfying = (versions, range, options) => {
+    var minSatisfying = (versions, range2, options) => {
       let min = null;
       let minSV = null;
       let rangeObj = null;
       try {
-        rangeObj = new Range(range, options);
+        rangeObj = new Range(range2, options);
       } catch (er) {
         return null;
       }
@@ -2684,19 +2476,19 @@ var require_min_version = __commonJS({
     var SemVer = require_semver();
     var Range = require_range();
     var gt = require_gt();
-    var minVersion = (range, loose) => {
-      range = new Range(range, loose);
+    var minVersion = (range2, loose) => {
+      range2 = new Range(range2, loose);
       let minver = new SemVer("0.0.0");
-      if (range.test(minver)) {
+      if (range2.test(minver)) {
         return minver;
       }
       minver = new SemVer("0.0.0-0");
-      if (range.test(minver)) {
+      if (range2.test(minver)) {
         return minver;
       }
       minver = null;
-      for (let i = 0; i < range.set.length; ++i) {
-        const comparators = range.set[i];
+      for (let i = 0; i < range2.set.length; ++i) {
+        const comparators = range2.set[i];
         let setMin = null;
         comparators.forEach((comparator) => {
           const compver = new SemVer(comparator.semver.version);
@@ -2727,7 +2519,7 @@ var require_min_version = __commonJS({
           minver = setMin;
         }
       }
-      if (minver && range.test(minver)) {
+      if (minver && range2.test(minver)) {
         return minver;
       }
       return null;
@@ -2741,9 +2533,9 @@ var require_valid2 = __commonJS({
   "node_modules/semver/ranges/valid.js"(exports, module) {
     "use strict";
     var Range = require_range();
-    var validRange = (range, options) => {
+    var validRange = (range2, options) => {
       try {
-        return new Range(range, options).range || "*";
+        return new Range(range2, options).range || "*";
       } catch (er) {
         return null;
       }
@@ -2763,23 +2555,23 @@ var require_outside = __commonJS({
     var satisfies = require_satisfies();
     var gt = require_gt();
     var lt = require_lt();
-    var lte = require_lte();
-    var gte = require_gte();
-    var outside = (version3, range, hilo, options) => {
+    var lte2 = require_lte();
+    var gte2 = require_gte();
+    var outside = (version3, range2, hilo, options) => {
       version3 = new SemVer(version3, options);
-      range = new Range(range, options);
+      range2 = new Range(range2, options);
       let gtfn, ltefn, ltfn, comp, ecomp;
       switch (hilo) {
         case ">":
           gtfn = gt;
-          ltefn = lte;
+          ltefn = lte2;
           ltfn = lt;
           comp = ">";
           ecomp = ">=";
           break;
         case "<":
           gtfn = lt;
-          ltefn = gte;
+          ltefn = gte2;
           ltfn = gt;
           comp = "<";
           ecomp = "<=";
@@ -2787,11 +2579,11 @@ var require_outside = __commonJS({
         default:
           throw new TypeError('Must provide a hilo val of "<" or ">"');
       }
-      if (satisfies(version3, range, options)) {
+      if (satisfies(version3, range2, options)) {
         return false;
       }
-      for (let i = 0; i < range.set.length; ++i) {
-        const comparators = range.set[i];
+      for (let i = 0; i < range2.set.length; ++i) {
+        const comparators = range2.set[i];
         let high = null;
         let low = null;
         comparators.forEach((comparator) => {
@@ -2826,7 +2618,7 @@ var require_gtr = __commonJS({
   "node_modules/semver/ranges/gtr.js"(exports, module) {
     "use strict";
     var outside = require_outside();
-    var gtr = (version3, range, options) => outside(version3, range, ">", options);
+    var gtr = (version3, range2, options) => outside(version3, range2, ">", options);
     module.exports = gtr;
   }
 });
@@ -2836,7 +2628,7 @@ var require_ltr = __commonJS({
   "node_modules/semver/ranges/ltr.js"(exports, module) {
     "use strict";
     var outside = require_outside();
-    var ltr = (version3, range, options) => outside(version3, range, "<", options);
+    var ltr = (version3, range2, options) => outside(version3, range2, "<", options);
     module.exports = ltr;
   }
 });
@@ -2861,13 +2653,13 @@ var require_simplify = __commonJS({
     "use strict";
     var satisfies = require_satisfies();
     var compare = require_compare();
-    module.exports = (versions, range, options) => {
+    module.exports = (versions, range2, options) => {
       const set = [];
       let first = null;
       let prev = null;
       const v = versions.sort((a, b) => compare(a, b, options));
       for (const version3 of v) {
-        const included = satisfies(version3, range, options);
+        const included = satisfies(version3, range2, options);
         if (included) {
           prev = version3;
           if (!first) {
@@ -2899,8 +2691,8 @@ var require_simplify = __commonJS({
         }
       }
       const simplified = ranges.join(" || ");
-      const original = typeof range.raw === "string" ? range.raw : String(range);
-      return simplified.length < original.length ? simplified : range;
+      const original = typeof range2.raw === "string" ? range2.raw : String(range2);
+      return simplified.length < original.length ? simplified : range2;
     };
   }
 });
@@ -3094,8 +2886,8 @@ var require_semver2 = __commonJS({
     var lt = require_lt();
     var eq = require_eq();
     var neq = require_neq();
-    var gte = require_gte();
-    var lte = require_lte();
+    var gte2 = require_gte();
+    var lte2 = require_lte();
     var cmp = require_cmp();
     var coerce = require_coerce();
     var Comparator = require_comparator();
@@ -3132,8 +2924,8 @@ var require_semver2 = __commonJS({
       lt,
       eq,
       neq,
-      gte,
-      lte,
+      gte: gte2,
+      lte: lte2,
       cmp,
       coerce,
       Comparator,
@@ -3172,12 +2964,34 @@ import { vitePlugin as apimockPlugin } from "@forsakringskassan/apimock-express"
 import fs from "node:fs";
 import { normalizePath as normalizePath$1, isCSSRequest, transformWithEsbuild, formatPostcssSourceMap, createFilter } from "vite";
 import { shallowRef, computed } from "vue";
+
+// node_modules/@rolldown/pluginutils/dist/index.js
+function exactRegex(str, flags) {
+  return new RegExp(`^${escapeRegex(str)}$`, flags);
+}
+var escapeRegexRE = /[-/\\^$*+?.()|[\]{}]/g;
+function escapeRegex(str) {
+  return str.replace(escapeRegexRE, "\\$&");
+}
+function makeIdFiltersToMatchWithQuery(input) {
+  if (!Array.isArray(input)) return makeIdFilterToMatchWithQuery(input);
+  return input.map((i) => makeIdFilterToMatchWithQuery(i));
+}
+function makeIdFilterToMatchWithQuery(input) {
+  if (typeof input === "string") return `${input}{?*,}`;
+  return makeRegexIdFilterToMatchWithQuery(input);
+}
+function makeRegexIdFilterToMatchWithQuery(input) {
+  return new RegExp(input.source.replace(/(?<!\\)\$/g, "(?:\\?.*)?$"), input.flags);
+}
+
+// node_modules/@vitejs/plugin-vue/dist/index.mjs
 import { createRequire } from "node:module";
 import path from "node:path";
 import crypto from "node:crypto";
 import require$$0 from "tty";
 import require$$1 from "util";
-var version = "5.2.4";
+var version = "6.0.0";
 function resolveCompiler(root) {
   const compiler = tryResolveCompiler(root) || tryResolveCompiler();
   if (!compiler) {
@@ -3316,12 +3130,8 @@ function setSrcDescriptor(filename, entry, scoped) {
   }
   cache.set(filename, entry);
 }
-var hash = (
-  // eslint-disable-next-line n/no-unsupported-features/node-builtins -- crypto.hash is supported in Node 21.7.0+, 20.12.0+
-  crypto.hash ?? ((algorithm, data, outputEncoding) => crypto.createHash(algorithm).update(data).digest(outputEncoding))
-);
 function getHash(text) {
-  return hash("sha256", text, "hex").substring(0, 8);
+  return crypto.hash("sha256", text, "hex").substring(0, 8);
 }
 function slash(path4) {
   const isExtendedLengthPath = path4.startsWith("\\\\?\\");
@@ -3348,9 +3158,10 @@ function createRollupError(id, error) {
   }
   return rollupError;
 }
-async function transformTemplateAsModule(code, descriptor, options, pluginContext, ssr, customElement) {
+async function transformTemplateAsModule(code, filename, descriptor, options, pluginContext, ssr, customElement) {
   const result = compile(
     code,
+    filename,
     descriptor,
     options,
     pluginContext,
@@ -3372,6 +3183,7 @@ import.meta.hot.accept(({ render }) => {
 function transformTemplateInMain(code, descriptor, options, pluginContext, ssr, customElement) {
   const result = compile(
     code,
+    descriptor.filename,
     descriptor,
     options,
     pluginContext,
@@ -3386,11 +3198,10 @@ function transformTemplateInMain(code, descriptor, options, pluginContext, ssr,
     )
   };
 }
-function compile(code, descriptor, options, pluginContext, ssr, customElement) {
-  const filename = descriptor.filename;
+function compile(code, filename, descriptor, options, pluginContext, ssr, customElement) {
   resolveScript(descriptor, options, ssr, customElement);
   const result = options.compiler.compileTemplate({
-    ...resolveTemplateCompilerOptions(descriptor, options, ssr),
+    ...resolveTemplateCompilerOptions(descriptor, options, filename, ssr),
     source: code
   });
   if (result.errors.length) {
@@ -3410,14 +3221,14 @@ function compile(code, descriptor, options, pluginContext, ssr, customElement) {
   }
   return result;
 }
-function resolveTemplateCompilerOptions(descriptor, options, ssr) {
+function resolveTemplateCompilerOptions(descriptor, options, filename, ssr) {
   const block = descriptor.template;
   if (!block) {
     return;
   }
   const resolvedScript = getResolvedScript(descriptor, ssr);
   const hasScoped = descriptor.styles.some((s) => s.scoped);
-  const { id, filename, cssVars } = descriptor;
+  const { id, cssVars } = descriptor;
   let transformAssetUrls = options.template?.transformAssetUrls;
   let assetUrlOptions;
   if (transformAssetUrls === false) ;
@@ -3529,7 +3340,12 @@ function resolveScript(descriptor, options, ssr, customElement) {
     id: descriptor.id,
     isProd: options.isProduction,
     inlineTemplate: isUseInlineTemplate(descriptor, options),
-    templateOptions: resolveTemplateCompilerOptions(descriptor, options, ssr),
+    templateOptions: resolveTemplateCompilerOptions(
+      descriptor,
+      options,
+      descriptor.filename,
+      ssr
+    ),
     sourceMap: options.sourceMap,
     genDefaultAs: canInlineMain(descriptor, options) ? scriptIdentifier : void 0,
     customElement,
@@ -3768,7 +3584,7 @@ function parseFileUrl(input) {
   const path4 = match2[2];
   return makeUrl("file:", "", match2[1] || "", "", isAbsolutePath(path4) ? path4 : "/" + path4, match2[3] || "", match2[4] || "");
 }
-function makeUrl(scheme, user, host, port, path4, query, hash2) {
+function makeUrl(scheme, user, host, port, path4, query, hash) {
   return {
     scheme,
     user,
@@ -3776,7 +3592,7 @@ function makeUrl(scheme, user, host, port, path4, query, hash2) {
     port,
     path: path4,
     query,
-    hash: hash2,
+    hash,
     type: 7
   };
 }
@@ -4294,12 +4110,12 @@ function requireCommon() {
     createDebug.skips = [];
     createDebug.formatters = {};
     function selectColor(namespace) {
-      let hash2 = 0;
+      let hash = 0;
       for (let i = 0; i < namespace.length; i++) {
-        hash2 = (hash2 << 5) - hash2 + namespace.charCodeAt(i);
-        hash2 |= 0;
+        hash = (hash << 5) - hash + namespace.charCodeAt(i);
+        hash |= 0;
       }
-      return createDebug.colors[Math.abs(hash2) % createDebug.colors.length];
+      return createDebug.colors[Math.abs(hash) % createDebug.colors.length];
     }
     createDebug.selectColor = selectColor;
     function createDebug(namespace) {
@@ -4378,7 +4194,7 @@ function requireCommon() {
       createDebug.namespaces = namespaces;
       createDebug.names = [];
       createDebug.skips = [];
-      const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(" ", ",").split(",").filter(Boolean);
+      const split = (typeof namespaces === "string" ? namespaces : "").trim().replace(/\s+/g, ",").split(",").filter(Boolean);
       for (const ns of split) {
         if (ns[0] === "-") {
           createDebug.skips.push(ns.slice(1));
@@ -4597,7 +4413,7 @@ function requireBrowser() {
     function load() {
       let r;
       try {
-        r = exports.storage.getItem("debug");
+        r = exports.storage.getItem("debug") || exports.storage.getItem("DEBUG");
       } catch (error) {
       }
       if (!r && typeof process !== "undefined" && "env" in process) {
@@ -5504,22 +5320,24 @@ function vuePlugin(rawOptions = {}) {
     isProduction: process.env.NODE_ENV === "production",
     compiler: null,
     // to be set in buildStart
-    include: /\.vue$/,
     customElement: /\.ce\.vue$/,
     ...rawOptions,
     root: process.cwd(),
     sourceMap: true,
     cssDevSourcemap: false
   });
-  const filter3 = computed(
-    () => createFilter(options.value.include, options.value.exclude)
+  const include = shallowRef(
+    rawOptions.include ?? /\.vue$/
   );
+  const exclude = shallowRef(rawOptions.exclude);
+  let optionsHookIsCalled = false;
+  const filter3 = computed(() => createFilter(include.value, exclude.value));
   const customElementFilter = computed(() => {
     const customElement = options.value.features?.customElement || options.value.customElement;
     return typeof customElement === "boolean" ? () => customElement : createFilter(customElement);
   });
   let transformCachedModule = false;
-  return {
+  const plugin = {
     name: "vite:vue",
     api: {
       get options() {
@@ -5528,6 +5346,28 @@ function vuePlugin(rawOptions = {}) {
       set options(value) {
         options.value = value;
       },
+      get include() {
+        return include.value;
+      },
+      set include(value) {
+        if (optionsHookIsCalled) {
+          throw new Error(
+            "include cannot be updated after `options` hook is called"
+          );
+        }
+        include.value = value;
+      },
+      get exclude() {
+        return exclude.value;
+      },
+      set exclude(value) {
+        if (optionsHookIsCalled) {
+          throw new Error(
+            "exclude cannot be updated after `options` hook is called"
+          );
+        }
+        exclude.value = value;
+      },
       version
     },
     handleHotUpdate(ctx) {
@@ -5603,6 +5443,18 @@ function vuePlugin(rawOptions = {}) {
       };
       transformCachedModule = config.command === "build" && options.value.sourceMap && config.build.watch != null;
     },
+    options() {
+      optionsHookIsCalled = true;
+      plugin.transform.filter = {
+        id: {
+          include: [
+            ...makeIdFiltersToMatchWithQuery(ensureArray(include.value)),
+            /[?&]vue\b/
+          ],
+          exclude: exclude.value
+        }
+      };
+    },
     shouldTransformCachedModule({ id }) {
       if (transformCachedModule && parseVueRequest(id).query.vue) {
         return true;
@@ -5620,97 +5472,330 @@ function vuePlugin(rawOptions = {}) {
         });
       }
     },
-    async resolveId(id) {
-      if (id === EXPORT_HELPER_ID) {
-        return id;
-      }
-      if (parseVueRequest(id).query.vue) {
-        return id;
+    resolveId: {
+      filter: {
+        id: [exactRegex(EXPORT_HELPER_ID), /[?&]vue\b/]
+      },
+      handler(id) {
+        if (id === EXPORT_HELPER_ID) {
+          return id;
+        }
+        if (parseVueRequest(id).query.vue) {
+          return id;
+        }
       }
     },
-    load(id, opt) {
-      if (id === EXPORT_HELPER_ID) {
-        return helperCode;
-      }
-      const ssr = opt?.ssr === true;
-      const { filename, query } = parseVueRequest(id);
-      if (query.vue) {
-        if (query.src) {
-          return fs.readFileSync(filename, "utf-8");
-        }
-        const descriptor = getDescriptor(filename, options.value);
-        let block;
-        if (query.type === "script") {
-          block = resolveScript(
-            descriptor,
-            options.value,
-            ssr,
-            customElementFilter.value(filename)
-          );
-        } else if (query.type === "template") {
-          block = descriptor.template;
-        } else if (query.type === "style") {
-          block = descriptor.styles[query.index];
-        } else if (query.index != null) {
-          block = descriptor.customBlocks[query.index];
-        }
-        if (block) {
-          return {
-            code: block.content,
-            map: block.map
-          };
+    load: {
+      filter: {
+        id: [exactRegex(EXPORT_HELPER_ID), /[?&]vue\b/]
+      },
+      handler(id, opt) {
+        if (id === EXPORT_HELPER_ID) {
+          return helperCode;
+        }
+        const ssr = opt?.ssr === true;
+        const { filename, query } = parseVueRequest(id);
+        if (query.vue) {
+          if (query.src) {
+            return fs.readFileSync(filename, "utf-8");
+          }
+          const descriptor = getDescriptor(filename, options.value);
+          let block;
+          if (query.type === "script") {
+            block = resolveScript(
+              descriptor,
+              options.value,
+              ssr,
+              customElementFilter.value(filename)
+            );
+          } else if (query.type === "template") {
+            block = descriptor.template;
+          } else if (query.type === "style") {
+            block = descriptor.styles[query.index];
+          } else if (query.index != null) {
+            block = descriptor.customBlocks[query.index];
+          }
+          if (block) {
+            return {
+              code: block.content,
+              map: block.map
+            };
+          }
         }
       }
     },
-    transform(code, id, opt) {
-      const ssr = opt?.ssr === true;
-      const { filename, query } = parseVueRequest(id);
-      if (query.raw || query.url) {
-        return;
-      }
-      if (!filter3.value(filename) && !query.vue) {
-        return;
-      }
-      if (!query.vue) {
-        return transformMain(
-          code,
-          filename,
-          options.value,
-          this,
-          ssr,
-          customElementFilter.value(filename)
-        );
-      } else {
-        const descriptor = query.src ? getSrcDescriptor(filename, query) || getTempSrcDescriptor(filename, query) : getDescriptor(filename, options.value);
-        if (query.src) {
-          this.addWatchFile(filename);
+    transform: {
+      // filter is set in options() hook
+      handler(code, id, opt) {
+        const ssr = opt?.ssr === true;
+        const { filename, query } = parseVueRequest(id);
+        if (query.raw || query.url) {
+          return;
+        }
+        if (!filter3.value(filename) && !query.vue) {
+          return;
         }
-        if (query.type === "template") {
-          return transformTemplateAsModule(
+        if (!query.vue) {
+          return transformMain(
             code,
-            descriptor,
+            filename,
             options.value,
             this,
             ssr,
             customElementFilter.value(filename)
           );
-        } else if (query.type === "style") {
-          return transformStyle(
-            code,
-            descriptor,
-            Number(query.index || 0),
-            options.value,
-            this,
-            filename
-          );
+        } else {
+          const descriptor = query.src ? getSrcDescriptor(filename, query) || getTempSrcDescriptor(filename, query) : getDescriptor(filename, options.value);
+          if (query.src) {
+            this.addWatchFile(filename);
+          }
+          if (query.type === "template") {
+            return transformTemplateAsModule(
+              code,
+              filename,
+              descriptor,
+              options.value,
+              this,
+              ssr,
+              customElementFilter.value(filename)
+            );
+          } else if (query.type === "style") {
+            return transformStyle(
+              code,
+              descriptor,
+              Number(query.index || 0),
+              options.value,
+              this,
+              filename
+            );
+          }
         }
       }
     }
   };
+  return plugin;
+}
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [value];
+}
+function vuePluginCjs(options) {
+  return vuePlugin.call(this, options);
 }
+Object.assign(vuePluginCjs, {
+  default: vuePluginCjs,
+  parseVueRequest
+});
 
-// node_modules/glob/node_modules/minimatch/dist/esm/index.js
-var import_brace_expansion = __toESM(require_brace_expansion(), 1);
+// node_modules/@isaacs/balanced-match/dist/esm/index.js
+var balanced = (a, b, str) => {
+  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+  const r = ma !== null && mb != null && range(ma, mb, str);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + ma.length, r[1]),
+    post: str.slice(r[1] + mb.length)
+  };
+};
+var maybeMatch = (reg, str) => {
+  const m = str.match(reg);
+  return m ? m[0] : null;
+};
+var range = (a, b, str) => {
+  let begs, beg, left, right = void 0, result;
+  let ai = str.indexOf(a);
+  let bi = str.indexOf(b, ai + 1);
+  let i = ai;
+  if (ai >= 0 && bi > 0) {
+    if (a === b) {
+      return [ai, bi];
+    }
+    begs = [];
+    left = str.length;
+    while (i >= 0 && !result) {
+      if (i === ai) {
+        begs.push(i);
+        ai = str.indexOf(a, i + 1);
+      } else if (begs.length === 1) {
+        const r = begs.pop();
+        if (r !== void 0)
+          result = [r, bi];
+      } else {
+        beg = begs.pop();
+        if (beg !== void 0 && beg < left) {
+          left = beg;
+          right = bi;
+        }
+        bi = str.indexOf(b, i + 1);
+      }
+      i = ai < bi && ai >= 0 ? ai : bi;
+    }
+    if (begs.length && right !== void 0) {
+      result = [left, right];
+    }
+  }
+  return result;
+};
+
+// node_modules/@isaacs/brace-expansion/dist/esm/index.js
+var escSlash = "\0SLASH" + Math.random() + "\0";
+var escOpen = "\0OPEN" + Math.random() + "\0";
+var escClose = "\0CLOSE" + Math.random() + "\0";
+var escComma = "\0COMMA" + Math.random() + "\0";
+var escPeriod = "\0PERIOD" + Math.random() + "\0";
+var escSlashPattern = new RegExp(escSlash, "g");
+var escOpenPattern = new RegExp(escOpen, "g");
+var escClosePattern = new RegExp(escClose, "g");
+var escCommaPattern = new RegExp(escComma, "g");
+var escPeriodPattern = new RegExp(escPeriod, "g");
+var slashPattern = /\\\\/g;
+var openPattern = /\\{/g;
+var closePattern = /\\}/g;
+var commaPattern = /\\,/g;
+var periodPattern = /\\./g;
+function numeric(str) {
+  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+function parseCommaParts(str) {
+  if (!str) {
+    return [""];
+  }
+  const parts = [];
+  const m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
+  }
+  const { pre, body, post } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    ;
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+  parts.push.apply(parts, p);
+  return parts;
+}
+function expand(str) {
+  if (!str) {
+    return [];
+  }
+  if (str.slice(0, 2) === "{}") {
+    str = "\\{\\}" + str.slice(2);
+  }
+  return expand_(escapeBraces(str), true).map(unescapeBraces);
+}
+function embrace(str) {
+  return "{" + str + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+  return i <= y;
+}
+function gte(i, y) {
+  return i >= y;
+}
+function expand_(str, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str);
+  if (!m)
+    return [str];
+  const pre = m.pre;
+  const post = m.post.length ? expand_(m.post, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0; k < post.length; k++) {
+      const expansion = pre + "{" + m.body + "}" + post[k];
+      expansions.push(expansion);
+    }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str);
+      }
+      return [str];
+    }
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
+    } else {
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== void 0) {
+        n = expand_(n[0], false).map(embrace);
+        if (n.length === 1) {
+          return post.map((p) => m.pre + n[0] + p);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i = x; test(i, y); i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
+          }
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
+              }
+            }
+          }
+        }
+        N.push(c);
+      }
+    } else {
+      N = [];
+      for (let j = 0; j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], false));
+      }
+    }
+    for (let j = 0; j < N.length; j++) {
+      for (let k = 0; k < post.length; k++) {
+        const expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
+        }
+      }
+    }
+  }
+  return expansions;
+}
 
 // node_modules/glob/node_modules/minimatch/dist/esm/assert-valid-pattern.js
 var MAX_PATTERN_LENGTH = 1024 * 64;
@@ -6437,7 +6522,7 @@ var braceExpand = (pattern, options = {}) => {
   if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
     return [pattern];
   }
-  return (0, import_brace_expansion.default)(pattern);
+  return expand(pattern);
 };
 minimatch.braceExpand = braceExpand;
 var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();