package-build-stats 8.0.0-beta.6 → 8.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Shubham Kanodia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,80 @@
+<img src="https://img.shields.io/npm/v/package-build-stats.svg" /> <img src="https://img.shields.io/npm/l/package-build-stats.svg" /> <img src="https://img.shields.io/github/workflow/status/pastelsky/package-build-stats/CI/master"/>
+
+This is the function that powers the core of building, minifying and gzipping of packages in bundlephobia.
+
+## Usage
+
+```js
+const { getPackageStats } = require('package-build-stats')
+```
+
+#### Building packages from npm
+
+##### Building the latest stable version
+
+```js
+const results = await getPackageStats('moment')
+```
+
+##### Building a specific version / tag
+
+```js
+const results = await getPackageStats('moment@2.24.0')
+```
+
+##### Building local packages (beta)
+
+```js
+const results = await getPackageStats('~/dev/my-npm-package') // must have a package.json
+```
+
+##### Using different package managers
+
+```js
+// Use Bun for 13x faster installs!
+const results = await getPackageStats('lodash', { client: 'bun' })
+
+// Or use pnpm
+const results = await getPackageStats('lodash', { client: 'pnpm' })
+
+// Or use yarn
+const results = await getPackageStats('lodash', { client: 'yarn' })
+```
+
+#### Passing options to the build
+
+```js
+const results = await getBuiltPackageStats('moment', options)
+```
+
+##### Options
+
+| Option             | Values                          | Default  | Description                                                                                                                                                     |
+| ------------------ | ------------------------------- | -------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| client             | `npm`, `yarn`, `pnpm`, or `bun` | `npm`    | Which client to use to install package for building. **Bun is 13x faster!**                                                                                     |
+| limitConcurrency   | `true` or `false`               | `false`  | When using `yarn` as the client, use the network mutex to limit concurrency                                                                                     |
+| networkConcurrency | `number`                        | `false`  | When using `yarn` or `bun` as client, limit simultaneous installs to this number.                                                                               |
+| customImports      | `Array<string>`                 | `null`   | By default, the default export is used for calculating sizes. Setting this option allows calculation of package stats based on more granular top-level exports. |
+| minifier           | `terser` or `esbuild`           | `terser` | ESbuild is faster, albeit with marginally larger file sizes                                                                                                     |
+| installTimeout     | number (ms)                     | 30000    | Timeout for package install                                                                                                                                     |
+
+## Listening to events
+
+`package-build-stats` emits various lifecycle events when building a package.
+You can listen to these events by subscribing to the event emitter (based on [mitt](https://github.com/developit/mitt)).
+
+```js
+import { eventQueue } from 'package-build-stats'
+
+// Listen to all events
+eventQueue.on('*', callback)
+
+// Listen to specific events
+eventQueue.on('TASK_PACKAGE_BUILD', callback)
+```
+
+For a list of all events, see [this](src/utils/telemetry.utils.ts).
+
+## Contributing
+
+See [contributing guide.](CONTRIBUTING.md)

package/bin/cli.js

@@ -0,0 +1,5 @@
+require('esbuild-register/dist/node').register({
+  target: 'es2020',
+})
+
+require('./cli.ts')

package/build/common.types.d.ts

@@ -1,29 +1,26 @@
-export declare type Minifier = 'esbuild' | 'terser';
-export declare type AllOptions = {
+type PackageManager = 'npm' | 'yarn' | 'pnpm' | 'bun';
+type AllOptions = {
     customImports?: Array<string>;
     splitCustomImports?: boolean;
     debug?: boolean;
-    calcParse?: boolean;
+    minify?: boolean;
     esm?: boolean;
     entryFilename?: string;
-    client?: 'npm' | 'yarn';
+    client?: PackageManager | PackageManager[];
     limitConcurrency?: boolean;
     networkConcurrency?: number;
     additionalPackages?: Array<string>;
     isLocal?: boolean;
     installTimeout?: number;
 };
-export declare type BuildPackageOptions = Pick<AllOptions, 'customImports' | 'splitCustomImports' | 'debug' | 'calcParse'> & {
+export type BuildPackageOptions = Pick<AllOptions, 'customImports' | 'splitCustomImports' | 'debug' | 'minify'> & {
     includeDependencySizes: boolean;
-    minifier: Minifier;
 };
-export declare type CreateEntryPointOptions = Pick<AllOptions, 'esm' | 'customImports' | 'entryFilename'>;
-export declare type InstallPackageOptions = Pick<AllOptions, 'client' | 'limitConcurrency' | 'networkConcurrency' | 'additionalPackages' | 'isLocal' | 'installTimeout'>;
-export declare type GetPackageStatsOptions = Pick<AllOptions, 'client' | 'limitConcurrency' | 'networkConcurrency' | 'debug' | 'customImports' | 'installTimeout'> & {
-    minifier?: Minifier;
-};
-export declare type Externals = {
+export type CreateEntryPointOptions = Pick<AllOptions, 'esm' | 'customImports' | 'entryFilename'>;
+export type InstallPackageOptions = Pick<AllOptions, 'client' | 'limitConcurrency' | 'networkConcurrency' | 'additionalPackages' | 'isLocal' | 'installTimeout' | 'debug'>;
+export type GetPackageStatsOptions = Pick<AllOptions, 'client' | 'limitConcurrency' | 'networkConcurrency' | 'debug' | 'customImports' | 'installTimeout' | 'minify'>;
+export type Externals = {
     externalPackages: Array<string>;
     externalBuiltIns: Array<string>;
 };
-//# sourceMappingURL=common.types.d.ts.map
+export {};

package/build/common.types.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=common.types.js.map

package/build/config/{index.d.ts → config.d.ts}

@@ -1,6 +1,4 @@
 declare const _default: {
     tmp: string;
-    compileConcurrency: number;
 };
 export default _default;
-//# sourceMappingURL=index.d.ts.map

package/build/config/{index.js → config.js}

@@ -7,6 +7,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 exports.default = {
     tmp: path_1.default.join('/tmp', 'tmp-build'),
-    compileConcurrency: 2,
 };
-//# sourceMappingURL=index.js.map

package/build/config/makeRspackConfig.d.ts

@@ -0,0 +1,11 @@
+import type { Entry, Configuration } from '@rspack/core';
+import { Externals } from '../common.types';
+type MakeRspackConfigOptions = {
+    packageName: string;
+    externals: Externals;
+    debug?: boolean;
+    minify?: boolean;
+    entry: Entry;
+};
+export default function makeRspackConfig({ packageName: _packageName, entry, externals, debug: _debug, minify, }: MakeRspackConfigOptions): Configuration;
+export {};

package/build/config/makeRspackConfig.js

@@ -0,0 +1,168 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = makeRspackConfig;
+const autoprefixer_1 = __importDefault(require("autoprefixer"));
+const escape_string_regexp_1 = __importDefault(require("escape-string-regexp"));
+const core_1 = __importDefault(require("@rspack/core"));
+function makeRspackConfig({ packageName: _packageName, entry, externals, debug: _debug, minify = true, }) {
+    const externalsRegex = makeExternalsRegex(externals.externalPackages);
+    const isExternalRequest = (request) => {
+        const isPeerDep = externals.externalPackages.length
+            ? externalsRegex.test(request)
+            : false;
+        const isBuiltIn = externals.externalBuiltIns.includes(request);
+        return isPeerDep || isBuiltIn;
+    };
+    const configuration = {
+        entry: entry,
+        mode: 'production',
+        devtool: _debug ? 'source-map' : false,
+        optimization: {
+            runtimeChunk: { name: 'runtime' },
+            realContentHash: false,
+            minimize: minify,
+            // Rspack automatically uses its built-in default minifiers:
+            // - SwcJsMinimizerRspackPlugin for JS (SWC-based, very fast)
+            // - LightningCssMinimizerRspackPlugin for CSS (Lightning CSS-based)
+            // See: https://rspack.rs/guide/optimization/production
+            splitChunks: {
+                cacheGroups: {
+                    styles: {
+                        name: 'main',
+                        test: /\.css$/,
+                        chunks: 'all',
+                    },
+                },
+            },
+        },
+        stats: {
+            source: true,
+            modules: true,
+            nestedModules: true,
+            reasons: true,
+            depth: true,
+            chunkModules: true,
+        },
+        resolve: {
+            modules: ['node_modules'],
+            extensions: [
+                '.web.mjs',
+                '.mjs',
+                '.web.js',
+                '.js',
+                '.mjs',
+                '.json',
+                '.css',
+                '.sass',
+                '.scss',
+            ],
+            mainFields: ['browser', 'module', 'main', 'style'],
+        },
+        module: {
+            rules: [
+                {
+                    type: 'javascript/auto',
+                    test: /\.mjs$/,
+                    use: [],
+                },
+                {
+                    test: /\.css$/,
+                    type: 'javascript/auto',
+                    use: [
+                        core_1.default.CssExtractRspackPlugin.loader,
+                        require.resolve('css-loader'),
+                    ],
+                },
+                {
+                    test: /\.(html|svelte)$/,
+                    use: {
+                        loader: require.resolve('svelte-loader'),
+                        options: {
+                            emitCss: true,
+                        },
+                    },
+                },
+                // {
+                //   test: /\.vue$/,
+                //   loader: require.resolve('vue-loader'),
+                // },
+                {
+                    test: /\.(scss|sass)$/,
+                    type: 'javascript/auto',
+                    use: [
+                        core_1.default.CssExtractRspackPlugin.loader,
+                        require.resolve('css-loader'),
+                        {
+                            loader: require.resolve('postcss-loader'),
+                            options: {
+                                postcssOptions: {
+                                    plugins: [(0, autoprefixer_1.default)()],
+                                },
+                            },
+                        },
+                        require.resolve('sass-loader'),
+                    ],
+                },
+                {
+                    test: /\.less$/,
+                    type: 'javascript/auto',
+                    use: [
+                        core_1.default.CssExtractRspackPlugin.loader,
+                        require.resolve('css-loader'),
+                        {
+                            loader: require.resolve('postcss-loader'),
+                            options: {
+                                postcssOptions: {
+                                    plugins: [
+                                        (0, autoprefixer_1.default)({
+                                            overrideBrowserslist: [
+                                                'last 5 Chrome versions',
+                                                'last 5 Firefox versions',
+                                                'Safari >= 8',
+                                                'Explorer >= 10',
+                                                'edge >= 12',
+                                            ],
+                                        }),
+                                    ],
+                                },
+                            },
+                        },
+                        {
+                            loader: require.resolve('less-loader'),
+                            options: {
+                                lessOptions: {
+                                    javascriptEnabled: true,
+                                },
+                            },
+                        },
+                    ],
+                },
+            ],
+        },
+        plugins: [
+            new core_1.default.CssExtractRspackPlugin({
+                filename: '[name].bundle.css',
+            }),
+        ],
+        node: {
+            global: false,
+        },
+        output: {
+            filename: '[name].bundle.js',
+        },
+        externals: ({ request }, callback) => isExternalRequest(request || '')
+            ? callback(undefined, 'commonjs ' + request)
+            : callback(undefined),
+    };
+    return configuration;
+}
+function makeExternalsRegex(externals) {
+    let externalsRegex = externals
+        .map(dep => `^${(0, escape_string_regexp_1.default)(dep)}$|^${(0, escape_string_regexp_1.default)(dep)}\\/`)
+        .join('|');
+    externalsRegex = `(${externalsRegex})`;
+    return new RegExp(externalsRegex);
+}

package/build/errors/CustomError.d.ts

@@ -40,4 +40,3 @@ export declare class UnexpectedBuildError extends CustomError {
     constructor(originalError: any, extra?: any);
 }
 export {};
-//# sourceMappingURL=CustomError.d.ts.map

package/build/errors/CustomError.js

@@ -78,4 +78,3 @@ class UnexpectedBuildError extends CustomError {
     }
 }
 exports.UnexpectedBuildError = UnexpectedBuildError;
-//# sourceMappingURL=CustomError.js.map

package/build/getDependencySizeTree.d.ts

@@ -0,0 +1,6 @@
+type RspackStatsCompilation = NonNullable<ReturnType<NonNullable<import('@rspack/core').Stats['toJson']>>>;
+declare function bundleSizeTree(packageName: string, stats: RspackStatsCompilation): Promise<{
+    name: string;
+    approximateSize: number;
+}[]>;
+export default bundleSizeTree;

package/build/getDependencySizeTree.js

@@ -0,0 +1,277 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const core_1 = require("@swc/core");
+const CustomError_1 = require("./errors/CustomError");
+const telemetry_utils_1 = __importDefault(require("./utils/telemetry.utils"));
+const perf_hooks_1 = require("perf_hooks");
+function modulePath(identifier) {
+    // the format of module paths is
+    //   '(<loader expression>!)?/path/to/module.js'
+    // OR
+    // 'javascript/esm|/some/path'
+    let loaderRegex = /.*!/;
+    const withoutLoader = identifier.replace(loaderRegex, '');
+    if (withoutLoader.includes('|'))
+        return withoutLoader.split('|')[1];
+    return withoutLoader;
+}
+function getUtf8Size(value) {
+    const size = Buffer.byteLength(value, 'utf8');
+    if (process.env.DEBUG_SIZE && Math.random() < 0.01) {
+        // Only debug 1% to avoid spam
+        console.log(`Size: ${size} bytes`);
+    }
+    return size;
+}
+/**
+ * Extract all package names from a module path to build a dependency chain.
+ * For example: /node_modules/a/node_modules/b/index.js returns ['a', 'b']
+ * This preserves the old behavior of showing nested dependencies.
+ */
+function extractPackageNamesFromPath(moduleFilePath) {
+    // pnpm will serve packages from a global symlink (.pnpm/package@version/node_modules/package)
+    // needs to be stripped off
+    const pnpmPrefix = '.pnpm\\' + path_1.default.sep + '.+\\' + path_1.default.sep + 'node_modules\\' + path_1.default.sep;
+    const packages = moduleFilePath.split(new RegExp('\\' + path_1.default.sep + 'node_modules\\' + path_1.default.sep + `(?:${pnpmPrefix})?`));
+    if (packages.length <= 1)
+        return [];
+    const lastSegment = packages.pop();
+    if (!lastSegment)
+        return [];
+    // Extract the package name from the last segment
+    let lastPackageName;
+    if (lastSegment[0] === '@') {
+        // package is a scoped package
+        const offset = lastSegment.indexOf(path_1.default.sep) + 1;
+        lastPackageName = lastSegment.slice(0, offset + lastSegment.slice(offset).indexOf(path_1.default.sep));
+    }
+    else {
+        lastPackageName = lastSegment.slice(0, lastSegment.indexOf(path_1.default.sep));
+    }
+    packages.push(lastPackageName);
+    packages.shift(); // Remove the first empty element
+    return packages;
+}
+async function minifyDependencyCode(source) {
+    if (process.env.DEBUG_SIZE) {
+        console.log('Minifying dependency code...');
+    }
+    try {
+        const startTime = Date.now();
+        const result = await (0, core_1.minify)(source, {
+            compress: true,
+            mangle: true,
+            module: true, // Treat as ES module to support import/export
+        });
+        const minifyTime = Date.now() - startTime;
+        if (process.env.DEBUG_SIZE) {
+            console.log(`Minify completed in ${minifyTime}ms`);
+        }
+        return { code: result.code };
+    }
+    catch (error) {
+        if (process.env.DEBUG_SIZE) {
+            console.log('Minify error occurred');
+        }
+        console.error('SWC minify error:', error);
+        throw error;
+    }
+}
+function normaliseModuleSource(mod) {
+    const identifier = mod.identifier || '';
+    const isJSON = identifier.endsWith('.json');
+    const rawSource = mod.source;
+    if (process.env.DEBUG_SIZE) {
+        console.log(`Normalising module: ${identifier}`);
+    }
+    if (rawSource === undefined || rawSource === null) {
+        if (process.env.DEBUG_SIZE) {
+            console.log(`No source for module: ${identifier}`);
+        }
+        return null;
+    }
+    let source;
+    if (typeof rawSource === 'string') {
+        source = rawSource;
+        if (process.env.DEBUG_SIZE) {
+            console.log(`Source is string`);
+        }
+    }
+    else if (Buffer.isBuffer(rawSource)) {
+        source = rawSource.toString('utf8');
+        if (process.env.DEBUG_SIZE) {
+            console.log(`Source is buffer`);
+        }
+    }
+    else {
+        source = String(rawSource);
+        if (process.env.DEBUG_SIZE) {
+            console.log(`Source is other type`);
+        }
+    }
+    const finalSource = isJSON ? `$a$=${source}` : source;
+    if (process.env.DEBUG_SIZE) {
+        console.log(`Module source normalised (length: ${finalSource.length})`);
+    }
+    return finalSource;
+}
+async function bundleSizeTree(packageName, stats) {
+    const startTime = perf_hooks_1.performance.now();
+    const statsTree = {
+        packageName: '<root>',
+        sources: [],
+        children: [],
+    };
+    if (!stats.modules)
+        return [];
+    // Collect modules with their sources
+    const modules = [];
+    const makeModule = (mod) => {
+        const identifier = mod.identifier || '';
+        const resolvedPath = modulePath(identifier);
+        const source = normaliseModuleSource(mod);
+        if (!source)
+            return null;
+        return {
+            path: resolvedPath,
+            source,
+        };
+    };
+    const filteredModules = stats.modules.filter(mod => { var _a; return !(((_a = mod.name) === null || _a === void 0 ? void 0 : _a.startsWith('external')) || mod.moduleType === 'runtime'); });
+    if (process.env.DEBUG_SIZE) {
+        console.log(`\n[LOCAL] ==================== ${packageName} ====================`);
+    }
+    filteredModules.forEach(mod => {
+        if (mod.modules) {
+            if (process.env.DEBUG_SIZE) {
+                console.log(`Module has ${mod.modules.length} sub-modules`);
+            }
+            mod.modules.forEach(subMod => {
+                const made = makeModule(subMod);
+                if (made)
+                    modules.push(made);
+            });
+        }
+        else {
+            const made = makeModule(mod);
+            if (made)
+                modules.push(made);
+        }
+    });
+    if (process.env.DEBUG_SIZE) {
+        console.log(`Collected ${modules.length} total modules`);
+    }
+    modules.sort((a, b) => {
+        if (a === b) {
+            return 0;
+        }
+        else {
+            return a < b ? -1 : 1;
+        }
+    });
+    // Build tree structure from module paths
+    modules.forEach((mod, modIndex) => {
+        const packages = extractPackageNamesFromPath(mod.path);
+        if (process.env.DEBUG_SIZE && modIndex < 5) {
+            console.log(`[${modIndex}] Extracted packages: ${packages.join(' > ')}`);
+        }
+        if (packages.length === 0) {
+            if (process.env.DEBUG_SIZE && modIndex < 5) {
+                console.log(`[${modIndex}] No packages found in path`);
+            }
+            return;
+        }
+        let parent = statsTree;
+        packages.forEach((pkg, pkgIndex) => {
+            const existing = parent.children.filter(child => child.packageName === pkg);
+            if (existing.length > 0) {
+                existing[0].sources.push(mod.source);
+                if (process.env.DEBUG_SIZE && modIndex < 5) {
+                    console.log(`[${modIndex}] Added to existing package: ${pkg}`);
+                }
+                parent = existing[0];
+            }
+            else {
+                const newChild = {
+                    path: mod.path,
+                    packageName: pkg,
+                    sources: [mod.source],
+                    children: [],
+                };
+                parent.children.push(newChild);
+                if (process.env.DEBUG_SIZE && modIndex < 5) {
+                    console.log(`[${modIndex}] Created new package: ${pkg}`);
+                }
+                parent = newChild;
+            }
+        });
+    });
+    // The old webpack implementation returned only the first-level children
+    // We need to preserve that behavior
+    const flattenedItems = statsTree.children;
+    if (process.env.DEBUG_SIZE) {
+        console.log(`\n[LOCAL] Tree structure built with ${flattenedItems.length} top-level dependencies:`);
+    }
+    const resultPromises = flattenedItems
+        .map(treeItem => ({
+        ...treeItem,
+        sources: treeItem.sources.filter(source => !!source),
+    }))
+        .filter(treeItem => treeItem.sources.length)
+        .map(async (treeItem) => {
+        if (process.env.DEBUG_SIZE) {
+            console.log(`\n[LOCAL] Processing dependency: ${treeItem.packageName}`);
+        }
+        const sourceMinifiedPromises = treeItem.sources.map(async (code, idx) => {
+            const originalSize = getUtf8Size(code);
+            if (process.env.DEBUG_SIZE) {
+                console.log(`Source ${idx}: ${originalSize} bytes (original)`);
+            }
+            const minified = await minifyDependencyCode(code);
+            const minifiedSize = getUtf8Size(minified.code || '');
+            const minifiedCode = minified.code || '';
+            if (process.env.DEBUG_SIZE) {
+                console.log(`Source ${idx}: ${minifiedSize} bytes (minified)`);
+            }
+            return minified;
+        });
+        try {
+            const sources = await Promise.all(sourceMinifiedPromises);
+            const size = sources.reduce((acc, source, idx) => {
+                const sourceSize = getUtf8Size(source.code || '');
+                if (process.env.DEBUG_SIZE) {
+                    console.log(`Total accumulation at idx ${idx}: ${acc + sourceSize} bytes`);
+                }
+                return acc + sourceSize;
+            }, 0);
+            if (process.env.DEBUG_SIZE) {
+                console.log(`Final size for ${treeItem.packageName}: ${size} bytes`);
+            }
+            return {
+                name: treeItem.packageName,
+                approximateSize: size,
+            };
+        }
+        catch (error) {
+            const { message, filename } = error;
+            throw new CustomError_1.MinifyError(error, {
+                message: message,
+                filePath: filename,
+            });
+        }
+    });
+    try {
+        const results = await Promise.all(resultPromises);
+        telemetry_utils_1.default.dependencySizes(packageName, startTime, true, { minifier: 'swc' });
+        return results;
+    }
+    catch (e) {
+        telemetry_utils_1.default.dependencySizes(packageName, startTime, false, { minifier: 'swc' }, e);
+        throw e;
+    }
+}
+exports.default = bundleSizeTree;

package/build/getPackageExportSizes.d.ts

@@ -2,19 +2,17 @@ import { GetPackageStatsOptions, InstallPackageOptions } from './common.types';
 export declare function getAllPackageExports(packageString: string, options?: InstallPackageOptions): Promise<{
     [key: string]: string;
 }>;
-export declare function getExportSize(packageString: string, exportName: string): Promise<void>;
 export declare function getPackageExportSizes(packageString: string, options?: GetPackageStatsOptions): Promise<{
-    buildVersion: any;
     assets: {
         path: string;
         name: string;
         type: string;
         size: number;
         gzip: number;
-        parse: {
-            baseParseTime?: number | undefined;
-            scriptParseTime?: number | undefined;
-        } | null;
     }[];
+    dependencySizes?: Array<{
+        name: string;
+        approximateSize: number;
+    }>;
+    ignoredMissingDependencies?: Array<string>;
 }>;
-//# sourceMappingURL=getPackageExportSizes.d.ts.map