@claudeye/linux-arm64 1.0.6-beta.2 → 1.0.6-beta.4

package/assets/standalone/node_modules/next/dist/build/webpack/plugins/build-manifest-plugin.js

@@ -1,183 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-0 && (module.exports = {
-    default: null,
-    generateClientManifest: null,
-    getEntrypointFiles: null
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    // This plugin creates a build-manifest.json for all assets that are being output
-    // It has a mapping of "entry" filename to real filename. Because the real filename can be hashed in production
-    default: function() {
-        return BuildManifestPlugin;
-    },
-    generateClientManifest: function() {
-        return generateClientManifest;
-    },
-    getEntrypointFiles: function() {
-        return getEntrypointFiles;
-    }
-});
-const _devalue = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/devalue"));
-const _webpack = require("next/dist/compiled/webpack/webpack");
-const _constants = require("../../../shared/lib/constants");
-const _getroutefromentrypoint = /*#__PURE__*/ _interop_require_default(require("../../../server/get-route-from-entrypoint"));
-const _utils = require("../../../shared/lib/router/utils");
-const _trace = require("../../../trace");
-const _utils1 = require("../utils");
-const _buildmanifestpluginutils = require("./build-manifest-plugin-utils");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-// nodejs: '/static/<build id>/low-priority.js'
-function buildNodejsLowPriorityPath(filename, buildId) {
-    return `${_constants.CLIENT_STATIC_FILES_PATH}/${buildId}/${filename}`;
-}
-function generateClientManifest(assetMap, rewrites, clientRouterFilters, compiler, compilation) {
-    const compilationSpan = compilation ? (0, _utils1.getCompilationSpan)(compilation) : compiler ? (0, _utils1.getCompilationSpan)(compiler) : new _trace.Span({
-        name: 'client-manifest'
-    });
-    const genClientManifestSpan = compilationSpan == null ? void 0 : compilationSpan.traceChild('NextJsBuildManifest-generateClientManifest');
-    return genClientManifestSpan == null ? void 0 : genClientManifestSpan.traceFn(()=>{
-        const clientManifest = {
-            __rewrites: (0, _buildmanifestpluginutils.normalizeRewritesForBuildManifest)(rewrites),
-            __routerFilterStatic: clientRouterFilters == null ? void 0 : clientRouterFilters.staticFilter,
-            __routerFilterDynamic: clientRouterFilters == null ? void 0 : clientRouterFilters.dynamicFilter
-        };
-        const appDependencies = new Set(assetMap.pages['/_app']);
-        const sortedPageKeys = (0, _utils.getSortedRoutes)(Object.keys(assetMap.pages));
-        sortedPageKeys.forEach((page)=>{
-            const dependencies = assetMap.pages[page];
-            if (page === '/_app') return;
-            // Filter out dependencies in the _app entry, because those will have already
-            // been loaded by the client prior to a navigation event
-            const filteredDeps = dependencies.filter((dep)=>!appDependencies.has(dep));
-            // The manifest can omit the page if it has no requirements
-            if (filteredDeps.length) {
-                clientManifest[page] = filteredDeps;
-            }
-        });
-        // provide the sorted pages as an array so we don't rely on the object's keys
-        // being in order and we don't slow down look-up time for page assets
-        clientManifest.sortedPages = sortedPageKeys;
-        return (0, _devalue.default)(clientManifest);
-    });
-}
-function getEntrypointFiles(entrypoint) {
-    return (entrypoint == null ? void 0 : entrypoint.getFiles().filter((file)=>{
-        // We don't want to include `.hot-update.js` files into the initial page
-        return /(?<!\.hot-update)\.(js|css)($|\?)/.test(file);
-    }).map((file)=>file.replace(/\\/g, '/'))) ?? [];
-}
-class BuildManifestPlugin {
-    constructor(options){
-        this.buildId = options.buildId;
-        this.isDevFallback = !!options.isDevFallback;
-        this.rewrites = {
-            beforeFiles: [],
-            afterFiles: [],
-            fallback: []
-        };
-        this.appDirEnabled = options.appDirEnabled;
-        this.clientRouterFilters = options.clientRouterFilters;
-        this.rewrites.beforeFiles = options.rewrites.beforeFiles.map(_buildmanifestpluginutils.processRoute);
-        this.rewrites.afterFiles = options.rewrites.afterFiles.map(_buildmanifestpluginutils.processRoute);
-        this.rewrites.fallback = options.rewrites.fallback.map(_buildmanifestpluginutils.processRoute);
-    }
-    createAssets(compiler, compilation) {
-        const compilationSpan = (0, _utils1.getCompilationSpan)(compilation) ?? (0, _utils1.getCompilationSpan)(compiler);
-        if (!compilationSpan) {
-            throw Object.defineProperty(new Error('No span found for compilation'), "__NEXT_ERROR_CODE", {
-                value: "E646",
-                enumerable: false,
-                configurable: true
-            });
-        }
-        const createAssetsSpan = compilationSpan.traceChild('NextJsBuildManifest-createassets');
-        return createAssetsSpan.traceFn(()=>{
-            const entrypoints = compilation.entrypoints;
-            const assetMap = {
-                polyfillFiles: [],
-                devFiles: [],
-                lowPriorityFiles: [],
-                rootMainFiles: [],
-                rootMainFilesTree: {},
-                pages: {
-                    '/_app': []
-                }
-            };
-            const mainFiles = new Set(getEntrypointFiles(entrypoints.get(_constants.CLIENT_STATIC_FILES_RUNTIME_MAIN)));
-            if (this.appDirEnabled) {
-                assetMap.rootMainFiles = [
-                    ...new Set(getEntrypointFiles(entrypoints.get(_constants.CLIENT_STATIC_FILES_RUNTIME_MAIN_APP)))
-                ];
-            }
-            const compilationAssets = compilation.getAssets();
-            assetMap.polyfillFiles = compilationAssets.filter((p)=>{
-                // Ensure only .js files are passed through
-                if (!p.name.endsWith('.js')) {
-                    return false;
-                }
-                return p.info && _constants.CLIENT_STATIC_FILES_RUNTIME_POLYFILLS_SYMBOL in p.info;
-            }).map((v)=>v.name);
-            assetMap.devFiles = getEntrypointFiles(entrypoints.get(_constants.CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH)).filter((file)=>!mainFiles.has(file));
-            for (const entrypoint of compilation.entrypoints.values()){
-                if (_constants.SYSTEM_ENTRYPOINTS.has(entrypoint.name)) continue;
-                const pagePath = (0, _getroutefromentrypoint.default)(entrypoint.name);
-                if (!pagePath) {
-                    continue;
-                }
-                const filesForPage = getEntrypointFiles(entrypoint);
-                assetMap.pages[pagePath] = [
-                    ...new Set([
-                        ...mainFiles,
-                        ...filesForPage
-                    ])
-                ];
-            }
-            if (!this.isDevFallback) {
-                // Add the runtime build manifest file (generated later in this file)
-                // as a dependency for the app. If the flag is false, the file won't be
-                // downloaded by the client.
-                const buildManifestPath = buildNodejsLowPriorityPath('_buildManifest.js', this.buildId);
-                const ssgManifestPath = buildNodejsLowPriorityPath('_ssgManifest.js', this.buildId);
-                assetMap.lowPriorityFiles.push(buildManifestPath, ssgManifestPath);
-                compilation.emitAsset(ssgManifestPath, new _webpack.sources.RawSource(_buildmanifestpluginutils.srcEmptySsgManifest));
-            }
-            assetMap.pages = Object.keys(assetMap.pages).sort().reduce(// eslint-disable-next-line
-            (a, c)=>(a[c] = assetMap.pages[c], a), {});
-            let buildManifestName = _constants.BUILD_MANIFEST;
-            if (this.isDevFallback) {
-                buildManifestName = `fallback-${_constants.BUILD_MANIFEST}`;
-            }
-            compilation.emitAsset(buildManifestName, new _webpack.sources.RawSource(JSON.stringify(assetMap, null, 2)));
-            compilation.emitAsset(`server/${_constants.MIDDLEWARE_BUILD_MANIFEST}.js`, new _webpack.sources.RawSource(`${(0, _buildmanifestpluginutils.createEdgeRuntimeManifest)(assetMap)}`));
-            if (!this.isDevFallback) {
-                compilation.emitAsset(`${_constants.CLIENT_STATIC_FILES_PATH}/${this.buildId}/_buildManifest.js`, new _webpack.sources.RawSource(`self.__BUILD_MANIFEST = ${generateClientManifest(assetMap, this.rewrites, this.clientRouterFilters, compiler, compilation)};self.__BUILD_MANIFEST_CB && self.__BUILD_MANIFEST_CB()`));
-            }
-        });
-    }
-    apply(compiler) {
-        compiler.hooks.make.tap('NextJsBuildManifest', (compilation)=>{
-            compilation.hooks.processAssets.tap({
-                name: 'NextJsBuildManifest',
-                stage: _webpack.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
-            }, ()=>{
-                this.createAssets(compiler, compilation);
-            });
-        });
-        return;
-    }
-}
-
-//# sourceMappingURL=build-manifest-plugin.js.map

package/assets/standalone/node_modules/next/dist/build/webpack/plugins/copy-file-plugin.js

@@ -1,67 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "CopyFilePlugin", {
-    enumerable: true,
-    get: function() {
-        return CopyFilePlugin;
-    }
-});
-const _fs = require("fs");
-const _loaderutils3 = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/loader-utils3"));
-const _webpack = require("next/dist/compiled/webpack/webpack");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-const PLUGIN_NAME = 'CopyFilePlugin';
-class CopyFilePlugin {
-    constructor({ filePath, cacheKey, name, info }){
-        this.filePath = filePath;
-        this.cacheKey = cacheKey;
-        this.name = name;
-        this.info = info;
-    }
-    apply(compiler) {
-        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation)=>{
-            const cache = compilation.getCache('CopyFilePlugin');
-            const hook = compilation.hooks.processAssets;
-            hook.tapPromise({
-                name: PLUGIN_NAME,
-                stage: _webpack.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
-            }, async ()=>{
-                if (cache) {
-                    const cachedResult = await cache.getPromise(this.filePath, this.cacheKey);
-                    if (cachedResult) {
-                        const { file, source } = cachedResult;
-                        compilation.emitAsset(file, source, {
-                            ...this.info
-                        });
-                        return;
-                    }
-                }
-                const content = await _fs.promises.readFile(this.filePath, 'utf8');
-                const file = _loaderutils3.default.interpolateName({
-                    resourcePath: this.filePath
-                }, this.name, {
-                    content,
-                    context: compiler.context
-                });
-                const source = new _webpack.sources.RawSource(content);
-                if (cache) {
-                    await cache.storePromise(this.filePath, this.cacheKey, {
-                        file,
-                        source
-                    });
-                }
-                compilation.emitAsset(file, source, {
-                    ...this.info
-                });
-            });
-        });
-    }
-}
-
-//# sourceMappingURL=copy-file-plugin.js.map

package/assets/standalone/node_modules/next/dist/build/webpack/plugins/css-chunking-plugin.js

@@ -1,277 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "CssChunkingPlugin", {
-    enumerable: true,
-    get: function() {
-        return CssChunkingPlugin;
-    }
-});
-const PLUGIN_NAME = 'CssChunkingPlugin';
-/**
- * Merge chunks until they are bigger than the target size.
- */ const MIN_CSS_CHUNK_SIZE = 30 * 1024;
-/**
- * Avoid merging chunks when they would be bigger than this size.
- */ const MAX_CSS_CHUNK_SIZE = 100 * 1024;
-function isGlobalCss(module) {
-    return !/\.module\.(css|scss|sass)$/.test(module.nameForCondition() || '');
-}
-class CssChunkingPlugin {
-    constructor(strict){
-        this.strict = strict;
-    }
-    apply(compiler) {
-        const strict = this.strict;
-        const summary = !!process.env.CSS_CHUNKING_SUMMARY;
-        compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation)=>{
-            let once = false;
-            compilation.hooks.optimizeChunks.tap({
-                name: PLUGIN_NAME,
-                stage: 5
-            }, ()=>{
-                if (once) {
-                    return;
-                }
-                once = true;
-                const chunkGraph = compilation.chunkGraph;
-                let changed = undefined;
-                const chunkStates = new Map();
-                const chunkStatesByModule = new Map();
-                // Collect all css modules in chunks and the execpted order of them
-                for (const chunk of compilation.chunks){
-                    var _chunk_name;
-                    if ((_chunk_name = chunk.name) == null ? void 0 : _chunk_name.startsWith('pages/')) continue;
-                    const modules = [];
-                    for (const module of chunkGraph.getChunkModulesIterable(chunk)){
-                        var _module_type;
-                        if (!((_module_type = module.type) == null ? void 0 : _module_type.startsWith('css'))) continue;
-                        modules.push(module);
-                    }
-                    if (!modules.length) continue;
-                    const chunkState = {
-                        chunk,
-                        modules,
-                        order: 0,
-                        requests: modules.length
-                    };
-                    chunkStates.set(chunk, chunkState);
-                    for(let i = 0; i < modules.length; i++){
-                        const module = modules[i];
-                        let moduleChunkStates = chunkStatesByModule.get(module);
-                        if (!moduleChunkStates) {
-                            moduleChunkStates = new Map();
-                            chunkStatesByModule.set(module, moduleChunkStates);
-                        }
-                        moduleChunkStates.set(chunkState, i);
-                        chunkStatesByModule.set(module, moduleChunkStates);
-                    }
-                }
-                // Sort modules by their index sum
-                const orderedModules = [];
-                for (const [module, moduleChunkStates] of chunkStatesByModule){
-                    let sum = 0;
-                    for (const i of moduleChunkStates.values()){
-                        sum += i;
-                    }
-                    orderedModules.push({
-                        module,
-                        sum
-                    });
-                }
-                orderedModules.sort((a, b)=>a.sum - b.sum);
-                // A queue of modules that still need to be processed
-                const remainingModules = new Set(orderedModules.map(({ module })=>module));
-                // In loose mode we guess the dependents of modules from the order
-                // assuming that when a module is a dependency of another module
-                // it will always appear before it in every chunk.
-                const allDependents = new Map();
-                if (!this.strict) {
-                    for (const b of remainingModules){
-                        const dependent = new Set();
-                        loop: for (const a of remainingModules){
-                            if (a === b) continue;
-                            // check if a depends on b
-                            for (const [chunkState, ia] of chunkStatesByModule.get(a)){
-                                const bChunkStates = chunkStatesByModule.get(b);
-                                const ib = bChunkStates.get(chunkState);
-                                if (ib === undefined) {
-                                    continue loop;
-                                }
-                                if (ib > ia) {
-                                    continue loop;
-                                }
-                            }
-                            dependent.add(a);
-                        }
-                        if (dependent.size > 0) allDependents.set(b, dependent);
-                    }
-                }
-                // Stores the new chunk for every module
-                const newChunksByModule = new Map();
-                // Process through all modules
-                for (const startModule of remainingModules){
-                    let globalCssMode = isGlobalCss(startModule);
-                    // The current position of processing in all selected chunks
-                    let allChunkStates = new Map(chunkStatesByModule.get(startModule));
-                    // The list of modules that goes into the new chunk
-                    const newChunkModules = new Set([
-                        startModule
-                    ]);
-                    // The current size of the new chunk
-                    let currentSize = startModule.size();
-                    // A pool of potential modules where the next module is selected from.
-                    // It's filled from the next module of the selected modules in every chunk.
-                    // It also keeps some metadata to improve performance [size, chunkStates].
-                    const potentialNextModules = new Map();
-                    for (const [chunkState, i] of allChunkStates){
-                        const nextModule = chunkState.modules[i + 1];
-                        if (nextModule && remainingModules.has(nextModule)) {
-                            potentialNextModules.set(nextModule, [
-                                nextModule.size(),
-                                chunkStatesByModule.get(nextModule)
-                            ]);
-                        }
-                    }
-                    // Try to add modules to the chunk until a break condition is met
-                    let cont;
-                    do {
-                        cont = false;
-                        // We try to select a module that reduces request count and
-                        // has the highest number of requests
-                        const orderedPotentialNextModules = [];
-                        for (const [nextModule, [size, nextChunkStates]] of potentialNextModules){
-                            let maxRequests = 0;
-                            for (const chunkState of nextChunkStates.keys()){
-                                // There is always some overlap
-                                if (allChunkStates.has(chunkState)) {
-                                    maxRequests = Math.max(maxRequests, chunkState.requests);
-                                }
-                            }
-                            orderedPotentialNextModules.push([
-                                nextModule,
-                                size,
-                                nextChunkStates,
-                                maxRequests
-                            ]);
-                        }
-                        orderedPotentialNextModules.sort((a, b)=>b[3] - a[3] || (a[0].identifier() < b[0].identifier() ? -1 : 1));
-                        // Try every potential module
-                        loop: for (const [nextModule, size, nextChunkStates] of orderedPotentialNextModules){
-                            if (currentSize + size > MAX_CSS_CHUNK_SIZE) {
-                                continue;
-                            }
-                            if (!strict) {
-                                // In loose mode we only check if the dependencies are not violated
-                                const dependent = allDependents.get(nextModule);
-                                if (dependent) {
-                                    for (const dep of dependent){
-                                        if (newChunkModules.has(dep)) {
-                                            continue loop;
-                                        }
-                                    }
-                                }
-                            } else {
-                                // In strict mode we check that none of the order in any chunk is changed by adding the module
-                                for (const [chunkState, i] of nextChunkStates){
-                                    const prevState = allChunkStates.get(chunkState);
-                                    if (prevState === undefined) {
-                                        // New chunk group, can add it, but should we?
-                                        // We only add that if below min size
-                                        if (currentSize < MIN_CSS_CHUNK_SIZE) {
-                                            continue;
-                                        } else {
-                                            continue loop;
-                                        }
-                                    } else if (prevState + 1 === i) {
-                                        continue;
-                                    } else {
-                                        continue loop;
-                                    }
-                                }
-                            }
-                            // Global CSS must not leak into unrelated chunks
-                            const nextIsGlobalCss = isGlobalCss(nextModule);
-                            if (nextIsGlobalCss && globalCssMode) {
-                                if (allChunkStates.size !== nextChunkStates.size) {
-                                    continue;
-                                }
-                            }
-                            if (globalCssMode) {
-                                for (const chunkState of nextChunkStates.keys()){
-                                    if (!allChunkStates.has(chunkState)) {
-                                        continue loop;
-                                    }
-                                }
-                            }
-                            if (nextIsGlobalCss) {
-                                for (const chunkState of allChunkStates.keys()){
-                                    if (!nextChunkStates.has(chunkState)) {
-                                        continue loop;
-                                    }
-                                }
-                            }
-                            potentialNextModules.delete(nextModule);
-                            currentSize += size;
-                            if (nextIsGlobalCss) {
-                                globalCssMode = true;
-                            }
-                            for (const [chunkState, i] of nextChunkStates){
-                                if (allChunkStates.has(chunkState)) {
-                                    // This reduces the request count of the chunk group
-                                    chunkState.requests--;
-                                }
-                                allChunkStates.set(chunkState, i);
-                                const newNextModule = chunkState.modules[i + 1];
-                                if (newNextModule && remainingModules.has(newNextModule) && !newChunkModules.has(newNextModule)) {
-                                    potentialNextModules.set(newNextModule, [
-                                        newNextModule.size(),
-                                        chunkStatesByModule.get(newNextModule)
-                                    ]);
-                                }
-                            }
-                            newChunkModules.add(nextModule);
-                            cont = true;
-                            break;
-                        }
-                    }while (cont);
-                    const newChunk = compilation.addChunk();
-                    newChunk.preventIntegration = true;
-                    newChunk.idNameHints.add('css');
-                    for (const module of newChunkModules){
-                        remainingModules.delete(module);
-                        chunkGraph.connectChunkAndModule(newChunk, module);
-                        newChunksByModule.set(module, newChunk);
-                    }
-                    changed = true;
-                }
-                for (const { chunk, modules } of chunkStates.values()){
-                    const chunks = new Set();
-                    for (const module of modules){
-                        const newChunk = newChunksByModule.get(module);
-                        if (newChunk) {
-                            chunkGraph.disconnectChunkAndModule(chunk, module);
-                            if (chunks.has(newChunk)) continue;
-                            chunks.add(newChunk);
-                            chunk.split(newChunk);
-                        }
-                    }
-                }
-                if (summary) {
-                    console.log('Top 20 chunks by request count:');
-                    const orderedChunkStates = [
-                        ...chunkStates.values()
-                    ];
-                    orderedChunkStates.sort((a, b)=>b.requests - a.requests);
-                    for (const { chunk, modules, requests } of orderedChunkStates.slice(0, 20)){
-                        console.log(`- ${requests} requests for ${chunk.name} (has ${modules.length} modules)`);
-                    }
-                }
-                return changed;
-            });
-        });
-    }
-}
-
-//# sourceMappingURL=css-chunking-plugin.js.map

package/assets/standalone/node_modules/next/dist/build/webpack/plugins/css-minimizer-plugin.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "CssMinimizerPlugin", {
-    enumerable: true,
-    get: function() {
-        return CssMinimizerPlugin;
-    }
-});
-const _cssnanosimple = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/cssnano-simple"));
-const _postcssscss = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/postcss-scss"));
-const _postcss = /*#__PURE__*/ _interop_require_default(require("postcss"));
-const _webpack = require("next/dist/compiled/webpack/webpack");
-const _utils = require("../utils");
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-// https://github.com/NMFR/optimize-css-assets-webpack-plugin/blob/0a410a9bf28c7b0e81a3470a13748e68ca2f50aa/src/index.js#L20
-const CSS_REGEX = /\.css(\?.*)?$/i;
-class CssMinimizerPlugin {
-    constructor(options){
-        this.__next_css_remove = true;
-        this.options = options;
-    }
-    optimizeAsset(file, asset) {
-        const postcssOptions = {
-            ...this.options.postcssOptions,
-            to: file,
-            from: file,
-            // We don't actually add this parser to support Sass. It can also be used
-            // for inline comment support. See the README:
-            // https://github.com/postcss/postcss-scss/blob/master/README.md#2-inline-comments-for-postcss
-            parser: _postcssscss.default
-        };
-        let input;
-        if (postcssOptions.map && asset.sourceAndMap) {
-            const { source, map } = asset.sourceAndMap();
-            input = source;
-            postcssOptions.map.prev = map ? map : false;
-        } else {
-            input = asset.source();
-        }
-        return (0, _postcss.default)([
-            (0, _cssnanosimple.default)({
-                colormin: false
-            }, _postcss.default)
-        ]).process(input, postcssOptions).then((res)=>{
-            if (res.map) {
-                return new _webpack.sources.SourceMapSource(res.css, file, res.map.toJSON());
-            } else {
-                return new _webpack.sources.RawSource(res.css);
-            }
-        });
-    }
-    apply(compiler) {
-        compiler.hooks.compilation.tap('CssMinimizerPlugin', (compilation)=>{
-            const cache = compilation.getCache('CssMinimizerPlugin');
-            compilation.hooks.processAssets.tapPromise({
-                name: 'CssMinimizerPlugin',
-                stage: _webpack.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_SIZE
-            }, async (assets)=>{
-                const compilationSpan = (0, _utils.getCompilationSpan)(compilation) || (0, _utils.getCompilationSpan)(compiler);
-                const cssMinimizerSpan = compilationSpan.traceChild('css-minimizer-plugin');
-                return cssMinimizerSpan.traceAsyncFn(async ()=>{
-                    const files = Object.keys(assets);
-                    await Promise.all(files.filter((file)=>CSS_REGEX.test(file)).map(async (file)=>{
-                        const assetSpan = cssMinimizerSpan.traceChild('minify-css');
-                        assetSpan.setAttribute('file', file);
-                        return assetSpan.traceAsyncFn(async ()=>{
-                            const assetSource = compilation.getAsset(file).source;
-                            const etag = cache.getLazyHashedEtag(assetSource);
-                            const cachedResult = await cache.getPromise(file, etag);
-                            assetSpan.setAttribute('cache', cachedResult ? 'HIT' : 'MISS');
-                            if (cachedResult) {
-                                compilation.updateAsset(file, cachedResult);
-                                return;
-                            }
-                            const result = await this.optimizeAsset(file, assetSource);
-                            await cache.storePromise(file, etag, result);
-                            compilation.updateAsset(file, result);
-                        });
-                    }));
-                });
-            });
-        });
-    }
-}
-
-//# sourceMappingURL=css-minimizer-plugin.js.map