@nilsr0711/drydock 0.1.0 → 0.1.1

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/webpack/plugins/rspack-flight-client-entry-plugin.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "RspackFlightClientEntryPlugin", {
+    enumerable: true,
+    get: function() {
+        return RspackFlightClientEntryPlugin;
+    }
+});
+const _ondemandentryhandler = require("../../../server/dev/on-demand-entry-handler");
+const _constants = require("../../../shared/lib/constants");
+const _buildcontext = require("../../build-context");
+const _pagetypes = require("../../../lib/page-types");
+const _getrspack = require("../../../shared/lib/get-rspack");
+const pluginState = (0, _buildcontext.getProxiedPluginState)({
+    // A map to track "action" -> "list of bundles".
+    serverActions: {},
+    edgeServerActions: {},
+    serverActionModules: {},
+    edgeServerActionModules: {},
+    ssrModules: {},
+    edgeSsrModules: {},
+    rscModules: {},
+    edgeRscModules: {},
+    injectedClientEntries: {}
+});
+class RspackFlightClientEntryPlugin {
+    constructor(options){
+        const { FlightClientEntryPlugin } = (0, _getrspack.getRspackCore)();
+        this.plugin = new FlightClientEntryPlugin({
+            ...options,
+            builtinAppLoader: !!process.env.BUILTIN_SWC_LOADER,
+            shouldInvalidateCb: ({ bundlePath, entryName, absolutePagePath, clientBrowserLoader })=>{
+                let shouldInvalidate = false;
+                const compiler = this.compiler;
+                const entries = (0, _ondemandentryhandler.getEntries)(compiler.outputPath);
+                const pageKey = (0, _ondemandentryhandler.getEntryKey)(_constants.COMPILER_NAMES.client, _pagetypes.PAGE_TYPES.APP, bundlePath);
+                if (!entries[pageKey]) {
+                    entries[pageKey] = {
+                        type: _ondemandentryhandler.EntryTypes.CHILD_ENTRY,
+                        parentEntries: new Set([
+                            entryName
+                        ]),
+                        absoluteEntryFilePath: absolutePagePath,
+                        bundlePath,
+                        request: clientBrowserLoader,
+                        dispose: false,
+                        lastActiveTime: Date.now()
+                    };
+                    shouldInvalidate = true;
+                } else {
+                    const entryData = entries[pageKey];
+                    // New version of the client loader
+                    if (entryData.request !== clientBrowserLoader) {
+                        entryData.request = clientBrowserLoader;
+                        shouldInvalidate = true;
+                    }
+                    if (entryData.type === _ondemandentryhandler.EntryTypes.CHILD_ENTRY) {
+                        entryData.parentEntries.add(entryName);
+                    }
+                    entryData.dispose = false;
+                    entryData.lastActiveTime = Date.now();
+                }
+                return shouldInvalidate;
+            },
+            invalidateCb: ()=>{
+                const compiler = this.compiler;
+                // Invalidate in development to trigger recompilation
+                const invalidator = (0, _ondemandentryhandler.getInvalidator)(compiler.outputPath);
+                // Check if any of the entry injections need an invalidation
+                if (invalidator) {
+                    invalidator.invalidate([
+                        _constants.COMPILER_NAMES.client
+                    ]);
+                }
+            },
+            stateCb: (state)=>{
+                Object.assign(pluginState.serverActions, state.serverActions);
+                Object.assign(pluginState.edgeServerActions, state.edgeServerActions);
+                Object.assign(pluginState.serverActionModules, state.serverActionModules);
+                Object.assign(pluginState.edgeServerActionModules, state.edgeServerActionModules);
+                Object.assign(pluginState.ssrModules, state.ssrModules);
+                Object.assign(pluginState.edgeSsrModules, state.edgeSsrModules);
+                Object.assign(pluginState.rscModules, state.rscModules);
+                Object.assign(pluginState.edgeRscModules, state.edgeRscModules);
+                Object.assign(pluginState.injectedClientEntries, state.injectedClientEntries);
+            }
+        });
+    }
+    apply(compiler) {
+        this.compiler = compiler;
+        this.plugin.apply(compiler);
+    }
+}
+
+//# sourceMappingURL=rspack-flight-client-entry-plugin.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/webpack/plugins/rspack-profiling-plugin.js

@@ -0,0 +1,62 @@
+// A basic implementation to allow loaders access to loaderContext.currentTraceSpan
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    RspackProfilingPlugin: null,
+    compilationSpans: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    RspackProfilingPlugin: function() {
+        return RspackProfilingPlugin;
+    },
+    compilationSpans: function() {
+        return compilationSpans;
+    }
+});
+const _getrspack = require("../../../shared/lib/get-rspack");
+const pluginName = 'RspackProfilingPlugin';
+const moduleSpansByCompilation = new WeakMap();
+const compilationSpans = new WeakMap();
+class RspackProfilingPlugin {
+    constructor({ runWebpackSpan }){
+        this.runWebpackSpan = runWebpackSpan;
+    }
+    apply(compiler) {
+        compiler.hooks.thisCompilation.tap({
+            name: pluginName,
+            stage: -Infinity
+        }, (compilation)=>{
+            const rspack = (0, _getrspack.getRspackCore)();
+            moduleSpansByCompilation.set(compilation, new WeakMap());
+            compilationSpans.set(compilation, this.runWebpackSpan.traceChild('compilation-' + compilation.name));
+            const compilationSpan = this.runWebpackSpan.traceChild(`compilation-${compilation.name}`);
+            const moduleHooks = rspack.NormalModule.getCompilationHooks(compilation);
+            moduleHooks.loader.tap(pluginName, (loaderContext, module1)=>{
+                var _moduleSpansByCompilation_get;
+                const moduleSpan = (_moduleSpansByCompilation_get = moduleSpansByCompilation.get(compilation)) == null ? void 0 : _moduleSpansByCompilation_get.get(module1);
+                loaderContext.currentTraceSpan = moduleSpan;
+            });
+            compilation.hooks.buildModule.tap(pluginName, (module1)=>{
+                var _moduleSpansByCompilation_get;
+                const span = compilationSpan.traceChild('build-module');
+                span.setAttribute('name', module1.userRequest);
+                span.setAttribute('layer', module1.layer);
+                moduleSpansByCompilation == null ? void 0 : (_moduleSpansByCompilation_get = moduleSpansByCompilation.get(compilation)) == null ? void 0 : _moduleSpansByCompilation_get.set(module1, span);
+            });
+            compilation.hooks.succeedModule.tap(pluginName, (module1)=>{
+                var _moduleSpansByCompilation_get_get, _moduleSpansByCompilation_get;
+                moduleSpansByCompilation == null ? void 0 : (_moduleSpansByCompilation_get = moduleSpansByCompilation.get(compilation)) == null ? void 0 : (_moduleSpansByCompilation_get_get = _moduleSpansByCompilation_get.get(module1)) == null ? void 0 : _moduleSpansByCompilation_get_get.stop();
+            });
+        });
+    }
+}
+
+//# sourceMappingURL=rspack-profiling-plugin.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/webpack/plugins/slow-module-detection-plugin.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return SlowModuleDetectionPlugin;
+    }
+});
+const _picocolors = require("../../../lib/picocolors");
+const PLUGIN_NAME = 'SlowModuleDetectionPlugin';
+const TreeSymbols = {
+    VERTICAL_LINE: '│  ',
+    BRANCH: '├─ '
+};
+const PATH_TRUNCATION_LENGTH = 120;
+// Matches node_modules paths, including pnpm-style paths
+const NODE_MODULES_PATH_PATTERN = /node_modules(?:\/\.pnpm)?\/(.*)/;
+const getModuleIdentifier = (module)=>{
+    const debugId = module.debugId;
+    return String(debugId);
+};
+const getModuleDisplayName = (module)=>{
+    const resourcePath = 'resource' in module && typeof module.resource === 'string' ? module.resource : undefined;
+    if (!resourcePath) {
+        return undefined;
+    }
+    let displayPath = resourcePath.replace(process.cwd(), '.');
+    const nodeModulesMatch = displayPath.match(NODE_MODULES_PATH_PATTERN);
+    if (nodeModulesMatch) {
+        return nodeModulesMatch[1];
+    }
+    return displayPath;
+};
+/**
+ * Truncates a path to a maximum length. If the path exceeds this length,
+ * it will be truncated in the middle and replaced with '...'.
+ */ function truncatePath(path, maxLength) {
+    // If the path length is within the limit, return it as is
+    if (path.length <= maxLength) return path;
+    // Calculate the available length for the start and end segments after accounting for '...'
+    const availableLength = maxLength - 3;
+    const startSegmentLength = Math.ceil(availableLength / 2);
+    const endSegmentLength = Math.floor(availableLength / 2);
+    // Extract the start and end segments of the path
+    const startSegment = path.slice(0, startSegmentLength);
+    const endSegment = path.slice(-endSegmentLength);
+    // Return the truncated path with '...' in the middle
+    return `${startSegment}...${endSegment}`;
+}
+class ModuleBuildTimeAnalyzer {
+    constructor(options){
+        this.options = options;
+        this.pendingModules = [];
+        this.modules = new Map();
+        this.moduleParents = new Map();
+        this.moduleChildren = new Map();
+        this.isFinalized = false;
+        this.moduleBuildTimes = new WeakMap();
+        this.buildTimeThresholdMs = options.buildTimeThresholdMs;
+    }
+    recordModuleBuildTime(module, duration) {
+        // Webpack guarantees that no more modules will be built after finishModules hook is called,
+        // where we generate the report. This check is just a defensive measure.
+        if (this.isFinalized) {
+            throw Object.defineProperty(new Error(`Invariant (SlowModuleDetectionPlugin): Module is recorded after the report is generated. This is a Next.js internal bug.`), "__NEXT_ERROR_CODE", {
+                value: "E630",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        if (duration < this.buildTimeThresholdMs) {
+            return; // Skip fast modules
+        }
+        this.moduleBuildTimes.set(module, duration);
+        this.pendingModules.push(module);
+    }
+    /**
+   * For each slow module, traverses up the dependency chain to find all ancestor modules.
+   * Builds a directed graph where:
+   * 1. Each slow module and its ancestors become nodes
+   * 2. Edges represent "imported by" relationships
+   * 3. Root nodes are entry points with no parents
+   *
+   * The resulting graph allows us to visualize the import chains that led to slow builds.
+   */ prepareReport(compilation) {
+        for (const module of this.pendingModules){
+            const chain = new Set();
+            // Walk up the module graph until we hit a root module (no issuer) to populate the chain
+            {
+                let currentModule = module;
+                chain.add(currentModule);
+                while(true){
+                    const issuerModule = compilation.moduleGraph.getIssuer(currentModule);
+                    if (!issuerModule) break;
+                    if (chain.has(issuerModule)) {
+                        throw Object.defineProperty(new Error(`Invariant (SlowModuleDetectionPlugin): Circular dependency detected in module graph. This is a Next.js internal bug.`), "__NEXT_ERROR_CODE", {
+                            value: "E631",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                    chain.add(issuerModule);
+                    currentModule = issuerModule;
+                }
+            }
+            // Add all visited modules to our graph and create parent-child relationships
+            let previousModule = null;
+            for (const currentModule of chain){
+                const moduleId = getModuleIdentifier(currentModule);
+                if (!this.modules.has(moduleId)) {
+                    this.modules.set(moduleId, currentModule);
+                }
+                if (previousModule) {
+                    this.moduleParents.set(previousModule, currentModule);
+                    let parentChildren = this.moduleChildren.get(currentModule);
+                    if (!parentChildren) {
+                        parentChildren = new Map();
+                        this.moduleChildren.set(currentModule, parentChildren);
+                    }
+                    parentChildren.set(getModuleIdentifier(previousModule), previousModule);
+                }
+                previousModule = currentModule;
+            }
+        }
+        this.isFinalized = true;
+    }
+    generateReport(compilation) {
+        if (!this.isFinalized) {
+            this.prepareReport(compilation);
+        }
+        // Find root modules (those with no parents)
+        const rootModules = [
+            ...this.modules.values()
+        ].filter((node)=>!this.moduleParents.has(node));
+        const formatModuleNode = (node, depth)=>{
+            const moduleName = getModuleDisplayName(node) || '';
+            if (!moduleName) {
+                return formatChildModules(node, depth);
+            }
+            const prefix = ' ' + TreeSymbols.VERTICAL_LINE.repeat(depth) + TreeSymbols.BRANCH;
+            const moduleText = (0, _picocolors.blue)(truncatePath(moduleName, PATH_TRUNCATION_LENGTH - prefix.length));
+            const buildTimeMs = this.moduleBuildTimes.get(node);
+            const duration = buildTimeMs ? (0, _picocolors.yellow)(` (${Math.ceil(buildTimeMs)}ms)`) : '';
+            return prefix + moduleText + duration + '\n' + formatChildModules(node, depth + 1);
+        };
+        const formatChildModules = (node, depth)=>{
+            const children = this.moduleChildren.get(node);
+            if (!children) return '';
+            return [
+                ...children
+            ].map(([_, child])=>formatModuleNode(child, depth)).join('');
+        };
+        const report = rootModules.map((root)=>formatModuleNode(root, 0)).join('');
+        if (report) {
+            console.log((0, _picocolors.green)(`🐌 Detected slow modules while compiling ${this.options.compilerType}:`) + '\n' + report);
+        }
+    }
+}
+class SlowModuleDetectionPlugin {
+    constructor(options){
+        this.options = options;
+        this.apply = (compiler)=>{
+            compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation)=>{
+                const analyzer = new ModuleBuildTimeAnalyzer(this.options);
+                const moduleBuildStartTimes = new WeakMap();
+                compilation.hooks.buildModule.tap(PLUGIN_NAME, (module)=>{
+                    moduleBuildStartTimes.set(module, performance.now());
+                });
+                compilation.hooks.succeedModule.tap(PLUGIN_NAME, (module)=>{
+                    const startTime = moduleBuildStartTimes.get(module);
+                    if (!startTime) {
+                        throw Object.defineProperty(new Error(`Invariant (SlowModuleDetectionPlugin): Unable to find the start time for a module build. This is a Next.js internal bug.`), "__NEXT_ERROR_CODE", {
+                            value: "E629",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                    analyzer.recordModuleBuildTime(module, performance.now() - startTime);
+                });
+                compilation.hooks.finishModules.tap(PLUGIN_NAME, ()=>{
+                    analyzer.generateReport(compilation);
+                });
+            });
+        };
+    }
+}
+
+//# sourceMappingURL=slow-module-detection-plugin.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/webpack/plugins/subresource-integrity-plugin.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "SubresourceIntegrityPlugin", {
+    enumerable: true,
+    get: function() {
+        return SubresourceIntegrityPlugin;
+    }
+});
+const _webpack = require("next/dist/compiled/webpack/webpack");
+const _crypto = /*#__PURE__*/ _interop_require_default(require("crypto"));
+const _constants = require("../../../shared/lib/constants");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const PLUGIN_NAME = 'SubresourceIntegrityPlugin';
+class SubresourceIntegrityPlugin {
+    constructor(algorithm){
+        this.algorithm = algorithm;
+    }
+    apply(compiler) {
+        compiler.hooks.make.tap(PLUGIN_NAME, (compilation)=>{
+            compilation.hooks.afterProcessAssets.tap({
+                name: PLUGIN_NAME,
+                stage: _webpack.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+            }, ()=>{
+                // Collect all the assets.
+                let files = new Set();
+                for (const asset of compilation.getAssets()){
+                    files.add(asset.name);
+                }
+                // For each file, deduped, calculate the file hash.
+                const hashes = {};
+                for (const file of files.values()){
+                    // Get the buffer for the asset.
+                    const asset = compilation.getAsset(file);
+                    if (!asset) {
+                        throw Object.defineProperty(new Error(`could not get asset: ${file}`), "__NEXT_ERROR_CODE", {
+                            value: "E349",
+                            enumerable: false,
+                            configurable: true
+                        });
+                    }
+                    // Get the buffer for the asset.
+                    const buffer = asset.source.buffer();
+                    // Create the hash for the content.
+                    const hash = _crypto.default.createHash(this.algorithm).update(buffer).digest().toString('base64');
+                    hashes[file] = `${this.algorithm}-${hash}`;
+                }
+                const json = JSON.stringify(hashes, null, 2);
+                const file = 'server/' + _constants.SUBRESOURCE_INTEGRITY_MANIFEST;
+                compilation.emitAsset(file + '.js', new _webpack.sources.RawSource(`self.__SUBRESOURCE_INTEGRITY_MANIFEST=${JSON.stringify(json)}`));
+                compilation.emitAsset(file + '.json', new _webpack.sources.RawSource(json));
+            });
+        });
+    }
+}
+
+//# sourceMappingURL=subresource-integrity-plugin.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/webpack/plugins/telemetry-plugin/telemetry-plugin.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TelemetryPlugin", {
+    enumerable: true,
+    get: function() {
+        return TelemetryPlugin;
+    }
+});
+const _usecachetrackerutils = require("./use-cache-tracker-utils");
+// Map of a feature module to the file it belongs in the next package.
+const FEATURE_MODULE_MAP = new Map([
+    [
+        'next/image',
+        '/next/image.js'
+    ],
+    [
+        'next/future/image',
+        '/next/future/image.js'
+    ],
+    [
+        'next/legacy/image',
+        '/next/legacy/image.js'
+    ],
+    [
+        'next/script',
+        '/next/script.js'
+    ],
+    [
+        'next/dynamic',
+        '/next/dynamic.js'
+    ]
+]);
+const FEATURE_MODULE_REGEXP_MAP = new Map([
+    [
+        '@next/font/google',
+        /\/@next\/font\/google\/target.css?.+$/
+    ],
+    [
+        '@next/font/local',
+        /\/@next\/font\/local\/target.css?.+$/
+    ],
+    [
+        'next/font/google',
+        /\/next\/font\/google\/target.css?.+$/
+    ],
+    [
+        'next/font/local',
+        /\/next\/font\/local\/target.css?.+$/
+    ]
+]);
+// List of build features used in webpack configuration
+const BUILD_FEATURES = [
+    'swcLoader',
+    'swcRelay',
+    'swcStyledComponents',
+    'swcReactRemoveProperties',
+    'swcExperimentalDecorators',
+    'swcRemoveConsole',
+    'swcImportSource',
+    'swcEmotion',
+    'swc/target/x86_64-apple-darwin',
+    'swc/target/x86_64-unknown-linux-gnu',
+    'swc/target/x86_64-pc-windows-msvc',
+    'swc/target/i686-pc-windows-msvc',
+    'swc/target/aarch64-unknown-linux-gnu',
+    'swc/target/armv7-unknown-linux-gnueabihf',
+    'swc/target/aarch64-apple-darwin',
+    'swc/target/aarch64-linux-android',
+    'swc/target/arm-linux-androideabi',
+    'swc/target/x86_64-unknown-freebsd',
+    'swc/target/x86_64-unknown-linux-musl',
+    'swc/target/aarch64-unknown-linux-musl',
+    'swc/target/aarch64-pc-windows-msvc',
+    'turbotrace',
+    'transpilePackages',
+    'skipProxyUrlNormalize',
+    'skipTrailingSlashRedirect',
+    'modularizeImports',
+    'esmExternals',
+    'webpackPlugins'
+];
+const eliminatedPackages = new Set();
+const useCacheTracker = (0, _usecachetrackerutils.createUseCacheTracker)();
+/**
+ * Determine if there is a feature of interest in the specified 'module'.
+ */ function findFeatureInModule(module) {
+    if (module.type !== 'javascript/auto') {
+        return;
+    }
+    for (const [feature, path] of FEATURE_MODULE_MAP){
+        var _module_resource;
+        // imports like "http" will be undefined resource in rspack
+        if ((_module_resource = module.resource) == null ? void 0 : _module_resource.endsWith(path)) {
+            return feature;
+        }
+    }
+    const normalizedIdentifier = module.identifier().replace(/\\/g, '/');
+    for (const [feature, regexp] of FEATURE_MODULE_REGEXP_MAP){
+        if (regexp.test(normalizedIdentifier)) {
+            return feature;
+        }
+    }
+}
+/**
+ * Find unique origin modules in the specified 'connections', which possibly
+ * contains more than one connection for a module due to different types of
+ * dependency.
+ */ function findUniqueOriginModulesInConnections(connections, originModule) {
+    const originModules = new Set();
+    for (const connection of connections){
+        if (!originModules.has(connection.originModule) && connection.originModule !== originModule) {
+            originModules.add(connection.originModule);
+        }
+    }
+    return originModules;
+}
+class TelemetryPlugin {
+    // Build feature usage is on/off and is known before the build starts
+    constructor(buildFeaturesMap){
+        this.usageTracker = new Map();
+        for (const featureName of BUILD_FEATURES){
+            this.usageTracker.set(featureName, {
+                featureName,
+                invocationCount: buildFeaturesMap.get(featureName) ? 1 : 0
+            });
+        }
+        for (const featureName of FEATURE_MODULE_MAP.keys()){
+            this.usageTracker.set(featureName, {
+                featureName,
+                invocationCount: 0
+            });
+        }
+        for (const featureName of FEATURE_MODULE_REGEXP_MAP.keys()){
+            this.usageTracker.set(featureName, {
+                featureName,
+                invocationCount: 0
+            });
+        }
+    }
+    addUsage(featureName, invocationCount) {
+        this.usageTracker.set(featureName, {
+            featureName,
+            invocationCount
+        });
+    }
+    apply(compiler) {
+        compiler.hooks.make.tapAsync(TelemetryPlugin.name, async (compilation, callback)=>{
+            compilation.hooks.finishModules.tapAsync(TelemetryPlugin.name, async (modules, modulesFinish)=>{
+                for (const module of modules){
+                    const feature = findFeatureInModule(module);
+                    if (!feature) {
+                        continue;
+                    }
+                    const connections = compilation.moduleGraph.getIncomingConnections(module);
+                    const originModules = findUniqueOriginModulesInConnections(connections, module);
+                    this.usageTracker.get(feature).invocationCount = originModules.size;
+                }
+                modulesFinish();
+            });
+            callback();
+        });
+        if (compiler.options.mode === 'production' && !compiler.watchMode) {
+            compiler.hooks.thisCompilation.tap(TelemetryPlugin.name, (compilation)=>{
+                const moduleHooks = compiler.webpack.NormalModule.getCompilationHooks(compilation);
+                moduleHooks.loader.tap(TelemetryPlugin.name, (loaderContext)=>{
+                    ;
+                    loaderContext.eliminatedPackages = eliminatedPackages;
+                    loaderContext.useCacheTracker = useCacheTracker;
+                });
+            });
+        }
+    }
+    usages() {
+        return [
+            ...this.usageTracker.values()
+        ];
+    }
+    packagesUsedInServerSideProps() {
+        return Array.from(eliminatedPackages);
+    }
+    getUseCacheTracker() {
+        return Object.fromEntries(useCacheTracker);
+    }
+}
+
+//# sourceMappingURL=telemetry-plugin.js.map

package/.next/standalone/node_modules/.pnpm/next@16.2.6_react-dom@19.2.6_react@19.2.6__react@19.2.6/node_modules/next/dist/build/webpack/plugins/telemetry-plugin/use-cache-tracker-utils.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+0 && (module.exports = {
+    createUseCacheTracker: null,
+    mergeUseCacheTrackers: null
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createUseCacheTracker: function() {
+        return createUseCacheTracker;
+    },
+    mergeUseCacheTrackers: function() {
+        return mergeUseCacheTrackers;
+    }
+});
+const createUseCacheTracker = ()=>new Map();
+const mergeUseCacheTrackers = (tracker1, tracker2)=>{
+    const mergedTracker = {
+        ...tracker1
+    };
+    if (tracker2) {
+        for(const key in tracker2){
+            if (Object.prototype.hasOwnProperty.call(tracker2, key)) {
+                const typedKey = key;
+                if (mergedTracker[typedKey] !== undefined) {
+                    mergedTracker[typedKey] += tracker2[typedKey];
+                } else {
+                    mergedTracker[typedKey] = tracker2[typedKey];
+                }
+            }
+        }
+    }
+    return mergedTracker;
+};
+
+//# sourceMappingURL=use-cache-tracker-utils.js.map