@ni/nimble-components 20.17.7 → 20.18.1

package/dist/esm/unit/volt/index.d.ts

@@ -0,0 +1,13 @@
+import { Unit } from '../base/unit';
+declare global {
+    interface HTMLElementTagNameMap {
+        'nimble-unit-volt': UnitVolt;
+    }
+}
+/**
+ * Element representing units for volts
+ */
+export declare class UnitVolt extends Unit {
+    constructor();
+}
+export declare const unitVoltTag = "nimble-unit-volt";

package/dist/esm/unit/volt/index.js

@@ -0,0 +1,20 @@
+import { DesignSystem } from '@microsoft/fast-foundation';
+import { template } from '../base/template';
+import { Unit } from '../base/unit';
+import { voltUnitScale } from '../../utilities/unit-format/unit-scale/volt-unit-scale';
+/**
+ * Element representing units for volts
+ */
+export class UnitVolt extends Unit {
+    constructor() {
+        super();
+        this.resolvedUnitScale = voltUnitScale;
+    }
+}
+const nimbleUnitVolt = UnitVolt.compose({
+    baseName: 'unit-volt',
+    template
+});
+DesignSystem.getOrCreate().withPrefix('nimble').register(nimbleUnitVolt());
+export const unitVoltTag = 'nimble-unit-volt';
+//# sourceMappingURL=index.js.map

package/dist/esm/unit/volt/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/unit/volt/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,cAAc,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,wDAAwD,CAAC;AAQvF;;GAEG;AACH,MAAM,OAAO,QAAS,SAAQ,IAAI;IAC9B;QACI,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,iBAAiB,GAAG,aAAa,CAAC;IAC3C,CAAC;CACJ;AAED,MAAM,cAAc,GAAG,QAAQ,CAAC,OAAO,CAAC;IACpC,QAAQ,EAAE,WAAW;IACrB,QAAQ;CACX,CAAC,CAAC;AAEH,YAAY,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,cAAc,EAAE,CAAC,CAAC;AAC3E,MAAM,CAAC,MAAM,WAAW,GAAG,kBAAkB,CAAC"}

package/dist/esm/utilities/unit-format/decimal-unit-format.d.ts

@@ -0,0 +1,22 @@
+import { UnitFormat, UnitFormatOptions } from './unit-format';
+import type { UnitScale } from './unit-scale/unit-scale';
+interface DecimalUnitFormatOptions extends UnitFormatOptions {
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+    unitScale?: UnitScale;
+}
+/**
+ * Format for decimal numbers with units.
+ */
+export declare class DecimalUnitFormat extends UnitFormat<DecimalUnitFormatOptions> {
+    private readonly unitScale;
+    private readonly minimumFractionDigits;
+    private readonly maximumFractionDigits;
+    private readonly scaledUnitFormatters;
+    private readonly tenPowDecimalDigits;
+    constructor(locale: string, { minimumFractionDigits, maximumFractionDigits, unitScale }?: DecimalUnitFormatOptions);
+    resolvedOptions(): Required<DecimalUnitFormatOptions>;
+    protected tryFormat(number: number): string;
+    private willRoundToZero;
+}
+export {};

package/dist/esm/utilities/unit-format/decimal-unit-format.js

@@ -0,0 +1,51 @@
+import { UnitFormat } from './unit-format';
+import { passthroughUnitScale } from './unit-scale/passthrough-unit-scale';
+/**
+ * Format for decimal numbers with units.
+ */
+export class DecimalUnitFormat extends UnitFormat {
+    constructor(locale, { minimumFractionDigits = 0, maximumFractionDigits = Math.max(3, minimumFractionDigits), unitScale = passthroughUnitScale } = {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: 3,
+        unitScale: passthroughUnitScale
+    }) {
+        super();
+        this.scaledUnitFormatters = new Map();
+        const intlNumberFormatOptions = {
+            maximumFractionDigits,
+            minimumFractionDigits,
+            useGrouping: true
+        };
+        for (const scaledUnit of unitScale.supportedScaledUnits) {
+            this.scaledUnitFormatters.set(scaledUnit.scaleFactor, scaledUnit.scaledUnitFormatFactory({
+                locale,
+                intlNumberFormatOptions
+            }));
+        }
+        this.tenPowDecimalDigits = 10 ** maximumFractionDigits;
+        this.unitScale = unitScale;
+        this.minimumFractionDigits = minimumFractionDigits;
+        this.maximumFractionDigits = maximumFractionDigits;
+    }
+    resolvedOptions() {
+        return {
+            unitScale: this.unitScale,
+            maximumFractionDigits: this.maximumFractionDigits,
+            minimumFractionDigits: this.minimumFractionDigits
+        };
+    }
+    tryFormat(number) {
+        const { scaledValue, scaledUnit } = this.unitScale.scaleNumber(number);
+        const numberNormalized = this.willRoundToZero(scaledValue)
+            ? 0
+            : scaledValue;
+        const scaledUnitFormatter = this.scaledUnitFormatters.get(scaledUnit.scaleFactor);
+        return scaledUnitFormatter.format(numberNormalized);
+    }
+    willRoundToZero(number) {
+        // Multiply the value by 10 raised to maximumFractionDigits so that Math.round can be used to emulate rounding to
+        // maximumFractionDigits decimal places. If that rounded value is 0, then the value will be rendered with only 0s.
+        return Math.round(number * this.tenPowDecimalDigits) === 0;
+    }
+}
+//# sourceMappingURL=decimal-unit-format.js.map

package/dist/esm/utilities/unit-format/decimal-unit-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimal-unit-format.js","sourceRoot":"","sources":["../../../../src/utilities/unit-format/decimal-unit-format.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAqB,MAAM,eAAe,CAAC;AAG9D,OAAO,EAAE,oBAAoB,EAAE,MAAM,qCAAqC,CAAC;AAQ3E;;GAEG;AACH,MAAM,OAAO,iBAAkB,SAAQ,UAAoC;IAQvE,YACI,MAAc,EACd,EACI,qBAAqB,GAAG,CAAC,EACzB,qBAAqB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,qBAAqB,CAAC,EAC1D,SAAS,GAAG,oBAAoB,KACN;QAC1B,qBAAqB,EAAE,CAAC;QACxB,qBAAqB,EAAE,CAAC;QACxB,SAAS,EAAE,oBAAoB;KAClC;QAED,KAAK,EAAE,CAAC;QAfK,yBAAoB,GAAG,IAAI,GAAG,EAA4B,CAAC;QAgBxE,MAAM,uBAAuB,GAAG;YAC5B,qBAAqB;YACrB,qBAAqB;YACrB,WAAW,EAAE,IAAI;SACpB,CAAC;QACF,KAAK,MAAM,UAAU,IAAI,SAAS,CAAC,oBAAoB,EAAE;YACrD,IAAI,CAAC,oBAAoB,CAAC,GAAG,CACzB,UAAU,CAAC,WAAW,EACtB,UAAU,CAAC,uBAAuB,CAAC;gBAC/B,MAAM;gBACN,uBAAuB;aAC1B,CAAC,CACL,CAAC;SACL;QACD,IAAI,CAAC,mBAAmB,GAAG,EAAE,IAAI,qBAAqB,CAAC;QACvD,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;QAC3B,IAAI,CAAC,qBAAqB,GAAG,qBAAqB,CAAC;QACnD,IAAI,CAAC,qBAAqB,GAAG,qBAAqB,CAAC;IACvD,CAAC;IAEe,eAAe;QAC3B,OAAO;YACH,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,qBAAqB,EAAE,IAAI,CAAC,qBAAqB;YACjD,qBAAqB,EAAE,IAAI,CAAC,qBAAqB;SACpD,CAAC;IACN,CAAC;IAES,SAAS,CAAC,MAAc;QAC9B,MAAM,EAAE,WAAW,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;QAEvE,MAAM,gBAAgB,GAAG,IAAI,CAAC,eAAe,CAAC,WAAW,CAAC;YACtD,CAAC,CAAC,CAAC;YACH,CAAC,CAAC,WAAW,CAAC;QAClB,MAAM,mBAAmB,GAAG,IAAI,CAAC,oBAAoB,CAAC,GAAG,CACrD,UAAU,CAAC,WAAW,CACxB,CAAC;QACH,OAAO,mBAAmB,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;IACxD,CAAC;IAEO,eAAe,CAAC,MAAc;QAClC,iHAAiH;QACjH,kHAAkH;QAClH,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC;CACJ"}

package/dist/esm/utilities/unit-format/default-unit-format.d.ts

@@ -0,0 +1,21 @@
+import { UnitFormat, UnitFormatOptions } from './unit-format';
+/**
+ * Format for numbers with units to show in a tabular form.
+ * Large and tiny numbers are shown exponentially and the rest as decimal.
+ */
+export declare class DefaultUnitFormat extends UnitFormat {
+    private static readonly maximumDigits;
+    private static readonly exponentialLowerBound;
+    private static readonly exponentialUpperBound;
+    private readonly unitScale;
+    private readonly defaultIntlNumberFormatOptions;
+    private readonly defaultScaledUnitFormatters;
+    private readonly leadingZeroIntlNumberFormatOptions;
+    private readonly leadingZeroScaledUnitFormatters;
+    private readonly exponentialIntlNumberFormatOptions;
+    private readonly exponentialScaledUnitFormatter;
+    constructor(locale: string, { unitScale }?: UnitFormatOptions);
+    resolvedOptions(): Required<UnitFormatOptions>;
+    protected tryFormat(number: number): string;
+    private resolveNumberStyle;
+}

package/dist/esm/utilities/unit-format/default-unit-format.js

@@ -0,0 +1,102 @@
+import { UnitFormat } from './unit-format';
+import { passthroughUnitScale } from './unit-scale/passthrough-unit-scale';
+/**
+ * Format for numbers with units to show in a tabular form.
+ * Large and tiny numbers are shown exponentially and the rest as decimal.
+ */
+export class DefaultUnitFormat extends UnitFormat {
+    constructor(locale, { unitScale = passthroughUnitScale } = {
+        unitScale: passthroughUnitScale
+    }) {
+        super();
+        // Format options to use by default. It renders the number with a maximum of 6 signficant digits.
+        this.defaultIntlNumberFormatOptions = {
+            maximumSignificantDigits: DefaultUnitFormat.maximumDigits,
+            useGrouping: true
+        };
+        this.defaultScaledUnitFormatters = new Map();
+        // Format options to use for numbers that have leading zeros. It limits the number of rendered
+        // digits using 'maximumFractionDigits', which will result in less than 6 significant digits
+        // in order to render no more than 6 total digits.
+        this.leadingZeroIntlNumberFormatOptions = {
+            maximumFractionDigits: DefaultUnitFormat.maximumDigits - 1,
+            useGrouping: true
+        };
+        this.leadingZeroScaledUnitFormatters = new Map();
+        // Format options for numbers that should be displayed in exponential notation. This should be used
+        // for numbers with magintudes over 'exponentialUpperBound' or under 'exponentialLowerBound'.
+        this.exponentialIntlNumberFormatOptions = {
+            maximumSignificantDigits: DefaultUnitFormat.maximumDigits,
+            notation: 'scientific'
+        };
+        for (const unit of unitScale.supportedScaledUnits) {
+            this.defaultScaledUnitFormatters.set(unit.scaleFactor, unit.scaledUnitFormatFactory({
+                locale,
+                intlNumberFormatOptions: this.defaultIntlNumberFormatOptions
+            }));
+            this.leadingZeroScaledUnitFormatters.set(unit.scaleFactor, unit.scaledUnitFormatFactory({
+                locale,
+                intlNumberFormatOptions: this.leadingZeroIntlNumberFormatOptions
+            }));
+        }
+        this.exponentialScaledUnitFormatter = unitScale.baseScaledUnit.scaledUnitFormatFactory({
+            locale,
+            intlNumberFormatOptions: this.exponentialIntlNumberFormatOptions
+        });
+        this.unitScale = unitScale;
+    }
+    resolvedOptions() {
+        return {
+            unitScale: this.unitScale
+        };
+    }
+    tryFormat(number) {
+        // Normalize +0 / -0 --> +0
+        const numberNormalized = number === 0 ? 0 : number;
+        const { scaledValue, scaledUnit } = this.unitScale.scaleNumber(numberNormalized);
+        const numberStyle = this.resolveNumberStyle(scaledValue);
+        switch (numberStyle) {
+            case 'default': {
+                const scaledUnitFormatter = this.defaultScaledUnitFormatters.get(scaledUnit.scaleFactor);
+                return scaledUnitFormatter.format(scaledValue);
+            }
+            case 'leadingZero': {
+                const scaledUnitFormatter = this.leadingZeroScaledUnitFormatters.get(scaledUnit.scaleFactor);
+                return scaledUnitFormatter.format(scaledValue);
+            }
+            case 'exponential': {
+                const scaledUnitFormatter = this.exponentialScaledUnitFormatter;
+                return scaledUnitFormatter.format(numberNormalized);
+            }
+            default:
+                throw new Error('Unexpected number format style');
+        }
+    }
+    resolveNumberStyle(number) {
+        if (number === 0) {
+            return 'default';
+        }
+        const absoluteValue = Math.abs(number);
+        if (absoluteValue >= DefaultUnitFormat.exponentialUpperBound
+            || absoluteValue < DefaultUnitFormat.exponentialLowerBound) {
+            return 'exponential';
+        }
+        // Ideally, we could set 'roundingPriority: "lessPrecision"' with a formatter that has both 'maximumSignificantDigits' and
+        // 'maximumFractionDigits' configured instead of having two different formatters that we conditionally choose between. However,
+        // 'roundingPrioirty' is not supported yet in all browsers.
+        if (absoluteValue < 1) {
+            return 'leadingZero';
+        }
+        return 'default';
+    }
+}
+// The maximum number of digits that should be rendered for any given value.
+DefaultUnitFormat.maximumDigits = 6;
+// Use exponential notation for numbers that will be rendered with 3 leading 0s or more.
+// Because a maximum of 6 digits are rendered, showing more than 3 leading 0s is not ideal
+// because then at least half of the displayed digits will be leading 0s.
+DefaultUnitFormat.exponentialLowerBound = 0.000995;
+// Use exponential formatting for numbers whose magnitude cannot otherwise be displayed
+// with 6 digits or less.
+DefaultUnitFormat.exponentialUpperBound = 999999.5;
+//# sourceMappingURL=default-unit-format.js.map

package/dist/esm/utilities/unit-format/default-unit-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default-unit-format.js","sourceRoot":"","sources":["../../../../src/utilities/unit-format/default-unit-format.ts"],"names":[],"mappings":"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"}

package/dist/esm/utilities/unit-format/scaled-unit/scaled-unit.d.ts

@@ -0,0 +1,16 @@
+import type { ScaledUnitFormat } from '../scaled-unit-format/scaled-unit-format';
+export interface ScaledUnitFormatFactoryOptions {
+    readonly locale: string;
+    readonly intlNumberFormatOptions?: Intl.NumberFormatOptions;
+}
+declare type ScaledUnitFormatFactory = (scaledUnitFormatFactoryOptions: ScaledUnitFormatFactoryOptions) => ScaledUnitFormat;
+/**
+ * A unit that represents a scaled version of a base unit.
+ */
+export declare class ScaledUnit {
+    readonly scaleFactor: number;
+    readonly scaledUnitFormatFactory: ScaledUnitFormatFactory;
+    constructor(scaleFactor: number, scaledUnitFormatFactory: ScaledUnitFormatFactory);
+    isBase(): boolean;
+}
+export {};

package/dist/esm/utilities/unit-format/scaled-unit/scaled-unit.js

@@ -0,0 +1,13 @@
+/**
+ * A unit that represents a scaled version of a base unit.
+ */
+export class ScaledUnit {
+    constructor(scaleFactor, scaledUnitFormatFactory) {
+        this.scaleFactor = scaleFactor;
+        this.scaledUnitFormatFactory = scaledUnitFormatFactory;
+    }
+    isBase() {
+        return this.scaleFactor === 1;
+    }
+}
+//# sourceMappingURL=scaled-unit.js.map

package/dist/esm/utilities/unit-format/scaled-unit/scaled-unit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaled-unit.js","sourceRoot":"","sources":["../../../../../src/utilities/unit-format/scaled-unit/scaled-unit.ts"],"names":[],"mappings":"AAWA;;GAEG;AACH,MAAM,OAAO,UAAU;IACnB,YACoB,WAAmB,EACnB,uBAAgD;QADhD,gBAAW,GAAX,WAAW,CAAQ;QACnB,4BAAuB,GAAvB,uBAAuB,CAAyB;IACjE,CAAC;IAEG,MAAM;QACT,OAAO,IAAI,CAAC,WAAW,KAAK,CAAC,CAAC;IAClC,CAAC;CACJ"}

package/dist/esm/utilities/unit-format/scaled-unit-format/intl-number-format-scaled-unit-format.d.ts

@@ -0,0 +1,11 @@
+import type { ScaledUnitFormatFactoryOptions } from '../scaled-unit/scaled-unit';
+import { ScaledUnitFormat } from './scaled-unit-format';
+/**
+ * A formatter for units that can be formatted/translated by Intl.NumberFormat
+ */
+export declare class IntlNumberFormatScaledUnitFormat extends ScaledUnitFormat {
+    private readonly formatter;
+    protected constructor(scaledUnitFormatFactoryOptions: ScaledUnitFormatFactoryOptions, unitSpecificIntlNumberFormatOptions: Intl.NumberFormatOptions);
+    static createFactory(unitSpecificIntlNumberFormatOptions: Intl.NumberFormatOptions): (scaledUnitFormatFactoryOptions: ScaledUnitFormatFactoryOptions) => IntlNumberFormatScaledUnitFormat;
+    format(value: number): string;
+}

package/dist/esm/utilities/unit-format/scaled-unit-format/intl-number-format-scaled-unit-format.js

@@ -0,0 +1,21 @@
+import { ScaledUnitFormat } from './scaled-unit-format';
+/**
+ * A formatter for units that can be formatted/translated by Intl.NumberFormat
+ */
+export class IntlNumberFormatScaledUnitFormat extends ScaledUnitFormat {
+    constructor(scaledUnitFormatFactoryOptions, unitSpecificIntlNumberFormatOptions) {
+        super(scaledUnitFormatFactoryOptions);
+        this.formatter = new Intl.NumberFormat(this.locale, {
+            ...unitSpecificIntlNumberFormatOptions,
+            // Application configured options override unit specific options
+            ...this.intlNumberFormatOptions
+        });
+    }
+    static createFactory(unitSpecificIntlNumberFormatOptions) {
+        return (scaledUnitFormatFactoryOptions) => new IntlNumberFormatScaledUnitFormat(scaledUnitFormatFactoryOptions, unitSpecificIntlNumberFormatOptions);
+    }
+    format(value) {
+        return this.formatter.format(value);
+    }
+}
+//# sourceMappingURL=intl-number-format-scaled-unit-format.js.map

package/dist/esm/utilities/unit-format/scaled-unit-format/intl-number-format-scaled-unit-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intl-number-format-scaled-unit-format.js","sourceRoot":"","sources":["../../../../../src/utilities/unit-format/scaled-unit-format/intl-number-format-scaled-unit-format.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD;;GAEG;AACH,MAAM,OAAO,gCAAiC,SAAQ,gBAAgB;IAGlE,YACI,8BAA8D,EAC9D,mCAA6D;QAE7D,KAAK,CAAC,8BAA8B,CAAC,CAAC;QACtC,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,EAAE;YAChD,GAAG,mCAAmC;YACtC,gEAAgE;YAChE,GAAG,IAAI,CAAC,uBAAuB;SAClC,CAAC,CAAC;IACP,CAAC;IAEM,MAAM,CAAC,aAAa,CACvB,mCAA6D;QAE7D,OAAO,CACH,8BAA8D,EAC9B,EAAE,CAAC,IAAI,gCAAgC,CACvE,8BAA8B,EAC9B,mCAAmC,CACtC,CAAC;IACN,CAAC;IAEM,MAAM,CAAC,KAAa;QACvB,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACxC,CAAC;CACJ"}

package/dist/esm/utilities/unit-format/scaled-unit-format/manually-translated-scaled-unit-format.d.ts

@@ -0,0 +1,43 @@
+import type { ScaledUnitFormatFactoryOptions } from '../scaled-unit/scaled-unit';
+import { ScaledUnitFormat } from './scaled-unit-format';
+/**
+ * Representations of a unit in a particular language
+ */
+export declare class UnitTranslation {
+    readonly singular: string;
+    readonly plural: string;
+    readonly symbol: string;
+    constructor(singular: string, plural: string, symbol: string);
+}
+/**
+ * A map of locales of string format "[lang]" or "[lang]-[region]", for example "en" and / or "en-us", to UnitTranslation objects
+ */
+export declare type UnitTranslations = ReadonlyMap<string, UnitTranslation>;
+export interface ManuallyTranslatedScaledUnitFormatOptions {
+    /**
+     * Translations for the unit by locale string.
+     * The locale strings must be of the form [lang] or [lang]-[region], for example "en" and / or "en-us".
+     * Other subtags besides lang and region are not supported.
+     * Translations for "en" must be provided.
+     */
+    readonly unitTranslations: UnitTranslations;
+    /**
+     * String for prefix of this scaled unit, for example "k" (for kilo-).
+     * Assumed the same across languages.
+     * Base unit must use "", i.e. empty string, as the scaled prefix text.
+     */
+    readonly scaledPrefixText: string;
+}
+/**
+ * A formatter for units that are not supported by Intl.NumberFormat
+ */
+export declare class ManuallyTranslatedScaledUnitFormat extends ScaledUnitFormat {
+    private readonly pluralRules;
+    private readonly formatter;
+    private readonly unitTranslation;
+    private readonly scaledPrefixText;
+    protected constructor(scaledUnitFormatFactoryOptions: ScaledUnitFormatFactoryOptions, { unitTranslations, scaledPrefixText }: ManuallyTranslatedScaledUnitFormatOptions);
+    static createFactory(manuallyTranslatedScaledUnitFormatOptions: ManuallyTranslatedScaledUnitFormatOptions): (scaledUnitFormatFactoryOptions: ScaledUnitFormatFactoryOptions) => ManuallyTranslatedScaledUnitFormat;
+    format(value: number): string;
+    private getTranslationToUse;
+}

package/dist/esm/utilities/unit-format/scaled-unit-format/manually-translated-scaled-unit-format.js

@@ -0,0 +1,62 @@
+import { ScaledUnitFormat } from './scaled-unit-format';
+/**
+ * Representations of a unit in a particular language
+ */
+export class UnitTranslation {
+    constructor(singular, plural, symbol) {
+        this.singular = singular;
+        this.plural = plural;
+        this.symbol = symbol;
+    }
+}
+/**
+ * A formatter for units that are not supported by Intl.NumberFormat
+ */
+export class ManuallyTranslatedScaledUnitFormat extends ScaledUnitFormat {
+    constructor(scaledUnitFormatFactoryOptions, { unitTranslations, scaledPrefixText }) {
+        super(scaledUnitFormatFactoryOptions);
+        if (!unitTranslations.get('en')) {
+            throw new Error('English translations must exist with locale string "en"');
+        }
+        this.pluralRules = new Intl.PluralRules(this.locale);
+        this.formatter = new Intl.NumberFormat(this.locale, this.intlNumberFormatOptions);
+        this.unitTranslation = this.getTranslationToUse(unitTranslations, this.locale);
+        this.scaledPrefixText = scaledPrefixText;
+    }
+    static createFactory(manuallyTranslatedScaledUnitFormatOptions) {
+        return (scaledUnitFormatFactoryOptions) => new ManuallyTranslatedScaledUnitFormat(scaledUnitFormatFactoryOptions, manuallyTranslatedScaledUnitFormatOptions);
+    }
+    format(value) {
+        const formatted = this.formatter.format(value);
+        // For non-base units (which are a scaled prefix text of empty string)
+        if (this.scaledPrefixText !== '') {
+            return `${formatted} ${this.scaledPrefixText}${this.unitTranslation.symbol}`;
+        }
+        // Some languages have more than two forms (singular/plural) of cardinal
+        // numbers, but we are treating anything other than the 'one' form as plural.
+        // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/PluralRules#description
+        //
+        // Because PluralRules.select() takes a number (not a string), it cannot differentiate
+        // between 1 and 1.0. When NumberFormat is configured to format with a set number
+        // of fractional digits, those fractional digits can have an effect on the pluralization
+        // of the unit. E.g. in English, it formats "1 byte" vs "1.0 bytes". Thus there is
+        // sometimes an inconsistency between unit pluralization for the same number, based
+        // on whether it's supported by NumberFormat, or manually translated.
+        const unitLabel = this.pluralRules.select(value) === 'one'
+            ? this.unitTranslation.singular
+            : this.unitTranslation.plural;
+        return `${formatted} ${unitLabel}`;
+    }
+    getTranslationToUse(unitTranslations, locale) {
+        const localeObject = new Intl.Locale(locale ?? 'en');
+        const language = localeObject.language;
+        const region = localeObject.region;
+        const regionSpecificMatchedTranslations = region
+            ? unitTranslations.get(`${language}-${region}`)
+            : undefined;
+        return (regionSpecificMatchedTranslations
+            ?? unitTranslations.get(language)
+            ?? unitTranslations.get('en'));
+    }
+}
+//# sourceMappingURL=manually-translated-scaled-unit-format.js.map

package/dist/esm/utilities/unit-format/scaled-unit-format/manually-translated-scaled-unit-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manually-translated-scaled-unit-format.js","sourceRoot":"","sources":["../../../../../src/utilities/unit-format/scaled-unit-format/manually-translated-scaled-unit-format.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD;;GAEG;AACH,MAAM,OAAO,eAAe;IACxB,YACoB,QAAgB,EAChB,MAAc,EACd,MAAc;QAFd,aAAQ,GAAR,QAAQ,CAAQ;QAChB,WAAM,GAAN,MAAM,CAAQ;QACd,WAAM,GAAN,MAAM,CAAQ;IAC/B,CAAC;CACP;AAqBD;;GAEG;AACH,MAAM,OAAO,kCAAmC,SAAQ,gBAAgB;IAMpE,YACI,8BAA8D,EAC9D,EACI,gBAAgB,EAChB,gBAAgB,EACwB;QAE5C,KAAK,CAAC,8BAA8B,CAAC,CAAC;QACtC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;YAC7B,MAAM,IAAI,KAAK,CACX,yDAAyD,CAC5D,CAAC;SACL;QACD,IAAI,CAAC,WAAW,GAAG,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACrD,IAAI,CAAC,SAAS,GAAG,IAAI,IAAI,CAAC,YAAY,CAClC,IAAI,CAAC,MAAM,EACX,IAAI,CAAC,uBAAuB,CAC/B,CAAC;QACF,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC,mBAAmB,CAC3C,gBAAgB,EAChB,IAAI,CAAC,MAAM,CACd,CAAC;QACF,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;IAC7C,CAAC;IAEM,MAAM,CAAC,aAAa,CACvB,yCAAoF;QAEpF,OAAO,CACH,8BAA8D,EAC5B,EAAE,CAAC,IAAI,kCAAkC,CAC3E,8BAA8B,EAC9B,yCAAyC,CAC5C,CAAC;IACN,CAAC;IAEM,MAAM,CAAC,KAAa;QACvB,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC/C,sEAAsE;QACtE,IAAI,IAAI,CAAC,gBAAgB,KAAK,EAAE,EAAE;YAC9B,OAAO,GAAG,SAAS,IAAI,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC;SAChF;QAED,wEAAwE;QACxE,6EAA6E;QAC7E,oHAAoH;QACpH,EAAE;QACF,sFAAsF;QACtF,iFAAiF;QACjF,wFAAwF;QACxF,kFAAkF;QAClF,mFAAmF;QACnF,qEAAqE;QACrE,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,KAAK;YACtD,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,QAAQ;YAC/B,CAAC,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC;QAClC,OAAO,GAAG,SAAS,IAAI,SAAS,EAAE,CAAC;IACvC,CAAC;IAEO,mBAAmB,CACvB,gBAAkC,EAClC,MAAc;QAEd,MAAM,YAAY,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,CAAC;QACrD,MAAM,QAAQ,GAAG,YAAY,CAAC,QAAQ,CAAC;QACvC,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC;QACnC,MAAM,iCAAiC,GAAG,MAAM;YAC5C,CAAC,CAAC,gBAAgB,CAAC,GAAG,CAAC,GAAG,QAAQ,IAAI,MAAM,EAAE,CAAC;YAC/C,CAAC,CAAC,SAAS,CAAC;QAChB,OAAO,CACH,iCAAiC;eAC9B,gBAAgB,CAAC,GAAG,CAAC,QAAQ,CAAC;eAC9B,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAE,CACjC,CAAC;IACN,CAAC;CACJ"}

package/dist/esm/utilities/unit-format/scaled-unit-format/scaled-unit-format.d.ts

@@ -0,0 +1,10 @@
+import type { ScaledUnitFormatFactoryOptions } from '../scaled-unit/scaled-unit';
+/**
+ * A class that knows how to format a numeric value as a string that includes units.
+ */
+export declare abstract class ScaledUnitFormat {
+    protected readonly locale: string;
+    protected readonly intlNumberFormatOptions?: Intl.NumberFormatOptions;
+    protected constructor(scaledUnitFormatFactoryOptions: ScaledUnitFormatFactoryOptions);
+    abstract format(value: number): string;
+}

package/dist/esm/utilities/unit-format/scaled-unit-format/scaled-unit-format.js

@@ -0,0 +1,10 @@
+/**
+ * A class that knows how to format a numeric value as a string that includes units.
+ */
+export class ScaledUnitFormat {
+    constructor(scaledUnitFormatFactoryOptions) {
+        this.locale = scaledUnitFormatFactoryOptions.locale;
+        this.intlNumberFormatOptions = scaledUnitFormatFactoryOptions.intlNumberFormatOptions;
+    }
+}
+//# sourceMappingURL=scaled-unit-format.js.map

package/dist/esm/utilities/unit-format/scaled-unit-format/scaled-unit-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaled-unit-format.js","sourceRoot":"","sources":["../../../../../src/utilities/unit-format/scaled-unit-format/scaled-unit-format.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,OAAgB,gBAAgB;IAIlC,YACI,8BAA8D;QAE9D,IAAI,CAAC,MAAM,GAAG,8BAA8B,CAAC,MAAM,CAAC;QACpD,IAAI,CAAC,uBAAuB,GAAG,8BAA8B,CAAC,uBAAuB,CAAC;IAC1F,CAAC;CAGJ"}

package/dist/esm/utilities/unit-format/unit-format.d.ts

@@ -0,0 +1,16 @@
+import type { UnitScale } from './unit-scale/unit-scale';
+export interface UnitFormatOptions {
+    unitScale?: UnitScale;
+}
+/**
+ * The base class for unit formats.
+ */
+export declare abstract class UnitFormat<Options extends UnitFormatOptions = UnitFormatOptions> {
+    /**
+     * Formats a number value to a string.
+     * For nullish values or values that result in an exception being thrown, empty string is returned
+     */
+    format(value: number | undefined | null): string;
+    abstract resolvedOptions(): Required<Options>;
+    protected abstract tryFormat(number: number): string;
+}

package/dist/esm/utilities/unit-format/unit-format.js

@@ -0,0 +1,21 @@
+/**
+ * The base class for unit formats.
+ */
+export class UnitFormat {
+    /**
+     * Formats a number value to a string.
+     * For nullish values or values that result in an exception being thrown, empty string is returned
+     */
+    format(value) {
+        if (typeof value !== 'number') {
+            return '';
+        }
+        try {
+            return this.tryFormat(value);
+        }
+        catch {
+            return '';
+        }
+    }
+}
+//# sourceMappingURL=unit-format.js.map

package/dist/esm/utilities/unit-format/unit-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-format.js","sourceRoot":"","sources":["../../../../src/utilities/unit-format/unit-format.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,OAAgB,UAAU;IAG5B;;;OAGG;IACI,MAAM,CAAC,KAAgC;QAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC3B,OAAO,EAAE,CAAC;SACb;QAED,IAAI;YACA,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;SAChC;QAAC,MAAM;YACJ,OAAO,EAAE,CAAC;SACb;IACL,CAAC;CAKJ"}

package/dist/esm/utilities/unit-format/unit-scale/byte-1024-unit-scale.d.ts

@@ -0,0 +1,9 @@
+import { UnitScale } from './unit-scale';
+/**
+ * Byte units (1024-based)
+ */
+declare class Byte1024UnitScale extends UnitScale {
+    constructor();
+}
+export declare const byte1024UnitScale: Byte1024UnitScale;
+export {};

package/dist/esm/utilities/unit-format/unit-scale/byte-1024-unit-scale.js

@@ -0,0 +1,31 @@
+import { ScaledUnit } from '../scaled-unit/scaled-unit';
+import { UnitScale } from './unit-scale';
+import { ManuallyTranslatedScaledUnitFormat, UnitTranslation } from '../scaled-unit-format/manually-translated-scaled-unit-format';
+const unitTranslations = new Map([
+    ['en', new UnitTranslation('byte', 'bytes', 'B')],
+    ['fr', new UnitTranslation('octet', 'octets', 'o')],
+    ['de', new UnitTranslation('Byte', 'Byte', 'B')],
+    ['ja', new UnitTranslation('バイト', 'バイト', 'B')],
+    ['zh', new UnitTranslation('字节', '字节', 'B')]
+]);
+const byte1024Prefixes = [
+    [1024 ** 0, ''],
+    [1024 ** 1, 'Ki'],
+    [1024 ** 2, 'Mi'],
+    [1024 ** 3, 'Gi'],
+    [1024 ** 4, 'Ti'],
+    [1024 ** 5, 'Pi']
+];
+/**
+ * Byte units (1024-based)
+ */
+class Byte1024UnitScale extends UnitScale {
+    constructor() {
+        super(byte1024Prefixes.map(([scaleFactor, scaledPrefixText]) => new ScaledUnit(scaleFactor, ManuallyTranslatedScaledUnitFormat.createFactory({
+            unitTranslations,
+            scaledPrefixText
+        }))));
+    }
+}
+export const byte1024UnitScale = new Byte1024UnitScale();
+//# sourceMappingURL=byte-1024-unit-scale.js.map

package/dist/esm/utilities/unit-format/unit-scale/byte-1024-unit-scale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"byte-1024-unit-scale.js","sourceRoot":"","sources":["../../../../../src/utilities/unit-format/unit-scale/byte-1024-unit-scale.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,OAAO,EACH,kCAAkC,EAElC,eAAe,EAClB,MAAM,8DAA8D,CAAC;AAEtE,MAAM,gBAAgB,GAAqB,IAAI,GAAG,CAAC;IAC/C,CAAC,IAAI,EAAE,IAAI,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC;IACjD,CAAC,IAAI,EAAE,IAAI,eAAe,CAAC,OAAO,EAAE,QAAQ,EAAE,GAAG,CAAC,CAAC;IACnD,CAAC,IAAI,EAAE,IAAI,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IAChD,CAAC,IAAI,EAAE,IAAI,eAAe,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC;IAC9C,CAAC,IAAI,EAAE,IAAI,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;CAC/C,CAAC,CAAC;AAEH,MAAM,gBAAgB,GAAG;IACrB,CAAC,IAAI,IAAI,CAAC,EAAE,EAAE,CAAC;IACf,CAAC,IAAI,IAAI,CAAC,EAAE,IAAI,CAAC;IACjB,CAAC,IAAI,IAAI,CAAC,EAAE,IAAI,CAAC;IACjB,CAAC,IAAI,IAAI,CAAC,EAAE,IAAI,CAAC;IACjB,CAAC,IAAI,IAAI,CAAC,EAAE,IAAI,CAAC;IACjB,CAAC,IAAI,IAAI,CAAC,EAAE,IAAI,CAAC;CACX,CAAC;AAEX;;GAEG;AACH,MAAM,iBAAkB,SAAQ,SAAS;IACrC;QACI,KAAK,CACD,gBAAgB,CAAC,GAAG,CAChB,CAAC,CAAC,WAAW,EAAE,gBAAgB,CAAC,EAAE,EAAE,CAAC,IAAI,UAAU,CAC/C,WAAW,EACX,kCAAkC,CAAC,aAAa,CAAC;YAC7C,gBAAgB;YAChB,gBAAgB;SACnB,CAAC,CACL,CACJ,CACJ,CAAC;IACN,CAAC;CACJ;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,iBAAiB,EAAE,CAAC"}

package/dist/esm/utilities/unit-format/unit-scale/byte-unit-scale.d.ts

@@ -0,0 +1,9 @@
+import { UnitScale } from './unit-scale';
+/**
+ * Byte units (1000-based)
+ */
+declare class ByteUnitScale extends UnitScale {
+    constructor();
+}
+export declare const byteUnitScale: ByteUnitScale;
+export {};

package/dist/esm/utilities/unit-format/unit-scale/byte-unit-scale.js

@@ -0,0 +1,25 @@
+import { IntlNumberFormatScaledUnitFormat } from '../scaled-unit-format/intl-number-format-scaled-unit-format';
+import { ScaledUnit } from '../scaled-unit/scaled-unit';
+import { UnitScale } from './unit-scale';
+const byteUnitScaleOptions = [
+    [1000 ** 0, 'byte', 'long'],
+    [1000 ** 1, 'kilobyte', 'short'],
+    [1000 ** 2, 'megabyte', 'short'],
+    [1000 ** 3, 'gigabyte', 'short'],
+    [1000 ** 4, 'terabyte', 'short'],
+    [1000 ** 5, 'petabyte', 'short']
+];
+/**
+ * Byte units (1000-based)
+ */
+class ByteUnitScale extends UnitScale {
+    constructor() {
+        super(byteUnitScaleOptions.map(([scaleFactor, unit, unitDisplay]) => new ScaledUnit(scaleFactor, IntlNumberFormatScaledUnitFormat.createFactory({
+            style: 'unit',
+            unit,
+            unitDisplay
+        }))));
+    }
+}
+export const byteUnitScale = new ByteUnitScale();
+//# sourceMappingURL=byte-unit-scale.js.map

package/dist/esm/utilities/unit-format/unit-scale/byte-unit-scale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"byte-unit-scale.js","sourceRoot":"","sources":["../../../../../src/utilities/unit-format/unit-scale/byte-unit-scale.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,MAAM,6DAA6D,CAAC;AAC/G,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,MAAM,oBAAoB,GAAG;IACzB,CAAC,IAAI,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC;IAC3B,CAAC,IAAI,IAAI,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC;IAChC,CAAC,IAAI,IAAI,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC;IAChC,CAAC,IAAI,IAAI,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC;IAChC,CAAC,IAAI,IAAI,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC;IAChC,CAAC,IAAI,IAAI,CAAC,EAAE,UAAU,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEX;;GAEG;AACH,MAAM,aAAc,SAAQ,SAAS;IACjC;QACI,KAAK,CACD,oBAAoB,CAAC,GAAG,CACpB,CAAC,CAAC,WAAW,EAAE,IAAI,EAAE,WAAW,CAAC,EAAE,EAAE,CAAC,IAAI,UAAU,CAChD,WAAW,EACX,gCAAgC,CAAC,aAAa,CAAC;YAC3C,KAAK,EAAE,MAAM;YACb,IAAI;YACJ,WAAW;SACd,CAAC,CACL,CACJ,CACJ,CAAC;IACN,CAAC;CACJ;AAED,MAAM,CAAC,MAAM,aAAa,GAAG,IAAI,aAAa,EAAE,CAAC"}

package/dist/esm/utilities/unit-format/unit-scale/passthrough-unit-scale.d.ts

@@ -0,0 +1,9 @@
+import { UnitScale } from './unit-scale';
+/**
+ * Unit scale that is used to passthrough a number without applying scaling or units
+ */
+declare class PassthroughUnitScale extends UnitScale {
+    constructor();
+}
+export declare const passthroughUnitScale: PassthroughUnitScale;
+export {};

package/dist/esm/utilities/unit-format/unit-scale/passthrough-unit-scale.js

@@ -0,0 +1,15 @@
+import { IntlNumberFormatScaledUnitFormat } from '../scaled-unit-format/intl-number-format-scaled-unit-format';
+import { ScaledUnit } from '../scaled-unit/scaled-unit';
+import { UnitScale } from './unit-scale';
+/**
+ * Unit scale that is used to passthrough a number without applying scaling or units
+ */
+class PassthroughUnitScale extends UnitScale {
+    constructor() {
+        super([
+            new ScaledUnit(10 ** 0, IntlNumberFormatScaledUnitFormat.createFactory({}))
+        ]);
+    }
+}
+export const passthroughUnitScale = new PassthroughUnitScale();
+//# sourceMappingURL=passthrough-unit-scale.js.map

package/dist/esm/utilities/unit-format/unit-scale/passthrough-unit-scale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"passthrough-unit-scale.js","sourceRoot":"","sources":["../../../../../src/utilities/unit-format/unit-scale/passthrough-unit-scale.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,MAAM,6DAA6D,CAAC;AAC/G,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC;;GAEG;AACH,MAAM,oBAAqB,SAAQ,SAAS;IACxC;QACI,KAAK,CAAC;YACF,IAAI,UAAU,CACV,EAAE,IAAI,CAAC,EACP,gCAAgC,CAAC,aAAa,CAAC,EAAE,CAAC,CACrD;SACJ,CAAC,CAAC;IACP,CAAC;CACJ;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,oBAAoB,EAAE,CAAC"}