@rollup/wasm-node 4.63.6 → 4.64.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/bin/rollup +151 -46
- package/dist/es/getLogFilter.js +2 -2
- package/dist/es/parseAst.js +2 -2
- package/dist/es/rollup.js +2 -2
- package/dist/es/shared/node-entry.js +166 -42
- package/dist/es/shared/parseAst.js +2 -2
- package/dist/es/shared/watch.js +2 -2
- package/dist/getLogFilter.js +2 -2
- package/dist/loadConfigFile.js +2 -2
- package/dist/parseAst.js +2 -2
- package/dist/rollup.js +2 -2
- package/dist/shared/fsevents-importer.js +2 -2
- package/dist/shared/index.js +2 -2
- package/dist/shared/loadConfigFile.js +2 -2
- package/dist/shared/node-entry.js +2 -2
- package/dist/shared/parseAst.js +2 -2
- package/dist/shared/rollup.js +165 -41
- package/dist/shared/watch-cli.js +2 -2
- package/dist/shared/watch.js +2 -2
- package/dist/wasm-node/bindings_wasm_bg.wasm +0 -0
- package/package.json +13 -13
package/dist/bin/rollup
CHANGED
|
@@ -1,8 +1,8 @@
|
|
|
1
1
|
#!/usr/bin/env node
|
|
2
2
|
/*
|
|
3
3
|
@license
|
|
4
|
-
Rollup.js v4.
|
|
5
|
-
|
|
4
|
+
Rollup.js v4.64.1
|
|
5
|
+
Wed, 07 Oct 2026 05:40:24 GMT - commit 2e1a7531fbf618c8fbc897519646ac6119cbaf9f
|
|
6
6
|
|
|
7
7
|
https://github.com/rollup/rollup
|
|
8
8
|
|
|
@@ -27,7 +27,7 @@ require('node:perf_hooks');
|
|
|
27
27
|
require('node:url');
|
|
28
28
|
require('../getLogFilter.js');
|
|
29
29
|
|
|
30
|
-
const help = "rollup version 4.
|
|
30
|
+
const help = "rollup version 4.64.1\n=====================================\n\nUsage: rollup [options] <entry file>\n\nOptions:\n\n-c, --config <filename> Use this config file (if argument is used but value\n is unspecified, Rollup will try to load configuration files in\n the following order:\n rollup.config.mjs -> rollup.config.cjs -> rollup.config.js)\n-d, --dir <dirname> Directory for chunks (if absent, prints to stdout)\n-e, --external <ids> Comma-separate list of module IDs to exclude\n-f, --format <format> Type of output (amd, cjs, es, iife, umd, system)\n-g, --globals <pairs> Comma-separate list of `moduleID:Global` pairs\n-h, --help Show this help message\n-i, --input <filename> Input (alternative to <entry file>)\n-m, --sourcemap Generate sourcemap (`-m inline` for inline map)\n-n, --name <name> Name for UMD export\n-o, --file <output> Single output file (if absent, prints to stdout)\n-p, --plugin <plugin> Use the plugin specified (may be repeated)\n-v, --version Show version number\n-w, --watch Watch files in bundle and rebuild on changes\n--amd.autoId Generate the AMD ID based off the chunk name\n--amd.basePath <prefix> Path to prepend to auto generated AMD ID\n--amd.define <name> Function to use in place of `define`\n--amd.forceJsExtensionForImports Use `.js` extension in AMD imports\n--amd.id <id> ID for AMD module (default is anonymous)\n--assetFileNames <pattern> Name pattern for emitted assets\n--banner <text> Code to insert at top of bundle (outside wrapper)\n--chunkFileNames <pattern> Name pattern for emitted secondary chunks\n--compact Minify wrapper code\n--context <variable> Specify top-level `this` value\n--no-dynamicImportInCjs Write external dynamic CommonJS imports as require\n--entryFileNames <pattern> Name pattern for emitted entry chunks\n--environment <values> Settings passed to config file (see example)\n--no-esModule Do not add __esModule property\n--exports <mode> Specify export mode (auto, default, named, none)\n--extend Extend global variable defined by --name\n--no-externalImportAttributes Omit import attributes in \"es\" output\n--no-externalLiveBindings Do not generate code to support live bindings\n--failAfterWarnings Exit with an error if the build produced warnings\n--filterLogs <filter> Filter log messages\n--footer <text> Code to insert at end of bundle (outside wrapper)\n--forceExit Force exit the process when done\n--no-freeze Do not freeze namespace objects\n--generatedCode <preset> Which code features to use (es5/es2015)\n--generatedCode.arrowFunctions Use arrow functions in generated code\n--generatedCode.constBindings Use \"const\" in generated code\n--generatedCode.objectShorthand Use shorthand properties in generated code\n--no-generatedCode.reservedNamesAsProps Always quote reserved names as props\n--generatedCode.symbols Use symbols in generated code\n--hashCharacters <name> Use the specified character set for file hashes\n--no-hoistTransitiveImports Do not hoist transitive imports into entry chunks\n--importAttributesKey <name> Use the specified keyword for import attributes\n--no-indent Don't indent result\n--inlineDynamicImports Create single bundle when using dynamic imports\n--no-interop Do not include interop block\n--intro <text> Code to insert at top of bundle (inside wrapper)\n--logLevel <level> Which kind of logs to display\n--no-makeAbsoluteExternalsRelative Prevent normalization of external imports\n--maxParallelFileOps <value> How many files to read in parallel\n--minifyInternalExports Force or disable minification of internal exports\n--noConflict Generate a noConflict method for UMD globals\n--outro <text> Code to insert at end of bundle (inside wrapper)\n--perf Display performance timings\n--no-preserveEntrySignatures Avoid facade chunks for entry points\n--preserveModules Preserve module structure\n--preserveModulesRoot Put preserved modules under this path at root level\n--preserveSymlinks Do not follow symlinks when resolving files\n--no-reexportProtoFromExternal Ignore `__proto__` in star re-exports\n--no-sanitizeFileName Do not replace invalid characters in file names\n--shimMissingExports Create shim variables for missing exports\n--silent Don't print warnings\n--sourcemapBaseUrl <url> Emit absolute sourcemap URLs with given base\n--sourcemapDebugIds Emit unique debug ids in source and sourcemaps\n--sourcemapExcludeSources Do not include source code in source maps\n--sourcemapFile <file> Specify bundle position for source maps\n--sourcemapFileNames <pattern> Name pattern for emitted sourcemaps\n--stdin=ext Specify file extension used for stdin input\n--no-stdin Do not read \"-\" from stdin\n--no-strict Don't emit `\"use strict\";` in the generated modules\n--strictDeprecations Throw errors for deprecated features\n--no-systemNullSetters Do not replace empty SystemJS setters with `null`\n--no-treeshake Disable tree-shaking optimisations\n--no-treeshake.annotations Ignore pure call annotations\n--treeshake.correctVarValueBeforeDeclaration Deoptimize variables until declared\n--treeshake.manualPureFunctions <names> Manually declare functions as pure\n--no-treeshake.moduleSideEffects Assume modules have no side effects\n--no-treeshake.propertyReadSideEffects Ignore property access side effects\n--no-treeshake.tryCatchDeoptimization Do not turn off try-catch-tree-shaking\n--no-treeshake.unknownGlobalSideEffects Assume unknown globals do not throw\n--validate Validate output\n--waitForBundleInput Wait for bundle input files\n--watch.allowInputInsideOutputPath Whether the input path is allowed to be a\n subpath of the output path\n--watch.buildDelay <number> Throttle watch rebuilds\n--no-watch.clearScreen Do not clear the screen when rebuilding\n--watch.exclude <files> Exclude files from being watched\n--watch.include <files> Limit watching to specified files\n--watch.onBundleEnd <cmd> Shell command to run on `\"BUNDLE_END\"` event\n--watch.onBundleStart <cmd> Shell command to run on `\"BUNDLE_START\"` event\n--watch.onEnd <cmd> Shell command to run on `\"END\"` event\n--watch.onError <cmd> Shell command to run on `\"ERROR\"` event\n--watch.onStart <cmd> Shell command to run on `\"START\"` event\n--watch.skipWrite Do not write files to disk when watching\n\nExamples:\n\n# use settings in config file\nrollup -c\n\n# in config file, process.env.INCLUDE_DEPS === 'true'\n# and process.env.BUILD === 'production'\nrollup -c --environment INCLUDE_DEPS,BUILD:production\n\n# create CommonJS bundle.js from src/main.js\nrollup --format=cjs --file=bundle.js -- src/main.js\n\n# create self-executing IIFE using `window.jQuery`\n# and `window._` as external globals\nrollup -f iife --globals jquery:jQuery,lodash:_ \\\n -i src/app.js -o build/app.js -m build/app.js.map\n\nNotes:\n\n* When piping to stdout, only inline sourcemaps are permitted\n\nFor more information visit https://rollupjs.org\n";
|
|
31
31
|
|
|
32
32
|
/**
|
|
33
33
|
* @license
|
|
@@ -1561,23 +1561,61 @@ const BIBIT_UNITS = [
|
|
|
1561
1561
|
'Yibit',
|
|
1562
1562
|
];
|
|
1563
1563
|
|
|
1564
|
+
// Indexed by `bits` and then `binary`, so the four unit systems are picked in one step.
|
|
1565
|
+
const UNIT_SETS = [BYTE_UNITS, BIBYTE_UNITS, BIT_UNITS, BIBIT_UNITS];
|
|
1566
|
+
|
|
1567
|
+
/*
|
|
1568
|
+
`Number#toString` switches to exponential notation outside the range [1e-6, 1e21) and `Intl.NumberFormat` drops every fraction digit past the 100 it accepts.
|
|
1569
|
+
Byte counts read as plain decimal numbers, so both losses are undone here. Expects a finite, non-negative number.
|
|
1570
|
+
*/
|
|
1571
|
+
const toDecimalString = number => {
|
|
1572
|
+
if (number >= 1e-6 && number < 1e21) {
|
|
1573
|
+
return String(number);
|
|
1574
|
+
}
|
|
1575
|
+
|
|
1576
|
+
const [mantissa, exponentString] = number.toExponential().split('e');
|
|
1577
|
+
const digits = mantissa.replace('.', '');
|
|
1578
|
+
const pointPosition = Number(exponentString) + 1;
|
|
1579
|
+
const isPositive = pointPosition > 0;
|
|
1580
|
+
const padded = isPositive ? digits.padEnd(pointPosition, '0') : '0'.repeat(1 - pointPosition) + digits;
|
|
1581
|
+
const integerPart = padded.slice(0, isPositive ? pointPosition : 1);
|
|
1582
|
+
const fractionPart = padded.slice(isPositive ? pointPosition : 1).replace(/0+$/, '');
|
|
1583
|
+
|
|
1584
|
+
return fractionPart ? `${integerPart}.${fractionPart}` : integerPart;
|
|
1585
|
+
};
|
|
1586
|
+
|
|
1564
1587
|
/*
|
|
1565
1588
|
Formats the given number using `Number#toLocaleString`.
|
|
1566
1589
|
- If locale is a string or array, the value is expected to be a BCP 47 language tag or list of language tags (for example: `de`).
|
|
1567
1590
|
- If locale is true, the system default locale is used for translation.
|
|
1568
|
-
- If locale is false or unspecified, formatting options are applied without localization; without options, the number is
|
|
1591
|
+
- If locale is false or unspecified, formatting options are applied without localization; without options, the number is written out as plain digits.
|
|
1569
1592
|
*/
|
|
1570
1593
|
const toLocaleString = (number, locale, options) => {
|
|
1571
|
-
|
|
1572
|
-
|
|
1573
|
-
|
|
1574
|
-
|
|
1575
|
-
|
|
1576
|
-
|
|
1577
|
-
|
|
1594
|
+
if (typeof locale === 'string' || Array.isArray(locale) || locale === true) {
|
|
1595
|
+
const locales = locale === true ? undefined : locale;
|
|
1596
|
+
|
|
1597
|
+
if (options !== undefined) {
|
|
1598
|
+
return number.toLocaleString(locales, options);
|
|
1599
|
+
}
|
|
1600
|
+
|
|
1601
|
+
// `Intl.NumberFormat` limits itself to 3 *fraction* digits while the default here is 3 *significant* digits, so the limit comes from the value.
|
|
1602
|
+
const text = toDecimalString(number);
|
|
1603
|
+
const pointIndex = text.indexOf('.');
|
|
1604
|
+
const maximumFractionDigits = pointIndex === -1 ? 0 : text.length - pointIndex - 1;
|
|
1605
|
+
|
|
1606
|
+
// `Intl.NumberFormat` accepts at most 100 fraction digits. Rounding to 3 significant digits only needs more than that for absurdly small values, which are written out as plain digits instead.
|
|
1607
|
+
if (maximumFractionDigits > 100) {
|
|
1608
|
+
return text;
|
|
1609
|
+
}
|
|
1610
|
+
|
|
1611
|
+
return number.toLocaleString(locales, {maximumFractionDigits});
|
|
1612
|
+
}
|
|
1613
|
+
|
|
1614
|
+
if (options === undefined) {
|
|
1615
|
+
return toDecimalString(number);
|
|
1578
1616
|
}
|
|
1579
1617
|
|
|
1580
|
-
return
|
|
1618
|
+
return number.toLocaleString('en-US', {...options, useGrouping: false});
|
|
1581
1619
|
};
|
|
1582
1620
|
|
|
1583
1621
|
const log10 = numberOrBigInt => {
|
|
@@ -1587,6 +1625,7 @@ const log10 = numberOrBigInt => {
|
|
|
1587
1625
|
|
|
1588
1626
|
const string = numberOrBigInt.toString(10);
|
|
1589
1627
|
|
|
1628
|
+
// A `number` only holds about 15 significant digits, so the remaining digits cannot move the magnitude. The result can still land exactly on a unit boundary, which the caller corrects for.
|
|
1590
1629
|
return string.length + Math.log10(`0.${string.slice(0, 15)}`);
|
|
1591
1630
|
};
|
|
1592
1631
|
|
|
@@ -1598,30 +1637,74 @@ const log = numberOrBigInt => {
|
|
|
1598
1637
|
return log10(numberOrBigInt) * Math.log(10);
|
|
1599
1638
|
};
|
|
1600
1639
|
|
|
1601
|
-
|
|
1602
|
-
|
|
1603
|
-
|
|
1640
|
+
/*
|
|
1641
|
+
A `bigint` that a `number` can hold exactly is divided the same way, so the output never depends on which type it was given as.
|
|
1642
|
+
`floor(a / b) + (a % b) / b` is a different double than `a / b`, which flips the rounding at ties like 1805 bytes.
|
|
1643
|
+
*/
|
|
1644
|
+
const divide = (numberOrBigInt, base, exponent) => {
|
|
1645
|
+
const divisor = base ** exponent;
|
|
1646
|
+
|
|
1647
|
+
if (typeof numberOrBigInt === 'number' || numberOrBigInt <= Number.MAX_SAFE_INTEGER) {
|
|
1648
|
+
return Number(numberOrBigInt) / divisor;
|
|
1604
1649
|
}
|
|
1605
1650
|
|
|
1606
|
-
|
|
1607
|
-
const
|
|
1651
|
+
// `divisor` is not exact for every unit, as `1000 ** 8` is not `1e24`, so the exact divisor is rebuilt from the base and the exponent.
|
|
1652
|
+
const bigintDivisor = BigInt(base) ** BigInt(exponent);
|
|
1653
|
+
const integerPart = numberOrBigInt / bigintDivisor;
|
|
1654
|
+
const remainder = numberOrBigInt % bigintDivisor;
|
|
1655
|
+
|
|
1608
1656
|
return Number(integerPart) + (Number(remainder) / divisor);
|
|
1609
1657
|
};
|
|
1610
1658
|
|
|
1611
|
-
|
|
1612
|
-
|
|
1613
|
-
|
|
1659
|
+
/*
|
|
1660
|
+
The plain decimal digits of a scaled value that no `number` can hold. `Intl.NumberFormat` is not involved, so the output carries no grouping or localized separator, the same as the fallback for a value with more fraction digits than it accepts.
|
|
1661
|
+
*/
|
|
1662
|
+
const toUnrepresentableString = (number, base, exponent, localeOptions) => {
|
|
1663
|
+
const scale = BigInt(base) ** BigInt(exponent);
|
|
1664
|
+
const whole = number / scale;
|
|
1665
|
+
|
|
1666
|
+
// The 3 significant digit default never bites here: it only ever rounds to at least as many digits as the value has integers, and this one has far more than 3.
|
|
1667
|
+
if (localeOptions === undefined) {
|
|
1668
|
+
return whole.toString();
|
|
1614
1669
|
}
|
|
1615
1670
|
|
|
1616
|
-
|
|
1617
|
-
|
|
1671
|
+
// The fraction digit options take over from that default, so the integer part stays exact and the fraction is truncated.
|
|
1672
|
+
const minimumFractionDigits = localeOptions.minimumFractionDigits ?? 0;
|
|
1673
|
+
const maximumFractionDigits = Math.max(localeOptions.maximumFractionDigits ?? 3, minimumFractionDigits);
|
|
1674
|
+
const truncated = ((number % scale) * (10n ** BigInt(maximumFractionDigits)) / scale).toString().padStart(maximumFractionDigits, '0');
|
|
1675
|
+
const fraction = truncated.replace(/0+$/, '').padEnd(minimumFractionDigits, '0');
|
|
1676
|
+
|
|
1677
|
+
return fraction ? `${whole}.${fraction}` : whole.toString();
|
|
1678
|
+
};
|
|
1679
|
+
|
|
1680
|
+
/*
|
|
1681
|
+
The sign to print in front of the number. A difference of exactly zero gets a space instead of a plus sign, for better alignment. `0 === 0n` is `false`, so both are compared.
|
|
1682
|
+
*/
|
|
1683
|
+
const signOf = (number, signed) => {
|
|
1684
|
+
if (number < 0) {
|
|
1685
|
+
return '-';
|
|
1618
1686
|
}
|
|
1619
1687
|
|
|
1620
|
-
if (
|
|
1621
|
-
return
|
|
1688
|
+
if (!signed) {
|
|
1689
|
+
return '';
|
|
1622
1690
|
}
|
|
1623
1691
|
|
|
1624
|
-
return
|
|
1692
|
+
return number === 0 || number === 0n ? ' ' : '+';
|
|
1693
|
+
};
|
|
1694
|
+
|
|
1695
|
+
const assertFixedWidth = fixedWidth => {
|
|
1696
|
+
if (fixedWidth !== undefined && (typeof fixedWidth !== 'number' || !Number.isSafeInteger(fixedWidth) || fixedWidth < 0)) {
|
|
1697
|
+
throw new TypeError(`Expected fixedWidth to be a non-negative integer, got ${typeof fixedWidth}: ${fixedWidth}`);
|
|
1698
|
+
}
|
|
1699
|
+
};
|
|
1700
|
+
|
|
1701
|
+
/*
|
|
1702
|
+
`Intl.NumberFormat` silently truncates non-integers, so they are rejected here instead of quietly changing the output.
|
|
1703
|
+
*/
|
|
1704
|
+
const assertFractionDigits = (name, value) => {
|
|
1705
|
+
if (value !== undefined && (typeof value !== 'number' || !Number.isInteger(value) || value < 0 || value > 100)) {
|
|
1706
|
+
throw new TypeError(`Expected ${name} to be an integer between 0 and 100, got ${typeof value}: ${value}`);
|
|
1707
|
+
}
|
|
1625
1708
|
};
|
|
1626
1709
|
|
|
1627
1710
|
const buildLocaleOptions = options => {
|
|
@@ -1631,6 +1714,14 @@ const buildLocaleOptions = options => {
|
|
|
1631
1714
|
return undefined;
|
|
1632
1715
|
}
|
|
1633
1716
|
|
|
1717
|
+
assertFractionDigits('minimumFractionDigits', minimumFractionDigits);
|
|
1718
|
+
assertFractionDigits('maximumFractionDigits', maximumFractionDigits);
|
|
1719
|
+
|
|
1720
|
+
// Checked here rather than left to `Intl.NumberFormat`, which is skipped for a value past the number range.
|
|
1721
|
+
if (minimumFractionDigits > maximumFractionDigits) {
|
|
1722
|
+
throw new RangeError(`Expected minimumFractionDigits (${minimumFractionDigits}) to not be greater than maximumFractionDigits (${maximumFractionDigits})`);
|
|
1723
|
+
}
|
|
1724
|
+
|
|
1634
1725
|
return {
|
|
1635
1726
|
...(minimumFractionDigits !== undefined && {minimumFractionDigits}),
|
|
1636
1727
|
...(maximumFractionDigits !== undefined && {maximumFractionDigits}),
|
|
@@ -1651,27 +1742,25 @@ function prettyBytes(number, options) {
|
|
|
1651
1742
|
...options,
|
|
1652
1743
|
};
|
|
1653
1744
|
|
|
1654
|
-
|
|
1655
|
-
|
|
1656
|
-
|
|
1745
|
+
assertFixedWidth(options.fixedWidth);
|
|
1746
|
+
const localeOptions = buildLocaleOptions(options);
|
|
1747
|
+
|
|
1748
|
+
// Indexed by `bits` then `binary`, so the four combinations line up in one table.
|
|
1749
|
+
const UNITS = UNIT_SETS[(options.bits ? 2 : 0) + (options.binary ? 1 : 0)];
|
|
1657
1750
|
|
|
1658
1751
|
const separator = options.space ? (options.nonBreakingSpace ? '\u00A0' : ' ') : '';
|
|
1659
1752
|
|
|
1660
|
-
//
|
|
1661
|
-
|
|
1662
|
-
|
|
1663
|
-
const result = ` 0${separator}${UNITS[0]}`;
|
|
1664
|
-
return applyFixedWidth(result, options.fixedWidth);
|
|
1753
|
+
// Normalize `-0` to `0` so it never formats as `-0`.
|
|
1754
|
+
if (Object.is(number, -0)) {
|
|
1755
|
+
number = 0;
|
|
1665
1756
|
}
|
|
1666
1757
|
|
|
1667
|
-
const
|
|
1668
|
-
const prefix = isNegative ? '-' : (options.signed ? '+' : '');
|
|
1758
|
+
const prefix = signOf(number, options.signed);
|
|
1669
1759
|
|
|
1670
|
-
if (
|
|
1760
|
+
if (number < 0) {
|
|
1671
1761
|
number = -number;
|
|
1672
1762
|
}
|
|
1673
1763
|
|
|
1674
|
-
const localeOptions = buildLocaleOptions(options);
|
|
1675
1764
|
const base = options.binary ? 1024 : 1000;
|
|
1676
1765
|
|
|
1677
1766
|
let exponent = 0;
|
|
@@ -1679,21 +1768,37 @@ function prettyBytes(number, options) {
|
|
|
1679
1768
|
exponent = Math.min(Math.floor(options.binary ? log(number) / Math.log(base) : log10(number) / 3), UNITS.length - 1);
|
|
1680
1769
|
}
|
|
1681
1770
|
|
|
1682
|
-
number
|
|
1771
|
+
// A `number` always scales down to something a `number` can hold, and a `bigint` stops being able to once the quotient passes `Number.MAX_VALUE`, where `divide` overflows to `Infinity` and the exact quotient is formatted instead.
|
|
1772
|
+
const scaled = divide(number, base, exponent);
|
|
1683
1773
|
|
|
1684
|
-
|
|
1685
|
-
|
|
1686
|
-
number =
|
|
1774
|
+
let numberString;
|
|
1775
|
+
if (Number.isFinite(scaled)) {
|
|
1776
|
+
number = scaled;
|
|
1687
1777
|
|
|
1688
|
-
|
|
1689
|
-
|
|
1690
|
-
|
|
1778
|
+
// A value that sits just below a unit boundary, like `999999999999999` bytes, has a `log10` that rounds up to the boundary itself, so the exponent has to be corrected back.
|
|
1779
|
+
if (number < 1 && exponent > 0) {
|
|
1780
|
+
number *= base;
|
|
1781
|
+
exponent -= 1;
|
|
1691
1782
|
}
|
|
1783
|
+
|
|
1784
|
+
if (!localeOptions) {
|
|
1785
|
+
const minimumPrecision = Math.max(3, Math.floor(number).toString().length);
|
|
1786
|
+
number = Number(number.toPrecision(minimumPrecision));
|
|
1787
|
+
|
|
1788
|
+
if (number >= base && exponent < UNITS.length - 1) {
|
|
1789
|
+
number /= base;
|
|
1790
|
+
exponent += 1;
|
|
1791
|
+
}
|
|
1792
|
+
}
|
|
1793
|
+
|
|
1794
|
+
numberString = toLocaleString(number, options.locale, localeOptions);
|
|
1795
|
+
} else {
|
|
1796
|
+
// The scaled value is past what a `number` can hold, so the exact quotient is written out instead.
|
|
1797
|
+
numberString = toUnrepresentableString(number, base, exponent, localeOptions);
|
|
1692
1798
|
}
|
|
1693
1799
|
|
|
1694
|
-
const numberString = toLocaleString(number, options.locale, localeOptions);
|
|
1695
1800
|
const result = prefix + numberString + separator + UNITS[exponent];
|
|
1696
|
-
return
|
|
1801
|
+
return result.padStart(options.fixedWidth ?? 0);
|
|
1697
1802
|
}
|
|
1698
1803
|
|
|
1699
1804
|
function printTimings(timings) {
|
package/dist/es/getLogFilter.js
CHANGED
package/dist/es/parseAst.js
CHANGED
package/dist/es/rollup.js
CHANGED