@rindo/core 4.22.3 → 4.23.1

package/compiler/rindo.js

@@ -1,5 +1,5 @@
 /*!
- Rindo Compiler v4.22.3 | MIT Licensed | https://rindojs.web.app
+ Rindo Compiler v4.23.1 | MIT Licensed | https://rindojs.web.app
  */
 "use strict";
 var __create = Object.create;
@@ -2338,7 +2338,7 @@ var require_typescript_5_5_4_bundle_cache_min = __commonJS({
     See the Apache Version 2.0 License for specific language governing permissions
     and limitations under the License.
     ***************************************************************************** */
-    var ts70 = {};
+    var ts71 = {};
     ((module3) => {
       "use strict";
       var _a;
@@ -207859,9 +207859,9 @@ ${e.message}`;
         };
       }
     })({ get exports() {
-      return ts70;
+      return ts71;
     }, set exports(v) {
-      ts70 = v;
+      ts71 = v;
       if (typeof module2 !== "undefined" && module2.exports) {
         module2.exports = v;
       }
@@ -217235,6 +217235,1523 @@ export {${name} as __module}`;
   }
 });
 
+// node_modules/@rollup/pluginutils/node_modules/picomatch/lib/constants.js
+var require_constants2 = __commonJS({
+  "node_modules/@rollup/pluginutils/node_modules/picomatch/lib/constants.js"(exports2, module2) {
+    "use strict";
+    var WIN_SLASH = "\\\\/";
+    var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+    var DOT_LITERAL = "\\.";
+    var PLUS_LITERAL = "\\+";
+    var QMARK_LITERAL = "\\?";
+    var SLASH_LITERAL = "\\/";
+    var ONE_CHAR = "(?=.)";
+    var QMARK = "[^/]";
+    var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+    var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+    var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+    var NO_DOT = `(?!${DOT_LITERAL})`;
+    var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+    var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+    var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+    var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+    var STAR = `${QMARK}*?`;
+    var SEP = "/";
+    var POSIX_CHARS = {
+      DOT_LITERAL,
+      PLUS_LITERAL,
+      QMARK_LITERAL,
+      SLASH_LITERAL,
+      ONE_CHAR,
+      QMARK,
+      END_ANCHOR,
+      DOTS_SLASH,
+      NO_DOT,
+      NO_DOTS,
+      NO_DOT_SLASH,
+      NO_DOTS_SLASH,
+      QMARK_NO_DOT,
+      STAR,
+      START_ANCHOR,
+      SEP
+    };
+    var WINDOWS_CHARS = {
+      ...POSIX_CHARS,
+      SLASH_LITERAL: `[${WIN_SLASH}]`,
+      QMARK: WIN_NO_SLASH,
+      STAR: `${WIN_NO_SLASH}*?`,
+      DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+      NO_DOT: `(?!${DOT_LITERAL})`,
+      NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+      NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+      NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+      QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+      START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+      END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+      SEP: "\\"
+    };
+    var POSIX_REGEX_SOURCE = {
+      alnum: "a-zA-Z0-9",
+      alpha: "a-zA-Z",
+      ascii: "\\x00-\\x7F",
+      blank: " \\t",
+      cntrl: "\\x00-\\x1F\\x7F",
+      digit: "0-9",
+      graph: "\\x21-\\x7E",
+      lower: "a-z",
+      print: "\\x20-\\x7E ",
+      punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+      space: " \\t\\r\\n\\v\\f",
+      upper: "A-Z",
+      word: "A-Za-z0-9_",
+      xdigit: "A-Fa-f0-9"
+    };
+    module2.exports = {
+      MAX_LENGTH: 1024 * 64,
+      POSIX_REGEX_SOURCE,
+      // regular expressions
+      REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+      REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+      REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+      REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+      REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+      REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+      // Replace globs with equivalent patterns to reduce parsing time.
+      REPLACEMENTS: {
+        "***": "*",
+        "**/**": "**",
+        "**/**/**": "**"
+      },
+      // Digits
+      CHAR_0: 48,
+      /* 0 */
+      CHAR_9: 57,
+      /* 9 */
+      // Alphabet chars.
+      CHAR_UPPERCASE_A: 65,
+      /* A */
+      CHAR_LOWERCASE_A: 97,
+      /* a */
+      CHAR_UPPERCASE_Z: 90,
+      /* Z */
+      CHAR_LOWERCASE_Z: 122,
+      /* z */
+      CHAR_LEFT_PARENTHESES: 40,
+      /* ( */
+      CHAR_RIGHT_PARENTHESES: 41,
+      /* ) */
+      CHAR_ASTERISK: 42,
+      /* * */
+      // Non-alphabetic chars.
+      CHAR_AMPERSAND: 38,
+      /* & */
+      CHAR_AT: 64,
+      /* @ */
+      CHAR_BACKWARD_SLASH: 92,
+      /* \ */
+      CHAR_CARRIAGE_RETURN: 13,
+      /* \r */
+      CHAR_CIRCUMFLEX_ACCENT: 94,
+      /* ^ */
+      CHAR_COLON: 58,
+      /* : */
+      CHAR_COMMA: 44,
+      /* , */
+      CHAR_DOT: 46,
+      /* . */
+      CHAR_DOUBLE_QUOTE: 34,
+      /* " */
+      CHAR_EQUAL: 61,
+      /* = */
+      CHAR_EXCLAMATION_MARK: 33,
+      /* ! */
+      CHAR_FORM_FEED: 12,
+      /* \f */
+      CHAR_FORWARD_SLASH: 47,
+      /* / */
+      CHAR_GRAVE_ACCENT: 96,
+      /* ` */
+      CHAR_HASH: 35,
+      /* # */
+      CHAR_HYPHEN_MINUS: 45,
+      /* - */
+      CHAR_LEFT_ANGLE_BRACKET: 60,
+      /* < */
+      CHAR_LEFT_CURLY_BRACE: 123,
+      /* { */
+      CHAR_LEFT_SQUARE_BRACKET: 91,
+      /* [ */
+      CHAR_LINE_FEED: 10,
+      /* \n */
+      CHAR_NO_BREAK_SPACE: 160,
+      /* \u00A0 */
+      CHAR_PERCENT: 37,
+      /* % */
+      CHAR_PLUS: 43,
+      /* + */
+      CHAR_QUESTION_MARK: 63,
+      /* ? */
+      CHAR_RIGHT_ANGLE_BRACKET: 62,
+      /* > */
+      CHAR_RIGHT_CURLY_BRACE: 125,
+      /* } */
+      CHAR_RIGHT_SQUARE_BRACKET: 93,
+      /* ] */
+      CHAR_SEMICOLON: 59,
+      /* ; */
+      CHAR_SINGLE_QUOTE: 39,
+      /* ' */
+      CHAR_SPACE: 32,
+      /*   */
+      CHAR_TAB: 9,
+      /* \t */
+      CHAR_UNDERSCORE: 95,
+      /* _ */
+      CHAR_VERTICAL_LINE: 124,
+      /* | */
+      CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+      /* \uFEFF */
+      /**
+       * Create EXTGLOB_CHARS
+       */
+      extglobChars(chars3) {
+        return {
+          "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars3.STAR})` },
+          "?": { type: "qmark", open: "(?:", close: ")?" },
+          "+": { type: "plus", open: "(?:", close: ")+" },
+          "*": { type: "star", open: "(?:", close: ")*" },
+          "@": { type: "at", open: "(?:", close: ")" }
+        };
+      },
+      /**
+       * Create GLOB_CHARS
+       */
+      globChars(win322) {
+        return win322 === true ? WINDOWS_CHARS : POSIX_CHARS;
+      }
+    };
+  }
+});
+
+// node_modules/@rollup/pluginutils/node_modules/picomatch/lib/utils.js
+var require_utils2 = __commonJS({
+  "node_modules/@rollup/pluginutils/node_modules/picomatch/lib/utils.js"(exports2) {
+    "use strict";
+    var {
+      REGEX_BACKSLASH,
+      REGEX_REMOVE_BACKSLASH,
+      REGEX_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_GLOBAL
+    } = require_constants2();
+    exports2.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+    exports2.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+    exports2.isRegexChar = (str) => str.length === 1 && exports2.hasRegexChars(str);
+    exports2.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+    exports2.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+    exports2.isWindows = () => {
+      if (typeof navigator !== "undefined" && navigator.platform) {
+        const platform = navigator.platform.toLowerCase();
+        return platform === "win32" || platform === "windows";
+      }
+      if (typeof process !== "undefined" && process.platform) {
+        return process.platform === "win32";
+      }
+      return false;
+    };
+    exports2.removeBackslashes = (str) => {
+      return str.replace(REGEX_REMOVE_BACKSLASH, (match2) => {
+        return match2 === "\\" ? "" : match2;
+      });
+    };
+    exports2.escapeLast = (input, char, lastIdx) => {
+      const idx = input.lastIndexOf(char, lastIdx);
+      if (idx === -1) return input;
+      if (input[idx - 1] === "\\") return exports2.escapeLast(input, char, idx - 1);
+      return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+    };
+    exports2.removePrefix = (input, state = {}) => {
+      let output = input;
+      if (output.startsWith("./")) {
+        output = output.slice(2);
+        state.prefix = "./";
+      }
+      return output;
+    };
+    exports2.wrapOutput = (input, state = {}, options = {}) => {
+      const prepend3 = options.contains ? "" : "^";
+      const append4 = options.contains ? "" : "$";
+      let output = `${prepend3}(?:${input})${append4}`;
+      if (state.negated === true) {
+        output = `(?:^(?!${output}).*$)`;
+      }
+      return output;
+    };
+    exports2.basename = (path6, { windows } = {}) => {
+      const segs = path6.split(windows ? /[\\/]/ : "/");
+      const last = segs[segs.length - 1];
+      if (last === "") {
+        return segs[segs.length - 2];
+      }
+      return last;
+    };
+  }
+});
+
+// node_modules/@rollup/pluginutils/node_modules/picomatch/lib/scan.js
+var require_scan2 = __commonJS({
+  "node_modules/@rollup/pluginutils/node_modules/picomatch/lib/scan.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils2();
+    var {
+      CHAR_ASTERISK,
+      /* * */
+      CHAR_AT,
+      /* @ */
+      CHAR_BACKWARD_SLASH,
+      /* \ */
+      CHAR_COMMA,
+      /* , */
+      CHAR_DOT,
+      /* . */
+      CHAR_EXCLAMATION_MARK,
+      /* ! */
+      CHAR_FORWARD_SLASH,
+      /* / */
+      CHAR_LEFT_CURLY_BRACE,
+      /* { */
+      CHAR_LEFT_PARENTHESES,
+      /* ( */
+      CHAR_LEFT_SQUARE_BRACKET,
+      /* [ */
+      CHAR_PLUS,
+      /* + */
+      CHAR_QUESTION_MARK,
+      /* ? */
+      CHAR_RIGHT_CURLY_BRACE,
+      /* } */
+      CHAR_RIGHT_PARENTHESES,
+      /* ) */
+      CHAR_RIGHT_SQUARE_BRACKET
+      /* ] */
+    } = require_constants2();
+    var isPathSeparator = (code) => {
+      return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+    };
+    var depth = (token) => {
+      if (token.isPrefix !== true) {
+        token.depth = token.isGlobstar ? Infinity : 1;
+      }
+    };
+    var scan = (input, options) => {
+      const opts = options || {};
+      const length3 = input.length - 1;
+      const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+      const slashes = [];
+      const tokens = [];
+      const parts = [];
+      let str = input;
+      let index2 = -1;
+      let start = 0;
+      let lastIndex = 0;
+      let isBrace = false;
+      let isBracket = false;
+      let isGlob2 = false;
+      let isExtglob = false;
+      let isGlobstar = false;
+      let braceEscaped = false;
+      let backslashes = false;
+      let negated = false;
+      let negatedExtglob = false;
+      let finished = false;
+      let braces = 0;
+      let prev;
+      let code;
+      let token = { value: "", depth: 0, isGlob: false };
+      const eos = () => index2 >= length3;
+      const peek = () => str.charCodeAt(index2 + 1);
+      const advance3 = () => {
+        prev = code;
+        return str.charCodeAt(++index2);
+      };
+      while (index2 < length3) {
+        code = advance3();
+        let next;
+        if (code === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          code = advance3();
+          if (code === CHAR_LEFT_CURLY_BRACE) {
+            braceEscaped = true;
+          }
+          continue;
+        }
+        if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+          braces++;
+          while (eos() !== true && (code = advance3())) {
+            if (code === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              advance3();
+              continue;
+            }
+            if (code === CHAR_LEFT_CURLY_BRACE) {
+              braces++;
+              continue;
+            }
+            if (braceEscaped !== true && code === CHAR_DOT && (code = advance3()) === CHAR_DOT) {
+              isBrace = token.isBrace = true;
+              isGlob2 = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (braceEscaped !== true && code === CHAR_COMMA) {
+              isBrace = token.isBrace = true;
+              isGlob2 = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (code === CHAR_RIGHT_CURLY_BRACE) {
+              braces--;
+              if (braces === 0) {
+                braceEscaped = false;
+                isBrace = token.isBrace = true;
+                finished = true;
+                break;
+              }
+            }
+          }
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_FORWARD_SLASH) {
+          slashes.push(index2);
+          tokens.push(token);
+          token = { value: "", depth: 0, isGlob: false };
+          if (finished === true) continue;
+          if (prev === CHAR_DOT && index2 === start + 1) {
+            start += 2;
+            continue;
+          }
+          lastIndex = index2 + 1;
+          continue;
+        }
+        if (opts.noext !== true) {
+          const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+          if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+            isGlob2 = token.isGlob = true;
+            isExtglob = token.isExtglob = true;
+            finished = true;
+            if (code === CHAR_EXCLAMATION_MARK && index2 === start) {
+              negatedExtglob = true;
+            }
+            if (scanToEnd === true) {
+              while (eos() !== true && (code = advance3())) {
+                if (code === CHAR_BACKWARD_SLASH) {
+                  backslashes = token.backslashes = true;
+                  code = advance3();
+                  continue;
+                }
+                if (code === CHAR_RIGHT_PARENTHESES) {
+                  isGlob2 = token.isGlob = true;
+                  finished = true;
+                  break;
+                }
+              }
+              continue;
+            }
+            break;
+          }
+        }
+        if (code === CHAR_ASTERISK) {
+          if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+          isGlob2 = token.isGlob = true;
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_QUESTION_MARK) {
+          isGlob2 = token.isGlob = true;
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (code === CHAR_LEFT_SQUARE_BRACKET) {
+          while (eos() !== true && (next = advance3())) {
+            if (next === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              advance3();
+              continue;
+            }
+            if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+              isBracket = token.isBracket = true;
+              isGlob2 = token.isGlob = true;
+              finished = true;
+              break;
+            }
+          }
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+        if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index2 === start) {
+          negated = token.negated = true;
+          start++;
+          continue;
+        }
+        if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+          isGlob2 = token.isGlob = true;
+          if (scanToEnd === true) {
+            while (eos() !== true && (code = advance3())) {
+              if (code === CHAR_LEFT_PARENTHESES) {
+                backslashes = token.backslashes = true;
+                code = advance3();
+                continue;
+              }
+              if (code === CHAR_RIGHT_PARENTHESES) {
+                finished = true;
+                break;
+              }
+            }
+            continue;
+          }
+          break;
+        }
+        if (isGlob2 === true) {
+          finished = true;
+          if (scanToEnd === true) {
+            continue;
+          }
+          break;
+        }
+      }
+      if (opts.noext === true) {
+        isExtglob = false;
+        isGlob2 = false;
+      }
+      let base2 = str;
+      let prefix = "";
+      let glob = "";
+      if (start > 0) {
+        prefix = str.slice(0, start);
+        str = str.slice(start);
+        lastIndex -= start;
+      }
+      if (base2 && isGlob2 === true && lastIndex > 0) {
+        base2 = str.slice(0, lastIndex);
+        glob = str.slice(lastIndex);
+      } else if (isGlob2 === true) {
+        base2 = "";
+        glob = str;
+      } else {
+        base2 = str;
+      }
+      if (base2 && base2 !== "" && base2 !== "/" && base2 !== str) {
+        if (isPathSeparator(base2.charCodeAt(base2.length - 1))) {
+          base2 = base2.slice(0, -1);
+        }
+      }
+      if (opts.unescape === true) {
+        if (glob) glob = utils.removeBackslashes(glob);
+        if (base2 && backslashes === true) {
+          base2 = utils.removeBackslashes(base2);
+        }
+      }
+      const state = {
+        prefix,
+        input,
+        start,
+        base: base2,
+        glob,
+        isBrace,
+        isBracket,
+        isGlob: isGlob2,
+        isExtglob,
+        isGlobstar,
+        negated,
+        negatedExtglob
+      };
+      if (opts.tokens === true) {
+        state.maxDepth = 0;
+        if (!isPathSeparator(code)) {
+          tokens.push(token);
+        }
+        state.tokens = tokens;
+      }
+      if (opts.parts === true || opts.tokens === true) {
+        let prevIndex;
+        for (let idx = 0; idx < slashes.length; idx++) {
+          const n3 = prevIndex ? prevIndex + 1 : start;
+          const i = slashes[idx];
+          const value = input.slice(n3, i);
+          if (opts.tokens) {
+            if (idx === 0 && start !== 0) {
+              tokens[idx].isPrefix = true;
+              tokens[idx].value = prefix;
+            } else {
+              tokens[idx].value = value;
+            }
+            depth(tokens[idx]);
+            state.maxDepth += tokens[idx].depth;
+          }
+          if (idx !== 0 || value !== "") {
+            parts.push(value);
+          }
+          prevIndex = i;
+        }
+        if (prevIndex && prevIndex + 1 < input.length) {
+          const value = input.slice(prevIndex + 1);
+          parts.push(value);
+          if (opts.tokens) {
+            tokens[tokens.length - 1].value = value;
+            depth(tokens[tokens.length - 1]);
+            state.maxDepth += tokens[tokens.length - 1].depth;
+          }
+        }
+        state.slashes = slashes;
+        state.parts = parts;
+      }
+      return state;
+    };
+    module2.exports = scan;
+  }
+});
+
+// node_modules/@rollup/pluginutils/node_modules/picomatch/lib/parse.js
+var require_parse2 = __commonJS({
+  "node_modules/@rollup/pluginutils/node_modules/picomatch/lib/parse.js"(exports2, module2) {
+    "use strict";
+    var constants = require_constants2();
+    var utils = require_utils2();
+    var {
+      MAX_LENGTH,
+      POSIX_REGEX_SOURCE,
+      REGEX_NON_SPECIAL_CHARS,
+      REGEX_SPECIAL_CHARS_BACKREF,
+      REPLACEMENTS
+    } = constants;
+    var expandRange = (args, options) => {
+      if (typeof options.expandRange === "function") {
+        return options.expandRange(...args, options);
+      }
+      args.sort();
+      const value = `[${args.join("-")}]`;
+      try {
+        new RegExp(value);
+      } catch (ex) {
+        return args.map((v) => utils.escapeRegex(v)).join("..");
+      }
+      return value;
+    };
+    var syntaxError = (type, char) => {
+      return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+    };
+    var parse5 = (input, options) => {
+      if (typeof input !== "string") {
+        throw new TypeError("Expected a string");
+      }
+      input = REPLACEMENTS[input] || input;
+      const opts = { ...options };
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      let len = input.length;
+      if (len > max) {
+        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+      }
+      const bos = { type: "bos", value: "", output: opts.prepend || "" };
+      const tokens = [bos];
+      const capture = opts.capture ? "" : "?:";
+      const PLATFORM_CHARS = constants.globChars(opts.windows);
+      const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+      const {
+        DOT_LITERAL,
+        PLUS_LITERAL,
+        SLASH_LITERAL,
+        ONE_CHAR,
+        DOTS_SLASH,
+        NO_DOT,
+        NO_DOT_SLASH,
+        NO_DOTS_SLASH,
+        QMARK,
+        QMARK_NO_DOT,
+        STAR,
+        START_ANCHOR
+      } = PLATFORM_CHARS;
+      const globstar = (opts2) => {
+        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+      };
+      const nodot = opts.dot ? "" : NO_DOT;
+      const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+      let star3 = opts.bash === true ? globstar(opts) : STAR;
+      if (opts.capture) {
+        star3 = `(${star3})`;
+      }
+      if (typeof opts.noext === "boolean") {
+        opts.noextglob = opts.noext;
+      }
+      const state = {
+        input,
+        index: -1,
+        start: 0,
+        dot: opts.dot === true,
+        consumed: "",
+        output: "",
+        prefix: "",
+        backtrack: false,
+        negated: false,
+        brackets: 0,
+        braces: 0,
+        parens: 0,
+        quotes: 0,
+        globstar: false,
+        tokens
+      };
+      input = utils.removePrefix(input, state);
+      len = input.length;
+      const extglobs = [];
+      const braces = [];
+      const stack = [];
+      let prev = bos;
+      let value;
+      const eos = () => state.index === len - 1;
+      const peek = state.peek = (n3 = 1) => input[state.index + n3];
+      const advance3 = state.advance = () => input[++state.index] || "";
+      const remaining = () => input.slice(state.index + 1);
+      const consume = (value2 = "", num = 0) => {
+        state.consumed += value2;
+        state.index += num;
+      };
+      const append4 = (token) => {
+        state.output += token.output != null ? token.output : token.value;
+        consume(token.value);
+      };
+      const negate = () => {
+        let count = 1;
+        while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+          advance3();
+          state.start++;
+          count++;
+        }
+        if (count % 2 === 0) {
+          return false;
+        }
+        state.negated = true;
+        state.start++;
+        return true;
+      };
+      const increment = (type) => {
+        state[type]++;
+        stack.push(type);
+      };
+      const decrement = (type) => {
+        state[type]--;
+        stack.pop();
+      };
+      const push2 = (tok) => {
+        if (prev.type === "globstar") {
+          const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+          const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+          if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+            state.output = state.output.slice(0, -prev.output.length);
+            prev.type = "star";
+            prev.value = "*";
+            prev.output = star3;
+            state.output += prev.output;
+          }
+        }
+        if (extglobs.length && tok.type !== "paren") {
+          extglobs[extglobs.length - 1].inner += tok.value;
+        }
+        if (tok.value || tok.output) append4(tok);
+        if (prev && prev.type === "text" && tok.type === "text") {
+          prev.output = (prev.output || prev.value) + tok.value;
+          prev.value += tok.value;
+          return;
+        }
+        tok.prev = prev;
+        tokens.push(tok);
+        prev = tok;
+      };
+      const extglobOpen = (type, value2) => {
+        const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
+        token.prev = prev;
+        token.parens = state.parens;
+        token.output = state.output;
+        const output = (opts.capture ? "(" : "") + token.open;
+        increment("parens");
+        push2({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+        push2({ type: "paren", extglob: true, value: advance3(), output });
+        extglobs.push(token);
+      };
+      const extglobClose = (token) => {
+        let output = token.close + (opts.capture ? ")" : "");
+        let rest;
+        if (token.type === "negate") {
+          let extglobStar = star3;
+          if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+            extglobStar = globstar(opts);
+          }
+          if (extglobStar !== star3 || eos() || /^\)+$/.test(remaining())) {
+            output = token.close = `)$))${extglobStar}`;
+          }
+          if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+            const expression = parse5(rest, { ...options, fastpaths: false }).output;
+            output = token.close = `)${expression})${extglobStar})`;
+          }
+          if (token.prev.type === "bos") {
+            state.negatedExtglob = true;
+          }
+        }
+        push2({ type: "paren", extglob: true, value, output });
+        decrement("parens");
+      };
+      if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+        let backslashes = false;
+        let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars3, first, rest, index2) => {
+          if (first === "\\") {
+            backslashes = true;
+            return m;
+          }
+          if (first === "?") {
+            if (esc) {
+              return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+            }
+            if (index2 === 0) {
+              return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+            }
+            return QMARK.repeat(chars3.length);
+          }
+          if (first === ".") {
+            return DOT_LITERAL.repeat(chars3.length);
+          }
+          if (first === "*") {
+            if (esc) {
+              return esc + first + (rest ? star3 : "");
+            }
+            return star3;
+          }
+          return esc ? m : `\\${m}`;
+        });
+        if (backslashes === true) {
+          if (opts.unescape === true) {
+            output = output.replace(/\\/g, "");
+          } else {
+            output = output.replace(/\\+/g, (m) => {
+              return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+            });
+          }
+        }
+        if (output === input && opts.contains === true) {
+          state.output = input;
+          return state;
+        }
+        state.output = utils.wrapOutput(output, state, options);
+        return state;
+      }
+      while (!eos()) {
+        value = advance3();
+        if (value === "\0") {
+          continue;
+        }
+        if (value === "\\") {
+          const next = peek();
+          if (next === "/" && opts.bash !== true) {
+            continue;
+          }
+          if (next === "." || next === ";") {
+            continue;
+          }
+          if (!next) {
+            value += "\\";
+            push2({ type: "text", value });
+            continue;
+          }
+          const match2 = /^\\+/.exec(remaining());
+          let slashes = 0;
+          if (match2 && match2[0].length > 2) {
+            slashes = match2[0].length;
+            state.index += slashes;
+            if (slashes % 2 !== 0) {
+              value += "\\";
+            }
+          }
+          if (opts.unescape === true) {
+            value = advance3();
+          } else {
+            value += advance3();
+          }
+          if (state.brackets === 0) {
+            push2({ type: "text", value });
+            continue;
+          }
+        }
+        if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+          if (opts.posix !== false && value === ":") {
+            const inner = prev.value.slice(1);
+            if (inner.includes("[")) {
+              prev.posix = true;
+              if (inner.includes(":")) {
+                const idx = prev.value.lastIndexOf("[");
+                const pre = prev.value.slice(0, idx);
+                const rest2 = prev.value.slice(idx + 2);
+                const posix3 = POSIX_REGEX_SOURCE[rest2];
+                if (posix3) {
+                  prev.value = pre + posix3;
+                  state.backtrack = true;
+                  advance3();
+                  if (!bos.output && tokens.indexOf(prev) === 1) {
+                    bos.output = ONE_CHAR;
+                  }
+                  continue;
+                }
+              }
+            }
+          }
+          if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
+            value = `\\${value}`;
+          }
+          if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
+            value = `\\${value}`;
+          }
+          if (opts.posix === true && value === "!" && prev.value === "[") {
+            value = "^";
+          }
+          prev.value += value;
+          append4({ value });
+          continue;
+        }
+        if (state.quotes === 1 && value !== '"') {
+          value = utils.escapeRegex(value);
+          prev.value += value;
+          append4({ value });
+          continue;
+        }
+        if (value === '"') {
+          state.quotes = state.quotes === 1 ? 0 : 1;
+          if (opts.keepQuotes === true) {
+            push2({ type: "text", value });
+          }
+          continue;
+        }
+        if (value === "(") {
+          increment("parens");
+          push2({ type: "paren", value });
+          continue;
+        }
+        if (value === ")") {
+          if (state.parens === 0 && opts.strictBrackets === true) {
+            throw new SyntaxError(syntaxError("opening", "("));
+          }
+          const extglob = extglobs[extglobs.length - 1];
+          if (extglob && state.parens === extglob.parens + 1) {
+            extglobClose(extglobs.pop());
+            continue;
+          }
+          push2({ type: "paren", value, output: state.parens ? ")" : "\\)" });
+          decrement("parens");
+          continue;
+        }
+        if (value === "[") {
+          if (opts.nobracket === true || !remaining().includes("]")) {
+            if (opts.nobracket !== true && opts.strictBrackets === true) {
+              throw new SyntaxError(syntaxError("closing", "]"));
+            }
+            value = `\\${value}`;
+          } else {
+            increment("brackets");
+          }
+          push2({ type: "bracket", value });
+          continue;
+        }
+        if (value === "]") {
+          if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+            push2({ type: "text", value, output: `\\${value}` });
+            continue;
+          }
+          if (state.brackets === 0) {
+            if (opts.strictBrackets === true) {
+              throw new SyntaxError(syntaxError("opening", "["));
+            }
+            push2({ type: "text", value, output: `\\${value}` });
+            continue;
+          }
+          decrement("brackets");
+          const prevValue = prev.value.slice(1);
+          if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
+            value = `/${value}`;
+          }
+          prev.value += value;
+          append4({ value });
+          if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+            continue;
+          }
+          const escaped = utils.escapeRegex(prev.value);
+          state.output = state.output.slice(0, -prev.value.length);
+          if (opts.literalBrackets === true) {
+            state.output += escaped;
+            prev.value = escaped;
+            continue;
+          }
+          prev.value = `(${capture}${escaped}|${prev.value})`;
+          state.output += prev.value;
+          continue;
+        }
+        if (value === "{" && opts.nobrace !== true) {
+          increment("braces");
+          const open = {
+            type: "brace",
+            value,
+            output: "(",
+            outputIndex: state.output.length,
+            tokensIndex: state.tokens.length
+          };
+          braces.push(open);
+          push2(open);
+          continue;
+        }
+        if (value === "}") {
+          const brace = braces[braces.length - 1];
+          if (opts.nobrace === true || !brace) {
+            push2({ type: "text", value, output: value });
+            continue;
+          }
+          let output = ")";
+          if (brace.dots === true) {
+            const arr = tokens.slice();
+            const range = [];
+            for (let i = arr.length - 1; i >= 0; i--) {
+              tokens.pop();
+              if (arr[i].type === "brace") {
+                break;
+              }
+              if (arr[i].type !== "dots") {
+                range.unshift(arr[i].value);
+              }
+            }
+            output = expandRange(range, opts);
+            state.backtrack = true;
+          }
+          if (brace.comma !== true && brace.dots !== true) {
+            const out = state.output.slice(0, brace.outputIndex);
+            const toks = state.tokens.slice(brace.tokensIndex);
+            brace.value = brace.output = "\\{";
+            value = output = "\\}";
+            state.output = out;
+            for (const t of toks) {
+              state.output += t.output || t.value;
+            }
+          }
+          push2({ type: "brace", value, output });
+          decrement("braces");
+          braces.pop();
+          continue;
+        }
+        if (value === "|") {
+          if (extglobs.length > 0) {
+            extglobs[extglobs.length - 1].conditions++;
+          }
+          push2({ type: "text", value });
+          continue;
+        }
+        if (value === ",") {
+          let output = value;
+          const brace = braces[braces.length - 1];
+          if (brace && stack[stack.length - 1] === "braces") {
+            brace.comma = true;
+            output = "|";
+          }
+          push2({ type: "comma", value, output });
+          continue;
+        }
+        if (value === "/") {
+          if (prev.type === "dot" && state.index === state.start + 1) {
+            state.start = state.index + 1;
+            state.consumed = "";
+            state.output = "";
+            tokens.pop();
+            prev = bos;
+            continue;
+          }
+          push2({ type: "slash", value, output: SLASH_LITERAL });
+          continue;
+        }
+        if (value === ".") {
+          if (state.braces > 0 && prev.type === "dot") {
+            if (prev.value === ".") prev.output = DOT_LITERAL;
+            const brace = braces[braces.length - 1];
+            prev.type = "dots";
+            prev.output += value;
+            prev.value += value;
+            brace.dots = true;
+            continue;
+          }
+          if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+            push2({ type: "text", value, output: DOT_LITERAL });
+            continue;
+          }
+          push2({ type: "dot", value, output: DOT_LITERAL });
+          continue;
+        }
+        if (value === "?") {
+          const isGroup = prev && prev.value === "(";
+          if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            extglobOpen("qmark", value);
+            continue;
+          }
+          if (prev && prev.type === "paren") {
+            const next = peek();
+            let output = value;
+            if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
+              output = `\\${value}`;
+            }
+            push2({ type: "text", value, output });
+            continue;
+          }
+          if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+            push2({ type: "qmark", value, output: QMARK_NO_DOT });
+            continue;
+          }
+          push2({ type: "qmark", value, output: QMARK });
+          continue;
+        }
+        if (value === "!") {
+          if (opts.noextglob !== true && peek() === "(") {
+            if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+              extglobOpen("negate", value);
+              continue;
+            }
+          }
+          if (opts.nonegate !== true && state.index === 0) {
+            negate();
+            continue;
+          }
+        }
+        if (value === "+") {
+          if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            extglobOpen("plus", value);
+            continue;
+          }
+          if (prev && prev.value === "(" || opts.regex === false) {
+            push2({ type: "plus", value, output: PLUS_LITERAL });
+            continue;
+          }
+          if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+            push2({ type: "plus", value });
+            continue;
+          }
+          push2({ type: "plus", value: PLUS_LITERAL });
+          continue;
+        }
+        if (value === "@") {
+          if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+            push2({ type: "at", extglob: true, value, output: "" });
+            continue;
+          }
+          push2({ type: "text", value });
+          continue;
+        }
+        if (value !== "*") {
+          if (value === "$" || value === "^") {
+            value = `\\${value}`;
+          }
+          const match2 = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+          if (match2) {
+            value += match2[0];
+            state.index += match2[0].length;
+          }
+          push2({ type: "text", value });
+          continue;
+        }
+        if (prev && (prev.type === "globstar" || prev.star === true)) {
+          prev.type = "star";
+          prev.star = true;
+          prev.value += value;
+          prev.output = star3;
+          state.backtrack = true;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        let rest = remaining();
+        if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+          extglobOpen("star", value);
+          continue;
+        }
+        if (prev.type === "star") {
+          if (opts.noglobstar === true) {
+            consume(value);
+            continue;
+          }
+          const prior = prev.prev;
+          const before = prior.prev;
+          const isStart = prior.type === "slash" || prior.type === "bos";
+          const afterStar = before && (before.type === "star" || before.type === "globstar");
+          if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+            push2({ type: "star", value, output: "" });
+            continue;
+          }
+          const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+          const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+          if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+            push2({ type: "star", value, output: "" });
+            continue;
+          }
+          while (rest.slice(0, 3) === "/**") {
+            const after = input[state.index + 4];
+            if (after && after !== "/") {
+              break;
+            }
+            rest = rest.slice(3);
+            consume("/**", 3);
+          }
+          if (prior.type === "bos" && eos()) {
+            prev.type = "globstar";
+            prev.value += value;
+            prev.output = globstar(opts);
+            state.output = prev.output;
+            state.globstar = true;
+            consume(value);
+            continue;
+          }
+          if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+            state.output = state.output.slice(0, -(prior.output + prev.output).length);
+            prior.output = `(?:${prior.output}`;
+            prev.type = "globstar";
+            prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+            prev.value += value;
+            state.globstar = true;
+            state.output += prior.output + prev.output;
+            consume(value);
+            continue;
+          }
+          if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+            const end = rest[1] !== void 0 ? "|$" : "";
+            state.output = state.output.slice(0, -(prior.output + prev.output).length);
+            prior.output = `(?:${prior.output}`;
+            prev.type = "globstar";
+            prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+            prev.value += value;
+            state.output += prior.output + prev.output;
+            state.globstar = true;
+            consume(value + advance3());
+            push2({ type: "slash", value: "/", output: "" });
+            continue;
+          }
+          if (prior.type === "bos" && rest[0] === "/") {
+            prev.type = "globstar";
+            prev.value += value;
+            prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+            state.output = prev.output;
+            state.globstar = true;
+            consume(value + advance3());
+            push2({ type: "slash", value: "/", output: "" });
+            continue;
+          }
+          state.output = state.output.slice(0, -prev.output.length);
+          prev.type = "globstar";
+          prev.output = globstar(opts);
+          prev.value += value;
+          state.output += prev.output;
+          state.globstar = true;
+          consume(value);
+          continue;
+        }
+        const token = { type: "star", value, output: star3 };
+        if (opts.bash === true) {
+          token.output = ".*?";
+          if (prev.type === "bos" || prev.type === "slash") {
+            token.output = nodot + token.output;
+          }
+          push2(token);
+          continue;
+        }
+        if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+          token.output = value;
+          push2(token);
+          continue;
+        }
+        if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+          if (prev.type === "dot") {
+            state.output += NO_DOT_SLASH;
+            prev.output += NO_DOT_SLASH;
+          } else if (opts.dot === true) {
+            state.output += NO_DOTS_SLASH;
+            prev.output += NO_DOTS_SLASH;
+          } else {
+            state.output += nodot;
+            prev.output += nodot;
+          }
+          if (peek() !== "*") {
+            state.output += ONE_CHAR;
+            prev.output += ONE_CHAR;
+          }
+        }
+        push2(token);
+      }
+      while (state.brackets > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+        state.output = utils.escapeLast(state.output, "[");
+        decrement("brackets");
+      }
+      while (state.parens > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+        state.output = utils.escapeLast(state.output, "(");
+        decrement("parens");
+      }
+      while (state.braces > 0) {
+        if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+        state.output = utils.escapeLast(state.output, "{");
+        decrement("braces");
+      }
+      if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
+        push2({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
+      }
+      if (state.backtrack === true) {
+        state.output = "";
+        for (const token of state.tokens) {
+          state.output += token.output != null ? token.output : token.value;
+          if (token.suffix) {
+            state.output += token.suffix;
+          }
+        }
+      }
+      return state;
+    };
+    parse5.fastpaths = (input, options) => {
+      const opts = { ...options };
+      const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+      const len = input.length;
+      if (len > max) {
+        throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+      }
+      input = REPLACEMENTS[input] || input;
+      const {
+        DOT_LITERAL,
+        SLASH_LITERAL,
+        ONE_CHAR,
+        DOTS_SLASH,
+        NO_DOT,
+        NO_DOTS,
+        NO_DOTS_SLASH,
+        STAR,
+        START_ANCHOR
+      } = constants.globChars(opts.windows);
+      const nodot = opts.dot ? NO_DOTS : NO_DOT;
+      const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+      const capture = opts.capture ? "" : "?:";
+      const state = { negated: false, prefix: "" };
+      let star3 = opts.bash === true ? ".*?" : STAR;
+      if (opts.capture) {
+        star3 = `(${star3})`;
+      }
+      const globstar = (opts2) => {
+        if (opts2.noglobstar === true) return star3;
+        return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+      };
+      const create = (str) => {
+        switch (str) {
+          case "*":
+            return `${nodot}${ONE_CHAR}${star3}`;
+          case ".*":
+            return `${DOT_LITERAL}${ONE_CHAR}${star3}`;
+          case "*.*":
+            return `${nodot}${star3}${DOT_LITERAL}${ONE_CHAR}${star3}`;
+          case "*/*":
+            return `${nodot}${star3}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star3}`;
+          case "**":
+            return nodot + globstar(opts);
+          case "**/*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star3}`;
+          case "**/*.*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star3}${DOT_LITERAL}${ONE_CHAR}${star3}`;
+          case "**/.*":
+            return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star3}`;
+          default: {
+            const match2 = /^(.*?)\.(\w+)$/.exec(str);
+            if (!match2) return;
+            const source2 = create(match2[1]);
+            if (!source2) return;
+            return source2 + DOT_LITERAL + match2[2];
+          }
+        }
+      };
+      const output = utils.removePrefix(input, state);
+      let source = create(output);
+      if (source && opts.strictSlashes !== true) {
+        source += `${SLASH_LITERAL}?`;
+      }
+      return source;
+    };
+    module2.exports = parse5;
+  }
+});
+
+// node_modules/@rollup/pluginutils/node_modules/picomatch/lib/picomatch.js
+var require_picomatch3 = __commonJS({
+  "node_modules/@rollup/pluginutils/node_modules/picomatch/lib/picomatch.js"(exports2, module2) {
+    "use strict";
+    var scan = require_scan2();
+    var parse5 = require_parse2();
+    var utils = require_utils2();
+    var constants = require_constants2();
+    var isObject4 = (val) => val && typeof val === "object" && !Array.isArray(val);
+    var picomatch = (glob, options, returnState = false) => {
+      if (Array.isArray(glob)) {
+        const fns = glob.map((input) => picomatch(input, options, returnState));
+        const arrayMatcher = (str) => {
+          for (const isMatch of fns) {
+            const state2 = isMatch(str);
+            if (state2) return state2;
+          }
+          return false;
+        };
+        return arrayMatcher;
+      }
+      const isState = isObject4(glob) && glob.tokens && glob.input;
+      if (glob === "" || typeof glob !== "string" && !isState) {
+        throw new TypeError("Expected pattern to be a non-empty string");
+      }
+      const opts = options || {};
+      const posix3 = opts.windows;
+      const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+      const state = regex.state;
+      delete regex.state;
+      let isIgnored = () => false;
+      if (opts.ignore) {
+        const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+        isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+      }
+      const matcher = (input, returnObject = false) => {
+        const { isMatch, match: match2, output } = picomatch.test(input, regex, options, { glob, posix: posix3 });
+        const result2 = { glob, state, regex, posix: posix3, input, output, match: match2, isMatch };
+        if (typeof opts.onResult === "function") {
+          opts.onResult(result2);
+        }
+        if (isMatch === false) {
+          result2.isMatch = false;
+          return returnObject ? result2 : false;
+        }
+        if (isIgnored(input)) {
+          if (typeof opts.onIgnore === "function") {
+            opts.onIgnore(result2);
+          }
+          result2.isMatch = false;
+          return returnObject ? result2 : false;
+        }
+        if (typeof opts.onMatch === "function") {
+          opts.onMatch(result2);
+        }
+        return returnObject ? result2 : true;
+      };
+      if (returnState) {
+        matcher.state = state;
+      }
+      return matcher;
+    };
+    picomatch.test = (input, regex, options, { glob, posix: posix3 } = {}) => {
+      if (typeof input !== "string") {
+        throw new TypeError("Expected input to be a string");
+      }
+      if (input === "") {
+        return { isMatch: false, output: "" };
+      }
+      const opts = options || {};
+      const format = opts.format || (posix3 ? utils.toPosixSlashes : null);
+      let match2 = input === glob;
+      let output = match2 && format ? format(input) : input;
+      if (match2 === false) {
+        output = format ? format(input) : input;
+        match2 = output === glob;
+      }
+      if (match2 === false || opts.capture === true) {
+        if (opts.matchBase === true || opts.basename === true) {
+          match2 = picomatch.matchBase(input, regex, options, posix3);
+        } else {
+          match2 = regex.exec(output);
+        }
+      }
+      return { isMatch: Boolean(match2), match: match2, output };
+    };
+    picomatch.matchBase = (input, glob, options) => {
+      const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+      return regex.test(utils.basename(input));
+    };
+    picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+    picomatch.parse = (pattern, options) => {
+      if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
+      return parse5(pattern, { ...options, fastpaths: false });
+    };
+    picomatch.scan = (input, options) => scan(input, options);
+    picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+      if (returnOutput === true) {
+        return state.output;
+      }
+      const opts = options || {};
+      const prepend3 = opts.contains ? "" : "^";
+      const append4 = opts.contains ? "" : "$";
+      let source = `${prepend3}(?:${state.output})${append4}`;
+      if (state && state.negated === true) {
+        source = `^(?!${source}).*$`;
+      }
+      const regex = picomatch.toRegex(source, options);
+      if (returnState === true) {
+        regex.state = state;
+      }
+      return regex;
+    };
+    picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+      if (!input || typeof input !== "string") {
+        throw new TypeError("Expected a non-empty string");
+      }
+      let parsed = { negated: false, fastpaths: true };
+      if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
+        parsed.output = parse5.fastpaths(input, options);
+      }
+      if (!parsed.output) {
+        parsed = parse5(input, options);
+      }
+      return picomatch.compileRe(parsed, options, returnOutput, returnState);
+    };
+    picomatch.toRegex = (source, options) => {
+      try {
+        const opts = options || {};
+        return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+      } catch (err2) {
+        if (options && options.debug === true) throw err2;
+        return /$^/;
+      }
+    };
+    picomatch.constants = constants;
+    module2.exports = picomatch;
+  }
+});
+
+// node_modules/@rollup/pluginutils/node_modules/picomatch/index.js
+var require_picomatch4 = __commonJS({
+  "node_modules/@rollup/pluginutils/node_modules/picomatch/index.js"(exports2, module2) {
+    "use strict";
+    var pico = require_picomatch3();
+    var utils = require_utils2();
+    function picomatch(glob, options, returnState = false) {
+      if (options && (options.windows === null || options.windows === void 0)) {
+        options = { ...options, windows: utils.isWindows() };
+      }
+      return pico(glob, options, returnState);
+    }
+    Object.assign(picomatch, pico);
+    module2.exports = picomatch;
+  }
+});
+
 // node_modules/builtin-modules/index.js
 var require_builtin_modules = __commonJS({
   "node_modules/builtin-modules/index.js"(exports2, module2) {
@@ -236627,17 +238144,17 @@ __export(compiler_exports, {
   optimizeJs: () => optimizeJs,
   transpile: () => transpile,
   transpileSync: () => transpileSync,
-  ts: () => import_typescript69.default,
+  ts: () => import_typescript70.default,
   validateConfig: () => validateConfig,
   vermoji: () => vermoji,
   version: () => version,
   versions: () => versions
 });
 module.exports = __toCommonJS(compiler_exports);
-var import_typescript69 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript70 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/version.ts
-var buildId = "1738329851";
+var buildId = "1757056899";
 var minfyJsId = "terser5.31.1_7";
 var optimizeCssId = "autoprefixer10.4.19_postcss8.4.38_7";
 var parse5Version = "7.1.2";
@@ -236645,8 +238162,8 @@ var rollupVersion = "2.56.3";
 var jqueryVersion = "4.0.0-pre";
 var terserVersion = "5.31.1";
 var typescriptVersion = "5.5.4";
-var vermoji = "\u{1F319}";
-var version = "4.22.3";
+var vermoji = "\u{1F691}";
+var version = "4.23.1";
 var versions = {
   rindo: version,
   parse5: parse5Version,
@@ -236772,6 +238289,12 @@ var formatFlags = (compilerProperty) => {
   if (compilerProperty.reflect) {
     type |= 512 /* ReflectAttr */;
   }
+  if (compilerProperty.getter) {
+    type |= 2048 /* Getter */;
+  }
+  if (compilerProperty.setter) {
+    type |= 4096 /* Setter */;
+  }
   return type;
 };
 var formatAttrName = (compilerProperty) => {
@@ -237884,7 +239407,7 @@ var validateComponentTag = (tag) => {
 };
 
 // src/compiler/compiler.ts
-var import_typescript65 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript66 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/build/compiler-ctx.ts
 var import_path4 = require("path");
@@ -239921,7 +241444,10 @@ var createStaticGetter = (propName, returnExpression) => {
 };
 var getStaticValue = (staticMembers, staticName) => {
   const staticMember = staticMembers.find(
-    (member2) => member2.name.escapedText === staticName
+    (member2) => {
+      var _a;
+      return ((_a = member2.name) == null ? void 0 : _a.escapedText) === staticName;
+    }
   );
   if (!staticMember || !staticMember.body || !staticMember.body.statements) {
     return null;
@@ -240333,6 +241859,7 @@ var updateConstructor = (classNode, classMembers, statements, parameters) => {
   var _a, _b, _c;
   const constructorIndex = classMembers.findIndex((m) => m.kind === import_typescript4.default.SyntaxKind.Constructor);
   const constructorMethod = classMembers[constructorIndex];
+  if (constructorIndex < 0 && !(statements == null ? void 0 : statements.length) && !needsSuper(classNode)) return classMembers;
   if (constructorIndex >= 0 && import_typescript4.default.isConstructorDeclaration(constructorMethod)) {
     const constructorBodyStatements = (_b = (_a = constructorMethod.body) == null ? void 0 : _a.statements) != null ? _b : import_typescript4.default.factory.createNodeArray();
     const hasSuper = constructorBodyStatements.some((s) => s.kind === import_typescript4.default.SyntaxKind.SuperKeyword);
@@ -240369,16 +241896,18 @@ var createConstructorBodyWithSuper = () => {
     import_typescript4.default.factory.createCallExpression(import_typescript4.default.factory.createIdentifier("super"), void 0, void 0)
   );
 };
-var tsPropDeclNameAsString = (node, typeChecker) => {
+var tsPropDeclName = (node, typeChecker) => {
   const declarationName = import_typescript4.default.getNameOfDeclaration(node);
-  let memberName = declarationName.getText();
+  let staticName = declarationName.getText();
+  let dynamicName;
   if (import_typescript4.default.isComputedPropertyName(declarationName)) {
+    dynamicName = declarationName.expression.getText();
     const type = typeChecker.getTypeAtLocation(declarationName.expression);
     if (type != null && type.isLiteral()) {
-      memberName = type.value.toString();
+      staticName = type.value.toString();
     }
   }
-  return memberName;
+  return { staticName, dynamicName };
 };
 function getExternalStyles(style) {
   return style.externalStyles.map((s) => s.absolutePath).reverse().reduce((extStyles, styleUrl) => {
@@ -240654,7 +242183,7 @@ function walk(ast, { enter, leave }) {
 }
 
 // node_modules/@rollup/pluginutils/dist/es/index.js
-var import_picomatch = __toESM(require_picomatch2(), 1);
+var import_picomatch = __toESM(require_picomatch4(), 1);
 var addExtension = function addExtension2(filename, ext2 = ".js") {
   let result2 = `${filename}`;
   if (!(0, import_path8.extname)(filename))
@@ -240729,7 +242258,7 @@ var attachScopes = function attachScopes2(ast, propertyName = "scope") {
   walk(ast, {
     enter(n3, parent) {
       const node = n3;
-      if (/(Function|Class)Declaration/.test(node.type)) {
+      if (/(?:Function|Class)Declaration/.test(node.type)) {
         scope.addDeclaration(node, false, false);
       }
       if (node.type === "VariableDeclaration") {
@@ -240751,7 +242280,7 @@ var attachScopes = function attachScopes2(ast, propertyName = "scope") {
           newScope.addDeclaration(func, false, false);
         }
       }
-      if (/For(In|Of)?Statement/.test(node.type)) {
+      if (/For(?:In|Of)?Statement/.test(node.type)) {
         newScope = new Scope({
           parent: scope,
           block: true
@@ -240796,8 +242325,9 @@ function ensureArray(thing) {
     return [];
   return [thing];
 }
+var normalizePathRegExp = new RegExp(`\\${import_path8.win32.sep}`, "g");
 var normalizePath2 = function normalizePath3(filename) {
-  return filename.split(import_path8.win32.sep).join(import_path8.posix.sep);
+  return filename.replace(normalizePathRegExp, import_path8.posix.sep);
 };
 function getMatcherString(id, resolutionBase) {
   if (resolutionBase === false || (0, import_path8.isAbsolute)(id) || id.startsWith("**")) {
@@ -240818,10 +242348,12 @@ var createFilter = function createFilter2(include, exclude, options) {
   };
   const includeMatchers = ensureArray(include).map(getMatcher);
   const excludeMatchers = ensureArray(exclude).map(getMatcher);
+  if (!includeMatchers.length && !excludeMatchers.length)
+    return (id) => typeof id === "string" && !id.includes("\0");
   return function result2(id) {
     if (typeof id !== "string")
       return false;
-    if (/\0/.test(id))
+    if (id.includes("\0"))
       return false;
     const pathId = normalizePath2(id);
     for (let i = 0; i < excludeMatchers.length; ++i) {
@@ -240923,7 +242455,7 @@ var dataToEsm = function dataToEsm2(data2, options = {}) {
   }
   let maxUnderbarPrefixLength = 0;
   for (const key of Object.keys(data2)) {
-    const underbarPrefixLength = (_b = (_a = key.match(/^(_+)/)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
+    const underbarPrefixLength = (_b = (_a = /^(_+)/.exec(key)) === null || _a === void 0 ? void 0 : _a[0].length) !== null && _b !== void 0 ? _b : 0;
     if (underbarPrefixLength > maxUnderbarPrefixLength) {
       maxUnderbarPrefixLength = underbarPrefixLength;
     }
@@ -255374,6 +256906,7 @@ var getBuildFeatures = (cmps) => {
     member: cmps.some((c) => c.hasMember),
     method: cmps.some((c) => c.hasMethod),
     mode: cmps.some((c) => c.hasMode),
+    modernPropertyDecls: cmps.some((c) => c.hasModernPropertyDecls),
     observeAttribute: cmps.some((c) => c.hasAttribute || c.hasWatchCallback),
     prop: cmps.some((c) => c.hasProp),
     propBoolean: cmps.some((c) => c.hasPropBoolean),
@@ -257216,6 +258749,7 @@ var getLazyBuildConditionals = (config, cmps) => {
   build2.initializeNextTick = config.extras.initializeNextTick;
   const hasHydrateOutputTargets = config.outputTargets.some(isOutputTargetHydrate);
   build2.hydrateClientSide = hasHydrateOutputTargets;
+  build2.modernPropertyDecls = cmps.some((c) => c.hasModernPropertyDecls);
   updateBuildConditionals(config, build2);
   return build2;
 };
@@ -258699,7 +260233,8 @@ var validateConfig = (userConfig = {}, bootstrapConfig) => {
       "appendChildSlotFix",
       "slotChildNodesFix",
       "cloneNodeFix",
-      "scopedSlotTextContentFix"
+      "scopedSlotTextContentFix",
+      "experimentalScopedSlotChanges"
     ];
     const conflictingFlags = possibleFlags.filter((flag) => validatedConfig.extras[flag] === false);
     if (conflictingFlags.length > 0) {
@@ -258716,13 +260251,14 @@ var validateConfig = (userConfig = {}, bootstrapConfig) => {
     validatedConfig.extras.cloneNodeFix = true;
     validatedConfig.extras.slotChildNodesFix = true;
     validatedConfig.extras.scopedSlotTextContentFix = true;
+    validatedConfig.extras.experimentalScopedSlotChanges = true;
   } else {
     validatedConfig.extras.appendChildSlotFix = !!validatedConfig.extras.appendChildSlotFix;
     validatedConfig.extras.cloneNodeFix = !!validatedConfig.extras.cloneNodeFix;
     validatedConfig.extras.slotChildNodesFix = !!validatedConfig.extras.slotChildNodesFix;
     validatedConfig.extras.scopedSlotTextContentFix = !!validatedConfig.extras.scopedSlotTextContentFix;
+    validatedConfig.extras.experimentalScopedSlotChanges = !!validatedConfig.extras.experimentalScopedSlotChanges;
   }
-  validatedConfig.extras.experimentalScopedSlotChanges = !!validatedConfig.extras.experimentalScopedSlotChanges;
   setBooleanConfig(
     validatedConfig,
     "sourceMap",
@@ -259084,7 +260620,9 @@ var getRealProperties = (properties) => {
     deprecation: getDocsDeprecationText(member2.docs.tags),
     values: parseTypeIntoValues(member2.complexType.resolved),
     optional: member2.optional,
-    required: member2.required
+    required: member2.required,
+    getter: member2.getter,
+    setter: member2.setter
   }));
 };
 var getVirtualProperties = (virtualProps) => {
@@ -259100,7 +260638,9 @@ var getVirtualProperties = (virtualProps) => {
     deprecation: void 0,
     values: parseTypeIntoValues(member2.type),
     optional: true,
-    required: false
+    required: false,
+    getter: void 0,
+    setter: void 0
   }));
 };
 var parseTypeIntoValues = (type) => {
@@ -260205,14 +261745,22 @@ function getType(cmpMethod, typeImportData, componentSourcePath) {
 // src/compiler/types/generate-prop-types.ts
 var generatePropTypes = (cmpMeta, typeImportData) => {
   return [
-    ...cmpMeta.properties.map((cmpProp) => ({
-      name: cmpProp.name,
-      type: getType2(cmpProp, typeImportData, cmpMeta.sourceFilePath),
-      optional: cmpProp.optional,
-      required: cmpProp.required,
-      internal: cmpProp.internal,
-      jsdoc: getTextDocs(cmpProp.docs)
-    })),
+    ...cmpMeta.properties.map((cmpProp) => {
+      let doc = getTextDocs(cmpProp.docs);
+      if (cmpProp.getter && !cmpProp.setter && !(doc == null ? void 0 : doc.match("@readonly"))) {
+        cmpProp.docs = cmpProp.docs || { tags: [], text: "" };
+        cmpProp.docs.tags = [...cmpProp.docs.tags || [], { name: "readonly", text: "" }];
+        doc = getTextDocs(cmpProp.docs);
+      }
+      return {
+        name: cmpProp.name,
+        type: getType2(cmpProp, typeImportData, cmpMeta.sourceFilePath),
+        optional: cmpProp.optional,
+        required: cmpProp.required,
+        internal: cmpProp.internal,
+        jsdoc: doc
+      };
+    }),
     ...cmpMeta.virtualProperties.map((cmpProp) => ({
       name: cmpProp.name,
       type: cmpProp.type,
@@ -261517,7 +263065,7 @@ var attachInternalsDecoratorsToStatic = (diagnostics, decoratedMembers, newMembe
     return;
   }
   const [decoratedProp] = attachInternalsMembers;
-  const name = tsPropDeclNameAsString(decoratedProp, typeChecker);
+  const { staticName: name } = tsPropDeclName(decoratedProp, typeChecker);
   newMembers.push(createStaticGetter("attachInternalsMemberName", convertValueToLiteral(name)));
 };
 
@@ -261731,7 +263279,6 @@ var MEMBER_DECORATORS_TO_REMOVE = [
   "State",
   "Watch"
 ];
-var CONSTRUCTOR_DEFINED_MEMBER_DECORATORS = ["State", "Prop"];
 
 // src/compiler/transformers/decorators-to-static/element-decorator.ts
 var import_typescript46 = __toESM(require_typescript_5_5_4_bundle_cache_min());
@@ -262577,20 +264124,20 @@ var validateMethods = (diagnostics, members) => {
 // src/compiler/transformers/decorators-to-static/prop-decorator.ts
 var import_typescript51 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var propDecoratorsToStatic = (diagnostics, decoratedProps, typeChecker, program, newMembers, decoratorName) => {
-  const properties = decoratedProps.filter(import_typescript51.default.isPropertyDeclaration).map((prop) => parsePropDecorator(diagnostics, typeChecker, program, prop, decoratorName)).filter((prop) => prop != null);
+  const properties = decoratedProps.filter((prop) => import_typescript51.default.isPropertyDeclaration(prop) || import_typescript51.default.isGetAccessor(prop)).map((prop) => parsePropDecorator(diagnostics, typeChecker, program, prop, decoratorName, newMembers)).filter((prop) => prop != null);
   if (properties.length > 0) {
     newMembers.push(createStaticGetter("properties", import_typescript51.default.factory.createObjectLiteralExpression(properties, true)));
   }
 };
-var parsePropDecorator = (diagnostics, typeChecker, program, prop, decoratorName) => {
-  var _a;
+var parsePropDecorator = (diagnostics, typeChecker, program, prop, decoratorName, newMembers) => {
+  var _a, _b;
   const propDecorator = (_a = retrieveTsDecorators(prop)) == null ? void 0 : _a.find(isDecoratorNamed(decoratorName));
   if (propDecorator == null) {
     return null;
   }
   const decoratorParams = getDecoratorParameters(propDecorator, typeChecker);
   const propOptions = decoratorParams[0] || {};
-  const propName = tsPropDeclNameAsString(prop, typeChecker);
+  const { staticName: propName, dynamicName: ogPropName } = tsPropDeclName(prop, typeChecker);
   if (isMemberPrivate(prop)) {
     const err2 = buildError(diagnostics);
     err2.messageText = 'Properties decorated with the @Prop() decorator cannot be "private" nor "protected". More info: https://rindojs.web.app/docs/properties';
@@ -262606,21 +264153,41 @@ var parsePropDecorator = (diagnostics, typeChecker, program, prop, decoratorName
   const symbol = typeChecker.getSymbolAtLocation(prop.name);
   const type = typeChecker.getTypeAtLocation(prop);
   const typeStr = propTypeFromTSType(type);
+  const foundSetter = import_typescript51.default.isGetAccessor(prop) ? findSetter(propName, newMembers) : null;
   const propMeta = {
     type: typeStr,
     mutable: !!propOptions.mutable,
     complexType: getComplexType2(typeChecker, prop, type, program),
     required: prop.exclamationToken !== void 0 && propName !== "mode",
     optional: prop.questionToken !== void 0,
-    docs: serializeSymbol(typeChecker, symbol)
+    docs: serializeSymbol(typeChecker, symbol),
+    getter: import_typescript51.default.isGetAccessor(prop),
+    setter: !!foundSetter
   };
+  if (ogPropName && ogPropName !== propName) propMeta.ogPropName = ogPropName;
   if (typeStr !== "unknown") {
     propMeta.attribute = getAttributeName(propName, propOptions);
     propMeta.reflect = getReflect(diagnostics, propDecorator, propOptions);
   }
-  const initializer = prop.initializer;
-  if (initializer) {
-    propMeta.defaultValue = initializer.getText();
+  if (import_typescript51.default.isPropertyDeclaration(prop) && prop.initializer) {
+    propMeta.defaultValue = prop.initializer.getText();
+  } else if (import_typescript51.default.isGetAccessorDeclaration(prop)) {
+    const returnStatement = (_b = prop.body) == null ? void 0 : _b.statements.find((st) => import_typescript51.default.isReturnStatement(st));
+    const returnExpression = returnStatement.expression;
+    if (returnExpression && import_typescript51.default.isLiteralExpression(returnExpression)) {
+      propMeta.defaultValue = returnExpression.getText();
+    } else if (returnExpression && import_typescript51.default.isPropertyAccessExpression(returnExpression)) {
+      const nameToFind = returnExpression.name.getText();
+      const foundProp = findGetProp(nameToFind, newMembers);
+      if (foundProp && foundProp.initializer) {
+        propMeta.defaultValue = foundProp.initializer.getText();
+        if (propMeta.type === "unknown") {
+          const type2 = typeChecker.getTypeAtLocation(foundProp);
+          propMeta.type = propTypeFromTSType(type2);
+          propMeta.complexType = getComplexType2(typeChecker, foundProp, type2, program);
+        }
+      }
+    }
   }
   const staticProp = import_typescript51.default.factory.createPropertyAssignment(
     import_typescript51.default.factory.createStringLiteral(propName),
@@ -262727,6 +264294,12 @@ var isAny = (t) => {
   }
   return false;
 };
+var findSetter = (propName, members) => {
+  return members.find((m) => import_typescript51.default.isSetAccessor(m) && m.name.getText() === propName);
+};
+var findGetProp = (propName, members) => {
+  return members.find((m) => import_typescript51.default.isPropertyDeclaration(m) && m.name.getText() === propName);
+};
 
 // src/compiler/transformers/decorators-to-static/state-decorator.ts
 var import_typescript52 = __toESM(require_typescript_5_5_4_bundle_cache_min());
@@ -262742,11 +264315,10 @@ var stateDecoratorToStatic = (prop, typeChecker, decoratorName) => {
   if (stateDecorator == null) {
     return null;
   }
-  const stateName = tsPropDeclNameAsString(prop, typeChecker);
-  return import_typescript52.default.factory.createPropertyAssignment(
-    import_typescript52.default.factory.createStringLiteral(stateName),
-    import_typescript52.default.factory.createObjectLiteralExpression([], true)
-  );
+  const { staticName: stateName, dynamicName: ogPropName } = tsPropDeclName(prop, typeChecker);
+  const meta = {};
+  if (ogPropName && ogPropName !== stateName) meta.ogPropName = ogPropName;
+  return import_typescript52.default.factory.createPropertyAssignment(import_typescript52.default.factory.createStringLiteral(stateName), convertValueToLiteral(meta));
 };
 
 // src/compiler/transformers/decorators-to-static/watch-decorator.ts
@@ -262846,9 +264418,9 @@ var visitClassDeclaration = (config, diagnostics, typeChecker, program, classNod
       importAliasMap.get("AttachInternals")
     );
   }
-  const updatedClassFields = handleClassFields(classNode, filteredMethodsAndFields, typeChecker, importAliasMap);
   validateMethods(diagnostics, classMembers);
   const currentDecorators = retrieveTsDecorators(classNode);
+  const updatedClassFields = updateConstructor(classNode, filteredMethodsAndFields, []);
   return import_typescript54.default.factory.updateClassDeclaration(
     classNode,
     [
@@ -262866,7 +264438,7 @@ var visitClassDeclaration = (config, diagnostics, typeChecker, program, classNod
 };
 var removeRindoMethodDecorators = (classMembers, diagnostics, importAliasMap) => {
   return classMembers.map((member2) => {
-    var _a;
+    var _a, _b;
     const currentDecorators = retrieveTsDecorators(member2);
     const newDecorators = filterDecorators(
       currentDecorators,
@@ -262885,20 +264457,29 @@ var removeRindoMethodDecorators = (classMembers, diagnostics, importAliasMap) =>
           member2.type,
           member2.body
         );
+      } else if (import_typescript54.default.isGetAccessor(member2)) {
+        return import_typescript54.default.factory.updateGetAccessorDeclaration(
+          member2,
+          [...newDecorators != null ? newDecorators : [], ...(_b = retrieveTsModifiers(member2)) != null ? _b : []],
+          member2.name,
+          member2.parameters,
+          member2.type,
+          member2.body
+        );
+      } else if (import_typescript54.default.isSetAccessor(member2)) {
+        const err2 = buildError(diagnostics);
+        err2.messageText = "A get accessor should be decorated before a set accessor";
+        augmentDiagnosticWithNode(err2, member2);
       } else if (import_typescript54.default.isPropertyDeclaration(member2)) {
-        if (shouldInitializeInConstructor(member2, importAliasMap)) {
-          return member2;
-        } else {
-          const modifiers = retrieveTsModifiers(member2);
-          return import_typescript54.default.factory.updatePropertyDeclaration(
-            member2,
-            [...newDecorators != null ? newDecorators : [], ...modifiers != null ? modifiers : []],
-            member2.name,
-            member2.questionToken,
-            member2.type,
-            member2.initializer
-          );
-        }
+        const modifiers = retrieveTsModifiers(member2);
+        return import_typescript54.default.factory.updatePropertyDeclaration(
+          member2,
+          [...newDecorators != null ? newDecorators : [], ...modifiers != null ? modifiers : []],
+          member2.name,
+          member2.questionToken,
+          member2.type,
+          member2.initializer
+        );
       } else {
         const err2 = buildError(diagnostics);
         err2.messageText = "Unknown class member encountered!";
@@ -262922,49 +264503,10 @@ var filterDecorators = (decorators, excludeList) => {
   }
   return decorators;
 };
-function handleClassFields(classNode, classMembers, typeChecker, importAliasMap) {
-  var _a;
-  const statements = [];
-  const updatedClassMembers = [];
-  for (const member2 of classMembers) {
-    if (shouldInitializeInConstructor(member2, importAliasMap) && import_typescript54.default.isPropertyDeclaration(member2)) {
-      const memberName = tsPropDeclNameAsString(member2, typeChecker);
-      statements.push(
-        import_typescript54.default.factory.createExpressionStatement(
-          import_typescript54.default.factory.createBinaryExpression(
-            import_typescript54.default.factory.createPropertyAccessExpression(import_typescript54.default.factory.createThis(), import_typescript54.default.factory.createIdentifier(memberName)),
-            import_typescript54.default.factory.createToken(import_typescript54.default.SyntaxKind.EqualsToken),
-            // if the member has no initializer we should default to setting it to
-            // just 'undefined'
-            (_a = member2.initializer) != null ? _a : import_typescript54.default.factory.createIdentifier("undefined")
-          )
-        )
-      );
-    } else {
-      updatedClassMembers.push(member2);
-    }
-  }
-  if (statements.length === 0) {
-    return updatedClassMembers;
-  } else {
-    return updateConstructor(classNode, updatedClassMembers, statements);
-  }
-}
-var shouldInitializeInConstructor = (member2, importAliasMap) => {
-  const currentDecorators = retrieveTsDecorators(member2);
-  if (currentDecorators === void 0) {
-    return false;
-  }
-  const filteredDecorators = filterDecorators(
-    currentDecorators,
-    CONSTRUCTOR_DEFINED_MEMBER_DECORATORS.map((decorator) => importAliasMap.get(decorator))
-  );
-  return currentDecorators !== filteredDecorators;
-};
 
 // src/compiler/transformers/static-to-meta/parse-static.ts
 var import_path51 = require("path");
-var import_typescript62 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript63 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/static-to-meta/call-expression.ts
 var import_typescript56 = __toESM(require_typescript_5_5_4_bundle_cache_min());
@@ -263085,7 +264627,7 @@ var visitCallExpressionArg = (m, arg) => {
 
 // src/compiler/transformers/static-to-meta/component.ts
 var import_path47 = require("path");
-var import_typescript59 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript60 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/add-component-meta-static.ts
 var import_typescript57 = __toESM(require_typescript_5_5_4_bundle_cache_min());
@@ -263157,6 +264699,27 @@ var setComponentBuildConditionals = (cmpMeta) => {
   cmpMeta.isPlain = !cmpMeta.hasMember && !cmpMeta.hasStyle && !cmpMeta.hasLifecycle && !cmpMeta.hasListener && !cmpMeta.hasVdomRender;
 };
 
+// src/compiler/transformers/detect-modern-prop-decls.ts
+var import_typescript58 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var detectModernPropDeclarations = (classNode, cmp) => {
+  const parsedProps = getStaticValue(classNode.members, "properties");
+  const parsedStates = getStaticValue(classNode.members, "states");
+  if (!parsedProps && !parsedStates) {
+    cmp.hasModernPropertyDecls = false;
+    return;
+  }
+  const members = [...Object.entries(parsedProps || {}), ...Object.entries(parsedStates || {})];
+  for (const [propName, meta] of members) {
+    const dynamicPropName = meta.ogPropName || "";
+    const prop = classNode.members.find((m) => {
+      return import_typescript58.default.isPropertyDeclaration(m) && (import_typescript58.default.isComputedPropertyName(m.name) && m.name.expression.getText() === dynamicPropName || m.name.getText() === propName);
+    });
+    if (!prop) continue;
+    cmp.hasModernPropertyDecls = true;
+    break;
+  }
+};
+
 // src/compiler/transformers/static-to-meta/attach-internals.ts
 var parseAttachInternals = (staticMembers) => {
   const parsedAttachInternalsMemberName = getStaticValue(staticMembers, "attachInternalsMemberName");
@@ -263168,13 +264731,13 @@ var parseAttachInternals = (staticMembers) => {
 };
 
 // src/compiler/transformers/static-to-meta/class-methods.ts
-var import_typescript58 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript59 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var parseClassMethods = (cmpNode, cmpMeta) => {
   const classMembers = cmpNode.members;
   if (!classMembers || classMembers.length === 0) {
     return;
   }
-  const classMethods = classMembers.filter((m) => import_typescript58.default.isMethodDeclaration(m));
+  const classMethods = classMembers.filter((m) => import_typescript59.default.isMethodDeclaration(m));
   if (classMethods.length === 0) {
     return;
   }
@@ -263309,7 +264872,9 @@ var parseStaticProps = (staticMembers) => {
       defaultValue: val.defaultValue,
       complexType: val.complexType,
       docs: val.docs,
-      internal: isInternal(val.docs)
+      internal: isInternal(val.docs),
+      getter: !!val.getter,
+      setter: !!val.setter
     };
   });
 };
@@ -263536,6 +265101,7 @@ var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, t
     hasMember: false,
     hasMethod: false,
     hasMode: false,
+    hasModernPropertyDecls: false,
     hasAttribute: false,
     hasProp: false,
     hasPropNumber: false,
@@ -263571,15 +265137,16 @@ var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, t
   };
   const visitComponentChildNode = (node) => {
     validateComponentMembers(node);
-    if (import_typescript59.default.isCallExpression(node)) {
+    if (import_typescript60.default.isCallExpression(node)) {
       parseCallExpression(cmp, node);
-    } else if (import_typescript59.default.isStringLiteral(node)) {
+    } else if (import_typescript60.default.isStringLiteral(node)) {
       parseStringLiteral(cmp, node);
     }
     node.forEachChild(visitComponentChildNode);
   };
   visitComponentChildNode(cmpNode);
   parseClassMethods(cmpNode, cmp);
+  detectModernPropDeclarations(cmpNode, cmp);
   cmp.htmlAttrNames = unique(cmp.htmlAttrNames);
   cmp.htmlTagNames = unique(cmp.htmlTagNames);
   cmp.potentialCmpRefs = unique(cmp.potentialCmpRefs);
@@ -263587,7 +265154,11 @@ var parseStaticComponentMeta = (compilerCtx, typeChecker, cmpNode, moduleFile, t
   if (transformOpts && transformOpts.componentMetadata === "compilerstatic") {
     cmpNode = addComponentMetaStatic(cmpNode, cmp);
   }
-  moduleFile.cmps.push(cmp);
+  const foundIndex = moduleFile.cmps.findIndex(
+    (c) => c.tagName === cmp.tagName && c.sourceFilePath === cmp.sourceFilePath
+  );
+  if (foundIndex > -1) moduleFile.cmps[foundIndex] = cmp;
+  else moduleFile.cmps.push(cmp);
   compilerCtx.nodeMap.set(cmpNode, cmp);
   return cmpNode;
 };
@@ -263596,15 +265167,15 @@ var validateComponentMembers = (node) => {
     /**
      * the component has a getter called "shadowRoot"
      */
-    import_typescript59.default.isGetAccessorDeclaration(node) && import_typescript59.default.isIdentifier(node.name) && typeof node.name.escapedText === "string" && BLACKLISTED_COMPONENT_METHODS.includes(node.name.escapedText) && /**
+    import_typescript60.default.isGetAccessorDeclaration(node) && import_typescript60.default.isIdentifier(node.name) && typeof node.name.escapedText === "string" && BLACKLISTED_COMPONENT_METHODS.includes(node.name.escapedText) && /**
      * the parent node is a class declaration
      */
-    node.parent && import_typescript59.default.isClassDeclaration(node.parent)
+    node.parent && import_typescript60.default.isClassDeclaration(node.parent)
   ) {
     const propName = node.name.escapedText;
-    const decorator = import_typescript59.default.getDecorators(node.parent)[0];
-    if (import_typescript59.default.isCallExpression(decorator.expression) && decorator.expression.arguments.length === 1 && import_typescript59.default.isObjectLiteralExpression(decorator.expression.arguments[0]) && decorator.expression.arguments[0].properties.some(
-      (prop) => import_typescript59.default.isPropertyAssignment(prop) && prop.name.getText() === "tag"
+    const decorator = import_typescript60.default.getDecorators(node.parent)[0];
+    if (import_typescript60.default.isCallExpression(decorator.expression) && decorator.expression.arguments.length === 1 && import_typescript60.default.isObjectLiteralExpression(decorator.expression.arguments[0]) && decorator.expression.arguments[0].properties.some(
+      (prop) => import_typescript60.default.isPropertyAssignment(prop) && prop.name.getText() === "tag"
     )) {
       const componentName = node.parent.name.getText();
       throw new Error(
@@ -263650,7 +265221,7 @@ var parseAssetsDirs = (staticMembers, componentFilePath) => {
 
 // src/compiler/transformers/static-to-meta/import.ts
 var import_path50 = require("path");
-var import_typescript61 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript62 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/collections/add-external-import.ts
 var import_path49 = require("path");
@@ -263659,7 +265230,7 @@ var import_path49 = require("path");
 var import_path48 = require("path");
 
 // src/compiler/transformers/collections/parse-collection-components.ts
-var import_typescript60 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript61 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var parseCollectionComponents = (config, compilerCtx, buildCtx, collectionDir, collectionManifest, collection) => {
   if (collectionManifest.entries) {
     collectionManifest.entries.forEach((entryPath) => {
@@ -263670,7 +265241,7 @@ var parseCollectionComponents = (config, compilerCtx, buildCtx, collectionDir, c
 };
 var transpileCollectionModule = (config, compilerCtx, buildCtx, collection, inputFileName) => {
   const sourceText = compilerCtx.fs.readFileSync(inputFileName);
-  const sourceFile = import_typescript60.default.createSourceFile(inputFileName, sourceText, import_typescript60.default.ScriptTarget.ES2017, true, import_typescript60.default.ScriptKind.JS);
+  const sourceFile = import_typescript61.default.createSourceFile(inputFileName, sourceText, import_typescript61.default.ScriptTarget.ES2017, true, import_typescript61.default.ScriptKind.JS);
   return updateModule(config, compilerCtx, buildCtx, sourceFile, sourceText, inputFileName, void 0, collection);
 };
 
@@ -263818,7 +265389,7 @@ var addExternalImport = (config, compilerCtx, buildCtx, moduleFile, containingFi
 
 // src/compiler/transformers/static-to-meta/import.ts
 var parseModuleImport = (config, compilerCtx, buildCtx, moduleFile, dirPath, importNode, resolveCollections) => {
-  if (importNode.moduleSpecifier && import_typescript61.default.isStringLiteral(importNode.moduleSpecifier)) {
+  if (importNode.moduleSpecifier && import_typescript62.default.isStringLiteral(importNode.moduleSpecifier)) {
     let importPath = importNode.moduleSpecifier.text;
     if (!moduleFile.originalImports.includes(importPath)) {
       moduleFile.originalImports.push(importPath);
@@ -263854,6 +265425,7 @@ var updateModule = (config, compilerCtx, buildCtx, tsSourceFile, sourceFileText,
   const emitFileName = (0, import_path51.basename)(emitFilePath);
   emitFilePath = normalizePath(join(srcDirPath, emitFileName));
   const moduleFile = createModule(tsSourceFile, sourceFileText, emitFilePath);
+  if (prevModuleFile == null ? void 0 : prevModuleFile.cmps) moduleFile.cmps = prevModuleFile.cmps;
   if (emitFilePath.endsWith(".js.map")) {
     moduleFile.sourceMapPath = emitFilePath;
     moduleFile.sourceMapFileText = sourceFileText;
@@ -263865,15 +265437,15 @@ var updateModule = (config, compilerCtx, buildCtx, tsSourceFile, sourceFileText,
   compilerCtx.moduleMap.set(moduleFileKey, moduleFile);
   compilerCtx.changedModules.add(moduleFile.sourceFilePath);
   const visitNode = (node) => {
-    if (import_typescript62.default.isClassDeclaration(node)) {
+    if (import_typescript63.default.isClassDeclaration(node)) {
       parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile);
       return;
-    } else if (import_typescript62.default.isImportDeclaration(node)) {
+    } else if (import_typescript63.default.isImportDeclaration(node)) {
       parseModuleImport(config, compilerCtx, buildCtx, moduleFile, srcDirPath, node, true);
       return;
-    } else if (import_typescript62.default.isCallExpression(node)) {
+    } else if (import_typescript63.default.isCallExpression(node)) {
       parseCallExpression(moduleFile, node);
-    } else if (import_typescript62.default.isStringLiteral(node)) {
+    } else if (import_typescript63.default.isStringLiteral(node)) {
       parseStringLiteral(moduleFile, node);
     }
     node.forEachChild(visitNode);
@@ -263885,12 +265457,12 @@ var updateModule = (config, compilerCtx, buildCtx, tsSourceFile, sourceFileText,
   }
   visitNode(tsSourceFile);
   if (moduleFile.cmps.length > 0) {
-    moduleFile.staticSourceFile = import_typescript62.default.createSourceFile(
+    moduleFile.staticSourceFile = import_typescript63.default.createSourceFile(
       sourceFilePath,
       sourceFileText,
       tsSourceFile.languageVersion,
       true,
-      import_typescript62.default.ScriptKind.JS
+      import_typescript63.default.ScriptKind.JS
     );
   }
   return moduleFile;
@@ -265133,7 +266705,7 @@ var isWatchIgnorePath = (config, path6) => {
 };
 
 // src/compiler/transpile/create-watch-program.ts
-var import_typescript63 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript64 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var createTsWatchProgram = async (config, buildCallback) => {
   let isRunning = false;
   let lastTsBuilder;
@@ -265141,7 +266713,7 @@ var createTsWatchProgram = async (config, buildCallback) => {
   let rebuildTimer;
   const optionsToExtend = getTsOptionsToExtend(config);
   const tsWatchSys = {
-    ...import_typescript63.default.sys,
+    ...import_typescript64.default.sys,
     /**
      * Override the default `setTimeout` implementation in the {@link ts.System}. The reasoning
      * behind this change is not explicitly clear, but this appears to be related to debouncing
@@ -265169,7 +266741,7 @@ var createTsWatchProgram = async (config, buildCallback) => {
     }
   };
   config.sys.addDestroy(() => tsWatchSys.clearTimeout(timeoutId));
-  const tsWatchHost = import_typescript63.default.createWatchCompilerHost(
+  const tsWatchHost = import_typescript64.default.createWatchCompilerHost(
     // Use the TS config from the Rindo project
     config.tsconfig,
     optionsToExtend,
@@ -265177,7 +266749,7 @@ var createTsWatchProgram = async (config, buildCallback) => {
     // We use the `createEmitAndSemanticDiagnosticsBuilderProgram` as opposed to the
     // `createSemanticDiagnosticsBuilderProgram` because we need our program to emit
     // output files in addition to checking for errors
-    import_typescript63.default.createEmitAndSemanticDiagnosticsBuilderProgram,
+    import_typescript64.default.createEmitAndSemanticDiagnosticsBuilderProgram,
     // Add a callback to log out diagnostics as the program runs
     (reportDiagnostic) => {
       config.logger.debug("watch reportDiagnostic:" + reportDiagnostic.messageText);
@@ -265204,7 +266776,7 @@ var createTsWatchProgram = async (config, buildCallback) => {
     // Create the watch builder program instance and make it available on the
     // returned object. This provides us an easy way to teardown the program
     // down-the-road.
-    program: import_typescript63.default.createWatchProgram(tsWatchHost),
+    program: import_typescript64.default.createWatchProgram(tsWatchHost),
     // This will be called via a callback on the watch build whenever a file
     // change is detected
     rebuild: () => {
@@ -267248,7 +268820,7 @@ var extname8 = (str) => {
 var SKIP_EXT = /* @__PURE__ */ new Set(["zip", "rar", "tar", "gz", "bz2", "png", "jpeg", "jpg", "gif", "pdf", "tiff", "psd"]);
 
 // src/compiler/sys/node-require.ts
-var import_typescript64 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript65 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var nodeRequire = (id) => {
   const results = {
     module: void 0,
@@ -267263,13 +268835,13 @@ var nodeRequire = (id) => {
     require.extensions[".ts"] = (module2, fileName) => {
       let sourceText = fs3.readFileSync(fileName, "utf8");
       if (fileName.endsWith(".ts")) {
-        const tsResults = import_typescript64.default.transpileModule(sourceText, {
+        const tsResults = import_typescript65.default.transpileModule(sourceText, {
           fileName,
           compilerOptions: {
-            module: import_typescript64.default.ModuleKind.CommonJS,
-            moduleResolution: import_typescript64.default.ModuleResolutionKind.NodeJs,
+            module: import_typescript65.default.ModuleKind.CommonJS,
+            moduleResolution: import_typescript65.default.ModuleResolutionKind.NodeJs,
             esModuleInterop: true,
-            target: import_typescript64.default.ScriptTarget.ES2017,
+            target: import_typescript65.default.ScriptTarget.ES2017,
             allowJs: true
           }
         });
@@ -268071,7 +269643,7 @@ var createCompiler = async (userConfig) => {
   const sys = config.sys;
   const compilerCtx = new CompilerContext();
   if (isFunction(config.sys.setupCompiler)) {
-    config.sys.setupCompiler({ ts: import_typescript65.default });
+    config.sys.setupCompiler({ ts: import_typescript66.default });
   }
   compilerCtx.fs = createInMemoryFs(sys);
   compilerCtx.cache = new Cache(config, createInMemoryFs(sys));
@@ -268105,7 +269677,7 @@ var import_path63 = require("path");
 
 // src/compiler/sys/typescript/typescript-config.ts
 var import_path62 = require("path");
-var import_typescript66 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript67 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var validateTsConfig = async (config, sys, init) => {
   var _a;
   const tsconfig = {
@@ -268127,7 +269699,7 @@ var validateTsConfig = async (config, sys, init) => {
     } else {
       tsconfig.path = readTsConfig.path;
       const host = {
-        ...import_typescript66.default.sys,
+        ...import_typescript67.default.sys,
         readFile: (p) => {
           if (p === tsconfig.path) {
             return readTsConfig.content;
@@ -268138,7 +269710,7 @@ var validateTsConfig = async (config, sys, init) => {
         fileExists: (p) => sys.accessSync(p),
         onUnRecoverableConfigFileDiagnostic: (e) => console.error(e)
       };
-      const results = import_typescript66.default.getParsedCommandLineOfConfigFile(tsconfig.path, {}, host);
+      const results = import_typescript67.default.getParsedCommandLineOfConfigFile(tsconfig.path, {}, host);
       if (results === void 0) {
         throw "Encountered an error reading tsconfig!";
       }
@@ -268182,12 +269754,12 @@ var validateTsConfig = async (config, sys, init) => {
         }
         if (results.options) {
           tsconfig.compilerOptions = results.options;
-          const target = (_a = tsconfig.compilerOptions.target) != null ? _a : import_typescript66.default.ScriptTarget.ES5;
-          if ([import_typescript66.default.ScriptTarget.ES3, import_typescript66.default.ScriptTarget.ES5, import_typescript66.default.ScriptTarget.ES2015, import_typescript66.default.ScriptTarget.ES2016].includes(target)) {
+          const target = (_a = tsconfig.compilerOptions.target) != null ? _a : import_typescript67.default.ScriptTarget.ES5;
+          if ([import_typescript67.default.ScriptTarget.ES3, import_typescript67.default.ScriptTarget.ES5, import_typescript67.default.ScriptTarget.ES2015, import_typescript67.default.ScriptTarget.ES2016].includes(target)) {
             const warn = buildWarn(tsconfig.diagnostics);
             warn.messageText = `To improve bundling, it is always recommended to set the tsconfig.json \u201Ctarget\u201D setting to "es2017". Note that the compiler will automatically handle transpilation for ES5-only browsers.`;
           }
-          if (tsconfig.compilerOptions.module !== import_typescript66.default.ModuleKind.ESNext && !config._isTesting) {
+          if (tsconfig.compilerOptions.module !== import_typescript67.default.ModuleKind.ESNext && !config._isTesting) {
             const warn = buildWarn(tsconfig.diagnostics);
             warn.messageText = `To improve bundling, it is always recommended to set the tsconfig.json \u201Cmodule\u201D setting to \u201Cesnext\u201D. Note that the compiler will automatically handle bundling both modern and legacy builds.`;
           }
@@ -269584,26 +271156,26 @@ var VALID_TARGET = /* @__PURE__ */ new Set(["latest", "esnext", "es2020", "es201
 
 // src/compiler/transpile/transpile-module.ts
 var import_sys_api_node5 = require("../sys/node/index.js");
-var import_typescript68 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript69 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 
 // src/compiler/transformers/static-to-meta/visitor.ts
 var import_path67 = require("path");
-var import_typescript67 = __toESM(require_typescript_5_5_4_bundle_cache_min());
+var import_typescript68 = __toESM(require_typescript_5_5_4_bundle_cache_min());
 var convertStaticToMeta = (config, compilerCtx, buildCtx, typeChecker, collection, transformOpts) => {
   return (transformCtx) => {
     let dirPath;
     let moduleFile;
     const visitNode = (node) => {
-      if (import_typescript67.default.isClassDeclaration(node)) {
+      if (import_typescript68.default.isClassDeclaration(node)) {
         return parseStaticComponentMeta(compilerCtx, typeChecker, node, moduleFile, transformOpts);
-      } else if (import_typescript67.default.isImportDeclaration(node)) {
+      } else if (import_typescript68.default.isImportDeclaration(node)) {
         parseModuleImport(config, compilerCtx, buildCtx, moduleFile, dirPath, node, !transformOpts.isolatedModules);
-      } else if (import_typescript67.default.isCallExpression(node)) {
+      } else if (import_typescript68.default.isCallExpression(node)) {
         parseCallExpression(moduleFile, node);
-      } else if (import_typescript67.default.isStringLiteral(node)) {
+      } else if (import_typescript68.default.isStringLiteral(node)) {
         parseStringLiteral(moduleFile, node);
       }
-      return import_typescript67.default.visitEachChild(node, visitNode, transformCtx);
+      return import_typescript68.default.visitEachChild(node, visitNode, transformCtx);
     };
     return (tsSourceFile) => {
       dirPath = (0, import_path67.dirname)(tsSourceFile.fileName);
@@ -269649,13 +271221,13 @@ var transpileModule = (config, input, transformOpts) => {
     moduleFile: null
   };
   if (transformOpts.module === "cjs") {
-    tsCompilerOptions.module = import_typescript68.default.ModuleKind.CommonJS;
+    tsCompilerOptions.module = import_typescript69.default.ModuleKind.CommonJS;
   } else {
-    tsCompilerOptions.module = import_typescript68.default.ModuleKind.ESNext;
+    tsCompilerOptions.module = import_typescript69.default.ModuleKind.ESNext;
   }
   tsCompilerOptions.target = getScriptTargetKind(transformOpts);
   if ((sourceFilePath.endsWith(".tsx") || sourceFilePath.endsWith(".jsx")) && tsCompilerOptions.jsx == null) {
-    tsCompilerOptions.jsx = import_typescript68.default.JsxEmit.React;
+    tsCompilerOptions.jsx = import_typescript69.default.JsxEmit.React;
   }
   if (tsCompilerOptions.jsx != null && !isString(tsCompilerOptions.jsxFactory)) {
     tsCompilerOptions.jsxFactory = "h";
@@ -269666,7 +271238,7 @@ var transpileModule = (config, input, transformOpts) => {
   if (tsCompilerOptions.paths && !isString(tsCompilerOptions.baseUrl)) {
     tsCompilerOptions.baseUrl = ".";
   }
-  const sourceFile = import_typescript68.default.createSourceFile(sourceFilePath, input, tsCompilerOptions.target);
+  const sourceFile = import_typescript69.default.createSourceFile(sourceFilePath, input, tsCompilerOptions.target);
   const compilerHost = {
     getSourceFile: (fileName) => {
       return normalizePath(fileName) === normalizePath(sourceFilePath) ? sourceFile : void 0;
@@ -269682,13 +271254,13 @@ var transpileModule = (config, input, transformOpts) => {
     useCaseSensitiveFileNames: () => false,
     getCanonicalFileName: (fileName) => fileName,
     getCurrentDirectory: () => transformOpts.currentDirectory || process.cwd(),
-    getNewLine: () => import_typescript68.default.sys.newLine || "\n",
+    getNewLine: () => import_typescript69.default.sys.newLine || "\n",
     fileExists: (fileName) => normalizePath(fileName) === normalizePath(sourceFilePath),
     readFile: () => "",
     directoryExists: () => true,
     getDirectories: () => []
   };
-  const program = import_typescript68.default.createProgram([sourceFilePath], tsCompilerOptions, compilerHost);
+  const program = import_typescript69.default.createProgram([sourceFilePath], tsCompilerOptions, compilerHost);
   const typeChecker = program.getTypeChecker();
   const transformers = {
     before: [
@@ -269720,10 +271292,10 @@ var transpileModule = (config, input, transformOpts) => {
 };
 var getScriptTargetKind = (transformOpts) => {
   const target = transformOpts.target && transformOpts.target.toUpperCase();
-  if (isNumber(import_typescript68.default.ScriptTarget[target])) {
-    return import_typescript68.default.ScriptTarget[target];
+  if (isNumber(import_typescript69.default.ScriptTarget[target])) {
+    return import_typescript69.default.ScriptTarget[target];
   }
-  return import_typescript68.default.ScriptTarget.Latest;
+  return import_typescript69.default.ScriptTarget.Latest;
 };
 
 // src/compiler/transpile.ts