vite 5.3.0-beta.0 → 5.3.0-beta.1

package/dist/node/chunks/{dep-BPjeYeh_.js → dep-ByQDP9Ky.js}

@@ -1,4 +1,4 @@
-import { B as getDefaultExportFromCjs } from './dep-BBErwUJM.js';
+import { B as getDefaultExportFromCjs } from './dep-Dz0We6of.js';
 import require$$0 from 'path';
 import require$$0__default from 'fs';
 import { l as lib } from './dep-IQS-Za7F.js';

package/dist/node/chunks/{dep-CTAUzmEN.js → dep-Cg_8Tny5.js}

@@ -1,4 +1,4 @@
-import { C as commonjsGlobal, B as getDefaultExportFromCjs } from './dep-BBErwUJM.js';
+import { C as commonjsGlobal, B as getDefaultExportFromCjs } from './dep-Dz0We6of.js';
 import require$$0__default from 'fs';
 import require$$0 from 'postcss';
 import require$$0$1 from 'path';

package/dist/node/chunks/{dep-BBErwUJM.js → dep-Dz0We6of.js}

@@ -11818,11 +11818,11 @@ function requireNode$1 () {
 		}
 
 		/**
-		 * Invokes `util.format()` with the specified arguments and writes to stderr.
+		 * Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
 		 */
 
 		function log(...args) {
-			return process.stderr.write(util.format(...args) + '\n');
+			return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + '\n');
 		}
 
 		/**
@@ -13920,6 +13920,20 @@ function pattern2regex(resolvedPattern, allowJs) {
 	return new RegExp(regexStr);
 }
 
+/**
+ * replace tokens like ${configDir}
+ * @param {any} tsconfig
+ * @param {string} configDir
+ * @returns {any}
+ */
+function replaceTokens(tsconfig, configDir) {
+	return JSON.parse(
+		JSON.stringify(tsconfig)
+			// replace ${configDir}, accounting for rebaseRelative emitted ../${configDir}
+			.replaceAll(/"(?:\.\.\/)*\${configDir}/g, `"${native2posix(configDir)}`)
+	);
+}
+
 /**
  * find the closest tsconfig.json file
  *
@@ -14280,7 +14294,8 @@ function normalizeTSConfig(tsconfig, dir) {
 	if (tsconfig.compilerOptions?.baseUrl && !path$o.isAbsolute(tsconfig.compilerOptions.baseUrl)) {
 		tsconfig.compilerOptions.baseUrl = resolve2posix(dir, tsconfig.compilerOptions.baseUrl);
 	}
-	return tsconfig;
+
+	return replaceTokens(tsconfig, dir);
 }
 
 /**
@@ -31528,6 +31543,7 @@ function getAttrSourceCodeLocation(node, attrKey) {
     return node.sourceCodeLocation.attrs[attrKey];
 }
 
+const decoder = new TextDecoder();
 function resolveCSSOptions(options) {
     if (options?.transformer === 'lightningcss') {
         return {
@@ -32436,8 +32452,8 @@ function createCachedImport(imp) {
         return cached;
     };
 }
-const importPostcssImport = createCachedImport(() => import('./dep-BPjeYeh_.js').then(function (n) { return n.i; }));
-const importPostcssModules = createCachedImport(() => import('./dep-CTAUzmEN.js').then(function (n) { return n.i; }));
+const importPostcssImport = createCachedImport(() => import('./dep-ByQDP9Ky.js').then(function (n) { return n.i; }));
+const importPostcssModules = createCachedImport(() => import('./dep-Cg_8Tny5.js').then(function (n) { return n.i; }));
 const importPostcss = createCachedImport(() => import('postcss'));
 const preprocessorWorkerControllerCache = new WeakMap();
 let alwaysFakeWorkerWorkerControllerCache;
@@ -32678,8 +32694,11 @@ async function minifyCSS(css, config, inlined) {
                 .map((w) => w.message)
                 .join('\n')}`));
         }
+        // NodeJS res.code = Buffer
+        // Deno res.code = Uint8Array
+        // For correct decode compiled css need to use TextDecoder
         // LightningCSS output does not return a linebreak at the end
-        return code.toString() + (inlined ? '' : '\n');
+        return decoder.decode(code) + (inlined ? '' : '\n');
     }
     try {
         const { code, warnings } = await transform$2(css, {
@@ -32815,6 +32834,7 @@ function fixScssBugImportValue(data) {
     }
     return data;
 }
+// #region Sass
 // .scss/.sass processor
 const makeScssWorker = (resolvers, alias, maxWorkers) => {
     const internalImporter = async (url, importer, filename) => {
@@ -32934,6 +32954,7 @@ const scssProcessor = (maxWorkers) => {
         },
     };
 };
+// #endregion
 /**
  * relative url() inside \@imported sass and less files must be rebased to use
  * root file as base.
@@ -32989,6 +33010,7 @@ async function rebaseUrls(file, rootFile, alias, variablePrefix, resolver) {
         contents: rebased,
     };
 }
+// #region Less
 // .less
 const makeLessWorker = (resolvers, alias, maxWorkers) => {
     const viteLessResolve = async (filename, dir, rootFile) => {
@@ -33123,6 +33145,8 @@ const lessProcessor = (maxWorkers) => {
         },
     };
 };
+// #endregion
+// #region Stylus
 // .styl
 const makeStylWorker = (maxWorkers) => {
     const worker = new WorkerWithFallback(() => {
@@ -33216,6 +33240,7 @@ function formatStylusSourceMap(mapBefore, root) {
     map.sources = map.sources.map(resolveFromRoot);
     return map;
 }
+// #endregion
 async function getSource(source, filename, additionalData, enableSourcemap, sep = '') {
     if (!additionalData)
         return { content: source };
@@ -33279,7 +33304,6 @@ function isPreProcessor(lang) {
     return lang && preprocessorSet.has(lang);
 }
 const importLightningCSS = createCachedImport(() => import('lightningcss'));
-const decoder = new TextDecoder();
 async function compileLightningCSS(id, src, config, urlReplacer) {
     const deps = new Set();
     // Relative path is needed to get stable hash when using CSS modules
@@ -33345,6 +33369,9 @@ async function compileLightningCSS(id, src, config, urlReplacer) {
                     const replaceUrl = await urlReplacer(dep.url, id);
                     css = css.replace(dep.placeholder, () => replaceUrl);
                 }
+                else {
+                    css = css.replace(dep.placeholder, () => dep.url);
+                }
                 break;
             default:
                 throw new Error(`Unsupported dependency type: ${dep.type}`);
@@ -49838,9 +49865,9 @@ function ssrFixStacktrace(e, moduleGraph) {
 }
 
 const pendingModules = new Map();
-const pendingImports = new Map();
+const pendingModuleDependencyGraph = new Map();
 const importErrors = new WeakMap();
-async function ssrLoadModule(url, server, context = { global }, urlStack = [], fixStacktrace) {
+async function ssrLoadModule(url, server, context = { global }, fixStacktrace) {
     url = unwrapId$1(url);
     // when we instantiate multiple dependency modules in parallel, they may
     // point to shared modules. We need to avoid duplicate instantiation attempts
@@ -49850,18 +49877,18 @@ async function ssrLoadModule(url, server, context = { global }, urlStack = [], f
     if (pending) {
         return pending;
     }
-    const modulePromise = instantiateModule(url, server, context, urlStack, fixStacktrace);
+    const modulePromise = instantiateModule(url, server, context, fixStacktrace);
     pendingModules.set(url, modulePromise);
     modulePromise
         .catch(() => {
-        pendingImports.delete(url);
+        /* prevent unhandled promise rejection error from bubbling up */
     })
         .finally(() => {
         pendingModules.delete(url);
     });
     return modulePromise;
 }
-async function instantiateModule(url, server, context = { global }, urlStack = [], fixStacktrace) {
+async function instantiateModule(url, server, context = { global }, fixStacktrace) {
     const { moduleGraph } = server;
     const mod = await moduleGraph.ensureEntryFromUrl(url, true);
     if (mod.ssrError) {
@@ -49891,8 +49918,6 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
         // The filesystem URL, matching native Node.js modules
         url: pathToFileURL(mod.file).toString(),
     };
-    urlStack = urlStack.concat(url);
-    const isCircular = (url) => urlStack.includes(url);
     const { isProduction, resolve: { dedupe, preserveSymlinks }, root, ssr, } = server.config;
     const overrideConditions = ssr.resolve?.externalConditions || [];
     const resolveOptions = {
@@ -49909,9 +49934,6 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
         legacyProxySsrExternalModules: server.config.legacy?.proxySsrExternalModules,
         packageCache: server.config.packageCache,
     };
-    // Since dynamic imports can happen in parallel, we need to
-    // account for multiple pending deps and duplicate imports.
-    const pendingDeps = [];
     const ssrImport = async (dep, metadata) => {
         try {
             if (dep[0] !== '.' && dep[0] !== '/') {
@@ -49919,22 +49941,25 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
             }
             // convert to rollup URL because `pendingImports`, `moduleGraph.urlToModuleMap` requires that
             dep = unwrapId$1(dep);
-            if (!isCircular(dep) && !pendingImports.get(dep)?.some(isCircular)) {
-                pendingDeps.push(dep);
-                if (pendingDeps.length === 1) {
-                    pendingImports.set(url, pendingDeps);
-                }
-                const mod = await ssrLoadModule(dep, server, context, urlStack, fixStacktrace);
-                if (pendingDeps.length === 1) {
-                    pendingImports.delete(url);
-                }
-                else {
-                    pendingDeps.splice(pendingDeps.indexOf(dep), 1);
+            // Handle any potential circular dependencies for static imports, preventing
+            // deadlock scenarios when two modules are indirectly waiting on one another
+            // to finish initializing. Dynamic imports are resolved at runtime, hence do
+            // not contribute to the static module dependency graph in the same way
+            if (!metadata?.isDynamicImport) {
+                addPendingModuleDependency(url, dep);
+                // If there's a circular dependency formed as a result of the dep import,
+                // return the current state of the dependent module being initialized, in
+                // order to avoid interlocking circular dependencies hanging indefinitely
+                if (checkModuleDependencyExists(dep, url)) {
+                    const depSsrModule = moduleGraph.urlToModuleMap.get(dep)?.ssrModule;
+                    if (!depSsrModule) {
+                        // Technically, this should never happen under normal circumstances
+                        throw new Error('[vite] The dependency module is not yet fully initialized due to circular dependency. This is a bug in Vite SSR');
+                    }
+                    return depSsrModule;
                 }
-                // return local module to avoid race condition #5470
-                return mod;
             }
-            return moduleGraph.urlToModuleMap.get(dep)?.ssrModule;
+            return ssrLoadModule(dep, server, context, fixStacktrace);
         }
         catch (err) {
             // tell external error handler which mod was imported with error
@@ -49994,8 +50019,41 @@ async function instantiateModule(url, server, context = { global }, urlStack = [
         });
         throw e;
     }
+    finally {
+        pendingModuleDependencyGraph.delete(url);
+    }
     return Object.freeze(ssrModule);
 }
+function addPendingModuleDependency(originUrl, depUrl) {
+    if (pendingModuleDependencyGraph.has(originUrl)) {
+        pendingModuleDependencyGraph.get(originUrl).add(depUrl);
+    }
+    else {
+        pendingModuleDependencyGraph.set(originUrl, new Set([depUrl]));
+    }
+}
+function checkModuleDependencyExists(originUrl, targetUrl) {
+    const visited = new Set();
+    const stack = [originUrl];
+    while (stack.length) {
+        const currentUrl = stack.pop();
+        if (currentUrl === targetUrl) {
+            return true;
+        }
+        if (!visited.has(currentUrl)) {
+            visited.add(currentUrl);
+            const dependencies = pendingModuleDependencyGraph.get(currentUrl);
+            if (dependencies) {
+                for (const depUrl of dependencies) {
+                    if (!visited.has(depUrl)) {
+                        stack.push(depUrl);
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
 // In node@12+ we can use dynamic import to load CJS and ESM
 async function nodeImport(id, importer, resolveOptions, metadata) {
     let url;
@@ -59743,7 +59801,7 @@ async function _createServer(inlineConfig = {}, options) {
             return devHtmlTransformFn(server, url, html, originalUrl);
         },
         async ssrLoadModule(url, opts) {
-            return ssrLoadModule(url, server, undefined, undefined, opts?.fixStacktrace);
+            return ssrLoadModule(url, server, undefined, opts?.fixStacktrace);
         },
         async ssrFetchModule(url, importer) {
             return ssrFetchModule(server, url, importer);
@@ -61602,6 +61660,7 @@ const preloadMarker = `__VITE_PRELOAD__`;
 const preloadHelperId = '\0vite/preload-helper.js';
 const preloadMarkerRE = new RegExp(preloadMarker, 'g');
 const dynamicImportPrefixRE = /import\s*\(/;
+const dynamicImportTreeshakenRE = /(\b(const|let|var)\s+(\{[^}.]+\})\s*=\s*await\s+import\([^)]+\))|(\(\s*await\s+import\([^)]+\)\s*\)(\??\.[^;[\s]+)+)|\bimport\([^)]+\)(\s*\.then\([^{]*?\(\s*\{([^}.]+)\})/g;
 function toRelativePath(filename, importer) {
     const relPath = path$o.posix.relative(path$o.posix.dirname(importer), filename);
     return relPath[0] === '.' ? relPath : `./${relPath}`;
@@ -61753,6 +61812,55 @@ function buildImportAnalysisPlugin(config) {
             if (!imports.length) {
                 return null;
             }
+            // when wrapping dynamic imports with a preload helper, Rollup is unable to analyze the
+            // accessed variables for treeshaking. This below tries to match common accessed syntax
+            // to "copy" it over to the dynamic import wrapped by the preload helper.
+            const dynamicImports = {};
+            if (insertPreload) {
+                let match;
+                while ((match = dynamicImportTreeshakenRE.exec(source))) {
+                    /* handle `const {foo} = await import('foo')`
+                     *
+                     * match[1]: `const {foo} = await import('foo')`
+                     * match[2]: `const`
+                     * match[3]: `{foo}`
+                     * import end: `const {foo} = await import('foo')_`
+                     *                                               ^
+                     */
+                    if (match[1]) {
+                        dynamicImports[dynamicImportTreeshakenRE.lastIndex] = {
+                            declaration: `${match[2]} ${match[3]}`,
+                            names: match[3]?.trim(),
+                        };
+                        continue;
+                    }
+                    /* handle `(await import('foo')).foo`
+                     *
+                     * match[4]: `(await import('foo')).foo`
+                     * match[5]: `.foo`
+                     * import end: `(await import('foo'))`
+                     *                                  ^
+                     */
+                    if (match[4]) {
+                        let names = match[5].match(/\.([^.?]+)/)?.[1] || '';
+                        // avoid `default` keyword error
+                        if (names === 'default') {
+                            names = 'default: __vite_default__';
+                        }
+                        dynamicImports[dynamicImportTreeshakenRE.lastIndex - match[5]?.length - 1] = { declaration: `const {${names}}`, names: `{ ${names} }` };
+                        continue;
+                    }
+                    /* handle `import('foo').then(({foo})=>{})`
+                     *
+                     * match[6]: `.then(({foo}`
+                     * match[7]: `foo`
+                     * import end: `import('foo').`
+                     *                           ^
+                     */
+                    const names = match[7]?.trim();
+                    dynamicImports[dynamicImportTreeshakenRE.lastIndex - match[6]?.length] = { declaration: `const {${names}}`, names: `{ ${names} }` };
+                }
+            }
             let s;
             const str = () => s || (s = new MagicString(source));
             let needPreloadHelper = false;
@@ -61770,7 +61878,23 @@ function buildImportAnalysisPlugin(config) {
                         source[start] === "'" ||
                         source[start] === '`')) {
                     needPreloadHelper = true;
-                    str().prependLeft(expStart, `${preloadMethod}(() => `);
+                    const { declaration, names } = dynamicImports[expEnd] || {};
+                    if (names) {
+                        /* transform `const {foo} = await import('foo')`
+                         * to `const {foo} = await __vitePreload(async () => { const {foo} = await import('foo');return {foo}}, ...)`
+                         *
+                         * transform `import('foo').then(({foo})=>{})`
+                         * to `__vitePreload(async () => { const {foo} = await import('foo');return { foo }},...).then(({foo})=>{})`
+                         *
+                         * transform `(await import('foo')).foo`
+                         * to `__vitePreload(async () => { const {foo} = (await import('foo')).foo; return { foo }},...)).foo`
+                         */
+                        str().prependLeft(expStart, `${preloadMethod}(async () => { ${declaration} = await `);
+                        str().appendRight(expEnd, `;return ${names}}`);
+                    }
+                    else {
+                        str().prependLeft(expStart, `${preloadMethod}(() => `);
+                    }
                     str().appendRight(expEnd, `,${isModernFlag}?${preloadMarker}:void 0${optimizeModulePreloadRelativePaths || customModulePreloadPaths
                         ? ',import.meta.url'
                         : ''})`);
@@ -61813,7 +61937,54 @@ function buildImportAnalysisPlugin(config) {
             return null;
         },
         generateBundle({ format }, bundle) {
-            if (format !== 'es' || ssr || isWorker) {
+            if (format !== 'es') {
+                return;
+            }
+            if (ssr || isWorker) {
+                const removedPureCssFiles = removedPureCssFilesCache.get(config);
+                if (removedPureCssFiles && removedPureCssFiles.size > 0) {
+                    for (const file in bundle) {
+                        const chunk = bundle[file];
+                        if (chunk.type === 'chunk' && chunk.code.includes('import')) {
+                            const code = chunk.code;
+                            let imports;
+                            try {
+                                imports = parse$f(code)[0].filter((i) => i.d > -1);
+                            }
+                            catch (e) {
+                                const loc = numberToPos(code, e.idx);
+                                this.error({
+                                    name: e.name,
+                                    message: e.message,
+                                    stack: e.stack,
+                                    cause: e.cause,
+                                    pos: e.idx,
+                                    loc: { ...loc, file: chunk.fileName },
+                                    frame: generateCodeFrame(code, loc),
+                                });
+                            }
+                            for (const imp of imports) {
+                                const { n: name, s: start, e: end, ss: expStart, se: expEnd, } = imp;
+                                let url = name;
+                                if (!url) {
+                                    const rawUrl = code.slice(start, end);
+                                    if (rawUrl[0] === `"` && rawUrl[rawUrl.length - 1] === `"`)
+                                        url = rawUrl.slice(1, -1);
+                                }
+                                if (!url)
+                                    continue;
+                                const normalizedFile = path$o.posix.join(path$o.posix.dirname(chunk.fileName), url);
+                                if (removedPureCssFiles.has(normalizedFile)) {
+                                    // remove with Promise.resolve({}) while preserving source map location
+                                    chunk.code =
+                                        chunk.code.slice(0, expStart) +
+                                            `Promise.resolve({${''.padEnd(expEnd - expStart - 19, ' ')}})` +
+                                            chunk.code.slice(expEnd);
+                                }
+                            }
+                        }
+                    }
+                }
                 return;
             }
             for (const file in bundle) {

package/dist/node/cli.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import fs from 'node:fs';
 import { performance } from 'node:perf_hooks';
 import { EventEmitter } from 'events';
-import { A as colors, v as createLogger, r as resolveConfig } from './chunks/dep-BBErwUJM.js';
+import { A as colors, v as createLogger, r as resolveConfig } from './chunks/dep-Dz0We6of.js';
 import { VERSION } from './constants.js';
 import 'node:fs/promises';
 import 'node:url';
@@ -757,7 +757,7 @@ cli
     filterDuplicateOptions(options);
     // output structure is preserved even after bundling so require()
     // is ok here
-    const { createServer } = await import('./chunks/dep-BBErwUJM.js').then(function (n) { return n.E; });
+    const { createServer } = await import('./chunks/dep-Dz0We6of.js').then(function (n) { return n.E; });
     try {
         const server = await createServer({
             root,
@@ -836,7 +836,7 @@ cli
     .option('-w, --watch', `[boolean] rebuilds when modules have changed on disk`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { build } = await import('./chunks/dep-BBErwUJM.js').then(function (n) { return n.F; });
+    const { build } = await import('./chunks/dep-Dz0We6of.js').then(function (n) { return n.F; });
     const buildOptions = cleanOptions(options);
     try {
         await build({
@@ -863,7 +863,7 @@ cli
     .option('--force', `[boolean] force the optimizer to ignore the cache and re-bundle`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { optimizeDeps } = await import('./chunks/dep-BBErwUJM.js').then(function (n) { return n.D; });
+    const { optimizeDeps } = await import('./chunks/dep-Dz0We6of.js').then(function (n) { return n.D; });
     try {
         const config = await resolveConfig({
             root,
@@ -889,7 +889,7 @@ cli
     .option('--outDir <dir>', `[string] output directory (default: dist)`)
     .action(async (root, options) => {
     filterDuplicateOptions(options);
-    const { preview } = await import('./chunks/dep-BBErwUJM.js').then(function (n) { return n.G; });
+    const { preview } = await import('./chunks/dep-Dz0We6of.js').then(function (n) { return n.G; });
     try {
         const server = await preview({
             root,

package/dist/node/index.js

@@ -1,6 +1,6 @@
 export { parseAst, parseAstAsync } from 'rollup/parseAst';
-import { i as isInNodeModules, a as arraify } from './chunks/dep-BBErwUJM.js';
-export { b as build, g as buildErrorMessage, k as createFilter, v as createLogger, c as createServer, d as defineConfig, h as fetchModule, f as formatPostcssSourceMap, x as isFileServingAllowed, l as loadConfigFromFile, y as loadEnv, j as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, e as preprocessCSS, p as preview, r as resolveConfig, z as resolveEnvPrefix, q as rollupVersion, w as searchForWorkspaceRoot, u as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-BBErwUJM.js';
+import { i as isInNodeModules, a as arraify } from './chunks/dep-Dz0We6of.js';
+export { b as build, g as buildErrorMessage, k as createFilter, v as createLogger, c as createServer, d as defineConfig, h as fetchModule, f as formatPostcssSourceMap, x as isFileServingAllowed, l as loadConfigFromFile, y as loadEnv, j as mergeAlias, m as mergeConfig, n as normalizePath, o as optimizeDeps, e as preprocessCSS, p as preview, r as resolveConfig, z as resolveEnvPrefix, q as rollupVersion, w as searchForWorkspaceRoot, u as send, s as sortUserPlugins, t as transformWithEsbuild } from './chunks/dep-Dz0We6of.js';
 export { VERSION as version } from './constants.js';
 export { version as esbuildVersion } from 'esbuild';
 import { existsSync, readFileSync } from 'node:fs';

package/dist/node-cjs/publicUtils.cjs

@@ -1127,11 +1127,11 @@ function requireNode () {
 		}
 
 		/**
-		 * Invokes `util.format()` with the specified arguments and writes to stderr.
+		 * Invokes `util.formatWithOptions()` with the specified arguments and writes to stderr.
 		 */
 
 		function log(...args) {
-			return process.stderr.write(util.format(...args) + '\n');
+			return process.stderr.write(util.formatWithOptions(exports.inspectOpts, ...args) + '\n');
 		}
 
 		/**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite",
-  "version": "5.3.0-beta.0",
+  "version": "5.3.0-beta.1",
   "type": "module",
   "license": "MIT",
   "author": "Evan You",
@@ -100,7 +100,7 @@
     "convert-source-map": "^2.0.0",
     "cors": "^2.8.5",
     "cross-spawn": "^7.0.3",
-    "debug": "^4.3.4",
+    "debug": "^4.3.5",
     "dep-types": "link:./src/types",
     "dotenv": "^16.4.5",
     "dotenv-expand": "^11.0.6",
@@ -129,12 +129,12 @@
     "rollup-plugin-dts": "^6.1.1",
     "rollup-plugin-esbuild": "^6.1.1",
     "rollup-plugin-license": "^3.4.0",
-    "sass": "^1.77.2",
+    "sass": "^1.77.4",
     "sirv": "^2.0.4",
     "source-map-support": "^0.5.21",
     "strip-ansi": "^7.1.0",
     "strip-literal": "^2.1.0",
-    "tsconfck": "^3.0.3",
+    "tsconfck": "^3.1.0",
     "tslib": "^2.6.2",
     "types": "link:./types",
     "ufo": "^1.5.3",