@rollup/wasm-node 4.14.3 → 4.16.0

package/dist/shared/rollup.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.14.3
-	Mon, 15 Apr 2024 07:18:00 GMT - commit e64f3d8d0cdc561f00d3efe503e3081f81889679
+	Rollup.js v4.16.0
+	Sun, 21 Apr 2024 04:41:09 GMT - commit 38fe70780cb7e374b47da99e3a3dca6b2a2170d2
 
 	https://github.com/rollup/rollup
 
@@ -31,7 +31,7 @@ function _interopNamespaceDefault(e) {
 
 const tty__namespace = /*#__PURE__*/_interopNamespaceDefault(tty);
 
-var version = "4.14.3";
+var version = "4.16.0";
 
 function ensureArray$1(items) {
     if (Array.isArray(items)) {
@@ -1262,6 +1262,7 @@ async function mergeOutputOptions(config, overrides, log) {
         globals: getOption('globals'),
         hashCharacters: getOption('hashCharacters'),
         hoistTransitiveImports: getOption('hoistTransitiveImports'),
+        importAttributesKey: getOption('importAttributesKey'),
         indent: getOption('indent'),
         inlineDynamicImports: getOption('inlineDynamicImports'),
         interop: getOption('interop'),
@@ -3392,6 +3393,9 @@ const NODE_INTERACTION_UNKNOWN_CALL = {
 };
 
 class Variable extends ExpressionEntity {
+    markReassigned() {
+        this.isReassigned = true;
+    }
     constructor(name) {
         super();
         this.name = name;
@@ -3399,16 +3403,36 @@ class Variable extends ExpressionEntity {
         this.forbiddenNames = null;
         this.initReached = false;
         this.isId = false;
-        this.isReassigned = false;
         this.kind = null;
         this.renderBaseName = null;
         this.renderName = null;
+        this.isReassigned = false;
+        this.onlyFunctionCallUsed = true;
     }
     /**
      * Binds identifiers that reference this variable to this variable.
      * Necessary to be able to change variable names.
      */
     addReference(_identifier) { }
+    /**
+     * Check if the identifier variable is only used as function call
+     * Forward the check to the export default variable if it is only used once
+     * @returns true if the variable is only used as function call
+     */
+    getOnlyFunctionCallUsed() {
+        return this.onlyFunctionCallUsed;
+    }
+    /**
+     * Collect the places where the identifier variable is used
+     * @param usedPlace Where the variable is used
+     */
+    addUsedPlace(usedPlace) {
+        const isFunctionCall = usedPlace.parent.type === parseAst_js.CallExpression &&
+            usedPlace.parent.callee === usedPlace;
+        if (!isFunctionCall && usedPlace.parent.type !== parseAst_js.ExportDefaultDeclaration) {
+            this.onlyFunctionCallUsed = false;
+        }
+    }
     /**
      * Prevent this variable from being renamed to this name to avoid name
      * collisions
@@ -7146,7 +7170,7 @@ class LocalVariable extends Variable {
             return;
         }
         if (path.length === 0) {
-            this.isReassigned = true;
+            this.markReassigned();
             const expressionsToBeDeoptimized = this.expressionsToBeDeoptimized;
             this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
             for (const expression of expressionsToBeDeoptimized) {
@@ -7240,7 +7264,7 @@ class LocalVariable extends Variable {
         if (this.additionalInitializers === null) {
             this.additionalInitializers = [this.init];
             this.init = UNKNOWN_EXPRESSION;
-            this.isReassigned = true;
+            this.markReassigned();
         }
         return this.additionalInitializers;
     }
@@ -7258,6 +7282,8 @@ class ParameterVariable extends LocalVariable {
         this.deoptimizations = new PathTracker();
         this.deoptimizedFields = new Set();
         this.entitiesToBeDeoptimized = new Set();
+        this.knownExpressionsToBeDeoptimized = [];
+        this.knownValue = UNKNOWN_EXPRESSION;
     }
     addEntityToBeDeoptimized(entity) {
         if (entity === UNKNOWN_EXPRESSION) {
@@ -7287,6 +7313,47 @@ class ParameterVariable extends LocalVariable {
             }
         }
     }
+    markReassigned() {
+        if (this.isReassigned) {
+            return;
+        }
+        super.markReassigned();
+        for (const expression of this.knownExpressionsToBeDeoptimized) {
+            expression.deoptimizeCache();
+        }
+        this.knownExpressionsToBeDeoptimized = [];
+    }
+    /**
+     * If we are sure about the value of this parameter, we can set it here.
+     * It can be a literal or the only possible value of the parameter.
+     * an undefined value means that the parameter is not known.
+     * @param value The known value of the parameter to be set.
+     */
+    setKnownValue(value) {
+        if (this.isReassigned) {
+            return;
+        }
+        if (this.knownValue !== value) {
+            for (const expression of this.knownExpressionsToBeDeoptimized) {
+                expression.deoptimizeCache();
+            }
+            this.knownExpressionsToBeDeoptimized = [];
+        }
+        this.knownValue = value;
+    }
+    getLiteralValueAtPath(path, recursionTracker, origin) {
+        if (this.isReassigned) {
+            return UnknownValue;
+        }
+        this.knownExpressionsToBeDeoptimized.push(origin);
+        return recursionTracker.withTrackedEntityAtPath(path, this.knownValue, () => this.knownValue.getLiteralValueAtPath(path, recursionTracker, origin), UnknownValue);
+    }
+    hasEffectsOnInteractionAtPath(path, interaction, context) {
+        // assigned is a bit different, since the value has a new name (the parameter)
+        return interaction.type === INTERACTION_ASSIGNED
+            ? super.hasEffectsOnInteractionAtPath(path, interaction, context)
+            : this.knownValue.hasEffectsOnInteractionAtPath(path, interaction, context);
+    }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path) {
         // For performance reasons, we fully deoptimize all deeper interactions
         if (path.length >= 2 ||
@@ -7311,7 +7378,11 @@ class ParameterVariable extends LocalVariable {
         }
     }
     deoptimizePath(path) {
-        if (path.length === 0 || this.deoptimizedFields.has(UnknownKey)) {
+        if (this.deoptimizedFields.has(UnknownKey)) {
+            return;
+        }
+        if (path.length === 0) {
+            this.markReassigned();
             return;
         }
         const key = path[0];
@@ -8673,11 +8744,11 @@ function getGlobalAtPath(path) {
 }
 
 class GlobalVariable extends Variable {
-    constructor() {
-        super(...arguments);
+    constructor(name) {
+        super(name);
         // Ensure we use live-bindings for globals as we do not know if they have
         // been reassigned
-        this.isReassigned = true;
+        this.markReassigned();
     }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
         switch (interaction.type) {
@@ -8731,6 +8802,7 @@ class Identifier extends NodeBase {
     constructor() {
         super(...arguments);
         this.variable = null;
+        this.isReferenceVariable = false;
     }
     get isTDZAccess() {
         if (!isFlagSet(this.flags, 4 /* Flag.tdzAccessDefined */)) {
@@ -8751,6 +8823,7 @@ class Identifier extends NodeBase {
         if (!this.variable && is_reference(this, this.parent)) {
             this.variable = this.scope.findVariable(this.name);
             this.variable.addReference(this);
+            this.isReferenceVariable = true;
         }
     }
     declare(kind, init) {
@@ -8913,6 +8986,9 @@ class Identifier extends NodeBase {
             this.variable.consolidateInitializers();
             this.scope.context.requestTreeshakingPass();
         }
+        if (this.isReferenceVariable) {
+            this.variable.addUsedPlace(this);
+        }
     }
     getVariableRespectingTDZ() {
         if (this.isPossibleTDZ()) {
@@ -9232,10 +9308,17 @@ class RestElement extends NodeBase {
     }
 }
 
+// This handler does nothing.
+// Since we always re-evaluate argument values in a new tree-shaking pass,
+// we don't need to get notified if it is deoptimized.
+const EMPTY_DEOPTIMIZABLE_HANDLER = { deoptimizeCache() { } };
 class FunctionBase extends NodeBase {
     constructor() {
         super(...arguments);
+        this.knownParameterValues = [];
+        this.allArguments = [];
         this.objectEntity = null;
+        this.functionParametersOptimized = false;
     }
     get async() {
         return isFlagSet(this.flags, 256 /* Flag.async */);
@@ -9255,6 +9338,87 @@ class FunctionBase extends NodeBase {
     set generator(value) {
         this.flags = setFlag(this.flags, 4194304 /* Flag.generator */, value);
     }
+    /**
+     * update knownParameterValues when a call is made to this function
+     * @param newArguments arguments of the call
+     */
+    updateKnownParameterValues(newArguments) {
+        for (let position = 0; position < this.params.length; position++) {
+            // only the "this" argument newArguments[0] can be null
+            // it's possible that some arguments are empty, so the value is undefined
+            const argument = newArguments[position + 1] ?? UNDEFINED_EXPRESSION;
+            const parameter = this.params[position];
+            // RestElement can be, and can only be, the last parameter
+            if (parameter instanceof RestElement) {
+                return;
+            }
+            const knownParameterValue = this.knownParameterValues[position];
+            if (knownParameterValue === undefined) {
+                this.knownParameterValues[position] = argument;
+                continue;
+            }
+            if (knownParameterValue === UNKNOWN_EXPRESSION ||
+                knownParameterValue === argument ||
+                (knownParameterValue instanceof Identifier &&
+                    argument instanceof Identifier &&
+                    knownParameterValue.variable === argument.variable)) {
+                continue;
+            }
+            const oldValue = knownParameterValue.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, EMPTY_DEOPTIMIZABLE_HANDLER);
+            const newValue = argument.getLiteralValueAtPath(EMPTY_PATH, SHARED_RECURSION_TRACKER, EMPTY_DEOPTIMIZABLE_HANDLER);
+            if (oldValue !== newValue || typeof oldValue === 'symbol') {
+                this.knownParameterValues[position] = UNKNOWN_EXPRESSION;
+            } // else both are the same literal, no need to update
+        }
+    }
+    forwardArgumentsForFunctionCalledOnce(newArguments) {
+        for (let position = 0; position < this.params.length; position++) {
+            const parameter = this.params[position];
+            if (parameter instanceof Identifier) {
+                const ParameterVariable = parameter.variable;
+                const argument = newArguments[position + 1] ?? UNDEFINED_EXPRESSION;
+                ParameterVariable?.setKnownValue(argument);
+            }
+        }
+    }
+    /**
+     * each time tree-shake starts, this method should be called to reoptimize the parameters
+     * a parameter's state will change at most twice:
+     *   `undefined` (no call is made) -> an expression -> `UnknownArgument`
+     * we are sure it will converge, and can use state from last iteration
+     */
+    applyFunctionParameterOptimization() {
+        if (this.allArguments.length === 0) {
+            return;
+        }
+        if (this.allArguments.length === 1) {
+            // we are sure what knownParameterValues will be, so skip it and do setKnownValue
+            this.forwardArgumentsForFunctionCalledOnce(this.allArguments[0]);
+            return;
+        }
+        // reoptimize all arguments, that's why we save them
+        for (const argumentsList of this.allArguments) {
+            this.updateKnownParameterValues(argumentsList);
+        }
+        for (let position = 0; position < this.params.length; position++) {
+            const parameter = this.params[position];
+            // Parameters without default values
+            if (parameter instanceof Identifier) {
+                const parameterVariable = parameter.variable;
+                // Only the RestElement may be undefined
+                const knownParameterValue = this.knownParameterValues[position];
+                parameterVariable?.setKnownValue(knownParameterValue);
+            }
+        }
+    }
+    deoptimizeFunctionParameters() {
+        for (const parameter of this.params) {
+            if (parameter instanceof Identifier) {
+                const parameterVariable = parameter.variable;
+                parameterVariable?.markReassigned();
+            }
+        }
+    }
     deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker) {
         if (interaction.type === INTERACTION_CALLED) {
             const { parameters } = this.scope;
@@ -9279,6 +9443,7 @@ class FunctionBase extends NodeBase {
                     this.addArgumentToBeDeoptimized(argument);
                 }
             }
+            this.allArguments.push(args);
         }
         else {
             this.getObjectEntity().deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
@@ -9293,6 +9458,7 @@ class FunctionBase extends NodeBase {
             for (const parameterList of this.scope.parameters) {
                 for (const parameter of parameterList) {
                     parameter.deoptimizePath(UNKNOWN_PATH);
+                    parameter.markReassigned();
                 }
             }
         }
@@ -9338,7 +9504,30 @@ class FunctionBase extends NodeBase {
         }
         return false;
     }
+    /**
+     * If the function (expression or declaration) is only used as function calls
+     */
+    onlyFunctionCallUsed() {
+        let variable = null;
+        if (this.parent.type === parseAst_js.VariableDeclarator) {
+            variable = this.parent.id.variable ?? null;
+        }
+        if (this.parent.type === parseAst_js.ExportDefaultDeclaration) {
+            variable = this.parent.variable;
+        }
+        return variable?.getOnlyFunctionCallUsed() ?? false;
+    }
     include(context, includeChildrenRecursively) {
+        const isIIFE = this.parent.type === parseAst_js.CallExpression &&
+            this.parent.callee === this;
+        const shoulOptimizeFunctionParameters = isIIFE || this.onlyFunctionCallUsed();
+        if (shoulOptimizeFunctionParameters) {
+            this.applyFunctionParameterOptimization();
+        }
+        else if (this.functionParametersOptimized) {
+            this.deoptimizeFunctionParameters();
+        }
+        this.functionParametersOptimized = shoulOptimizeFunctionParameters;
         if (!this.deoptimized)
             this.applyDeoptimizations();
         this.included = true;
@@ -10088,7 +10277,7 @@ class MemberExpression extends NodeBase {
     }
     deoptimizeCache() {
         const { expressionsToBeDeoptimized, object } = this;
-        this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
+        this.expressionsToBeDeoptimized = [];
         this.propertyKey = UnknownKey;
         object.deoptimizePath(UNKNOWN_PATH);
         for (const expression of expressionsToBeDeoptimized) {
@@ -10237,6 +10426,9 @@ class MemberExpression extends NodeBase {
             this.object.deoptimizeArgumentsOnInteractionAtPath(this.accessInteraction, [propertyKey], SHARED_RECURSION_TRACKER);
             this.scope.context.requestTreeshakingPass();
         }
+        if (this.variable) {
+            this.variable.addUsedPlace(this);
+        }
     }
     applyAssignmentDeoptimization() {
         this.assignmentDeoptimized = true;
@@ -10886,15 +11078,16 @@ class ConditionalExpression extends NodeBase {
         this.alternate.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
     }
     deoptimizeCache() {
+        this.isBranchResolutionAnalysed = false;
+        const { expressionsToBeDeoptimized } = this;
+        this.expressionsToBeDeoptimized = [];
+        for (const expression of expressionsToBeDeoptimized) {
+            expression.deoptimizeCache();
+        }
         if (this.usedBranch !== null) {
             const unusedBranch = this.usedBranch === this.consequent ? this.alternate : this.consequent;
             this.usedBranch = null;
             unusedBranch.deoptimizePath(UNKNOWN_PATH);
-            const { expressionsToBeDeoptimized } = this;
-            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
-            for (const expression of expressionsToBeDeoptimized) {
-                expression.deoptimizeCache();
-            }
         }
     }
     deoptimizePath(path) {
@@ -10908,10 +11101,10 @@ class ConditionalExpression extends NodeBase {
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
+        this.expressionsToBeDeoptimized.push(origin);
         const usedBranch = this.getUsedBranch();
         if (!usedBranch)
             return UnknownValue;
-        this.expressionsToBeDeoptimized.push(origin);
         return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
@@ -11110,6 +11303,10 @@ class FunctionDeclaration extends FunctionNode {
             this.id.variable.isId = true;
         }
     }
+    onlyFunctionCallUsed() {
+        // call super.onlyFunctionCallUsed for export default anonymous function
+        return this.id?.variable.getOnlyFunctionCallUsed() ?? super.onlyFunctionCallUsed();
+    }
     parseNode(esTreeNode) {
         if (esTreeNode.id !== null) {
             this.id = new Identifier(this, this.scope.parent).parseNode(esTreeNode.id);
@@ -11398,7 +11595,7 @@ class IfStatement extends NodeBase {
         this.testValue = unset;
     }
     deoptimizeCache() {
-        this.testValue = UnknownValue;
+        this.testValue = unset;
     }
     hasEffects(context) {
         if (this.test.hasEffects(context)) {
@@ -12206,12 +12403,10 @@ class LogicalExpression extends NodeBase {
         this.right.deoptimizeArgumentsOnInteractionAtPath(interaction, path, recursionTracker);
     }
     deoptimizeCache() {
-        if (this.usedBranch) {
-            const unusedBranch = this.usedBranch === this.left ? this.right : this.left;
-            this.usedBranch = null;
-            unusedBranch.deoptimizePath(UNKNOWN_PATH);
+        this.isBranchResolutionAnalysed = false;
+        if (this.expressionsToBeDeoptimized.length > 0) {
             const { scope: { context }, expressionsToBeDeoptimized } = this;
-            this.expressionsToBeDeoptimized = parseAst_js.EMPTY_ARRAY;
+            this.expressionsToBeDeoptimized = [];
             for (const expression of expressionsToBeDeoptimized) {
                 expression.deoptimizeCache();
             }
@@ -12219,6 +12414,11 @@ class LogicalExpression extends NodeBase {
             // it is rendered
             context.requestTreeshakingPass();
         }
+        if (this.usedBranch) {
+            const unusedBranch = this.usedBranch === this.left ? this.right : this.left;
+            this.usedBranch = null;
+            unusedBranch.deoptimizePath(UNKNOWN_PATH);
+        }
     }
     deoptimizePath(path) {
         const usedBranch = this.getUsedBranch();
@@ -12231,10 +12431,10 @@ class LogicalExpression extends NodeBase {
         }
     }
     getLiteralValueAtPath(path, recursionTracker, origin) {
+        this.expressionsToBeDeoptimized.push(origin);
         const usedBranch = this.getUsedBranch();
         if (!usedBranch)
             return UnknownValue;
-        this.expressionsToBeDeoptimized.push(origin);
         return usedBranch.getLiteralValueAtPath(path, recursionTracker, origin);
     }
     getReturnExpressionWhenCalledAtPath(path, interaction, recursionTracker, origin) {
@@ -13176,6 +13376,15 @@ class ExportDefaultVariable extends LocalVariable {
             this.name = identifier.name;
         }
     }
+    addUsedPlace(usedPlace) {
+        const original = this.getOriginalVariable();
+        if (original === this) {
+            super.addUsedPlace(usedPlace);
+        }
+        else {
+            original.addUsedPlace(usedPlace);
+        }
+    }
     forbidName(name) {
         const original = this.getOriginalVariable();
         if (original === this) {
@@ -13449,7 +13658,7 @@ class UpdateExpression extends NodeBase {
         this.argument.deoptimizePath(EMPTY_PATH);
         if (this.argument instanceof Identifier) {
             const variable = this.scope.findVariable(this.argument.name);
-            variable.isReassigned = true;
+            variable.markReassigned();
         }
         this.scope.context.requestTreeshakingPass();
     }
@@ -16291,9 +16500,9 @@ function getImportBlock$1(dependencies, { _, cnst, n }, compact) {
     return '';
 }
 
-function es(magicString, { accessedGlobals, indent: t, intro, outro, dependencies, exports, snippets }, { externalLiveBindings, freeze, generatedCode: { symbols } }) {
+function es(magicString, { accessedGlobals, indent: t, intro, outro, dependencies, exports, snippets }, { externalLiveBindings, freeze, generatedCode: { symbols }, importAttributesKey }) {
     const { n } = snippets;
-    const importBlock = getImportBlock(dependencies, snippets);
+    const importBlock = getImportBlock(dependencies, importAttributesKey, snippets);
     if (importBlock.length > 0)
         intro += importBlock.join(n) + n + n;
     intro += getHelpersBlock(null, accessedGlobals, t, snippets, externalLiveBindings, freeze, symbols);
@@ -16306,10 +16515,10 @@ function es(magicString, { accessedGlobals, indent: t, intro, outro, dependencie
         magicString.append(outro);
     magicString.trim();
 }
-function getImportBlock(dependencies, { _ }) {
+function getImportBlock(dependencies, importAttributesKey, { _ }) {
     const importBlock = [];
     for (const { importPath, reexports, imports, name, attributes } of dependencies) {
-        const assertion = attributes ? `${_}assert${_}${attributes}` : '';
+        const assertion = attributes ? `${_}${importAttributesKey}${_}${attributes}` : '';
         const pathWithAssertion = `'${importPath}'${assertion};`;
         if (!reexports && !imports) {
             importBlock.push(`import${_}${pathWithAssertion}`);
@@ -19434,7 +19643,7 @@ function addModuleToManualChunk(alias, module, manualChunkAliasByEntry) {
 
 function flru (max) {
 	var num, curr, prev;
-	var limit = max || 1;
+	var limit = max ;
 
 	function keep(key, value) {
 		if (++num > limit) {
@@ -20574,6 +20783,7 @@ async function normalizeOutputOptions(config, inputOptions, unsetInputOptions) {
         globals: config.globals || {},
         hashCharacters: config.hashCharacters ?? 'base64',
         hoistTransitiveImports: config.hoistTransitiveImports ?? true,
+        importAttributesKey: config.importAttributesKey ?? 'assert',
         indent: getIndent(config, compact),
         inlineDynamicImports,
         interop: getInterop(config),

package/dist/shared/watch-cli.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.14.3
-	Mon, 15 Apr 2024 07:18:00 GMT - commit e64f3d8d0cdc561f00d3efe503e3081f81889679
+	Rollup.js v4.16.0
+	Sun, 21 Apr 2024 04:41:09 GMT - commit 38fe70780cb7e374b47da99e3a3dca6b2a2170d2
 
 	https://github.com/rollup/rollup
 

package/dist/shared/watch.js

@@ -1,7 +1,7 @@
 /*
   @license
-	Rollup.js v4.14.3
-	Mon, 15 Apr 2024 07:18:00 GMT - commit e64f3d8d0cdc561f00d3efe503e3081f81889679
+	Rollup.js v4.16.0
+	Sun, 21 Apr 2024 04:41:09 GMT - commit 38fe70780cb7e374b47da99e3a3dca6b2a2170d2
 
 	https://github.com/rollup/rollup
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rollup/wasm-node",
-  "version": "4.14.3",
+  "version": "4.16.0",
   "description": "Next-generation ES module bundler with Node wasm",
   "main": "dist/rollup.js",
   "module": "dist/es/rollup.js",
@@ -38,7 +38,7 @@
     "@codemirror/language": "^6.10.1",
     "@codemirror/search": "^6.5.6",
     "@codemirror/state": "^6.4.1",
-    "@codemirror/view": "^6.26.1",
+    "@codemirror/view": "^6.26.3",
     "@jridgewell/sourcemap-codec": "^1.4.15",
     "@mermaid-js/mermaid-cli": "^10.8.0",
     "@napi-rs/cli": "^2.18.1",
@@ -51,14 +51,14 @@
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^11.1.6",
     "@rollup/pluginutils": "^5.1.0",
-    "@shikijs/vitepress-twoslash": "^1.2.4",
-    "@types/eslint": "^8.56.7",
+    "@shikijs/vitepress-twoslash": "^1.3.0",
+    "@types/eslint": "^8.56.9",
     "@types/inquirer": "^9.0.7",
     "@types/mocha": "^10.0.6",
     "@types/node": "~18.18.14",
     "@types/yargs-parser": "^21.0.3",
-    "@typescript-eslint/eslint-plugin": "^7.6.0",
-    "@typescript-eslint/parser": "^7.6.0",
+    "@typescript-eslint/eslint-plugin": "^7.7.0",
+    "@typescript-eslint/parser": "^7.7.0",
     "@vue/eslint-config-prettier": "^9.0.0",
     "@vue/eslint-config-typescript": "^13.0.0",
     "acorn": "^8.11.3",
@@ -77,13 +77,13 @@
     "eslint-plugin-import": "^2.29.1",
     "eslint-plugin-prettier": "^5.1.3",
     "eslint-plugin-unicorn": "^52.0.0",
-    "eslint-plugin-vue": "^9.24.1",
+    "eslint-plugin-vue": "^9.25.0",
     "fixturify": "^3.0.0",
     "flru": "^1.0.2",
     "fs-extra": "^11.2.0",
     "github-api": "^3.4.0",
     "husky": "^9.0.11",
-    "inquirer": "^9.2.17",
+    "inquirer": "^9.2.18",
     "is-reference": "^3.0.2",
     "lint-staged": "^15.2.2",
     "locate-character": "^3.0.0",
@@ -95,7 +95,7 @@
     "pretty-bytes": "^6.1.1",
     "pretty-ms": "^9.0.0",
     "requirejs": "^2.3.6",
-    "rollup": "^4.14.1",
+    "rollup": "^4.14.3",
     "rollup-plugin-license": "^3.3.1",
     "rollup-plugin-string": "^3.0.0",
     "semver": "^7.6.0",
@@ -106,10 +106,10 @@
     "systemjs": "^6.14.3",
     "terser": "^5.30.3",
     "tslib": "^2.6.2",
-    "typescript": "^5.4.4",
-    "vite": "^5.2.8",
-    "vitepress": "^1.0.2",
-    "vue": "^3.4.21",
+    "typescript": "^5.4.5",
+    "vite": "^5.2.9",
+    "vitepress": "^1.1.0",
+    "vue": "^3.4.22",
     "wasm-pack": "^0.12.1",
     "weak-napi": "^2.0.2",
     "yargs-parser": "^21.1.1"