@storm-software/workspace-tools 1.56.13 → 1.56.14

package/src/utils/index.js

@@ -84565,9 +84565,9 @@ var require_source_map = __commonJS({
   }
 });
 
-// node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/native.js
+// node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/native.js
 var require_native = __commonJS({
-  "node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/native.js"(exports2, module2) {
+  "node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/native.js"(exports2, module2) {
     var { existsSync: existsSync3 } = require("node:fs");
     var { join: join3 } = require("node:path");
     var { platform, arch, report } = require("node:process");
@@ -84584,6 +84584,7 @@ var require_native = __commonJS({
       linux: {
         arm: { base: "linux-arm-gnueabihf", musl: null },
         arm64: { base: "linux-arm64-gnu", musl: "linux-arm64-musl" },
+        riscv64: { base: "linux-riscv64-gnu", musl: null },
         x64: { base: "linux-x64-gnu", musl: "linux-x64-musl" }
       },
       win32: {
@@ -84592,6 +84593,11 @@ var require_native = __commonJS({
         x64: { base: "win32-x64-msvc" }
       }
     };
+    var msvcLinkFilenameByArch = {
+      arm64: "vc_redist.arm64.exe",
+      ia32: "vc_redist.x86.exe",
+      x64: "vc_redist.x64.exe"
+    };
     var packageBase = getPackageBase();
     if (!packageBase) {
       throw new Error(
@@ -84619,16 +84625,37 @@ If this is important to you, please consider supporting Rollup to make a native
       return imported.base;
     }
     var localName = `./rollup.${packageBase}.node`;
-    var { parse, parseAsync, xxhashBase64Url } = existsSync3(join3(__dirname, localName)) ? require(localName) : require(`@rollup/rollup-${packageBase}`);
+    var requireWithFriendlyError = (id) => {
+      try {
+        return require(id);
+      } catch (error) {
+        if (platform === "win32" && error instanceof Error && error.code === "ERR_DLOPEN_FAILED" && error.message.includes("The specified module could not be found")) {
+          const msvcDownloadLink = `https://aka.ms/vs/17/release/${msvcLinkFilenameByArch[arch]}`;
+          throw new Error(
+            `Failed to load module ${id}. Required DLL was not found. This error usually happens when Microsoft Visual C++ Redistributable is not installed. You can download it from ${msvcDownloadLink}`,
+            { cause: error }
+          );
+        }
+        throw new Error(
+          `Cannot find module ${id}. npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). Please try \`npm i\` again after removing both package-lock.json and node_modules directory.`,
+          { cause: error }
+        );
+      }
+    };
+    var { parse, parseAsync, xxhashBase64Url, xxhashBase36, xxhashBase16 } = requireWithFriendlyError(
+      existsSync3(join3(__dirname, localName)) ? localName : `@rollup/rollup-${packageBase}`
+    );
     module2.exports.parse = parse;
     module2.exports.parseAsync = parseAsync;
     module2.exports.xxhashBase64Url = xxhashBase64Url;
+    module2.exports.xxhashBase36 = xxhashBase36;
+    module2.exports.xxhashBase16 = xxhashBase16;
   }
 });
 
-// node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/shared/parseAst.js
+// node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/shared/parseAst.js
 var require_parseAst = __commonJS({
-  "node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/shared/parseAst.js"(exports2) {
+  "node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/shared/parseAst.js"(exports2) {
     "use strict";
     var native_js = require_native();
     var node_path = require("node:path");
@@ -85264,12 +85291,6 @@ Original error: ${originalError.message}`,
         plugin
       };
     }
-    function logInvalidRollupPhaseForAddWatchFile() {
-      return {
-        code: INVALID_ROLLUP_PHASE,
-        message: `Cannot call "addWatchFile" after the build has finished.`
-      };
-    }
     function logInvalidRollupPhaseForChunkEmission() {
       return {
         code: INVALID_ROLLUP_PHASE,
@@ -85664,19 +85685,22 @@ ${smallChunks} are below minChunkSize.`
       "pure",
       "noSideEffects"
     ];
-    var convertProgram = (buffer, readString) => convertNode(0, new Uint32Array(buffer), readString);
-    var convertNode = (position, buffer, readString) => {
-      const nodeType = buffer[position];
-      const converter = nodeConverters[nodeType];
-      if (!converter) {
-        console.trace();
-        throw new Error(`Unknown node type: ${nodeType}`);
-      }
-      return converter(position + 1, buffer, readString);
-    };
+    var ANNOTATION_KEY = "_rollupAnnotations";
+    var INVALID_ANNOTATION_KEY = "_rollupRemoved";
+    function convertProgram(buffer, readString) {
+      return convertNode(0, new Uint32Array(buffer), readString);
+    }
     var nodeConverters = [
-      // index:0; ArrayExpression
-      (position, buffer, readString) => {
+      function parseError(position, buffer, readString) {
+        const pos = buffer[position++];
+        const message = convertString(position, buffer, readString);
+        error(logParseError(message, pos));
+      },
+      function panicError(position, buffer, readString) {
+        const message = convertString(position, buffer, readString);
+        error(logParseError(message));
+      },
+      function arrayExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const elements = convertNodeList(position, buffer, readString);
@@ -85687,8 +85711,7 @@ ${smallChunks} are below minChunkSize.`
           elements
         };
       },
-      // index:1; ArrayPattern
-      (position, buffer, readString) => {
+      function arrayPattern(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const elements = convertNodeList(position, buffer, readString);
@@ -85699,30 +85722,30 @@ ${smallChunks} are below minChunkSize.`
           elements
         };
       },
-      // index:2; ArrowFunctionExpression
-      (position, buffer, readString) => {
+      function arrowFunctionExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const async = !!buffer[position++];
-        const generator = !!buffer[position++];
-        const expression = !!buffer[position++];
+        const flags = buffer[position++];
+        const async = (flags & 1) === 1;
+        const expression = (flags & 2) === 2;
+        const generator = (flags & 4) === 4;
         const parameters = convertNodeList(buffer[position++], buffer, readString);
         const body = convertNode(buffer[position++], buffer, readString);
-        const annotations = convertAnnotationList(position, buffer);
-        return addAnnotationProperty({
+        const annotations = convertAnnotations(position, buffer);
+        return {
           type: "ArrowFunctionExpression",
           start,
           end,
           async,
-          body,
           expression,
           generator,
-          id: null,
-          params: parameters
-        }, annotations, ANNOTATION_KEY);
+          ...annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {},
+          params: parameters,
+          body,
+          id: null
+        };
       },
-      // index:3; AssignmentExpression
-      (position, buffer, readString) => {
+      function assignmentExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const operator = FIXED_STRINGS[buffer[position++]];
@@ -85732,13 +85755,12 @@ ${smallChunks} are below minChunkSize.`
           type: "AssignmentExpression",
           start,
           end,
-          left,
           operator,
+          left,
           right
         };
       },
-      // index:4; AssignmentPattern
-      (position, buffer, readString) => {
+      function assignmentPattern(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const right = convertNode(buffer[position++], buffer, readString);
@@ -85751,20 +85773,18 @@ ${smallChunks} are below minChunkSize.`
           right
         };
       },
-      // index:5; AwaitExpression
-      (position, buffer, readString) => {
+      function awaitExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const argument = convertNode(position, buffer, readString);
         return {
           type: "AwaitExpression",
           start,
-          argument,
-          end
+          end,
+          argument
         };
       },
-      // index:6; BinaryExpression
-      (position, buffer, readString) => {
+      function binaryExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const operator = FIXED_STRINGS[buffer[position++]];
@@ -85774,68 +85794,67 @@ ${smallChunks} are below minChunkSize.`
           type: "BinaryExpression",
           start,
           end,
-          left,
           operator,
+          left,
           right
         };
       },
-      // index:7; BlockStatement
-      (position, buffer, readString) => {
+      function blockStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const body = convertNodeList(position, buffer, readString);
         return {
           type: "BlockStatement",
           start,
-          body,
-          end
+          end,
+          body
         };
       },
-      // index:8; BreakStatement
-      (position, buffer, readString) => {
+      function breakStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const labelPosition = buffer[position++];
+        const labelPosition = buffer[position];
+        const label = labelPosition === 0 ? null : convertNode(labelPosition, buffer, readString);
         return {
           type: "BreakStatement",
           start,
           end,
-          label: labelPosition ? convertNode(labelPosition, buffer, readString) : null
+          label
         };
       },
-      // index:9; CallExpression
-      (position, buffer, readString) => {
+      function callExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const optional = !!buffer[position++];
+        const flags = buffer[position++];
+        const optional = (flags & 1) === 1;
         const callee = convertNode(buffer[position++], buffer, readString);
-        const argumentsList = convertNodeList(buffer[position++], buffer, readString);
-        const annotations = convertAnnotationList(position, buffer);
-        return addAnnotationProperty({
+        const callArguments = convertNodeList(buffer[position++], buffer, readString);
+        const annotations = convertAnnotations(position, buffer);
+        return {
           type: "CallExpression",
           start,
           end,
-          arguments: argumentsList,
+          optional,
+          ...annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {},
           callee,
-          optional
-        }, annotations, ANNOTATION_KEY);
+          arguments: callArguments
+        };
       },
-      // index:10; CatchClause
-      (position, buffer, readString) => {
+      function catchClause(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const parameterPosition = buffer[position++];
+        const parameter = parameterPosition === 0 ? null : convertNode(parameterPosition, buffer, readString);
         const body = convertNode(buffer[position], buffer, readString);
         return {
           type: "CatchClause",
           start,
           end,
-          body,
-          param: parameterPosition ? convertNode(parameterPosition, buffer, readString) : null
+          param: parameter,
+          body
         };
       },
-      // index:11; ChainExpression
-      (position, buffer, readString) => {
+      function chainExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const expression = convertNode(position, buffer, readString);
@@ -85846,8 +85865,7 @@ ${smallChunks} are below minChunkSize.`
           expression
         };
       },
-      // index:12; ClassBody
-      (position, buffer, readString) => {
+      function classBody(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const body = convertNodeList(position, buffer, readString);
@@ -85858,40 +85876,41 @@ ${smallChunks} are below minChunkSize.`
           body
         };
       },
-      // index:13; ClassDeclaration
-      (position, buffer, readString) => {
+      function classDeclaration(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const idPosition = buffer[position++];
+        const id = idPosition === 0 ? null : convertNode(idPosition, buffer, readString);
         const superClassPosition = buffer[position++];
+        const superClass = superClassPosition === 0 ? null : convertNode(superClassPosition, buffer, readString);
         const body = convertNode(buffer[position], buffer, readString);
         return {
           type: "ClassDeclaration",
           start,
           end,
-          body,
-          id: idPosition ? convertNode(idPosition, buffer, readString) : null,
-          superClass: superClassPosition ? convertNode(superClassPosition, buffer, readString) : null
+          id,
+          superClass,
+          body
         };
       },
-      // index:14; ClassExpression
-      (position, buffer, readString) => {
+      function classExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const idPosition = buffer[position++];
+        const id = idPosition === 0 ? null : convertNode(idPosition, buffer, readString);
         const superClassPosition = buffer[position++];
+        const superClass = superClassPosition === 0 ? null : convertNode(superClassPosition, buffer, readString);
         const body = convertNode(buffer[position], buffer, readString);
         return {
           type: "ClassExpression",
           start,
           end,
-          body,
-          id: idPosition ? convertNode(idPosition, buffer, readString) : null,
-          superClass: superClassPosition ? convertNode(superClassPosition, buffer, readString) : null
+          id,
+          superClass,
+          body
         };
       },
-      // index:15; ConditionalExpression
-      (position, buffer, readString) => {
+      function conditionalExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const consequent = convertNode(buffer[position++], buffer, readString);
@@ -85901,25 +85920,24 @@ ${smallChunks} are below minChunkSize.`
           type: "ConditionalExpression",
           start,
           end,
-          alternate,
+          test,
           consequent,
-          test
+          alternate
         };
       },
-      // index:16; ContinueStatement
-      (position, buffer, readString) => {
+      function continueStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const labelPosition = buffer[position];
+        const label = labelPosition === 0 ? null : convertNode(labelPosition, buffer, readString);
         return {
           type: "ContinueStatement",
           start,
           end,
-          label: labelPosition ? convertNode(labelPosition, buffer, readString) : null
+          label
         };
       },
-      // index:17; DebuggerStatement
-      (position, buffer) => {
+      function debuggerStatement(position, buffer) {
         const start = buffer[position++];
         const end = buffer[position++];
         return {
@@ -85928,8 +85946,20 @@ ${smallChunks} are below minChunkSize.`
           end
         };
       },
-      // index:18; DoWhileStatement
-      (position, buffer, readString) => {
+      function directive(position, buffer, readString) {
+        const start = buffer[position++];
+        const end = buffer[position++];
+        const expression = convertNode(buffer[position++], buffer, readString);
+        const directive2 = convertString(position, buffer, readString);
+        return {
+          type: "ExpressionStatement",
+          start,
+          end,
+          directive: directive2,
+          expression
+        };
+      },
+      function doWhileStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const test = convertNode(buffer[position++], buffer, readString);
@@ -85942,8 +85972,7 @@ ${smallChunks} are below minChunkSize.`
           test
         };
       },
-      // index:19; EmptyStatement
-      (position, buffer) => {
+      function emptyStatement(position, buffer) {
         const start = buffer[position++];
         const end = buffer[position++];
         return {
@@ -85952,24 +85981,23 @@ ${smallChunks} are below minChunkSize.`
           end
         };
       },
-      // index:20; ExportAllDeclaration
-      (position, buffer, readString) => {
+      function exportAllDeclaration(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const exportedPosition = buffer[position++];
+        const exported = exportedPosition === 0 ? null : convertNode(exportedPosition, buffer, readString);
         const source = convertNode(buffer[position++], buffer, readString);
         const attributes = convertNodeList(buffer[position], buffer, readString);
         return {
           type: "ExportAllDeclaration",
           start,
           end,
-          exported: exportedPosition ? convertNode(exportedPosition, buffer, readString) : null,
+          exported,
           source,
           attributes
         };
       },
-      // index:21; ExportDefaultDeclaration
-      (position, buffer, readString) => {
+      function exportDefaultDeclaration(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const declaration = convertNode(position, buffer, readString);
@@ -85980,55 +86008,50 @@ ${smallChunks} are below minChunkSize.`
           declaration
         };
       },
-      // index:22; ExportNamedDeclaration
-      (position, buffer, readString) => {
+      function exportNamedDeclaration(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const declarationPosition = buffer[position++];
         const sourcePosition = buffer[position++];
+        const source = sourcePosition === 0 ? null : convertNode(sourcePosition, buffer, readString);
         const attributes = convertNodeList(buffer[position++], buffer, readString);
+        const declarationPosition = buffer[position++];
+        const declaration = declarationPosition === 0 ? null : convertNode(declarationPosition, buffer, readString);
         const specifiers = convertNodeList(position, buffer, readString);
         return {
           type: "ExportNamedDeclaration",
           start,
           end,
-          declaration: declarationPosition ? convertNode(declarationPosition, buffer, readString) : null,
-          source: sourcePosition ? convertNode(sourcePosition, buffer, readString) : null,
           specifiers,
-          attributes
+          source,
+          attributes,
+          declaration
         };
       },
-      // index:23; ExportSpecifier
-      (position, buffer, readString) => {
+      function exportSpecifier(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const exportedPosition = buffer[position++];
         const local = convertNode(position, buffer, readString);
-        const exported = exportedPosition ? convertNode(exportedPosition, buffer, readString) : local;
         return {
           type: "ExportSpecifier",
           start,
           end,
-          exported,
-          local
+          local,
+          exported: exportedPosition === 0 ? { ...local } : convertNode(exportedPosition, buffer, readString)
         };
       },
-      // index:24; ExpressionStatement
-      (position, buffer, readString) => {
+      function expressionStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const directivePosition = buffer[position++];
         const expression = convertNode(position, buffer, readString);
         return {
           type: "ExpressionStatement",
           start,
           end,
-          expression,
-          ...directivePosition ? { directive: convertString(directivePosition, buffer, readString) } : {}
+          expression
         };
       },
-      // index:25; ForInStatement
-      (position, buffer, readString) => {
+      function forInStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const right = convertNode(buffer[position++], buffer, readString);
@@ -86038,16 +86061,16 @@ ${smallChunks} are below minChunkSize.`
           type: "ForInStatement",
           start,
           end,
-          body,
           left,
-          right
+          right,
+          body
         };
       },
-      // index:26; ForOfStatement
-      (position, buffer, readString) => {
+      function forOfStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const awaited = !!buffer[position++];
+        const flags = buffer[position++];
+        const awaited = (flags & 1) === 1;
         const right = convertNode(buffer[position++], buffer, readString);
         const body = convertNode(buffer[position++], buffer, readString);
         const left = convertNode(position, buffer, readString);
@@ -86056,75 +86079,80 @@ ${smallChunks} are below minChunkSize.`
           start,
           end,
           await: awaited,
-          body,
           left,
-          right
+          right,
+          body
         };
       },
-      // index:27; ForStatement
-      (position, buffer, readString) => {
+      function forStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const initPosition = buffer[position++];
+        const init = initPosition === 0 ? null : convertNode(initPosition, buffer, readString);
         const testPosition = buffer[position++];
+        const test = testPosition === 0 ? null : convertNode(testPosition, buffer, readString);
         const updatePosition = buffer[position++];
+        const update = updatePosition === 0 ? null : convertNode(updatePosition, buffer, readString);
         const body = convertNode(buffer[position], buffer, readString);
         return {
           type: "ForStatement",
           start,
           end,
-          body,
-          init: initPosition ? convertNode(initPosition, buffer, readString) : null,
-          test: testPosition ? convertNode(testPosition, buffer, readString) : null,
-          update: updatePosition ? convertNode(updatePosition, buffer, readString) : null
+          init,
+          test,
+          update,
+          body
         };
       },
-      // index:28; FunctionDeclaration
-      (position, buffer, readString) => {
+      function functionDeclaration(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const async = !!buffer[position++];
-        const generator = !!buffer[position++];
+        const flags = buffer[position++];
+        const async = (flags & 1) === 1;
+        const generator = (flags & 2) === 2;
         const idPosition = buffer[position++];
+        const id = idPosition === 0 ? null : convertNode(idPosition, buffer, readString);
         const parameters = convertNodeList(buffer[position++], buffer, readString);
         const body = convertNode(buffer[position++], buffer, readString);
-        const annotations = convertAnnotationList(position, buffer);
-        return addAnnotationProperty({
+        const annotations = convertAnnotations(position, buffer);
+        return {
           type: "FunctionDeclaration",
           start,
           end,
           async,
-          body,
-          expression: false,
           generator,
-          id: idPosition ? convertNode(idPosition, buffer, readString) : null,
-          params: parameters
-        }, annotations, ANNOTATION_KEY);
+          ...annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {},
+          id,
+          params: parameters,
+          body,
+          expression: false
+        };
       },
-      // index:29; FunctionExpression
-      (position, buffer, readString) => {
+      function functionExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const async = !!buffer[position++];
-        const generator = !!buffer[position++];
+        const flags = buffer[position++];
+        const async = (flags & 1) === 1;
+        const generator = (flags & 2) === 2;
         const idPosition = buffer[position++];
+        const id = idPosition === 0 ? null : convertNode(idPosition, buffer, readString);
         const parameters = convertNodeList(buffer[position++], buffer, readString);
         const body = convertNode(buffer[position++], buffer, readString);
-        const annotations = convertAnnotationList(position, buffer);
-        return addAnnotationProperty({
+        const annotations = convertAnnotations(position, buffer);
+        return {
           type: "FunctionExpression",
           start,
           end,
           async,
-          body,
-          expression: false,
           generator,
-          id: idPosition ? convertNode(idPosition, buffer, readString) : null,
-          params: parameters
-        }, annotations, ANNOTATION_KEY);
+          ...annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {},
+          id,
+          params: parameters,
+          body,
+          expression: false
+        };
       },
-      // index:30; Identifier
-      (position, buffer, readString) => {
+      function identifier(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const name = convertString(position, buffer, readString);
@@ -86135,24 +86163,23 @@ ${smallChunks} are below minChunkSize.`
           name
         };
       },
-      // index:31; IfStatement
-      (position, buffer, readString) => {
+      function ifStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const consequent = convertNode(buffer[position++], buffer, readString);
         const alternatePosition = buffer[position++];
+        const alternate = alternatePosition === 0 ? null : convertNode(alternatePosition, buffer, readString);
         const test = convertNode(position, buffer, readString);
         return {
           type: "IfStatement",
           start,
           end,
-          alternate: alternatePosition ? convertNode(alternatePosition, buffer, readString) : null,
+          test,
           consequent,
-          test
+          alternate
         };
       },
-      // index:32; ImportAttribute
-      (position, buffer, readString) => {
+      function importAttribute(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const value = convertNode(buffer[position++], buffer, readString);
@@ -86165,8 +86192,7 @@ ${smallChunks} are below minChunkSize.`
           value
         };
       },
-      // index:33; ImportDeclaration
-      (position, buffer, readString) => {
+      function importDeclaration(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const source = convertNode(buffer[position++], buffer, readString);
@@ -86176,13 +86202,12 @@ ${smallChunks} are below minChunkSize.`
           type: "ImportDeclaration",
           start,
           end,
-          source,
           specifiers,
+          source,
           attributes
         };
       },
-      // index:34; ImportDefaultSpecifier
-      (position, buffer, readString) => {
+      function importDefaultSpecifier(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const local = convertNode(position, buffer, readString);
@@ -86193,22 +86218,21 @@ ${smallChunks} are below minChunkSize.`
           local
         };
       },
-      // index:35; ImportExpression
-      (position, buffer, readString) => {
+      function importExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const optionsPosition = buffer[position++];
+        const options = optionsPosition === 0 ? null : convertNode(optionsPosition, buffer, readString);
         const source = convertNode(position, buffer, readString);
         return {
           type: "ImportExpression",
           start,
           end,
           source,
-          options: optionsPosition ? convertNode(optionsPosition, buffer, readString) : null
+          options
         };
       },
-      // index:36; ImportNamespaceSpecifier
-      (position, buffer, readString) => {
+      function importNamespaceSpecifier(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const local = convertNode(position, buffer, readString);
@@ -86219,23 +86243,20 @@ ${smallChunks} are below minChunkSize.`
           local
         };
       },
-      // index:37; ImportSpecifier
-      (position, buffer, readString) => {
+      function importSpecifier(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const importedPosition = buffer[position++];
         const local = convertNode(buffer[position], buffer, readString);
-        const imported = importedPosition ? convertNode(importedPosition, buffer, readString) : local;
         return {
           type: "ImportSpecifier",
           start,
           end,
-          imported,
+          imported: importedPosition === 0 ? { ...local } : convertNode(importedPosition, buffer, readString),
           local
         };
       },
-      // index:38; LabeledStatement
-      (position, buffer, readString) => {
+      function labeledStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const body = convertNode(buffer[position++], buffer, readString);
@@ -86244,67 +86265,63 @@ ${smallChunks} are below minChunkSize.`
           type: "LabeledStatement",
           start,
           end,
-          body,
-          label
+          label,
+          body
         };
       },
-      // index:39; Literal<string>
-      (position, buffer, readString) => {
+      function literalBigInt(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const rawPosition = buffer[position++];
-        const raw = rawPosition ? convertString(rawPosition, buffer, readString) : void 0;
-        const value = convertString(position, buffer, readString);
+        const raw = convertString(buffer[position++], buffer, readString);
+        const bigint = convertString(position, buffer, readString);
         return {
           type: "Literal",
           start,
           end,
+          bigint,
           raw,
-          value
+          value: BigInt(bigint)
         };
       },
-      // index:40; Literal<boolean>
-      (position, buffer) => {
+      function literalBoolean(position, buffer) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const value = !!buffer[position++];
+        const flags = buffer[position++];
+        const value = (flags & 1) === 1;
         return {
           type: "Literal",
           start,
           end,
-          raw: value ? "true" : "false",
-          value
+          value,
+          raw: value ? "true" : "false"
         };
       },
-      // index:41; Literal<number>
-      (position, buffer, readString) => {
+      function literalNull(position, buffer) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const rawPosition = buffer[position++];
-        const raw = rawPosition ? convertString(rawPosition, buffer, readString) : void 0;
-        const value = new DataView(buffer.buffer).getFloat64(position << 2, true);
         return {
           type: "Literal",
           start,
           end,
-          raw,
-          value
+          raw: "null",
+          value: null
         };
       },
-      // index:42; Literal<null>
-      (position, buffer) => {
+      function literalNumber(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
+        const rawPosition = buffer[position++];
+        const raw = rawPosition === 0 ? void 0 : convertString(rawPosition, buffer, readString);
+        const value = new DataView(buffer.buffer).getFloat64(position << 2, true);
         return {
           type: "Literal",
           start,
           end,
-          raw: "null",
-          value: null
+          raw,
+          value
         };
       },
-      // index:43; Literal<RegExp>
-      (position, buffer, readString) => {
+      function literalRegExp(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const pattern = convertString(buffer[position++], buffer, readString);
@@ -86314,30 +86331,25 @@ ${smallChunks} are below minChunkSize.`
           start,
           end,
           raw: `/${pattern}/${flags}`,
-          regex: {
-            flags,
-            pattern
-          },
+          regex: { flags, pattern },
           value: new RegExp(pattern, flags)
         };
       },
-      // index:44; Literal<bigint>
-      (position, buffer, readString) => {
+      function literalString(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const bigint = convertString(buffer[position++], buffer, readString);
-        const raw = convertString(position, buffer, readString);
+        const rawPosition = buffer[position++];
+        const raw = rawPosition === 0 ? void 0 : convertString(rawPosition, buffer, readString);
+        const value = convertString(position, buffer, readString);
         return {
           type: "Literal",
           start,
           end,
-          bigint,
-          raw,
-          value: BigInt(bigint)
+          value,
+          raw
         };
       },
-      // index:45; LogicalExpression
-      (position, buffer, readString) => {
+      function logicalExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const operator = FIXED_STRINGS[buffer[position++]];
@@ -86347,17 +86359,17 @@ ${smallChunks} are below minChunkSize.`
           type: "LogicalExpression",
           start,
           end,
-          left,
           operator,
+          left,
           right
         };
       },
-      // index:46; MemberExpression
-      (position, buffer, readString) => {
+      function memberExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const optional = !!buffer[position++];
-        const computed = !!buffer[position++];
+        const flags = buffer[position++];
+        const computed = (flags & 1) === 1;
+        const optional = (flags & 2) === 2;
         const property = convertNode(buffer[position++], buffer, readString);
         const object = convertNode(position, buffer, readString);
         return {
@@ -86365,13 +86377,12 @@ ${smallChunks} are below minChunkSize.`
           start,
           end,
           computed,
-          object,
           optional,
+          object,
           property
         };
       },
-      // index:47; MetaProperty
-      (position, buffer, readString) => {
+      function metaProperty(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const property = convertNode(buffer[position++], buffer, readString);
@@ -86384,43 +86395,42 @@ ${smallChunks} are below minChunkSize.`
           property
         };
       },
-      // index:48; MethodDefinition
-      (position, buffer, readString) => {
+      function methodDefinition(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const kind = FIXED_STRINGS[buffer[position++]];
-        const computed = !!buffer[position++];
-        const isStatic = !!buffer[position++];
+        const flags = buffer[position++];
+        const computed = (flags & 1) === 1;
+        const isStatic = (flags & 2) === 2;
         const value = convertNode(buffer[position++], buffer, readString);
+        const kind = FIXED_STRINGS[buffer[position++]];
         const key = convertNode(position, buffer, readString);
         return {
           type: "MethodDefinition",
           start,
           end,
           computed,
-          key,
-          kind,
           static: isStatic,
-          value
+          key,
+          value,
+          kind
         };
       },
-      // index:49; NewExpression
-      (position, buffer, readString) => {
+      function newExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const callee = convertNode(buffer[position++], buffer, readString);
-        const argumentsPosition = buffer[position++];
-        const annotations = convertAnnotationList(position, buffer);
-        return addAnnotationProperty({
+        const callArguments = convertNodeList(buffer[position++], buffer, readString);
+        const annotations = convertAnnotations(position, buffer);
+        return {
           type: "NewExpression",
           start,
           end,
-          arguments: argumentsPosition ? convertNodeList(argumentsPosition, buffer, readString) : [],
-          callee
-        }, annotations, ANNOTATION_KEY);
+          ...annotations.length > 0 ? { [ANNOTATION_KEY]: annotations } : {},
+          callee,
+          arguments: callArguments
+        };
       },
-      // index:50; ObjectExpression
-      (position, buffer, readString) => {
+      function objectExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const properties = convertNodeList(position, buffer, readString);
@@ -86431,8 +86441,7 @@ ${smallChunks} are below minChunkSize.`
           properties
         };
       },
-      // index:51; ObjectPattern
-      (position, buffer, readString) => {
+      function objectPattern(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const properties = convertNodeList(position, buffer, readString);
@@ -86443,8 +86452,7 @@ ${smallChunks} are below minChunkSize.`
           properties
         };
       },
-      // index:52; PrivateIdentifier
-      (position, buffer, readString) => {
+      function privateIdentifier(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const name = convertString(position, buffer, readString);
@@ -86455,62 +86463,62 @@ ${smallChunks} are below minChunkSize.`
           name
         };
       },
-      // index:53; Program
-      (position, buffer, readString) => {
+      function program(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const annotations = convertAnnotationList(buffer[position++], buffer);
+        const annotations = convertAnnotations(buffer[position++], buffer);
         const body = convertNodeList(position, buffer, readString);
-        return addAnnotationProperty({
+        return {
           type: "Program",
           start,
           end,
           body,
+          ...annotations.length > 0 ? { [INVALID_ANNOTATION_KEY]: annotations } : {},
           sourceType: "module"
-        }, annotations, INVALID_ANNOTATION_KEY);
+        };
       },
-      // index:54; Property
-      (position, buffer, readString) => {
+      function property(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const kind = FIXED_STRINGS[buffer[position++]];
-        const method = !!buffer[position++];
-        const computed = !!buffer[position++];
-        const shorthand = !!buffer[position++];
-        const key = convertNode(buffer[position++], buffer, readString);
-        const valuePosition = buffer[position];
+        const flags = buffer[position++];
+        const method = (flags & 1) === 1;
+        const shorthand = (flags & 2) === 2;
+        const computed = (flags & 4) === 4;
+        const keyPosition = buffer[position++];
+        const value = convertNode(buffer[position++], buffer, readString);
+        const kind = FIXED_STRINGS[buffer[position]];
         return {
           type: "Property",
           start,
           end,
-          computed,
-          key,
-          kind,
           method,
           shorthand,
-          value: valuePosition ? convertNode(valuePosition, buffer, readString) : { ...key }
+          computed,
+          key: keyPosition === 0 ? { ...value } : convertNode(keyPosition, buffer, readString),
+          value,
+          kind
         };
       },
-      // index:55; PropertyDefinition
-      (position, buffer, readString) => {
+      function propertyDefinition(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const computed = !!buffer[position++];
-        const isStatic = !!buffer[position++];
+        const flags = buffer[position++];
+        const computed = (flags & 1) === 1;
+        const isStatic = (flags & 2) === 2;
         const valuePosition = buffer[position++];
+        const value = valuePosition === 0 ? null : convertNode(valuePosition, buffer, readString);
         const key = convertNode(position, buffer, readString);
         return {
           type: "PropertyDefinition",
           start,
           end,
           computed,
-          key,
           static: isStatic,
-          value: valuePosition ? convertNode(valuePosition, buffer, readString) : null
+          key,
+          value
         };
       },
-      // index:56; RestElement
-      (position, buffer, readString) => {
+      function restElement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const argument = convertNode(position, buffer, readString);
@@ -86521,20 +86529,19 @@ ${smallChunks} are below minChunkSize.`
           argument
         };
       },
-      // index:57; ReturnStatement
-      (position, buffer, readString) => {
+      function returnStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const argumentPosition = buffer[position];
+        const argument = argumentPosition === 0 ? null : convertNode(argumentPosition, buffer, readString);
         return {
           type: "ReturnStatement",
           start,
           end,
-          argument: argumentPosition ? convertNode(argumentPosition, buffer, readString) : null
+          argument
         };
       },
-      // index:58; SequenceExpression
-      (position, buffer, readString) => {
+      function sequenceExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const expressions = convertNodeList(position, buffer, readString);
@@ -86545,8 +86552,7 @@ ${smallChunks} are below minChunkSize.`
           expressions
         };
       },
-      // index:59; SpreadElement
-      (position, buffer, readString) => {
+      function spreadElement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const argument = convertNode(position, buffer, readString);
@@ -86557,8 +86563,7 @@ ${smallChunks} are below minChunkSize.`
           argument
         };
       },
-      // index:60; StaticBlock
-      (position, buffer, readString) => {
+      function staticBlock(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const body = convertNodeList(position, buffer, readString);
@@ -86569,8 +86574,7 @@ ${smallChunks} are below minChunkSize.`
           body
         };
       },
-      // index:61; Super
-      (position, buffer) => {
+      function superElement(position, buffer) {
         const start = buffer[position++];
         const end = buffer[position++];
         return {
@@ -86579,22 +86583,21 @@ ${smallChunks} are below minChunkSize.`
           end
         };
       },
-      // index:62; SwitchCase
-      (position, buffer, readString) => {
+      function switchCase(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const testPosition = buffer[position++];
+        const test = testPosition === 0 ? null : convertNode(testPosition, buffer, readString);
         const consequent = convertNodeList(buffer[position], buffer, readString);
         return {
           type: "SwitchCase",
           start,
           end,
-          consequent,
-          test: testPosition ? convertNode(testPosition, buffer, readString) : null
+          test,
+          consequent
         };
       },
-      // index:63; SwitchStatement
-      (position, buffer, readString) => {
+      function switchStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const cases = convertNodeList(buffer[position++], buffer, readString);
@@ -86603,12 +86606,11 @@ ${smallChunks} are below minChunkSize.`
           type: "SwitchStatement",
           start,
           end,
-          cases,
-          discriminant
+          discriminant,
+          cases
         };
       },
-      // index:64; TaggedTemplateExpression
-      (position, buffer, readString) => {
+      function taggedTemplateExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const quasi = convertNode(buffer[position++], buffer, readString);
@@ -86617,30 +86619,27 @@ ${smallChunks} are below minChunkSize.`
           type: "TaggedTemplateExpression",
           start,
           end,
-          quasi,
-          tag
+          tag,
+          quasi
         };
       },
-      // index:65; TemplateElement
-      (position, buffer, readString) => {
+      function templateElement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const tail = !!buffer[position++];
+        const flags = buffer[position++];
+        const tail = (flags & 1) === 1;
         const cookedPosition = buffer[position++];
+        const cooked = cookedPosition === 0 ? void 0 : convertString(cookedPosition, buffer, readString);
         const raw = convertString(position, buffer, readString);
         return {
           type: "TemplateElement",
           start,
           end,
           tail,
-          value: {
-            cooked: cookedPosition ? convertString(cookedPosition, buffer, readString) : null,
-            raw
-          }
+          value: { cooked, raw }
         };
       },
-      // index:66; TemplateLiteral
-      (position, buffer, readString) => {
+      function templateLiteral(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const expressions = convertNodeList(buffer[position++], buffer, readString);
@@ -86649,12 +86648,11 @@ ${smallChunks} are below minChunkSize.`
           type: "TemplateLiteral",
           start,
           end,
-          expressions,
-          quasis
+          quasis,
+          expressions
         };
       },
-      // index:67; ThisExpression
-      (position, buffer) => {
+      function thisExpression(position, buffer) {
         const start = buffer[position++];
         const end = buffer[position++];
         return {
@@ -86663,8 +86661,7 @@ ${smallChunks} are below minChunkSize.`
           end
         };
       },
-      // index:68; ThrowStatement
-      (position, buffer, readString) => {
+      function throwStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const argument = convertNode(position, buffer, readString);
@@ -86675,24 +86672,24 @@ ${smallChunks} are below minChunkSize.`
           argument
         };
       },
-      // index:69; TryStatement
-      (position, buffer, readString) => {
+      function tryStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const handlerPosition = buffer[position++];
+        const handler = handlerPosition === 0 ? null : convertNode(handlerPosition, buffer, readString);
         const finalizerPosition = buffer[position++];
+        const finalizer = finalizerPosition === 0 ? null : convertNode(finalizerPosition, buffer, readString);
         const block = convertNode(position, buffer, readString);
         return {
           type: "TryStatement",
           start,
           end,
           block,
-          finalizer: finalizerPosition ? convertNode(finalizerPosition, buffer, readString) : null,
-          handler: handlerPosition ? convertNode(handlerPosition, buffer, readString) : null
+          handler,
+          finalizer
         };
       },
-      // index:70; UnaryExpression
-      (position, buffer, readString) => {
+      function unaryExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const operator = FIXED_STRINGS[buffer[position++]];
@@ -86701,29 +86698,28 @@ ${smallChunks} are below minChunkSize.`
           type: "UnaryExpression",
           start,
           end,
-          argument,
           operator,
+          argument,
           prefix: true
         };
       },
-      // index:71; UpdateExpression
-      (position, buffer, readString) => {
+      function updateExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const prefix = !!buffer[position++];
+        const flags = buffer[position++];
+        const prefix = (flags & 1) === 1;
         const operator = FIXED_STRINGS[buffer[position++]];
         const argument = convertNode(position, buffer, readString);
         return {
           type: "UpdateExpression",
           start,
           end,
-          argument,
+          prefix,
           operator,
-          prefix
+          argument
         };
       },
-      // index:72; VariableDeclaration
-      (position, buffer, readString) => {
+      function variableDeclaration(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const kind = FIXED_STRINGS[buffer[position++]];
@@ -86732,26 +86728,25 @@ ${smallChunks} are below minChunkSize.`
           type: "VariableDeclaration",
           start,
           end,
-          declarations,
-          kind
+          kind,
+          declarations
         };
       },
-      // index:73; VariableDeclarator
-      (position, buffer, readString) => {
+      function variableDeclarator(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const init_position = buffer[position++];
+        const initPosition = buffer[position++];
+        const init = initPosition === 0 ? null : convertNode(initPosition, buffer, readString);
         const id = convertNode(position, buffer, readString);
         return {
           type: "VariableDeclarator",
           start,
           end,
           id,
-          init: init_position ? convertNode(init_position, buffer, readString) : null
+          init
         };
       },
-      // index:74; WhileStatement
-      (position, buffer, readString) => {
+      function whileStatement(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
         const body = convertNode(buffer[position++], buffer, readString);
@@ -86760,32 +86755,36 @@ ${smallChunks} are below minChunkSize.`
           type: "WhileStatement",
           start,
           end,
-          body,
-          test
+          test,
+          body
         };
       },
-      // index:75; YieldExpression
-      (position, buffer, readString) => {
+      function yieldExpression(position, buffer, readString) {
         const start = buffer[position++];
         const end = buffer[position++];
-        const delegate = !!buffer[position++];
+        const flags = buffer[position++];
+        const delegate = (flags & 1) === 1;
         const argumentPosition = buffer[position];
+        const argument = argumentPosition === 0 ? null : convertNode(argumentPosition, buffer, readString);
         return {
           type: "YieldExpression",
           start,
           end,
-          argument: argumentPosition ? convertNode(argumentPosition, buffer, readString) : null,
-          delegate
+          delegate,
+          argument
         };
-      },
-      // index:76; Syntax Error
-      (position, buffer, readString) => {
-        const pos = buffer[position++];
-        const message = convertString(position, buffer, readString);
-        error(logParseError(message, pos));
       }
     ];
-    var convertNodeList = (position, buffer, readString) => {
+    function convertNode(position, buffer, readString) {
+      const nodeType = buffer[position];
+      const converter = nodeConverters[nodeType];
+      if (!converter) {
+        console.trace();
+        throw new Error(`Unknown node type: ${nodeType}`);
+      }
+      return converter(position + 1, buffer, readString);
+    }
+    function convertNodeList(position, buffer, readString) {
       const length = buffer[position++];
       const list = [];
       for (let index = 0; index < length; index++) {
@@ -86793,8 +86792,8 @@ ${smallChunks} are below minChunkSize.`
         list.push(nodePosition ? convertNode(nodePosition, buffer, readString) : null);
       }
       return list;
-    };
-    var convertAnnotationList = (position, buffer) => {
+    }
+    var convertAnnotations = (position, buffer) => {
       const length = buffer[position++];
       const list = [];
       for (let index = 0; index < length; index++) {
@@ -86808,22 +86807,11 @@ ${smallChunks} are below minChunkSize.`
       const type = FIXED_STRINGS[buffer[position]];
       return { end, start, type };
     };
-    var addAnnotationProperty = (node, annotations, key) => {
-      if (annotations.length > 0) {
-        return {
-          ...node,
-          [key]: annotations
-        };
-      }
-      return node;
-    };
     var convertString = (position, buffer, readString) => {
       const length = buffer[position++];
       const bytePosition = position << 2;
       return readString(bytePosition, length);
     };
-    var ANNOTATION_KEY = "_rollupAnnotations";
-    var INVALID_ANNOTATION_KEY = "_rollupRemoved";
     function getReadStringFunction(astBuffer) {
       if (typeof Buffer !== "undefined" && astBuffer instanceof Buffer) {
         return function readString(start, length) {
@@ -86838,15 +86826,11 @@ ${smallChunks} are below minChunkSize.`
     }
     var parseAst = (input, { allowReturnOutsideFunction = false } = {}) => {
       const astBuffer = native_js.parse(input, allowReturnOutsideFunction);
-      const readString = getReadStringFunction(astBuffer);
-      const result = convertProgram(astBuffer.buffer, readString);
-      return result;
+      return convertProgram(astBuffer.buffer, getReadStringFunction(astBuffer));
     };
     var parseAstAsync = async (input, { allowReturnOutsideFunction = false, signal } = {}) => {
       const astBuffer = await native_js.parseAsync(input, allowReturnOutsideFunction, signal);
-      const readString = getReadStringFunction(astBuffer);
-      const result = convertProgram(astBuffer.buffer, readString);
-      return result;
+      return convertProgram(astBuffer.buffer, getReadStringFunction(astBuffer));
     };
     exports2.ANNOTATION_KEY = ANNOTATION_KEY;
     exports2.INVALID_ANNOTATION_KEY = INVALID_ANNOTATION_KEY;
@@ -86939,7 +86923,6 @@ ${smallChunks} are below minChunkSize.`
     exports2.logInvalidFunctionPluginHook = logInvalidFunctionPluginHook;
     exports2.logInvalidLogPosition = logInvalidLogPosition;
     exports2.logInvalidOption = logInvalidOption;
-    exports2.logInvalidRollupPhaseForAddWatchFile = logInvalidRollupPhaseForAddWatchFile;
     exports2.logInvalidRollupPhaseForChunkEmission = logInvalidRollupPhaseForChunkEmission;
     exports2.logInvalidSetAssetSourceCall = logInvalidSetAssetSourceCall;
     exports2.logInvalidSourcemapForError = logInvalidSourcemapForError;
@@ -86985,9 +86968,9 @@ ${smallChunks} are below minChunkSize.`
   }
 });
 
-// node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/shared/rollup.js
+// node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/shared/rollup.js
 var require_rollup = __commonJS({
-  "node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/shared/rollup.js"(exports2) {
+  "node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/shared/rollup.js"(exports2) {
     "use strict";
     var parseAst_js = require_parseAst();
     var process$1 = require("node:process");
@@ -87008,7 +86991,7 @@ var require_rollup = __commonJS({
       return n2;
     }
     var tty__namespace = /* @__PURE__ */ _interopNamespaceDefault(tty);
-    var version = "4.5.2";
+    var version = "4.10.0";
     function ensureArray$1(items) {
       if (Array.isArray(items)) {
         return items.filter(Boolean);
@@ -87025,19 +87008,23 @@ var require_rollup = __commonJS({
       BuildPhase2[BuildPhase2["GENERATE"] = 2] = "GENERATE";
     })(BuildPhase || (BuildPhase = {}));
     var textEncoder;
-    function getXxhash(input) {
-      let buffer;
+    var getHash64 = (input) => native_js.xxhashBase64Url(ensureBuffer(input));
+    var getHash36 = (input) => native_js.xxhashBase36(ensureBuffer(input));
+    var getHash16 = (input) => native_js.xxhashBase16(ensureBuffer(input));
+    var hasherByType = {
+      base36: getHash36,
+      base64: getHash64,
+      hex: getHash16
+    };
+    function ensureBuffer(input) {
       if (typeof input === "string") {
         if (typeof Buffer === "undefined") {
           textEncoder ??= new TextEncoder();
-          buffer = textEncoder.encode(input);
-        } else {
-          buffer = Buffer.from(input);
+          return textEncoder.encode(input);
         }
-      } else {
-        buffer = input;
+        return Buffer.from(input);
       }
-      return native_js.xxhashBase64Url(buffer);
+      return input;
     }
     function getOrCreate(map, key, init2) {
       const existing = map.get(key);
@@ -87068,13 +87055,13 @@ var require_rollup = __commonJS({
     var hashPlaceholderLeft = "!~{";
     var hashPlaceholderRight = "}~";
     var hashPlaceholderOverhead = hashPlaceholderLeft.length + hashPlaceholderRight.length;
-    var maxHashSize = 22;
-    var defaultHashSize = 8;
+    var MAX_HASH_SIZE = 22;
+    var DEFAULT_HASH_SIZE = 8;
     var getHashPlaceholderGenerator = () => {
       let nextIndex = 0;
-      return (optionName, hashSize = defaultHashSize) => {
-        if (hashSize > maxHashSize) {
-          return parseAst_js.error(parseAst_js.logFailedValidation(`Hashes cannot be longer than ${maxHashSize} characters, received ${hashSize}. Check the "${optionName}" option.`));
+      return (optionName, hashSize) => {
+        if (hashSize > MAX_HASH_SIZE) {
+          return parseAst_js.error(parseAst_js.logFailedValidation(`Hashes cannot be longer than ${MAX_HASH_SIZE} characters, received ${hashSize}. Check the "${optionName}" option.`));
         }
         const placeholder = `${hashPlaceholderLeft}${toBase64(++nextIndex).padStart(hashSize - hashPlaceholderOverhead, "0")}${hashPlaceholderRight}`;
         if (placeholder.length > hashSize) {
@@ -87083,7 +87070,7 @@ var require_rollup = __commonJS({
         return placeholder;
       };
     };
-    var REPLACER_REGEX = new RegExp(`${hashPlaceholderLeft}[0-9a-zA-Z_$]{1,${maxHashSize - hashPlaceholderOverhead}}${hashPlaceholderRight}`, "g");
+    var REPLACER_REGEX = new RegExp(`${hashPlaceholderLeft}[0-9a-zA-Z_$]{1,${MAX_HASH_SIZE - hashPlaceholderOverhead}}${hashPlaceholderRight}`, "g");
     var replacePlaceholders = (code, hashesByPlaceholder) => code.replace(REPLACER_REGEX, (placeholder) => hashesByPlaceholder.get(placeholder) || placeholder);
     var replaceSinglePlaceholder = (code, placeholder, value) => code.replace(REPLACER_REGEX, (match) => match === placeholder ? value : match);
     var replacePlaceholdersWithDefaultAndGetContainedPlaceholders = (code, placeholders) => {
@@ -87169,7 +87156,7 @@ var require_rollup = __commonJS({
       return makeUnique(renderNamePattern(typeof outputOptions.assetFileNames === "function" ? outputOptions.assetFileNames({ name, source, type: "asset" }) : outputOptions.assetFileNames, "output.assetFileNames", {
         ext: () => node_path.extname(emittedName).slice(1),
         extname: () => node_path.extname(emittedName),
-        hash: (size) => sourceHash.slice(0, Math.max(0, size || defaultHashSize)),
+        hash: (size) => sourceHash.slice(0, Math.max(0, size || DEFAULT_HASH_SIZE)),
         name: () => emittedName.slice(0, Math.max(0, emittedName.length - node_path.extname(emittedName).length))
       }), bundle);
     }
@@ -87275,9 +87262,11 @@ var require_rollup = __commonJS({
           this.facadeChunkByModule = facadeChunkByModule;
         };
         this.setOutputBundle = (bundle, outputOptions) => {
+          const getHash = hasherByType[outputOptions.hashCharacters];
           const output = this.output = {
             bundle,
             fileNamesBySource: /* @__PURE__ */ new Map(),
+            getHash,
             outputOptions
           };
           for (const emittedFile of this.filesByReferenceId.values()) {
@@ -87291,7 +87280,7 @@ var require_rollup = __commonJS({
               if (consumedFile.fileName) {
                 this.finalizeAdditionalAsset(consumedFile, consumedFile.source, output);
               } else {
-                const sourceHash = getXxhash(consumedFile.source);
+                const sourceHash = getHash(consumedFile.source);
                 getOrCreate(consumedAssetsByHash, sourceHash, () => []).push(consumedFile);
               }
             } else if (consumedFile.type === "prebuilt-chunk") {
@@ -87311,7 +87300,7 @@ var require_rollup = __commonJS({
       assignReferenceId(file, idBase) {
         let referenceId = idBase;
         do {
-          referenceId = getXxhash(referenceId).slice(0, 8).replaceAll("-", "$");
+          referenceId = getHash64(referenceId).slice(0, 8).replaceAll("-", "$");
         } while (this.filesByReferenceId.has(referenceId) || this.outputFileEmitters.some(({ filesByReferenceId }) => filesByReferenceId.has(referenceId)));
         file.referenceId = referenceId;
         this.filesByReferenceId.set(referenceId, file);
@@ -87411,10 +87400,10 @@ var require_rollup = __commonJS({
         }
         return referenceId;
       }
-      finalizeAdditionalAsset(consumedFile, source, { bundle, fileNamesBySource, outputOptions }) {
+      finalizeAdditionalAsset(consumedFile, source, { bundle, fileNamesBySource, getHash, outputOptions }) {
         let { fileName, needsCodeReference, referenceId } = consumedFile;
         if (!fileName) {
-          const sourceHash = getXxhash(source);
+          const sourceHash = getHash(source);
           fileName = fileNamesBySource.get(sourceHash);
           if (!fileName) {
             fileName = generateAssetFileName(consumedFile.name, source, sourceHash, outputOptions, bundle);
@@ -87728,9 +87717,6 @@ var require_rollup = __commonJS({
       }
       return {
         addWatchFile(id) {
-          if (graph.phase >= BuildPhase.GENERATE) {
-            return this.error(parseAst_js.logInvalidRollupPhaseForAddWatchFile());
-          }
           graph.watchFiles[id] = true;
         },
         cache: cacheInstance,
@@ -88166,6 +88152,7 @@ var require_rollup = __commonJS({
         freeze: getOption("freeze"),
         generatedCode: getObjectOption(config, overrides, "generatedCode", objectifyOptionWithPresets(generatedCodePresets, "output.generatedCode", parseAst_js.URL_OUTPUT_GENERATEDCODE, "")),
         globals: getOption("globals"),
+        hashCharacters: getOption("hashCharacters"),
         hoistTransitiveImports: getOption("hoistTransitiveImports"),
         indent: getOption("indent"),
         inlineDynamicImports: getOption("inlineDynamicImports"),
@@ -88564,6 +88551,15 @@ var require_rollup = __commonJS({
       prependRight(content) {
         this.intro = content + this.intro;
       }
+      reset() {
+        this.intro = "";
+        this.outro = "";
+        if (this.edited) {
+          this.content = this.original;
+          this.storeName = false;
+          this.edited = false;
+        }
+      }
       split(index) {
         const sliceIndex = index - this.start;
         const originalBefore = this.original.slice(0, sliceIndex);
@@ -88632,8 +88628,8 @@ var require_rollup = __commonJS({
       }
     };
     function getBtoa() {
-      if (typeof window !== "undefined" && typeof window.btoa === "function") {
-        return (str) => window.btoa(unescape(encodeURIComponent(str)));
+      if (typeof globalThis !== "undefined" && typeof globalThis.btoa === "function") {
+        return (str) => globalThis.btoa(unescape(encodeURIComponent(str)));
       } else if (typeof Buffer === "function") {
         return (str) => Buffer.from(str, "utf-8").toString("base64");
       } else {
@@ -89184,6 +89180,26 @@ var require_rollup = __commonJS({
         }
         return this;
       }
+      reset(start, end) {
+        while (start < 0)
+          start += this.original.length;
+        while (end < 0)
+          end += this.original.length;
+        if (start === end)
+          return this;
+        if (start < 0 || end > this.original.length)
+          throw new Error("Character is out of bounds");
+        if (start > end)
+          throw new Error("end must be greater than start");
+        this._split(start);
+        this._split(end);
+        let chunk = this.byStart[start];
+        while (chunk) {
+          chunk.reset();
+          chunk = end > chunk.end ? this.byStart[chunk.end] : null;
+        }
+        return this;
+      }
       lastChar() {
         if (this.outro.length)
           return this.outro[this.outro.length - 1];
@@ -90028,10 +90044,9 @@ var require_rollup = __commonJS({
       "with",
       "yield"
     ]);
-    var RESERVED_NAMES$1 = RESERVED_NAMES;
     var illegalCharacters = /[^\w$]/g;
     var startsWithDigit = (value) => /\d/.test(value[0]);
-    var needsEscape = (value) => startsWithDigit(value) || RESERVED_NAMES$1.has(value) || value === "arguments";
+    var needsEscape = (value) => startsWithDigit(value) || RESERVED_NAMES.has(value) || value === "arguments";
     function isLegal(value) {
       if (needsEscape(value)) {
         return false;
@@ -90044,6 +90059,23 @@ var require_rollup = __commonJS({
         value = `_${value}`;
       return value || "_";
     }
+    var VALID_IDENTIFIER_REGEXP = /^[$_\p{ID_Start}][$\u200C\u200D\p{ID_Continue}]*$/u;
+    var NUMBER_REGEXP = /^(?:0|[1-9]\d*)$/;
+    function stringifyObjectKeyIfNeeded(key) {
+      if (VALID_IDENTIFIER_REGEXP.test(key)) {
+        return key === "__proto__" ? '["__proto__"]' : key;
+      }
+      if (NUMBER_REGEXP.test(key) && +key <= Number.MAX_SAFE_INTEGER) {
+        return key;
+      }
+      return JSON.stringify(key);
+    }
+    function stringifyIdentifierIfNeeded(key) {
+      if (VALID_IDENTIFIER_REGEXP.test(key)) {
+        return key;
+      }
+      return JSON.stringify(key);
+    }
     var ExternalModule = class {
       constructor(options, id, moduleSideEffects, meta, renormalizeRenderPath, attributes) {
         this.options = options;
@@ -92163,8 +92195,15 @@ var require_rollup = __commonJS({
         this.description = description;
       }
       deoptimizeArgumentsOnInteractionAtPath({ args, type }, path2) {
-        if (type === INTERACTION_CALLED && path2.length === 0 && this.description.mutatesSelfAsArray) {
-          args[0]?.deoptimizePath(UNKNOWN_INTEGER_PATH);
+        if (type === INTERACTION_CALLED && path2.length === 0) {
+          if (this.description.mutatesSelfAsArray) {
+            args[0]?.deoptimizePath(UNKNOWN_INTEGER_PATH);
+          }
+          if (this.description.mutatesArgs) {
+            for (let index = 1; index < args.length; index++) {
+              args[index].deoptimizePath(UNKNOWN_PATH);
+            }
+          }
         }
       }
       getReturnExpressionWhenCalledAtPath(path2, { args }) {
@@ -92200,6 +92239,7 @@ var require_rollup = __commonJS({
     var METHOD_RETURNS_BOOLEAN = [
       new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: false,
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_BOOLEAN
@@ -92208,6 +92248,7 @@ var require_rollup = __commonJS({
     var METHOD_RETURNS_STRING = [
       new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: false,
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_STRING
@@ -92216,6 +92257,7 @@ var require_rollup = __commonJS({
     var METHOD_RETURNS_NUMBER = [
       new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: false,
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_NUMBER
@@ -92224,6 +92266,7 @@ var require_rollup = __commonJS({
     var METHOD_RETURNS_UNKNOWN = [
       new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: false,
         returns: null,
         returnsPrimitive: UNKNOWN_EXPRESSION
@@ -92610,6 +92653,7 @@ var require_rollup = __commonJS({
     var METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_BOOLEAN = [
       new Method({
         callsArgs: [0],
+        mutatesArgs: false,
         mutatesSelfAsArray: "deopt-only",
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_BOOLEAN
@@ -92618,6 +92662,7 @@ var require_rollup = __commonJS({
     var METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NUMBER = [
       new Method({
         callsArgs: [0],
+        mutatesArgs: false,
         mutatesSelfAsArray: "deopt-only",
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_NUMBER
@@ -92626,6 +92671,7 @@ var require_rollup = __commonJS({
     var METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY = [
       new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: true,
         returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
         returnsPrimitive: null
@@ -92634,6 +92680,7 @@ var require_rollup = __commonJS({
     var METHOD_DEOPTS_SELF_RETURNS_NEW_ARRAY = [
       new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: "deopt-only",
         returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
         returnsPrimitive: null
@@ -92642,14 +92689,16 @@ var require_rollup = __commonJS({
     var METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY = [
       new Method({
         callsArgs: [0],
+        mutatesArgs: false,
         mutatesSelfAsArray: "deopt-only",
         returns: () => new ObjectEntity(NEW_ARRAY_PROPERTIES, ARRAY_PROTOTYPE),
         returnsPrimitive: null
       })
     ];
-    var METHOD_MUTATES_SELF_RETURNS_NUMBER = [
+    var METHOD_MUTATES_SELF_AND_ARGS_RETURNS_NUMBER = [
       new Method({
         callsArgs: null,
+        mutatesArgs: true,
         mutatesSelfAsArray: true,
         returns: null,
         returnsPrimitive: UNKNOWN_LITERAL_NUMBER
@@ -92658,6 +92707,7 @@ var require_rollup = __commonJS({
     var METHOD_MUTATES_SELF_RETURNS_UNKNOWN = [
       new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: true,
         returns: null,
         returnsPrimitive: UNKNOWN_EXPRESSION
@@ -92666,6 +92716,7 @@ var require_rollup = __commonJS({
     var METHOD_DEOPTS_SELF_RETURNS_UNKNOWN = [
       new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: "deopt-only",
         returns: null,
         returnsPrimitive: UNKNOWN_EXPRESSION
@@ -92674,6 +92725,7 @@ var require_rollup = __commonJS({
     var METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN = [
       new Method({
         callsArgs: [0],
+        mutatesArgs: false,
         mutatesSelfAsArray: "deopt-only",
         returns: null,
         returnsPrimitive: UNKNOWN_EXPRESSION
@@ -92682,6 +92734,7 @@ var require_rollup = __commonJS({
     var METHOD_MUTATES_SELF_RETURNS_SELF = [
       new Method({
         callsArgs: null,
+        mutatesArgs: false,
         mutatesSelfAsArray: true,
         returns: "self",
         returnsPrimitive: null
@@ -92690,6 +92743,7 @@ var require_rollup = __commonJS({
     var METHOD_CALLS_ARG_MUTATES_SELF_RETURNS_SELF = [
       new Method({
         callsArgs: [0],
+        mutatesArgs: false,
         mutatesSelfAsArray: true,
         returns: "self",
         returnsPrimitive: null
@@ -92719,7 +92773,7 @@ var require_rollup = __commonJS({
       lastIndexOf: METHOD_RETURNS_NUMBER,
       map: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_NEW_ARRAY,
       pop: METHOD_MUTATES_SELF_RETURNS_UNKNOWN,
-      push: METHOD_MUTATES_SELF_RETURNS_NUMBER,
+      push: METHOD_MUTATES_SELF_AND_ARGS_RETURNS_NUMBER,
       reduce: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
       reduceRight: METHOD_CALLS_ARG_DEOPTS_SELF_RETURNS_UNKNOWN,
       reverse: METHOD_MUTATES_SELF_RETURNS_SELF,
@@ -92730,7 +92784,7 @@ var require_rollup = __commonJS({
       splice: METHOD_MUTATES_SELF_RETURNS_NEW_ARRAY,
       toLocaleString: METHOD_RETURNS_STRING,
       toString: METHOD_RETURNS_STRING,
-      unshift: METHOD_MUTATES_SELF_RETURNS_NUMBER,
+      unshift: METHOD_MUTATES_SELF_AND_ARGS_RETURNS_NUMBER,
       values: METHOD_DEOPTS_SELF_RETURNS_UNKNOWN
     }, OBJECT_PROTOTYPE, true);
     var ArrayExpression = class extends NodeBase {
@@ -93049,7 +93103,7 @@ var require_rollup = __commonJS({
     function getSafeName(baseName, usedNames, forbiddenNames) {
       let safeName = baseName;
       let count = 1;
-      while (usedNames.has(safeName) || RESERVED_NAMES$1.has(safeName) || forbiddenNames?.has(safeName)) {
+      while (usedNames.has(safeName) || RESERVED_NAMES.has(safeName) || forbiddenNames?.has(safeName)) {
         safeName = `${baseName}$${toBase64(count++)}`;
       }
       usedNames.add(safeName);
@@ -94489,7 +94543,7 @@ var require_rollup = __commonJS({
         if (this.variable.declarations && this.variable.declarations.length === 1 && (decl_id = this.variable.declarations[0]) && this.start < decl_id.start && closestParentFunctionOrProgram(this) === closestParentFunctionOrProgram(decl_id)) {
           return this.isTDZAccess = true;
         }
-        if (!this.variable.initReached) {
+        if (!this.variable.initReached && this.scope.context.module.isExecuted) {
           return this.isTDZAccess = true;
         }
         return this.isTDZAccess = false;
@@ -94671,7 +94725,7 @@ var require_rollup = __commonJS({
           const name = identifier.name;
           const existingVariable = this.hoistedVariables?.get(name) || this.variables.get(name);
           if (existingVariable) {
-            if (existingVariable.kind === "var") {
+            if (existingVariable.kind === "var" || kind === "var" && existingVariable.kind === "parameter") {
               existingVariable.addDeclaration(identifier, init2);
               return existingVariable;
             }
@@ -94995,7 +95049,7 @@ var require_rollup = __commonJS({
     function getSystemExportStatement(exportedVariables, { exportNamesByVariable, snippets: { _, getObject, getPropertyAccess } }, modifier = "") {
       if (exportedVariables.length === 1 && exportNamesByVariable.get(exportedVariables[0]).length === 1) {
         const variable = exportedVariables[0];
-        return `exports('${exportNamesByVariable.get(variable)}',${_}${variable.getName(getPropertyAccess)}${modifier})`;
+        return `exports(${JSON.stringify(exportNamesByVariable.get(variable)[0])},${_}${variable.getName(getPropertyAccess)}${modifier})`;
       } else {
         const fields = [];
         for (const variable of exportedVariables) {
@@ -95007,7 +95061,7 @@ var require_rollup = __commonJS({
       }
     }
     function renderSystemExportExpression(exportedVariable, expressionStart, expressionEnd, code, { exportNamesByVariable, snippets: { _ } }) {
-      code.prependRight(expressionStart, `exports('${exportNamesByVariable.get(exportedVariable)}',${_}`);
+      code.prependRight(expressionStart, `exports(${JSON.stringify(exportNamesByVariable.get(exportedVariable)[0])},${_}`);
       code.appendLeft(expressionEnd, ")");
     }
     function renderSystemExportFunction(exportedVariables, expressionStart, expressionEnd, needsParens, code, options) {
@@ -96626,7 +96680,7 @@ var require_rollup = __commonJS({
         const hasTrailingSemicolon = code.original.charCodeAt(this.end - 1) === 59;
         const systemExportNames = format === "system" && exportNamesByVariable.get(this.variable);
         if (systemExportNames) {
-          code.overwrite(this.start, declarationStart, `${cnst} ${this.variable.getName(getPropertyAccess)} = exports('${systemExportNames[0]}', `);
+          code.overwrite(this.start, declarationStart, `${cnst} ${this.variable.getName(getPropertyAccess)} = exports(${JSON.stringify(systemExportNames[0])}, `);
           code.appendRight(hasTrailingSemicolon ? this.end - 1 : this.end, ")" + (hasTrailingSemicolon ? "" : ";"));
         } else {
           code.overwrite(this.start, declarationStart, `${cnst} ${this.variable.getName(getPropertyAccess)} = `);
@@ -97051,14 +97105,14 @@ var require_rollup = __commonJS({
         return `function ${INTEROP_NAMESPACE_COMPAT_VARIABLE}(e)${_}{${n2}${t}if${_}(${getIsCompatNamespace(snippets)})${_}return e;${n2}` + createNamespaceObject(t, t, snippets, liveBindings, freeze, symbols) + `}${n2}${n2}`;
       },
       [INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE](_t, snippets, _liveBindings, freeze, symbols) {
-        const { getDirectReturnFunction, getObject, n: n2 } = snippets;
+        const { getDirectReturnFunction, getObject, n: n2, _ } = snippets;
         const [left, right] = getDirectReturnFunction(["e"], {
           functionReturn: true,
           lineBreakIndent: null,
           name: INTEROP_NAMESPACE_DEFAULT_ONLY_VARIABLE
         });
         return `${left}${getFrozen(freeze, getWithToStringTag(symbols, getObject([
-          ["__proto__", "null"],
+          [null, `__proto__:${_}null`],
           ["default", "e"]
         ], { lineBreakIndent: null }), snippets))}${right}${n2}${n2}`;
       },
@@ -97471,26 +97525,33 @@ var require_rollup = __commonJS({
     };
     var LabeledStatement = class extends NodeBase {
       hasEffects(context) {
-        const brokenFlow = context.brokenFlow;
+        const { brokenFlow, includedLabels } = context;
         context.ignore.labels.add(this.label.name);
-        if (this.body.hasEffects(context))
-          return true;
-        context.ignore.labels.delete(this.label.name);
-        if (context.includedLabels.has(this.label.name)) {
-          context.includedLabels.delete(this.label.name);
-          context.brokenFlow = brokenFlow;
+        context.includedLabels = /* @__PURE__ */ new Set();
+        let bodyHasEffects = false;
+        if (this.body.hasEffects(context)) {
+          bodyHasEffects = true;
+        } else {
+          context.ignore.labels.delete(this.label.name);
+          if (context.includedLabels.has(this.label.name)) {
+            context.includedLabels.delete(this.label.name);
+            context.brokenFlow = brokenFlow;
+          }
         }
-        return false;
+        context.includedLabels = /* @__PURE__ */ new Set([...includedLabels, ...context.includedLabels]);
+        return bodyHasEffects;
       }
       include(context, includeChildrenRecursively) {
         this.included = true;
-        const brokenFlow = context.brokenFlow;
+        const { brokenFlow, includedLabels } = context;
+        context.includedLabels = /* @__PURE__ */ new Set();
         this.body.include(context, includeChildrenRecursively);
         if (includeChildrenRecursively || context.includedLabels.has(this.label.name)) {
           this.label.include();
           context.includedLabels.delete(this.label.name);
           context.brokenFlow = brokenFlow;
         }
+        context.includedLabels = /* @__PURE__ */ new Set([...includedLabels, ...context.includedLabels]);
       }
       render(code, options) {
         if (this.label.included) {
@@ -99027,7 +99088,7 @@ var require_rollup = __commonJS({
           if (this.referencedEarly || variable.isReassigned || variable === this) {
             return [
               null,
-              `get ${name2}${_}()${_}{${_}return ${variable.getName(getPropertyAccess)}${s}${_}}`
+              `get ${stringifyObjectKeyIfNeeded(name2)}${_}()${_}{${_}return ${variable.getName(getPropertyAccess)}${s}${_}}`
             ];
           }
           return [name2, variable.getName(getPropertyAccess)];
@@ -99523,7 +99584,7 @@ var require_rollup = __commonJS({
         this.ast.bind();
       }
       error(properties, pos) {
-        this.addLocationToLogProps(properties, pos);
+        pos !== void 0 && this.addLocationToLogProps(properties, pos);
         return parseAst_js.error(properties);
       }
       // sum up the length of all ast nodes that are included
@@ -99971,7 +100032,7 @@ var require_rollup = __commonJS({
           const source = node.source.value;
           this.addSource(source, node);
           if (node.exported) {
-            const name = node.exported.name;
+            const name = node.exported instanceof Literal ? node.exported.value : node.exported.name;
             this.assertUniqueExportName(name, node.exported.start);
             this.reexportDescriptions.set(name, {
               localName: "*",
@@ -100272,7 +100333,9 @@ var require_rollup = __commonJS({
                   lineBreakIndent: null,
                   name: null
                 });
-                exportBlock += `Object.defineProperty(exports,${_}'${specifier.reexported}',${_}{${n2}${t}enumerable:${_}true,${n2}${t}get:${_}${left}${importName}${right}${n2}});`;
+                exportBlock += `Object.defineProperty(exports,${_}${JSON.stringify(specifier.reexported)},${_}{${n2}${t}enumerable:${_}true,${n2}${t}get:${_}${left}${importName}${right}${n2}});`;
+              } else if (specifier.reexported === "__proto__") {
+                exportBlock += `Object.defineProperty(exports,${_}"__proto__",${_}{${n2}${t}enumerable:${_}true,${n2}${t}value:${_}${importName}${n2}});`;
               } else {
                 exportBlock += `exports${getPropertyAccess(specifier.reexported)}${_}=${_}${importName};`;
               }
@@ -100286,7 +100349,7 @@ var require_rollup = __commonJS({
         if (lhs !== rhs) {
           if (exportBlock)
             exportBlock += n2;
-          exportBlock += `${lhs}${_}=${_}${rhs};`;
+          exportBlock += exported === "__proto__" ? `Object.defineProperty(exports,${_}"__proto__",${_}{${n2}${t}enumerable:${_}true,${n2}${t}value:${_}${rhs}${n2}});` : `${lhs}${_}=${_}${rhs};`;
         }
       }
       for (const { name, reexports } of dependencies) {
@@ -100367,7 +100430,7 @@ var require_rollup = __commonJS({
         });
         return `Object.defineProperty(exports,${_}k,${_}{${n2}${t}${t}enumerable:${_}true,${n2}${t}${t}get:${_}${left}${name}[k]${right}${n2}${t}})`;
       }
-      return `exports[k]${_}=${_}${name}[k]`;
+      return `k${_}===${_}'__proto__'${_}?${_}Object.defineProperty(exports,${_}k,${_}{${n2}${t}${t}enumerable:${_}true,${n2}${t}${t}value:${_}${name}[k]${n2}${t}})${_}:${_}exports[k]${_}=${_}${name}[k]`;
     };
     function getInteropBlock(dependencies, interop, externalLiveBindings, freeze, symbols, accessedGlobals, indent, snippets) {
       const { _, cnst, n: n2 } = snippets;
@@ -100605,7 +100668,7 @@ var require_rollup = __commonJS({
           if (defaultImport && importedNames.length === 0) {
             importBlock.push(`import ${defaultImport.local} from${_}${pathWithAssertion}`);
           } else if (importedNames.length > 0) {
-            importBlock.push(`import ${defaultImport ? `${defaultImport.local},${_}` : ""}{${_}${importedNames.map((specifier) => specifier.imported === specifier.local ? specifier.imported : `${specifier.imported} as ${specifier.local}`).join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
+            importBlock.push(`import ${defaultImport ? `${defaultImport.local},${_}` : ""}{${_}${importedNames.map((specifier) => specifier.imported === specifier.local ? specifier.imported : `${stringifyIdentifierIfNeeded(specifier.imported)} as ${specifier.local}`).join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
           }
         }
         if (reexports) {
@@ -100629,11 +100692,11 @@ var require_rollup = __commonJS({
               importBlock.push(`import${_}*${_}as ${name} from${_}${pathWithAssertion}`);
             }
             for (const specifier of namespaceReexports) {
-              importBlock.push(`export${_}{${_}${name === specifier.reexported ? name : `${name} as ${specifier.reexported}`} };`);
+              importBlock.push(`export${_}{${_}${name === specifier.reexported ? name : `${name} as ${stringifyIdentifierIfNeeded(specifier.reexported)}`} };`);
             }
           }
           if (namedReexports.length > 0) {
-            importBlock.push(`export${_}{${_}${namedReexports.map((specifier) => specifier.imported === specifier.reexported ? specifier.imported : `${specifier.imported} as ${specifier.reexported}`).join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
+            importBlock.push(`export${_}{${_}${namedReexports.map((specifier) => specifier.imported === specifier.reexported ? stringifyIdentifierIfNeeded(specifier.imported) : `${stringifyIdentifierIfNeeded(specifier.imported)} as ${stringifyIdentifierIfNeeded(specifier.reexported)}`).join(`,${_}`)}${_}}${_}from${_}${pathWithAssertion}`);
           }
         }
       }
@@ -100646,7 +100709,7 @@ var require_rollup = __commonJS({
         if (specifier.expression) {
           exportBlock.push(`${cnst} ${specifier.local}${_}=${_}${specifier.expression};`);
         }
-        exportDeclaration.push(specifier.exported === specifier.local ? specifier.local : `${specifier.local} as ${specifier.exported}`);
+        exportDeclaration.push(specifier.exported === specifier.local ? specifier.local : `${specifier.local} as ${stringifyIdentifierIfNeeded(specifier.exported)}`);
       }
       if (exportDeclaration.length > 0) {
         exportBlock.push(`export${_}{${_}${exportDeclaration.join(`,${_}`)}${_}};`);
@@ -100789,18 +100852,20 @@ var require_rollup = __commonJS({
             }
           }
           if (reexportedNames.length > 1 || hasStarReexport) {
-            const exportMapping = getObject(reexportedNames, { lineBreakIndent: null });
             if (hasStarReexport) {
               if (!starExcludes) {
                 starExcludes = getStarExcludes({ dependencies, exports: exports3 });
               }
+              reexportedNames.unshift([null, `__proto__:${_}null`]);
+              const exportMapping = getObject(reexportedNames, { lineBreakIndent: null });
               setter.push(`${cnst} setter${_}=${_}${exportMapping};`, `for${_}(${cnst} name in module)${_}{`, `${t}if${_}(!_starExcludes[name])${_}setter[name]${_}=${_}module[name];`, "}", "exports(setter);");
             } else {
+              const exportMapping = getObject(reexportedNames, { lineBreakIndent: null });
               setter.push(`exports(${exportMapping});`);
             }
           } else {
             const [key, value] = reexportedNames[0];
-            setter.push(`exports('${key}',${_}${value});`);
+            setter.push(`exports(${JSON.stringify(key)},${_}${value});`);
           }
         }
         setters.push(setter.join(`${n2}${t}${t}${t}`));
@@ -100820,7 +100885,19 @@ var require_rollup = __commonJS({
       }
       return starExcludes;
     };
-    var getStarExcludesBlock = (starExcludes, t, { _, cnst, getObject, n: n2 }) => starExcludes ? `${n2}${t}${cnst} _starExcludes${_}=${_}${getObject([...starExcludes].map((property) => [property, "1"]), { lineBreakIndent: { base: t, t } })};` : "";
+    var getStarExcludesBlock = (starExcludes, t, { _, cnst, getObject, n: n2 }) => {
+      if (starExcludes) {
+        const fields = [...starExcludes].map((property) => [
+          property,
+          "1"
+        ]);
+        fields.unshift([null, `__proto__:${_}null`]);
+        return `${n2}${t}${cnst} _starExcludes${_}=${_}${getObject(fields, {
+          lineBreakIndent: { base: t, t }
+        })};`;
+      }
+      return "";
+    };
     var getImportBindingsBlock = (importBindings, t, { _, n: n2 }) => importBindings.length > 0 ? `${n2}${t}var ${importBindings.join(`,${_}`)};` : "";
     var getHoistedExportsBlock = (exports3, t, snippets) => getExportsBlock(exports3.filter((expt) => expt.hoisted).map((expt) => ({ name: expt.exported, value: expt.local })), t, snippets);
     function getExportsBlock(exports3, t, { _, n: n2 }) {
@@ -100828,9 +100905,9 @@ var require_rollup = __commonJS({
         return "";
       }
       if (exports3.length === 1) {
-        return `exports('${exports3[0].name}',${_}${exports3[0].value});${n2}${n2}`;
+        return `exports(${JSON.stringify(exports3[0].name)},${_}${exports3[0].value});${n2}${n2}`;
       }
-      return `exports({${n2}` + exports3.map(({ name, value }) => `${t}${name}:${_}${value}`).join(`,${n2}`) + `${n2}});${n2}${n2}`;
+      return `exports({${n2}` + exports3.map(({ name, value }) => `${t}${stringifyObjectKeyIfNeeded(name)}:${_}${value}`).join(`,${n2}`) + `${n2}});${n2}${n2}`;
     }
     var getSyntheticExportsBlock = (exports3, t, snippets) => getExportsBlock(exports3.filter((expt) => expt.expression).map((expt) => ({ name: expt.exported, value: expt.local })), t, snippets);
     var getMissingExportsBlock = (exports3, t, snippets) => getExportsBlock(exports3.filter((expt) => expt.local === MISSING_EXPORT_SHIM_VARIABLE).map((expt) => ({ name: expt.exported, value: MISSING_EXPORT_SHIM_VARIABLE })), t, snippets);
@@ -100971,7 +101048,7 @@ ${outro}`;
         } else if (module3 instanceof ExternalModule && name === "default") {
           variable.setRenderNames(null, getSafeName([...module3.exportedVariables].some(([exportedVariable, exportedName]) => exportedName === "*" && exportedVariable.included) ? module3.suggestedVariableName + "__default" : module3.suggestedVariableName, usedNames, variable.forbiddenNames));
         } else {
-          variable.setRenderNames(null, getSafeName(name, usedNames, variable.forbiddenNames));
+          variable.setRenderNames(null, getSafeName(makeLegal(name), usedNames, variable.forbiddenNames));
         }
       }
       for (const variable of syntheticExports) {
@@ -101043,7 +101120,7 @@ ${outro}`;
               nameIndex += 9 * 64 ** (exportName.length - 1);
               exportName = toBase64(nameIndex);
             }
-          } while (RESERVED_NAMES$1.has(exportName) || exportsByName.has(exportName));
+          } while (RESERVED_NAMES.has(exportName) || exportsByName.has(exportName));
         }
         exportsByName.set(exportName, variable);
         exportNamesByVariable.set(variable, [exportName]);
@@ -101402,7 +101479,7 @@ ${outro}`;
           const [pattern, patternName] = preserveModules || this.facadeModule?.isUserDefinedEntryPoint ? [entryFileNames, "output.entryFileNames"] : [chunkFileNames, "output.chunkFileNames"];
           fileName = renderNamePattern(typeof pattern === "function" ? pattern(this.getPreRenderedChunkInfo()) : pattern, patternName, {
             format: () => format,
-            hash: (size) => hashPlaceholder || (hashPlaceholder = this.getPlaceholder(patternName, size)),
+            hash: (size) => hashPlaceholder || (hashPlaceholder = this.getPlaceholder(patternName, size || DEFAULT_HASH_SIZE)),
             name: () => this.getChunkName()
           });
           if (!hashPlaceholder) {
@@ -101428,7 +101505,7 @@ ${outro}`;
           sourcemapFileName = renderNamePattern(typeof pattern === "function" ? pattern(this.getPreRenderedChunkInfo()) : pattern, patternName, {
             chunkhash: () => this.getPreliminaryFileName().hashPlaceholder || "",
             format: () => format,
-            hash: (size) => hashPlaceholder || (hashPlaceholder = this.getPlaceholder(patternName, size)),
+            hash: (size) => hashPlaceholder || (hashPlaceholder = this.getPlaceholder(patternName, size || DEFAULT_HASH_SIZE)),
             name: () => this.getChunkName()
           });
           if (!hashPlaceholder) {
@@ -102144,9 +102221,12 @@ ${outro}`;
     function getChunkAssignments(entries, manualChunkAliasByEntry, minChunkSize, log) {
       const { chunkDefinitions, modulesInManualChunks } = getChunkDefinitionsFromManualChunks(manualChunkAliasByEntry);
       const { allEntries, dependentEntriesByModule, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry } = analyzeModuleGraph(entries);
-      const initialChunks = getChunksFromDependentEntries(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks));
-      removeUnnecessaryDependentEntries(initialChunks, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
-      chunkDefinitions.push(...getOptimizedChunks(getChunksFromDependentEntries(initialChunks), allEntries.length, minChunkSize, log).map(({ modules }) => ({
+      const chunkAtoms = getChunksWithSameDependentEntries(getModulesWithDependentEntries(dependentEntriesByModule, modulesInManualChunks));
+      const staticDependencyAtomsByEntry = getStaticDependencyAtomsByEntry(allEntries, chunkAtoms);
+      const alreadyLoadedAtomsByEntry = getAlreadyLoadedAtomsByEntry(staticDependencyAtomsByEntry, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries);
+      removeUnnecessaryDependentEntries(chunkAtoms, alreadyLoadedAtomsByEntry);
+      const { chunks, sideEffectAtoms, sizeByAtom } = getChunksWithSameDependentEntriesAndCorrelatedAtoms(chunkAtoms, staticDependencyAtomsByEntry, alreadyLoadedAtomsByEntry, minChunkSize);
+      chunkDefinitions.push(...getOptimizedChunks(chunks, minChunkSize, sideEffectAtoms, sizeByAtom, log).map(({ modules }) => ({
         alias: null,
         modules
       })));
@@ -102253,7 +102333,7 @@ ${outro}`;
       }
       return dynamicallyDependentEntriesByDynamicEntry;
     }
-    function getChunksFromDependentEntries(modulesWithDependentEntries) {
+    function getChunksWithSameDependentEntries(modulesWithDependentEntries) {
       const chunkModules = /* @__PURE__ */ Object.create(null);
       for (const { dependentEntries, modules } of modulesWithDependentEntries) {
         let chunkSignature = 0n;
@@ -102274,107 +102354,162 @@ ${outro}`;
         }
       }
     }
-    function removeUnnecessaryDependentEntries(chunks, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries) {
-      const staticDependenciesPerEntry = allEntries.map(() => 0n);
-      const alreadyLoadedChunksPerEntry = allEntries.map((_entry, entryIndex) => dynamicallyDependentEntriesByDynamicEntry.has(entryIndex) ? -1n : 0n);
-      let chunkMask = 1n;
-      for (const { dependentEntries } of chunks) {
+    function getStaticDependencyAtomsByEntry(allEntries, chunkAtoms) {
+      const staticDependencyAtomsByEntry = allEntries.map(() => 0n);
+      let atomMask = 1n;
+      for (const { dependentEntries } of chunkAtoms) {
         for (const entryIndex of dependentEntries) {
-          staticDependenciesPerEntry[entryIndex] |= chunkMask;
+          staticDependencyAtomsByEntry[entryIndex] |= atomMask;
         }
-        chunkMask <<= 1n;
+        atomMask <<= 1n;
       }
-      const updatedDynamicallyDependentEntriesByDynamicEntry = dynamicallyDependentEntriesByDynamicEntry;
-      for (const [dynamicEntryIndex, updatedDynamicallyDependentEntries] of updatedDynamicallyDependentEntriesByDynamicEntry) {
-        updatedDynamicallyDependentEntriesByDynamicEntry.delete(dynamicEntryIndex);
-        const previousLoadedModules = alreadyLoadedChunksPerEntry[dynamicEntryIndex];
-        let newLoadedModules = previousLoadedModules;
-        for (const entryIndex of updatedDynamicallyDependentEntries) {
-          newLoadedModules &= staticDependenciesPerEntry[entryIndex] | alreadyLoadedChunksPerEntry[entryIndex];
+      return staticDependencyAtomsByEntry;
+    }
+    function getAlreadyLoadedAtomsByEntry(staticDependencyAtomsByEntry, dynamicallyDependentEntriesByDynamicEntry, dynamicImportsByEntry, allEntries) {
+      const alreadyLoadedAtomsByEntry = allEntries.map((_entry, entryIndex) => dynamicallyDependentEntriesByDynamicEntry.has(entryIndex) ? -1n : 0n);
+      for (const [dynamicEntryIndex, dynamicallyDependentEntries] of dynamicallyDependentEntriesByDynamicEntry) {
+        dynamicallyDependentEntriesByDynamicEntry.delete(dynamicEntryIndex);
+        const knownLoadedAtoms = alreadyLoadedAtomsByEntry[dynamicEntryIndex];
+        let updatedLoadedAtoms = knownLoadedAtoms;
+        for (const entryIndex of dynamicallyDependentEntries) {
+          updatedLoadedAtoms &= staticDependencyAtomsByEntry[entryIndex] | alreadyLoadedAtomsByEntry[entryIndex];
         }
-        if (newLoadedModules !== previousLoadedModules) {
-          alreadyLoadedChunksPerEntry[dynamicEntryIndex] = newLoadedModules;
+        if (updatedLoadedAtoms !== knownLoadedAtoms) {
+          alreadyLoadedAtomsByEntry[dynamicEntryIndex] = updatedLoadedAtoms;
           for (const dynamicImport of dynamicImportsByEntry[dynamicEntryIndex]) {
-            getOrCreate(updatedDynamicallyDependentEntriesByDynamicEntry, dynamicImport, getNewSet).add(dynamicEntryIndex);
+            getOrCreate(dynamicallyDependentEntriesByDynamicEntry, dynamicImport, getNewSet).add(dynamicEntryIndex);
           }
         }
       }
-      chunkMask = 1n;
-      for (const { dependentEntries } of chunks) {
+      return alreadyLoadedAtomsByEntry;
+    }
+    function removeUnnecessaryDependentEntries(chunkAtoms, alreadyLoadedAtomsByEntry) {
+      let chunkMask = 1n;
+      for (const { dependentEntries } of chunkAtoms) {
         for (const entryIndex of dependentEntries) {
-          if ((alreadyLoadedChunksPerEntry[entryIndex] & chunkMask) === chunkMask) {
+          if ((alreadyLoadedAtomsByEntry[entryIndex] & chunkMask) === chunkMask) {
             dependentEntries.delete(entryIndex);
           }
         }
         chunkMask <<= 1n;
       }
     }
-    function getOptimizedChunks(initialChunks, numberOfEntries, minChunkSize, log) {
-      timeStart("optimize chunks", 3);
-      const chunkPartition = getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize);
-      if (!chunkPartition) {
-        timeEnd("optimize chunks", 3);
-        return initialChunks;
-      }
-      minChunkSize > 1 && log("info", parseAst_js.logOptimizeChunkStatus(initialChunks.length, chunkPartition.small.size, "Initially"));
-      mergeChunks(chunkPartition, minChunkSize);
-      minChunkSize > 1 && log("info", parseAst_js.logOptimizeChunkStatus(chunkPartition.small.size + chunkPartition.big.size, chunkPartition.small.size, "After merging chunks"));
-      timeEnd("optimize chunks", 3);
-      return [...chunkPartition.small, ...chunkPartition.big];
-    }
-    function getPartitionedChunks(initialChunks, numberOfEntries, minChunkSize) {
-      const smallChunks = [];
-      const bigChunks = [];
+    function getChunksWithSameDependentEntriesAndCorrelatedAtoms(chunkAtoms, staticDependencyAtomsByEntry, alreadyLoadedAtomsByEntry, minChunkSize) {
+      const chunksBySignature = /* @__PURE__ */ Object.create(null);
       const chunkByModule = /* @__PURE__ */ new Map();
       const sizeByAtom = [];
       let sideEffectAtoms = 0n;
-      let containedAtoms = 1n;
-      for (const { dependentEntries, modules } of initialChunks) {
-        const chunkDescription = {
-          containedAtoms,
-          correlatedAtoms: 0n,
+      let atomMask = 1n;
+      for (const { dependentEntries, modules } of chunkAtoms) {
+        let chunkSignature = 0n;
+        let correlatedAtoms = -1n;
+        for (const entryIndex of dependentEntries) {
+          chunkSignature |= 1n << BigInt(entryIndex);
+          correlatedAtoms &= staticDependencyAtomsByEntry[entryIndex] | alreadyLoadedAtomsByEntry[entryIndex];
+        }
+        const chunk = chunksBySignature[String(chunkSignature)] ||= {
+          containedAtoms: 0n,
+          correlatedAtoms,
           dependencies: /* @__PURE__ */ new Set(),
           dependentChunks: /* @__PURE__ */ new Set(),
-          dependentEntries,
-          modules,
+          dependentEntries: new Set(dependentEntries),
+          modules: [],
           pure: true,
           size: 0
         };
-        let size = 0;
+        let atomSize = 0;
         let pure = true;
         for (const module3 of modules) {
-          chunkByModule.set(module3, chunkDescription);
+          chunkByModule.set(module3, chunk);
           if (module3.isIncluded()) {
             pure &&= !module3.hasEffects();
-            size += minChunkSize > 1 ? module3.estimateSize() : 1;
+            atomSize += minChunkSize > 1 ? module3.estimateSize() : 1;
           }
         }
-        chunkDescription.pure = pure;
-        chunkDescription.size = size;
-        sizeByAtom.push(size);
         if (!pure) {
-          sideEffectAtoms |= containedAtoms;
+          sideEffectAtoms |= atomMask;
         }
-        (size < minChunkSize ? smallChunks : bigChunks).push(chunkDescription);
-        containedAtoms <<= 1n;
+        sizeByAtom.push(atomSize);
+        chunk.containedAtoms |= atomMask;
+        chunk.modules.push(...modules);
+        chunk.pure &&= pure;
+        chunk.size += atomSize;
+        atomMask <<= 1n;
+      }
+      const chunks = Object.values(chunksBySignature);
+      sideEffectAtoms |= addChunkDependenciesAndGetExternalSideEffectAtoms(chunks, chunkByModule, atomMask);
+      return { chunks, sideEffectAtoms, sizeByAtom };
+    }
+    function addChunkDependenciesAndGetExternalSideEffectAtoms(chunks, chunkByModule, nextAvailableAtomMask) {
+      const signatureByExternalModule = /* @__PURE__ */ new Map();
+      let externalSideEffectAtoms = 0n;
+      for (const chunk of chunks) {
+        const { dependencies, modules } = chunk;
+        for (const module3 of modules) {
+          for (const dependency of module3.getDependenciesToBeIncluded()) {
+            if (dependency instanceof ExternalModule) {
+              if (dependency.info.moduleSideEffects) {
+                const signature = getOrCreate(signatureByExternalModule, dependency, () => {
+                  const signature2 = nextAvailableAtomMask;
+                  nextAvailableAtomMask <<= 1n;
+                  externalSideEffectAtoms |= signature2;
+                  return signature2;
+                });
+                chunk.containedAtoms |= signature;
+                chunk.correlatedAtoms |= signature;
+              }
+            } else {
+              const dependencyChunk = chunkByModule.get(dependency);
+              if (dependencyChunk && dependencyChunk !== chunk) {
+                dependencies.add(dependencyChunk);
+                dependencyChunk.dependentChunks.add(chunk);
+              }
+            }
+          }
+        }
+      }
+      return externalSideEffectAtoms;
+    }
+    function getOptimizedChunks(chunks, minChunkSize, sideEffectAtoms, sizeByAtom, log) {
+      timeStart("optimize chunks", 3);
+      const chunkPartition = getPartitionedChunks(chunks, minChunkSize);
+      if (!chunkPartition) {
+        timeEnd("optimize chunks", 3);
+        return chunks;
+      }
+      minChunkSize > 1 && log("info", parseAst_js.logOptimizeChunkStatus(chunks.length, chunkPartition.small.size, "Initially"));
+      mergeChunks(chunkPartition, minChunkSize, sideEffectAtoms, sizeByAtom);
+      minChunkSize > 1 && log("info", parseAst_js.logOptimizeChunkStatus(chunkPartition.small.size + chunkPartition.big.size, chunkPartition.small.size, "After merging chunks"));
+      timeEnd("optimize chunks", 3);
+      return [...chunkPartition.small, ...chunkPartition.big];
+    }
+    function getPartitionedChunks(chunks, minChunkSize) {
+      const smallChunks = [];
+      const bigChunks = [];
+      for (const chunk of chunks) {
+        (chunk.size < minChunkSize ? smallChunks : bigChunks).push(chunk);
       }
       if (smallChunks.length === 0) {
         return null;
       }
-      sideEffectAtoms |= addChunkDependenciesAndAtomsAndGetSideEffectAtoms([bigChunks, smallChunks], chunkByModule, numberOfEntries, containedAtoms);
+      smallChunks.sort(compareChunkSize);
+      bigChunks.sort(compareChunkSize);
       return {
         big: new Set(bigChunks),
-        sideEffectAtoms,
-        sizeByAtom,
         small: new Set(smallChunks)
       };
     }
-    function mergeChunks(chunkPartition, minChunkSize) {
+    function compareChunkSize({ size: sizeA }, { size: sizeB }) {
+      return sizeA - sizeB;
+    }
+    function mergeChunks(chunkPartition, minChunkSize, sideEffectAtoms, sizeByAtom) {
       const { small } = chunkPartition;
       for (const mergedChunk of small) {
         const bestTargetChunk = findBestMergeTarget(
           mergedChunk,
           chunkPartition,
+          sideEffectAtoms,
+          sizeByAtom,
           // In the default case, we do not accept size increases
           minChunkSize <= 1 ? 1 : Infinity
         );
@@ -102407,55 +102542,7 @@ ${outro}`;
         }
       }
     }
-    function addChunkDependenciesAndAtomsAndGetSideEffectAtoms(chunkLists, chunkByModule, numberOfEntries, nextAtomSignature) {
-      const signatureByExternalModule = /* @__PURE__ */ new Map();
-      let sideEffectAtoms = 0n;
-      const atomsByEntry = [];
-      for (let index = 0; index < numberOfEntries; index++) {
-        atomsByEntry.push(0n);
-      }
-      for (const chunks of chunkLists) {
-        chunks.sort(compareChunkSize);
-        for (const chunk of chunks) {
-          const { dependencies, dependentEntries, modules } = chunk;
-          for (const module3 of modules) {
-            for (const dependency of module3.getDependenciesToBeIncluded()) {
-              if (dependency instanceof ExternalModule) {
-                if (dependency.info.moduleSideEffects) {
-                  chunk.containedAtoms |= getOrCreate(signatureByExternalModule, dependency, () => {
-                    const signature = nextAtomSignature;
-                    nextAtomSignature <<= 1n;
-                    sideEffectAtoms |= signature;
-                    return signature;
-                  });
-                }
-              } else {
-                const dependencyChunk = chunkByModule.get(dependency);
-                if (dependencyChunk && dependencyChunk !== chunk) {
-                  dependencies.add(dependencyChunk);
-                  dependencyChunk.dependentChunks.add(chunk);
-                }
-              }
-            }
-          }
-          const { containedAtoms } = chunk;
-          for (const entryIndex of dependentEntries) {
-            atomsByEntry[entryIndex] |= containedAtoms;
-          }
-        }
-      }
-      for (const chunks of chunkLists) {
-        for (const chunk of chunks) {
-          const { dependentEntries } = chunk;
-          chunk.correlatedAtoms = -1n;
-          for (const entryIndex of dependentEntries) {
-            chunk.correlatedAtoms &= atomsByEntry[entryIndex];
-          }
-        }
-      }
-      return sideEffectAtoms;
-    }
-    function findBestMergeTarget(mergedChunk, { big, sideEffectAtoms, sizeByAtom, small }, smallestAdditionalSize) {
+    function findBestMergeTarget(mergedChunk, { big, small }, sideEffectAtoms, sizeByAtom, smallestAdditionalSize) {
       let bestTargetChunk = null;
       for (const targetChunk of concatLazy([small, big])) {
         if (mergedChunk === targetChunk)
@@ -102470,12 +102557,6 @@ ${outro}`;
       }
       return bestTargetChunk;
     }
-    function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
-      return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
-    }
-    function compareChunkSize({ size: sizeA }, { size: sizeB }) {
-      return sizeA - sizeB;
-    }
     function getAdditionalSizeAfterMerge(mergedChunk, targetChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom) {
       const firstSize = getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(mergedChunk, targetChunk, currentAdditionalSize, sideEffectAtoms, sizeByAtom);
       return firstSize < currentAdditionalSize ? firstSize + getAdditionalSizeIfNoTransitiveDependencyOrNonCorrelatedSideEffect(targetChunk, mergedChunk, currentAdditionalSize - firstSize, sideEffectAtoms, sizeByAtom) : Infinity;
@@ -102519,15 +102600,18 @@ ${outro}`;
       }
       return size;
     }
+    function getChunksInPartition(chunk, minChunkSize, chunkPartition) {
+      return chunk.size < minChunkSize ? chunkPartition.small : chunkPartition.big;
+    }
     function commondir(files) {
       if (files.length === 0)
         return "/";
       if (files.length === 1)
         return node_path.dirname(files[0]);
       const commonSegments = files.slice(1).reduce((commonSegments2, file) => {
-        const pathSegements = file.split(/\/+|\\+/);
+        const pathSegments = file.split(/\/+|\\+/);
         let index;
-        for (index = 0; commonSegments2[index] === pathSegements[index] && index < Math.min(commonSegments2.length, pathSegements.length); index++)
+        for (index = 0; commonSegments2[index] === pathSegments[index] && index < Math.min(commonSegments2.length, pathSegments.length); index++)
           ;
         return commonSegments2.slice(0, index);
       }, files[0].split(/\/+|\\+/));
@@ -102613,7 +102697,7 @@ ${outro}`;
         })}${arrowFunctions ? lineBreakIndent ? `${n2}${lineBreakIndent.base}${lineBreakIndent.t}` : "" : `{${lineBreakIndent ? `${n2}${lineBreakIndent.base}${lineBreakIndent.t}` : _}${functionReturn ? "return " : ""}`}`,
         arrowFunctions ? `${name ? ";" : ""}${lineBreakIndent ? `${n2}${lineBreakIndent.base}` : ""}` : `${s}${lineBreakIndent ? `${n2}${lineBreakIndent.base}` : _}}`
       ];
-      const isValidPropertyName = reservedNamesAsProps ? (name) => validPropertyName.test(name) : (name) => !RESERVED_NAMES$1.has(name) && validPropertyName.test(name);
+      const isValidPropertyName = reservedNamesAsProps ? (name) => VALID_IDENTIFIER_REGEXP.test(name) : (name) => !RESERVED_NAMES.has(name) && VALID_IDENTIFIER_REGEXP.test(name);
       return {
         _,
         cnst,
@@ -102633,8 +102717,8 @@ ${outro}`;
           return `{${fields.map(([key, value]) => {
             if (key === null)
               return `${prefix}${value}`;
-            const needsQuotes = !isValidPropertyName(key);
-            return key === value && objectShorthand && !needsQuotes ? prefix + key : `${prefix}${needsQuotes ? `'${key}'` : key}:${_}${value}`;
+            const keyInObject = stringifyObjectKeyIfNeeded(key);
+            return key === value && objectShorthand && key === keyInObject ? prefix + key : `${prefix}${keyInObject}:${_}${value}`;
           }).join(`,`)}${fields.length === 0 ? "" : lineBreakIndent ? `${n2}${lineBreakIndent.base}` : _}}`;
         },
         getPropertyAccess: (name) => isValidPropertyName(name) ? `.${name}` : `[${JSON.stringify(name)}]`,
@@ -102643,7 +102727,6 @@ ${outro}`;
       };
     }
     var wrapIfNeeded = (code, needsParens) => needsParens ? `(${code})` : code;
-    var validPropertyName = /^(?!\d)[\w$]+$/;
     var Source = class {
       constructor(filename, content) {
         this.isOriginal = true;
@@ -102791,9 +102874,10 @@ ${outro}`;
       const renderedChunks = await Promise.all(chunks.map((chunk) => chunk.render()));
       timeEnd("render chunks", 2);
       timeStart("transform chunks", 2);
+      const getHash = hasherByType[outputOptions.hashCharacters];
       const chunkGraph = getChunkGraph(chunks);
-      const { initialHashesByPlaceholder, nonHashedChunksWithPlaceholders, renderedChunksByPlaceholder, hashDependenciesByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, log);
-      const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, bundle);
+      const { initialHashesByPlaceholder, nonHashedChunksWithPlaceholders, renderedChunksByPlaceholder, hashDependenciesByPlaceholder } = await transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, getHash, log);
+      const hashesByPlaceholder = generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, bundle, getHash);
       addChunksToBundle(renderedChunksByPlaceholder, hashesByPlaceholder, bundle, nonHashedChunksWithPlaceholders, pluginDriver, outputOptions);
       timeEnd("transform chunks", 2);
     }
@@ -102871,7 +102955,7 @@ ${outro}`;
         map
       };
     }
-    async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, log) {
+    async function transformChunksAndGenerateContentHashes(renderedChunks, chunkGraph, outputOptions, pluginDriver, getHash, log) {
       const nonHashedChunksWithPlaceholders = [];
       const renderedChunksByPlaceholder = /* @__PURE__ */ new Map();
       const hashDependenciesByPlaceholder = /* @__PURE__ */ new Map();
@@ -102904,14 +102988,14 @@ ${outro}`;
           renderedChunksByPlaceholder.set(hashPlaceholder, transformedChunk);
           hashDependenciesByPlaceholder.set(hashPlaceholder, {
             containedPlaceholders,
-            contentHash: getXxhash(contentToHash)
+            contentHash: getHash(contentToHash)
           });
         } else {
           nonHashedChunksWithPlaceholders.push(transformedChunk);
         }
         const sourcemapHashPlaceholder = preliminarySourcemapFileName?.hashPlaceholder;
         if (map && sourcemapHashPlaceholder) {
-          initialHashesByPlaceholder.set(preliminarySourcemapFileName.hashPlaceholder, getXxhash(map.toString()).slice(0, preliminarySourcemapFileName.hashPlaceholder.length));
+          initialHashesByPlaceholder.set(preliminarySourcemapFileName.hashPlaceholder, getHash(map.toString()).slice(0, preliminarySourcemapFileName.hashPlaceholder.length));
         }
       }));
       return {
@@ -102921,7 +103005,7 @@ ${outro}`;
         renderedChunksByPlaceholder
       };
     }
-    function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, bundle) {
+    function generateFinalHashes(renderedChunksByPlaceholder, hashDependenciesByPlaceholder, initialHashesByPlaceholder, bundle, getHash) {
       const hashesByPlaceholder = new Map(initialHashesByPlaceholder);
       for (const [placeholder, { fileName }] of renderedChunksByPlaceholder) {
         let contentToHash = "";
@@ -102939,7 +103023,7 @@ ${outro}`;
           if (finalHash) {
             contentToHash = finalHash;
           }
-          finalHash = getXxhash(contentToHash).slice(0, placeholder.length);
+          finalHash = getHash(contentToHash).slice(0, placeholder.length);
           finalFileName = replaceSinglePlaceholder(fileName, placeholder, finalHash);
         } while (bundle[lowercaseBundleKeys].has(finalFileName.toLowerCase()));
         bundle[finalFileName] = FILE_PLACEHOLDER;
@@ -104163,6 +104247,7 @@ ${outro}`;
         freeze: config.freeze ?? true,
         generatedCode,
         globals: config.globals || {},
+        hashCharacters: config.hashCharacters ?? "base64",
         hoistTransitiveImports: config.hoistTransitiveImports ?? true,
         indent: getIndent(config, compact),
         inlineDynamicImports,
@@ -104439,7 +104524,9 @@ ${outro}`;
             return parseAst_js.error(parseAst_js.logAlreadyClosed());
           return handleGenerateWrite(false, inputOptions, unsetInputOptions, rawOutputOptions, graph);
         },
-        watchFiles: Object.keys(graph.watchFiles),
+        get watchFiles() {
+          return Object.keys(graph.watchFiles);
+        },
         async write(rawOutputOptions) {
           if (result.closed)
             return parseAst_js.error(parseAst_js.logAlreadyClosed());
@@ -104580,9 +104667,9 @@ ${outro}`;
   }
 });
 
-// node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/shared/fsevents-importer.js
+// node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/shared/fsevents-importer.js
 var require_fsevents_importer = __commonJS({
-  "node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/shared/fsevents-importer.js"(exports2) {
+  "node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/shared/fsevents-importer.js"(exports2) {
     "use strict";
     var fsEvents;
     var fsEventsImportError;
@@ -104608,9 +104695,9 @@ var require_fsevents_importer = __commonJS({
   }
 });
 
-// node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/shared/index.js
+// node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/shared/index.js
 var require_shared = __commonJS({
-  "node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/shared/index.js"(exports2) {
+  "node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/shared/index.js"(exports2) {
     "use strict";
     var rollup = require_rollup();
     var require$$0$1 = require("fs");
@@ -106420,6 +106507,7 @@ var require_shared = __commonJS({
       exports3.FSEVENT_MOVED = "moved";
       exports3.FSEVENT_CLONED = "cloned";
       exports3.FSEVENT_UNKNOWN = "unknown";
+      exports3.FSEVENT_FLAG_MUST_SCAN_SUBDIRS = 1;
       exports3.FSEVENT_TYPE_FILE = "file";
       exports3.FSEVENT_TYPE_DIRECTORY = "directory";
       exports3.FSEVENT_TYPE_SYMLINK = "symlink";
@@ -106990,6 +107078,7 @@ var require_shared = __commonJS({
       FSEVENT_MOVED,
       // FSEVENT_CLONED,
       FSEVENT_UNKNOWN,
+      FSEVENT_FLAG_MUST_SCAN_SUBDIRS,
       FSEVENT_TYPE_FILE,
       FSEVENT_TYPE_DIRECTORY,
       FSEVENT_TYPE_SYMLINK,
@@ -107054,6 +107143,8 @@ var require_shared = __commonJS({
           watcher: createFSEventsInstance(watchPath, (fullPath, flags) => {
             if (!cont.listeners.size)
               return;
+            if (flags & FSEVENT_FLAG_MUST_SCAN_SUBDIRS)
+              return;
             const info = fsevents.getInfo(fullPath, flags);
             cont.listeners.forEach((list) => {
               list(fullPath, flags, info);
@@ -107717,7 +107808,7 @@ var require_shared = __commonJS({
           if (!this._readyCount)
             this._readyCount = paths.length;
           if (this.options.persistent)
-            this._readyCount *= 2;
+            this._readyCount += paths.length;
           paths.forEach((path2) => this._fsEventsHandler._addToFsEvents(path2));
         } else {
           if (!this._readyCount)
@@ -108171,9 +108262,9 @@ var require_shared = __commonJS({
   }
 });
 
-// node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/shared/watch.js
+// node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/shared/watch.js
 var require_watch = __commonJS({
-  "node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/shared/watch.js"(exports2) {
+  "node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/shared/watch.js"(exports2) {
     "use strict";
     Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
     var node_path = require("node:path");
@@ -108404,7 +108495,13 @@ var require_watch = __commonJS({
             return;
           }
           this.updateWatchedFiles(result);
-          this.skipWrite || await Promise.all(this.outputs.map((output) => result.write(output)));
+          if (!this.skipWrite) {
+            await Promise.all(this.outputs.map((output) => result.write(output)));
+            if (this.closed) {
+              return;
+            }
+            this.updateWatchedFiles(result);
+          }
           await this.watcher.emitter.emit("event", {
             code: "BUNDLE_END",
             duration: Date.now() - start,
@@ -108464,13 +108561,21 @@ var require_watch = __commonJS({
   }
 });
 
-// node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/shared/watch-proxy.js
-var require_watch_proxy = __commonJS({
-  "node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/shared/watch-proxy.js"(exports2) {
+// node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/rollup.js
+var require_rollup2 = __commonJS({
+  "node_modules/.pnpm/rollup@4.10.0/node_modules/rollup/dist/rollup.js"(exports2) {
     "use strict";
+    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
     var rollup = require_rollup();
     var parseAst_js = require_parseAst();
     var fseventsImporter = require_fsevents_importer();
+    require("node:process");
+    require("tty");
+    require("node:path");
+    require("path");
+    require("node:perf_hooks");
+    require_native();
+    require("node:fs/promises");
     var WatchEmitter = class {
       constructor() {
         this.currentHandlers = /* @__PURE__ */ Object.create(null);
@@ -108538,30 +108643,10 @@ var require_watch_proxy = __commonJS({
       const { Watcher } = await Promise.resolve().then(() => require_watch());
       new Watcher(watchOptionsList, emitter);
     }
-    exports2.watch = watch;
-  }
-});
-
-// node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/rollup.js
-var require_rollup2 = __commonJS({
-  "node_modules/.pnpm/rollup@4.5.2/node_modules/rollup/dist/rollup.js"(exports2) {
-    "use strict";
-    Object.defineProperty(exports2, Symbol.toStringTag, { value: "Module" });
-    var rollup = require_rollup();
-    var watchProxy = require_watch_proxy();
-    require_parseAst();
-    require_native();
-    require("node:path");
-    require("node:process");
-    require("tty");
-    require("path");
-    require("node:perf_hooks");
-    require("node:fs/promises");
-    require_fsevents_importer();
     exports2.VERSION = rollup.version;
     exports2.defineConfig = rollup.defineConfig;
     exports2.rollup = rollup.rollup;
-    exports2.watch = watchProxy.watch;
+    exports2.watch = watch;
   }
 });
 
@@ -118504,8 +118589,8 @@ cosmiconfig/dist/ExplorerSync.js:
 rollup/dist/shared/parseAst.js:
   (*
     @license
-  	Rollup.js v4.5.2
-  	Fri, 24 Nov 2023 06:29:16 GMT - commit 2e94641971195c1a4eb9e1a3fe6d73b9d04ffae0
+  	Rollup.js v4.10.0
+  	Sat, 10 Feb 2024 05:58:12 GMT - commit 762420860765e8e46e24d48b38f5b98ca31735fa
   
   	https://github.com/rollup/rollup
   
@@ -118515,8 +118600,8 @@ rollup/dist/shared/parseAst.js:
 rollup/dist/shared/rollup.js:
   (*
     @license
-  	Rollup.js v4.5.2
-  	Fri, 24 Nov 2023 06:29:16 GMT - commit 2e94641971195c1a4eb9e1a3fe6d73b9d04ffae0
+  	Rollup.js v4.10.0
+  	Sat, 10 Feb 2024 05:58:12 GMT - commit 762420860765e8e46e24d48b38f5b98ca31735fa
   
   	https://github.com/rollup/rollup
   
@@ -118526,8 +118611,8 @@ rollup/dist/shared/rollup.js:
 rollup/dist/shared/fsevents-importer.js:
   (*
     @license
-  	Rollup.js v4.5.2
-  	Fri, 24 Nov 2023 06:29:16 GMT - commit 2e94641971195c1a4eb9e1a3fe6d73b9d04ffae0
+  	Rollup.js v4.10.0
+  	Sat, 10 Feb 2024 05:58:12 GMT - commit 762420860765e8e46e24d48b38f5b98ca31735fa
   
   	https://github.com/rollup/rollup
   
@@ -118537,8 +118622,8 @@ rollup/dist/shared/fsevents-importer.js:
 rollup/dist/shared/index.js:
   (*
     @license
-  	Rollup.js v4.5.2
-  	Fri, 24 Nov 2023 06:29:16 GMT - commit 2e94641971195c1a4eb9e1a3fe6d73b9d04ffae0
+  	Rollup.js v4.10.0
+  	Sat, 10 Feb 2024 05:58:12 GMT - commit 762420860765e8e46e24d48b38f5b98ca31735fa
   
   	https://github.com/rollup/rollup
   
@@ -118584,19 +118669,8 @@ rollup/dist/shared/index.js:
 rollup/dist/shared/watch.js:
   (*
     @license
-  	Rollup.js v4.5.2
-  	Fri, 24 Nov 2023 06:29:16 GMT - commit 2e94641971195c1a4eb9e1a3fe6d73b9d04ffae0
-  
-  	https://github.com/rollup/rollup
-  
-  	Released under the MIT License.
-  *)
-
-rollup/dist/shared/watch-proxy.js:
-  (*
-    @license
-  	Rollup.js v4.5.2
-  	Fri, 24 Nov 2023 06:29:16 GMT - commit 2e94641971195c1a4eb9e1a3fe6d73b9d04ffae0
+  	Rollup.js v4.10.0
+  	Sat, 10 Feb 2024 05:58:12 GMT - commit 762420860765e8e46e24d48b38f5b98ca31735fa
   
   	https://github.com/rollup/rollup
   
@@ -118606,8 +118680,8 @@ rollup/dist/shared/watch-proxy.js:
 rollup/dist/rollup.js:
   (*
     @license
-  	Rollup.js v4.5.2
-  	Fri, 24 Nov 2023 06:29:16 GMT - commit 2e94641971195c1a4eb9e1a3fe6d73b9d04ffae0
+  	Rollup.js v4.10.0
+  	Sat, 10 Feb 2024 05:58:12 GMT - commit 762420860765e8e46e24d48b38f5b98ca31735fa
   
   	https://github.com/rollup/rollup