atomic-fns 1.2.0 → 2.0.0

package/dist/i18n/date/utils.js

@@ -1,192 +0,0 @@
-import { asDate } from '../format.js';
-/**
- * Returns x % n but takes the sign of n instead of x
- * @param x
- * @param n
- * @returns {number}
- */
-function floorMod(x, n) {
-    return x - n * Math.floor(x / n);
-}
-function parseFloating(str) {
-    if (str != null && str !== '')
-        return parseFloat(str);
-}
-function parseMilliseconds(str) {
-    if (str != null && str !== '') {
-        const f = parseFloat(`0.${str}`) * 1000;
-        return Math.floor(f);
-    }
-}
-export function minDate(...dates) {
-    let ans = dates[0];
-    if (Array.isArray(ans)) {
-        dates = ans;
-        ans = ans[0];
-    }
-    for (let i = 1; i < dates.length; i++) {
-        if (dates[i].valueOf() < ans.valueOf() || Number.isNaN(ans.valueOf())) {
-            ans = dates[i];
-        }
-    }
-    return ans;
-}
-export function maxDate(...dates) {
-    let ans = dates[0];
-    if (Array.isArray(ans)) {
-        dates = ans;
-        ans = ans[0];
-    }
-    for (let i = 1; i < dates.length; i++) {
-        if (dates[i].valueOf() > ans.valueOf() || Number.isNaN(ans.valueOf())) {
-            ans = dates[i];
-        }
-    }
-    return ans;
-}
-/**
- * Returns `true` if the year is a leap year, otherwise `false`.
- * @param year The date year
- * @returns {boolean} `true` if is a leap year
- */
-export function isLeapYear(year) {
-    return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
-}
-/**
- * Get the number of days in the given year.
- * @param year The date year
- * @returns {number} Number of days in year
- */
-export function daysInYear(year) {
-    return isLeapYear(year) ? 366 : 365;
-}
-/**
- * Get the number of days in the given date's month and year.
- * @param date The specified date
- * @returns {number} Number of days in month
- */
-export function daysInMonth(date) {
-    const d = asDate(date), year = d.getFullYear(), month = d.getMonth() + 1;
-    const modMonth = floorMod(month - 1, 12) + 1, modYear = year + (month - modMonth) / 12;
-    if (modMonth === 2) {
-        return isLeapYear(modYear) ? 29 : 28;
-    }
-    else {
-        return [31, null, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][modMonth - 1];
-    }
-}
-// COERCION
-export function asNumber(value) {
-    const numericValue = Number(value);
-    if (typeof value === 'boolean' || value === '' || Number.isNaN(numericValue))
-        throw new Error(`Invalid unit value ${value}`);
-    return numericValue;
-}
-const isoDuration = /^-?P(?:(?:(-?\d{1,20}(?:\.\d{1,20})?)Y)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20}(?:\.\d{1,20})?)W)?(?:(-?\d{1,20}(?:\.\d{1,20})?)D)?(?:T(?:(-?\d{1,20}(?:\.\d{1,20})?)H)?(?:(-?\d{1,20}(?:\.\d{1,20})?)M)?(?:(-?\d{1,20})(?:[.,](-?\d{1,20}))?S)?)?)$/;
-function extractISODuration(match) {
-    const [s, yearStr, monthStr, weekStr, dayStr, hourStr, minuteStr, secondStr, millisecondsStr] = match;
-    const hasNegativePrefix = s[0] === '-';
-    const negativeSeconds = secondStr && secondStr[0] === '-';
-    const maybeNegate = (num, force = false) => num !== undefined && (force || (num && hasNegativePrefix)) ? -num : num;
-    return [
-        {
-            years: maybeNegate(parseFloating(yearStr)),
-            months: maybeNegate(parseFloating(monthStr)),
-            weeks: maybeNegate(parseFloating(weekStr)),
-            days: maybeNegate(parseFloating(dayStr)),
-            hours: maybeNegate(parseFloating(hourStr)),
-            minutes: maybeNegate(parseFloating(minuteStr)),
-            seconds: maybeNegate(parseFloating(secondStr), secondStr === '-0'),
-            milliseconds: maybeNegate(parseMilliseconds(millisecondsStr), negativeSeconds)
-        }
-    ];
-}
-function parse(s, ...patterns) {
-    if (s == null) {
-        return [null, null];
-    }
-    for (const [regex, extractor] of patterns) {
-        const m = regex.exec(s);
-        if (m) {
-            return extractor(m);
-        }
-    }
-    return [null, null];
-}
-export function parseISODuration(s) {
-    return parse(s, [isoDuration, extractISODuration]);
-}
-function createUTCDate(...args) {
-    let date, y = args[0];
-    // the Date.UTC function remaps years 0-99 to 1900-1999
-    if (y < 100 && y >= 0) {
-        // preserve leap years using a full 400 year cycle, then reset
-        args[0] = y + 400;
-        date = new Date(Date.UTC.apply(null, args));
-        if (Number.isFinite(date.getUTCFullYear())) {
-            date.setUTCFullYear(y);
-        }
-    }
-    else {
-        date = new Date(Date.UTC.apply(null, args));
-    }
-    return date;
-}
-function firstWeekOffset(year, dow, doy) {
-    var // first-week day -- which january is always in the first week (4 for iso, 1 for other)
-    fwd = 7 + dow - doy, 
-    // first-week day local weekday -- which local weekday is fwd
-    fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
-    return -fwdlw + fwd - 1;
-}
-/**
- * Returns the number of weeks in the specified year.
- * @param year
- * @param firstDayOfWeek
- * @param firstDayOfYear
- */
-export function weeksInYear(year, firstDayOfWeek = 1, firstDayOfYear = 1) {
-    var weekOffset = firstWeekOffset(year, firstDayOfWeek, firstDayOfYear), weekOffsetNext = firstWeekOffset(year + 1, firstDayOfWeek, firstDayOfYear);
-    return (daysInYear(year) - weekOffset + weekOffsetNext) / 7;
-}
-/**
- * Returns the week of the year for the specified date
- * @param date The date value
- * @param firstDayOfWeek The weekday a week starts on, where Sunday is 0
- * @param firstDayOfYear Picks week 1: the week holding January `7 + firstDayOfWeek - firstDayOfYear`, so `1, 4` gives ISO weeks
- * @returns The week and the year that week belongs to
- */
-export function weekOfYear(date, firstDayOfWeek = 1, firstDayOfYear = 1) {
-    const year = asDate(date).getFullYear();
-    const doy = dayOfYear(date);
-    let weekOffset = firstWeekOffset(year, firstDayOfWeek, firstDayOfYear), week = Math.floor((doy - weekOffset - 1) / 7) + 1, resWeek, resYear;
-    if (week < 1) {
-        resYear = year - 1;
-        resWeek = week + weeksInYear(resYear, firstDayOfWeek, firstDayOfYear);
-    }
-    else if (week > weeksInYear(year, firstDayOfWeek, firstDayOfYear)) {
-        resWeek = week - weeksInYear(year, firstDayOfWeek, firstDayOfYear);
-        resYear = year + 1;
-    }
-    else {
-        resYear = year;
-        resWeek = week;
-    }
-    return {
-        week: resWeek,
-        year: resYear
-    };
-}
-export function isoWeeksInYear(year) {
-    return weeksInYear(year, 1, 4);
-}
-export function dayOfYear(input) {
-    input = asDate(input);
-    input.setHours(0);
-    input.setMinutes(0);
-    input.setSeconds(0);
-    input.setMilliseconds(0);
-    const start = new Date(input);
-    start.setMonth(0, 1);
-    return Math.round((+input - start.getTime()) / 864e5) + 1;
-}

package/dist/i18n/duration.d.ts

@@ -1,113 +0,0 @@
-export type DurationUnit = 'year' | 'years' | 'quarter' | 'quarters' | 'month' | 'months' | 'week' | 'weeks' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds';
-export interface TDuration {
-    years?: number;
-    months?: number;
-    weeks?: number;
-    days?: number;
-    hours?: number;
-    minutes?: number;
-    seconds?: number;
-    milliseconds?: number;
-}
-export declare const UNITS_PLURAL: Record<DurationUnit, DurationUnit>;
-export declare class Duration {
-    values: TDuration;
-    private matrix;
-    constructor(dur?: number | TDuration | Duration, exact?: boolean);
-    private withValues;
-    /** Get the years. */
-    get years(): number;
-    /** Get the months. */
-    get months(): number;
-    /** Get the weeks. */
-    get weeks(): number;
-    /** Get the days. */
-    get days(): number;
-    /** Get the hours. */
-    get hours(): number;
-    /** Get the minutes. */
-    get minutes(): number;
-    /** Get the seconds. */
-    get seconds(): number;
-    /** Get the milliseconds. */
-    get milliseconds(): number;
-    /**
-     * Get the value of unit.
-     * @param {string} unit - a unit such as 'minute' or 'day'
-     * @example new Duration({years: 2, days: 3}).get('years') // 2
-     * @example new Duration({years: 2, days: 3}).get('months') // 0
-     * @example new Duration({years: 2, days: 3}).get('days') // 3
-     * @return {number}
-     */
-    get(unit: string): number;
-    add(duration: TDuration): Duration;
-    /**
-     * Make this Duration shorter by the specified amount. Return a newly-constructed Duration.
-     * @param {Duration|Object|number} duration - The amount to subtract.
-     * @return {Duration}
-     */
-    subtract(duration: Duration | TDuration | number): Duration;
-    /**
-     * Return the negative of this Duration.
-     * @example
-  ```js
-  new Duration({ hours: 1, seconds: 30 }).negated().toObject()
-  // { hours: -1, seconds: -30 }
-  ```
-     * @returns {Duration}
-     */
-    negated(): Duration;
-    /**
-     * Return the absolute values of this Duration.
-     * @example
-  ```js
-  new Duration({ hours: 1, seconds: -30 }).abs().toObject()
-  // { hours: 1, seconds: 30 }
-  ```
-     * @returns {Duration}
-     */
-    abs(): Duration;
-    private shiftToAll;
-    private shiftTo;
-    total(unit: DurationUnit): number;
-    exact(unit?: DurationUnit): number | this;
-    toObject(): {
-        years?: number;
-        months?: number;
-        weeks?: number;
-        days?: number;
-        hours?: number;
-        minutes?: number;
-        seconds?: number;
-        milliseconds?: number;
-    };
-    normalize(): Duration;
-    rescale(): Duration;
-    /**
-     * Returns an ISO 8601-compliant string representation of this Duration.
-     * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
-     * @example new Duration({ years: 3, seconds: 45 }).toString() // 'P3YT45S'
-     * @example new Duration({ months: 4, seconds: 45 }).toString() // 'P4MT45S'
-     * @example new Duration({ months: 5 }).toString() // 'P5M'
-     * @example new Duration({ minutes: 5 }).toString() // 'PT5M'
-     * @example new Duration({ milliseconds: 6 }).toString() // 'PT0.006S'
-     * @return {string}
-     */
-    toISOString(): string;
-    toString(): string;
-    /**
-     * Create a Duration from an ISO 8601 duration string.
-     *
-     * @example
-  ```js
-  Duration.fromISO('P3Y6M1W4DT12H30M5S').toObject()
-  // { years: 3, months: 6, weeks: 1, days: 4, hours: 12, minutes: 30, seconds: 5 }
-  Duration.fromISO('PT23H').toObject()
-  // { hours: 23 }
-  Duration.fromISO('P5Y3M').toObject()
-  // { years: 5, months: 3 }
-  ```
-     * @return {Duration}
-     */
-    static fromISO(text: string): Duration;
-}

package/dist/i18n/duration.js

@@ -1,398 +0,0 @@
-import { pick } from '../collections/index.js';
-import { isNumber, isObject, ValueError } from '../globals/index.js';
-import { round } from '../math/index.js';
-import { parseISODuration } from './date/utils.js';
-const lowOrderMatrix = {
-    weeks: {
-        days: 7,
-        hours: 7 * 24,
-        minutes: 7 * 24 * 60,
-        seconds: 7 * 24 * 60 * 60,
-        milliseconds: 7 * 24 * 60 * 60 * 1000
-    },
-    days: {
-        hours: 24,
-        minutes: 24 * 60,
-        seconds: 24 * 60 * 60,
-        milliseconds: 24 * 60 * 60 * 1000
-    },
-    hours: { minutes: 60, seconds: 60 * 60, milliseconds: 60 * 60 * 1000 },
-    minutes: { seconds: 60, milliseconds: 60 * 1000 },
-    seconds: { milliseconds: 1000 }
-};
-const casualMatrix = {
-    years: {
-        quarters: 4,
-        months: 12,
-        weeks: 52,
-        days: 365,
-        hours: 365 * 24,
-        minutes: 365 * 24 * 60,
-        seconds: 365 * 24 * 60 * 60,
-        milliseconds: 365 * 24 * 60 * 60 * 1000
-    },
-    quarters: {
-        months: 3,
-        weeks: 13,
-        days: 91,
-        hours: 91 * 24,
-        minutes: 91 * 24 * 60,
-        seconds: 91 * 24 * 60 * 60,
-        milliseconds: 91 * 24 * 60 * 60 * 1000
-    },
-    months: {
-        weeks: 4,
-        days: 30,
-        hours: 30 * 24,
-        minutes: 30 * 24 * 60,
-        seconds: 30 * 24 * 60 * 60,
-        milliseconds: 30 * 24 * 60 * 60 * 1000
-    },
-    ...lowOrderMatrix
-};
-const exactDaysInYear = 146097.0 / 400;
-const exactDaysInMonth = 146097.0 / 4800;
-const exactMatrix = {
-    years: {
-        quarters: 4,
-        months: 12,
-        weeks: exactDaysInYear / 7,
-        days: exactDaysInYear,
-        hours: exactDaysInYear * 24,
-        minutes: exactDaysInYear * 24 * 60,
-        seconds: exactDaysInYear * 24 * 60 * 60,
-        milliseconds: exactDaysInYear * 24 * 60 * 60 * 1000
-    },
-    quarters: {
-        months: 3,
-        weeks: exactDaysInYear / 28,
-        days: exactDaysInYear / 4,
-        hours: (exactDaysInYear * 24) / 4,
-        minutes: (exactDaysInYear * 24 * 60) / 4,
-        seconds: (exactDaysInYear * 24 * 60 * 60) / 4,
-        milliseconds: (exactDaysInYear * 24 * 60 * 60 * 1000) / 4
-    },
-    months: {
-        weeks: exactDaysInMonth / 7,
-        days: exactDaysInMonth,
-        hours: exactDaysInMonth * 24,
-        minutes: exactDaysInMonth * 24 * 60,
-        seconds: exactDaysInMonth * 24 * 60 * 60,
-        milliseconds: exactDaysInMonth * 24 * 60 * 60 * 1000
-    },
-    ...lowOrderMatrix
-};
-export const UNITS_PLURAL = {
-    year: 'years',
-    years: 'years',
-    quarter: 'quarters',
-    quarters: 'quarters',
-    month: 'months',
-    months: 'months',
-    week: 'weeks',
-    weeks: 'weeks',
-    day: 'days',
-    days: 'days',
-    hour: 'hours',
-    hours: 'hours',
-    minute: 'minutes',
-    minutes: 'minutes',
-    second: 'seconds',
-    seconds: 'seconds',
-    millisecond: 'milliseconds',
-    milliseconds: 'milliseconds'
-};
-const orderedUnits = [
-    'years',
-    'quarters',
-    'months',
-    'weeks',
-    'days',
-    'hours',
-    'minutes',
-    'seconds',
-    'milliseconds'
-];
-const reverseUnits = orderedUnits.slice(0).reverse();
-export class Duration {
-    values = {};
-    matrix = casualMatrix;
-    constructor(dur = {}, exact = false) {
-        if (dur instanceof Duration) {
-            this.values = { ...dur.values };
-        }
-        else if (typeof dur === 'number') {
-            this.values = { milliseconds: dur };
-        }
-        else if (isObject(dur)) {
-            this.values = normalizeUnits(dur);
-        }
-        if (exact || (dur instanceof Duration && dur.matrix === exactMatrix)) {
-            // Set the conversion matrix to use
-            this.matrix = exactMatrix;
-        }
-    }
-    withValues(values) {
-        return new Duration(values, this.matrix === exactMatrix);
-    }
-    /** Get the years. */
-    get years() {
-        return this.values.years || 0;
-    }
-    /** Get the months. */
-    get months() {
-        return this.values.months || 0;
-    }
-    /** Get the weeks. */
-    get weeks() {
-        return this.values.weeks || 0;
-    }
-    /** Get the days. */
-    get days() {
-        return this.values.days || 0;
-    }
-    /** Get the hours. */
-    get hours() {
-        return this.values.hours || 0;
-    }
-    /** Get the minutes. */
-    get minutes() {
-        return this.values.minutes || 0;
-    }
-    /** Get the seconds. */
-    get seconds() {
-        return this.values.seconds || 0;
-    }
-    /** Get the milliseconds. */
-    get milliseconds() {
-        return this.values.milliseconds || 0;
-    }
-    /**
-     * Get the value of unit.
-     * @param {string} unit - a unit such as 'minute' or 'day'
-     * @example new Duration({years: 2, days: 3}).get('years') // 2
-     * @example new Duration({years: 2, days: 3}).get('months') // 0
-     * @example new Duration({years: 2, days: 3}).get('days') // 3
-     * @return {number}
-     */
-    get(unit) {
-        return this.values[UNITS_PLURAL[unit.toLowerCase()]] ?? 0;
-    }
-    add(duration) {
-        const dur = new Duration(duration);
-        const result = {};
-        for (const k of orderedUnits) {
-            if (dur.values[k] || this.values[k]) {
-                result[k] = dur.get(k) + this.get(k);
-            }
-        }
-        return this.withValues(result);
-    }
-    /**
-     * Make this Duration shorter by the specified amount. Return a newly-constructed Duration.
-     * @param {Duration|Object|number} duration - The amount to subtract.
-     * @return {Duration}
-     */
-    subtract(duration) {
-        const dur = new Duration(duration);
-        return this.add(dur.negated());
-    }
-    /**
-     * Return the negative of this Duration.
-     * @example
-  ```js
-  new Duration({ hours: 1, seconds: 30 }).negated().toObject()
-  // { hours: -1, seconds: -30 }
-  ```
-     * @returns {Duration}
-     */
-    negated() {
-        const negated = {};
-        for (const k of Object.keys(this.values)) {
-            negated[k] = this.values[k] === 0 ? 0 : -this.values[k];
-        }
-        return this.withValues(negated);
-    }
-    /**
-     * Return the absolute values of this Duration.
-     * @example
-  ```js
-  new Duration({ hours: 1, seconds: -30 }).abs().toObject()
-  // { hours: 1, seconds: 30 }
-  ```
-     * @returns {Duration}
-     */
-    abs() {
-        const parts = {};
-        for (const k of Object.keys(this.values)) {
-            parts[k] = Math.abs(this.values[k]);
-        }
-        return this.withValues(parts);
-    }
-    shiftToAll() {
-        return this.shiftTo('years', 'months', 'weeks', 'days', 'hours', 'minutes', 'seconds', 'milliseconds');
-    }
-    shiftTo(...units) {
-        if (units.length === 0) {
-            return this;
-        }
-        units = units.map((u) => UNITS_PLURAL[u.toLowerCase()]);
-        const built = {};
-        const accumulated = {};
-        const vals = this.toObject();
-        let lastUnit;
-        for (const toUnit of orderedUnits) {
-            if (units.includes(toUnit)) {
-                lastUnit = toUnit;
-                let own = 0;
-                // anything we haven't boiled down yet should get boiled to this unit
-                for (const fromUnit in accumulated) {
-                    own += accumulated[fromUnit] * this.matrix[fromUnit][toUnit];
-                    accumulated[fromUnit] = 0;
-                }
-                // plus anything that's already in this unit
-                if (typeof vals[toUnit] === 'number') {
-                    own += vals[toUnit];
-                }
-                const i = Math.trunc(own);
-                built[toUnit] = i;
-                accumulated[toUnit] = (own * 1000 - i * 1000) / 1000;
-                // plus anything further down the chain that should be rolled up in to this
-                for (const fromUnit in vals) {
-                    if (orderedUnits.indexOf(fromUnit) > orderedUnits.indexOf(toUnit)) {
-                        convert(this.matrix, vals, fromUnit, built, toUnit);
-                    }
-                }
-            }
-            else if (isNumber(vals[toUnit])) {
-                accumulated[toUnit] = vals[toUnit];
-            }
-        }
-        // anything leftover becomes the decimal for the last unit
-        // lastUnit must be defined since units is not empty
-        for (const key in accumulated) {
-            if (accumulated[key] !== 0) {
-                built[lastUnit] +=
-                    key === lastUnit ? accumulated[key] : accumulated[key] / this.matrix[lastUnit][key];
-            }
-        }
-        return this.withValues(built);
-    }
-    total(unit) {
-        return this.shiftTo(unit).get(unit);
-    }
-    exact(unit) {
-        if (unit)
-            return new Duration(this, true).total(unit);
-        this.matrix = exactMatrix;
-        return this;
-    }
-    toObject() {
-        return { ...this.values };
-    }
-    normalize() {
-        const values = this.toObject();
-        normalizeValues(this.matrix, values);
-        return this.withValues(values);
-    }
-    rescale() {
-        const dur = this.normalize().shiftToAll();
-        const vals = removeZeroes(dur.values);
-        return this.withValues(vals);
-    }
-    /**
-     * Returns an ISO 8601-compliant string representation of this Duration.
-     * @see https://en.wikipedia.org/wiki/ISO_8601#Durations
-     * @example new Duration({ years: 3, seconds: 45 }).toString() // 'P3YT45S'
-     * @example new Duration({ months: 4, seconds: 45 }).toString() // 'P4MT45S'
-     * @example new Duration({ months: 5 }).toString() // 'P5M'
-     * @example new Duration({ minutes: 5 }).toString() // 'PT5M'
-     * @example new Duration({ milliseconds: 6 }).toString() // 'PT0.006S'
-     * @return {string}
-     */
-    toISOString() {
-        let s = 'P';
-        const months = this.get('quarters') * 3 + this.months;
-        if (this.years !== 0)
-            s += `${this.years}Y`;
-        if (months !== 0)
-            s += `${months}M`;
-        if (this.weeks !== 0)
-            s += `${this.weeks}W`;
-        if (this.days !== 0)
-            s += `${this.days}D`;
-        if (this.hours !== 0 || this.minutes !== 0 || this.seconds !== 0 || this.milliseconds !== 0)
-            s += 'T';
-        if (this.hours !== 0)
-            s += `${this.hours}H`;
-        if (this.minutes !== 0)
-            s += `${this.minutes}M`;
-        if (this.seconds !== 0 || this.milliseconds !== 0)
-            // this will handle "floating point madness" by removing extra decimal places
-            // https://stackoverflow.com/questions/588004/is-floating-point-math-broken
-            s += `${round(this.seconds + this.milliseconds / 1000, 3)}S`;
-        if (s === 'P')
-            s += 'T0S';
-        return s;
-    }
-    toString() {
-        return this.toISOString();
-    }
-    /**
-     * Create a Duration from an ISO 8601 duration string.
-     *
-     * @example
-  ```js
-  Duration.fromISO('P3Y6M1W4DT12H30M5S').toObject()
-  // { years: 3, months: 6, weeks: 1, days: 4, hours: 12, minutes: 30, seconds: 5 }
-  Duration.fromISO('PT23H').toObject()
-  // { hours: 23 }
-  Duration.fromISO('P5Y3M').toObject()
-  // { years: 5, months: 3 }
-  ```
-     * @return {Duration}
-     */
-    static fromISO(text) {
-        const [parsed] = parseISODuration(text);
-        if (parsed)
-            return new Duration(parsed);
-        throw new ValueError(`The input "${text}" can't be parsed as ISO 8601`);
-    }
-}
-function normalizeUnits(obj) {
-    const vals = {};
-    for (const unit of Object.keys(obj)) {
-        if (obj[unit] != null)
-            vals[UNITS_PLURAL[unit]] = obj[unit];
-    }
-    return vals;
-}
-function antiTrunc(n) {
-    return n < 0 ? Math.floor(n) : Math.ceil(n);
-}
-// NB: mutates parameters
-function convert(matrix, sources, fromUnit, result, toUnit) {
-    const conv = matrix[toUnit][fromUnit];
-    const raw = sources[fromUnit] / conv;
-    const sameSign = Math.sign(raw) === Math.sign(result[toUnit]);
-    // ok, so this is wild, but see the matrix in the tests
-    const added = !sameSign && result[toUnit] !== 0 && Math.abs(raw) <= 1 ? antiTrunc(raw) : Math.trunc(raw);
-    result[toUnit] += added;
-    sources[fromUnit] -= added * conv;
-}
-// NB: mutates parameters
-function normalizeValues(matrix, vals) {
-    reverseUnits.reduce((previous, current) => {
-        if (vals[current]) {
-            if (previous) {
-                convert(matrix, vals, previous, vals, current);
-            }
-            return current;
-        }
-        return previous;
-    }, null);
-}
-// Remove all properties with a value of 0 from an object
-function removeZeroes(vals) {
-    return pick(vals, (value) => value !== 0);
-}