@bbn/bbn 2.0.62 → 2.0.64

package/dist/dt/classes/duration.js

@@ -0,0 +1,185 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _bbnDtDuration_instances, _bbnDtDuration_value, _bbnDtDuration_unit, _bbnDtDuration_getUnitValue;
+import { Temporal } from 'temporal-polyfill';
+import { units, unitsCorrespondence } from '../vars/units.js';
+import getRow from '../../fn/object/getRow.js';
+const DURATION_RELATIVE_TO = Temporal.ZonedDateTime.from('1970-01-01T00:00Z[UTC]');
+class bbnDtDuration {
+    static fromUnit(value, unit) {
+        const realUnit = unitsCorrespondence[unit] || 'ms';
+        if (!realUnit) {
+            throw new Error('Invalid unit for duration: ' + unit);
+        }
+        const ctx = [
+            realUnit === 'y' ? value : 0,
+            realUnit === 'm' ? value : 0,
+            realUnit === 'd' ? value : 0,
+            realUnit === 'h' ? value : 0,
+            realUnit === 'i' ? value : 0,
+            realUnit === 's' ? value : 0,
+            ['y', 'm', 'd', 'h', 'i', 's'].includes(realUnit) ? 0 : value
+        ];
+        const dur = new Temporal.Duration(...ctx);
+        return new bbnDtDuration(dur, 0, 0, 0, 0, 0, 0, realUnit);
+    }
+    constructor(y, m, d, h, i, s, ms, unit) {
+        _bbnDtDuration_instances.add(this);
+        _bbnDtDuration_value.set(this, void 0);
+        _bbnDtDuration_unit.set(this, void 0);
+        if (y instanceof Temporal.Duration) {
+            __classPrivateFieldSet(this, _bbnDtDuration_value, y, "f");
+        }
+        else if (typeof y === 'object') {
+            __classPrivateFieldSet(this, _bbnDtDuration_value, new Temporal.Duration(y.years || 0, y.months || 0, y.weeks || 0, y.days || 0, y.hours || 0, y.minutes || 0, y.seconds || 0, y.milliseconds || 0, 0, 0), "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _bbnDtDuration_value, new Temporal.Duration(y || 0, m || 0, d || 0, h || 0, i || 0, s || 0, ms || 0, 0, 0), "f");
+        }
+        const realUnit = unitsCorrespondence[unit || ''] || unit;
+        __classPrivateFieldSet(this, _bbnDtDuration_unit, realUnit || 'ms', "f");
+        const row = getRow(units, (a) => a[0] === realUnit);
+        if (!row) {
+            throw new Error('Invalid unit for duration: ' + realUnit);
+        }
+    }
+    get value() {
+        return __classPrivateFieldGet(this, _bbnDtDuration_value, "f");
+    }
+    // -----------------------
+    //     Public getters
+    // -----------------------
+    years(remaining = false) { return __classPrivateFieldGet(this, _bbnDtDuration_instances, "m", _bbnDtDuration_getUnitValue).call(this, 'year', remaining); }
+    months(remaining = false) { return __classPrivateFieldGet(this, _bbnDtDuration_instances, "m", _bbnDtDuration_getUnitValue).call(this, 'month', remaining); }
+    weeks(remaining = false) { return __classPrivateFieldGet(this, _bbnDtDuration_instances, "m", _bbnDtDuration_getUnitValue).call(this, 'week', remaining); }
+    days(remaining = false) { return __classPrivateFieldGet(this, _bbnDtDuration_instances, "m", _bbnDtDuration_getUnitValue).call(this, 'day', remaining); }
+    hours(remaining = false) { return __classPrivateFieldGet(this, _bbnDtDuration_instances, "m", _bbnDtDuration_getUnitValue).call(this, 'hour', remaining); }
+    minutes(remaining = false) { return __classPrivateFieldGet(this, _bbnDtDuration_instances, "m", _bbnDtDuration_getUnitValue).call(this, 'minute', remaining); }
+    seconds(remaining = false) { return __classPrivateFieldGet(this, _bbnDtDuration_instances, "m", _bbnDtDuration_getUnitValue).call(this, 'second', remaining); }
+    // -----------------------
+    //      Day.js style
+    //   "asX" conversions
+    // -----------------------
+    toJSON() {
+        return {
+            years: this.years(true),
+            months: this.months(true),
+            days: this.days(true),
+            hours: this.hours(true),
+            minutes: this.minutes(true),
+            seconds: this.seconds(true),
+            milliseconds: this.toMilliseconds()
+        };
+    }
+    /**
+     * Returns the full duration expressed as X (float), like Day.js.
+     */
+    asYears() {
+        return __classPrivateFieldGet(this, _bbnDtDuration_value, "f").total({
+            unit: 'year',
+            relativeTo: DURATION_RELATIVE_TO
+        });
+    }
+    asMonths() {
+        return __classPrivateFieldGet(this, _bbnDtDuration_value, "f").total({
+            unit: 'month',
+            relativeTo: DURATION_RELATIVE_TO
+        });
+    }
+    asWeeks() {
+        return __classPrivateFieldGet(this, _bbnDtDuration_value, "f").total({
+            unit: 'week',
+            relativeTo: DURATION_RELATIVE_TO
+        });
+    }
+    asDays() {
+        return __classPrivateFieldGet(this, _bbnDtDuration_value, "f").total({
+            unit: 'day',
+            relativeTo: DURATION_RELATIVE_TO
+        });
+    }
+    asHours() {
+        return __classPrivateFieldGet(this, _bbnDtDuration_value, "f").total({
+            unit: 'hour',
+            relativeTo: DURATION_RELATIVE_TO
+        });
+    }
+    asMinutes() {
+        return __classPrivateFieldGet(this, _bbnDtDuration_value, "f").total({
+            unit: 'minute',
+            relativeTo: DURATION_RELATIVE_TO
+        });
+    }
+    asSeconds() {
+        return __classPrivateFieldGet(this, _bbnDtDuration_value, "f").total({
+            unit: 'second',
+            relativeTo: DURATION_RELATIVE_TO
+        });
+    }
+    /**
+     * Add any unit (or instance default).
+     */
+    add(value, unit) {
+        const targetUnit = unit
+            ? (unitsCorrespondence[unit] || unit)
+            : __classPrivateFieldGet(this, _bbnDtDuration_unit, "f");
+        // Map to Temporal.DurationLike field name, e.g. 'year' → 'years'
+        const field = (targetUnit + 's');
+        if (!['years', 'months', 'weeks', 'days', 'hours', 'minutes', 'seconds', 'milliseconds'].includes(field)) {
+            throw new Error('Invalid unit for duration: ' + (unit !== null && unit !== void 0 ? unit : targetUnit));
+        }
+        const delta = { [field]: value };
+        const newDuration = __classPrivateFieldGet(this, _bbnDtDuration_value, "f").add(delta);
+        // Adapt this constructor call to however you now construct your duration:
+        return new bbnDtDuration(newDuration, undefined, undefined, undefined, undefined, undefined, undefined, __classPrivateFieldGet(this, _bbnDtDuration_unit, "f"));
+    }
+    subtract(value, unit) {
+        return this.add(-value, unit);
+    }
+    toMilliseconds() {
+        const d = __classPrivateFieldGet(this, _bbnDtDuration_value, "f");
+        // If there are no calendar units, we can let Temporal do it directly:
+        if (!d.years && !d.months && !d.weeks && !d.days) {
+            return d.total({ unit: 'millisecond' });
+        }
+        // Otherwise we must supply a relativeTo (same as in asX)
+        return d.total({
+            unit: 'millisecond',
+            relativeTo: DURATION_RELATIVE_TO
+        });
+    }
+}
+_bbnDtDuration_value = new WeakMap(), _bbnDtDuration_unit = new WeakMap(), _bbnDtDuration_instances = new WeakSet(), _bbnDtDuration_getUnitValue = function _bbnDtDuration_getUnitValue(name, remaining) {
+    const d = __classPrivateFieldGet(this, _bbnDtDuration_value, "f"); // Temporal.Duration
+    if (remaining) {
+        switch (name) {
+            case 'year': return d.years;
+            case 'month': return d.months;
+            case 'week': return d.weeks;
+            case 'day': return d.days;
+            case 'hour': return d.hours;
+            case 'minute': return d.minutes;
+            case 'second':
+                // seconds component only; sub-second parts go to milliseconds in toJSON()
+                return d.seconds;
+        }
+    }
+    // Total units: use Duration.total()
+    const total = d.total({
+        unit: name,
+        relativeTo: DURATION_RELATIVE_TO
+    });
+    // Keep same semantics as old code (Math.floor on totals)
+    return Math.floor(total);
+};
+export default bbnDtDuration;
+;

package/dist/dt/classes/monthDay.d.ts

@@ -1,6 +1,10 @@
 import { Temporal } from 'temporal-polyfill';
-export default class bbnDtMonthDay {
+import { BbnDtKind } from '../vars/types.js';
+import bbnDt from './dt.js';
+export default class bbnDtMonthDay extends bbnDt<Temporal.PlainMonthDay> {
     #private;
+    readonly kind: BbnDtKind;
     constructor(m?: any, d?: number);
     get value(): Temporal.PlainMonthDay;
+    fdate(long?: boolean, withTime?: boolean, weekday?: boolean): string;
 }

package/dist/dt/classes/monthDay.js

@@ -11,9 +11,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _bbnDtMonthDay_value;
 import { Temporal } from 'temporal-polyfill';
-class bbnDtMonthDay {
+import bbnDt from './dt.js';
+class bbnDtMonthDay extends bbnDt {
     constructor(m, d) {
+        super();
         _bbnDtMonthDay_value.set(this, void 0);
+        this.kind = 'month-day';
         if (!m) {
             const d = new Date();
             __classPrivateFieldSet(this, _bbnDtMonthDay_value, new Temporal.PlainMonthDay(d.getMonth() + 1, d.getDate()), "f");
@@ -40,6 +43,18 @@ class bbnDtMonthDay {
     get value() {
         return __classPrivateFieldGet(this, _bbnDtMonthDay_value, "f");
     }
+    fdate(long = false, withTime = false, weekday = false) {
+        if (!this.value) {
+            return '';
+        }
+        const date = new Date(2000, this.month() - 1, this.day());
+        const opt = {
+            month: long ? 'long' : 'numeric',
+            day: 'numeric'
+        };
+        const d = new Intl.DateTimeFormat([bbn.env.lang, ...navigator.languages], opt);
+        return d.format(date);
+    }
 }
 _bbnDtMonthDay_value = new WeakMap();
 export default bbnDtMonthDay;

package/dist/dt/classes/time.d.ts

@@ -1,6 +1,9 @@
 import { Temporal } from 'temporal-polyfill';
-export default class bbnDtTime {
+import bbnDt from './dt.js';
+export default class bbnDtTime extends bbnDt<Temporal.PlainTime> {
     #private;
+    readonly kind: 'time';
     constructor(h?: any, i?: number, s?: number, ms?: number);
     get value(): Temporal.PlainTime;
+    ftime(withSeconds?: boolean): string;
 }

package/dist/dt/classes/time.js

@@ -11,9 +11,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _bbnDtTime_value;
 import { Temporal } from 'temporal-polyfill';
-class bbnDtTime {
+import bbnDt from './dt.js';
+class bbnDtTime extends bbnDt {
     constructor(h, i, s, ms) {
+        super();
         _bbnDtTime_value.set(this, void 0);
+        this.kind = 'time';
         if (!h) {
             const d = new Date();
             __classPrivateFieldSet(this, _bbnDtTime_value, new Temporal.PlainTime(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds() * 1000000), "f");
@@ -42,6 +45,21 @@ class bbnDtTime {
     get value() {
         return __classPrivateFieldGet(this, _bbnDtTime_value, "f");
     }
+    ftime(withSeconds = false) {
+        if (!this.value) {
+            return '';
+        }
+        const date = new Date(2000, 1, 1, this.hour(), this.minute(), this.second());
+        const opt = {
+            hour: '2-digit',
+            minute: '2-digit',
+        };
+        if (withSeconds) {
+            opt.second = '2-digit';
+        }
+        const t = new Intl.DateTimeFormat([bbn.env.lang, ...navigator.languages], opt);
+        return t.format(date);
+    }
 }
 _bbnDtTime_value = new WeakMap();
 export default bbnDtTime;

package/dist/dt/classes/yearMonth.d.ts

@@ -1,6 +1,10 @@
 import { Temporal } from 'temporal-polyfill';
-export default class bbnDtYearMonth {
+import { BbnDtKind } from '../vars/types.js';
+import { bbnDt } from './dt.js';
+export default class bbnDtYearMonth extends bbnDt<Temporal.PlainYearMonth> {
     #private;
+    readonly kind: BbnDtKind;
     constructor(y?: any, m?: number);
     get value(): Temporal.PlainYearMonth;
+    fdate(long?: boolean, withTime?: boolean, weekday?: boolean): string;
 }

package/dist/dt/classes/yearMonth.js

@@ -11,9 +11,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _bbnDtYearMonth_value;
 import { Temporal } from 'temporal-polyfill';
-class bbnDtYearMonth {
+import { bbnDt } from './dt.js';
+class bbnDtYearMonth extends bbnDt {
     constructor(y, m) {
+        super();
         _bbnDtYearMonth_value.set(this, void 0);
+        this.kind = 'year-month';
         if (!y) {
             const d = new Date();
             __classPrivateFieldSet(this, _bbnDtYearMonth_value, new Temporal.PlainYearMonth(d.getFullYear(), d.getMonth() + 1), "f");
@@ -37,6 +40,18 @@ class bbnDtYearMonth {
     get value() {
         return __classPrivateFieldGet(this, _bbnDtYearMonth_value, "f");
     }
+    fdate(long = false, withTime = false, weekday = false) {
+        if (!this.value) {
+            return '';
+        }
+        const date = new Date(this.year(), this.month() - 1);
+        const opt = {
+            year: 'numeric',
+            month: long ? 'long' : 'numeric',
+        };
+        const d = new Intl.DateTimeFormat([bbn.env.lang, ...navigator.languages], opt);
+        return d.format(date);
+    }
 }
 _bbnDtYearMonth_value = new WeakMap();
 export default bbnDtYearMonth;

package/dist/dt/classes/zoned.d.ts

@@ -1,6 +1,11 @@
 import { Temporal } from 'temporal-polyfill';
-export default class bbnDtZoned {
+import { BbnDtKind } from '../vars/types.js';
+import bbnDt from './dt.js';
+export default class bbnDtZoned extends bbnDt<Temporal.ZonedDateTime> {
     #private;
+    readonly kind: BbnDtKind;
     constructor(z?: any, y?: any, m?: number, d?: number, h?: number, i?: number, s?: number, ms?: number);
     get value(): Temporal.ZonedDateTime;
+    fdate(long?: boolean, withTime?: boolean, weekday?: boolean): string;
+    ftime(withSeconds?: boolean): string;
 }

package/dist/dt/classes/zoned.js

@@ -12,9 +12,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _bbnDtZoned_value;
 import { Temporal } from 'temporal-polyfill';
 import fromJsDate from '../functions/fromJsDate.js';
-class bbnDtZoned {
+import bbnDt from './dt.js';
+class bbnDtZoned extends bbnDt {
     constructor(z, y, m, d, h, i, s, ms) {
+        super();
         _bbnDtZoned_value.set(this, void 0);
+        this.kind = 'zoned';
         if (!z) {
             const date = new Date();
             __classPrivateFieldSet(this, _bbnDtZoned_value, new Temporal.ZonedDateTime(BigInt(date.getTime() * 1000000), Intl.DateTimeFormat().resolvedOptions().timeZone), "f");
@@ -42,6 +45,30 @@ class bbnDtZoned {
     get value() {
         return __classPrivateFieldGet(this, _bbnDtZoned_value, "f");
     }
+    fdate(long = false, withTime = false, weekday = false) {
+        if (!this.value) {
+            return '';
+        }
+        const date = new Date(this.year(), this.month() - 1, this.day(), this.hour(), this.minute(), this.second());
+        const opt = Object.assign(Object.assign({ year: 'numeric', month: long ? 'long' : 'numeric', day: 'numeric' }, (weekday ? { weekday: (long ? 'long' : 'short') } : {})), (withTime ? { hour: (long ? '2-digit' : 'numeric'), minute: '2-digit' } : {}));
+        const d = new Intl.DateTimeFormat([bbn.env.lang, ...navigator.languages], opt);
+        return d.format(date);
+    }
+    ftime(withSeconds = false) {
+        if (!this.value) {
+            return '';
+        }
+        const date = new Date(2000, 1, 1, this.hour(), this.minute(), this.second());
+        const opt = {
+            hour: '2-digit',
+            minute: '2-digit',
+        };
+        if (withSeconds) {
+            opt.second = '2-digit';
+        }
+        const t = new Intl.DateTimeFormat([bbn.env.lang, ...navigator.languages], opt);
+        return t.format(date);
+    }
 }
 _bbnDtZoned_value = new WeakMap();
 export default bbnDtZoned;

package/dist/dt/functions/getWeekday.d.ts

@@ -0,0 +1,3 @@
+declare const getWeekday: (n: 0 | 1 | 2 | 3 | 4 | 5 | 6, mode?: string, locale?: string) => any;
+declare const getWeekdayIndex: (name: string, locale?: string) => number;
+export { getWeekday, getWeekdayIndex };

package/dist/dt/functions/getWeekday.js

@@ -0,0 +1,58 @@
+const getWeekday = (n, mode = 'long', locale) => {
+    if (!mode) {
+        const letter = getWeekday(n, 'narrow', locale);
+        const abbr = getWeekday(n, 'short', locale);
+        const full = getWeekday(n, 'long', locale);
+        return {
+            letter,
+            abbr,
+            full,
+            long: full,
+            short: abbr,
+            narrow: letter
+        };
+    }
+    let m;
+    if (mode === 'letter') {
+        m = 'narrow';
+    }
+    else if (mode === 'abbr') {
+        m = 'short';
+    }
+    else if (mode === 'full') {
+        m = 'long';
+    }
+    else if (!['long', 'short', 'narrow'].includes(mode)) {
+        throw new Error('Invalid mode for getWeekDay: ' + mode + '. Allowed values are "long", "short", "narrow", "letter", "abbr", "full".');
+    }
+    else {
+        m = mode;
+    }
+    // Create a date with the right weekday
+    // 2023-01-01 was a Sunday → base for offset
+    const base = new Date(2023, 0, 1 + n);
+    return base.toLocaleDateString([locale || bbn.env.lang, ...navigator.languages], { weekday: m });
+};
+const getWeekdayIndex = (name, locale) => {
+    const loc = locale || bbn.env.lang;
+    const input = name.trim().toLowerCase();
+    // Build a localized map only once per locale (optional optimization)
+    const langs = [loc, ...navigator.languages];
+    for (let i = 0; i < langs.length; i++) {
+        if (!langs[i]) {
+            continue;
+        }
+        const formatter = new Intl.DateTimeFormat(langs[i], { weekday: "long" });
+        // Generate localized weekday names for Sun → Sat
+        for (let i = 0; i < 7; i++) {
+            // 2023-01-01 was Sunday
+            const date = new Date(2023, 0, 1 + i);
+            const localized = formatter.format(date).toLowerCase();
+            if (localized === input) {
+                return i; // JS weekday number
+            }
+        }
+    }
+    throw new Error(`Unknown weekday name '${name}' for locale '${loc}'`);
+};
+export { getWeekday, getWeekdayIndex };

package/dist/dt/vars/types.d.ts

@@ -0,0 +1,3 @@
+import { Temporal } from 'temporal-polyfill';
+export type BbnDtKind = 'datetime' | 'date' | 'time' | 'year-month' | 'month-day' | 'zoned';
+export type BbnDtTemporal = Temporal.PlainDateTime | Temporal.PlainDate | Temporal.PlainTime | Temporal.PlainYearMonth | Temporal.PlainMonthDay | Temporal.ZonedDateTime;

package/dist/dt/vars/types.js

@@ -0,0 +1 @@
+export {};

package/dist/dt/vars/units.d.ts

@@ -0,0 +1,11 @@
+declare const units: [string, Intl.RelativeTimeFormatUnit, number][];
+declare const unitsCorrespondence: {
+    [key: string]: string;
+};
+declare const unitsMap: {
+    [key: string]: string;
+};
+declare const formatsMap: {
+    [key: string]: string;
+};
+export { units, unitsCorrespondence, unitsMap, formatsMap };

package/dist/dt/vars/units.js

@@ -0,0 +1,109 @@
+const units = [
+    ['y', "year", 365 * 24 * 60 * 60 * 1000],
+    ['m', "month", 30 * 24 * 60 * 60 * 1000],
+    ['w', "week", 7 * 24 * 60 * 60 * 1000],
+    ['d', "day", 24 * 60 * 60 * 1000],
+    ['h', "hour", 60 * 60 * 1000],
+    ['i', "minute", 60 * 1000],
+    ['s', "second", 1000]
+];
+const unitsCorrespondence = {
+    'years': 'y',
+    'year': 'y',
+    'YEARS': 'y',
+    'YEAR': 'y',
+    'Years': 'y',
+    'Year': 'y',
+    'YYYY': 'y',
+    'YY': 'y',
+    'yyyy': 'y',
+    'yy': 'y',
+    'months': 'm',
+    'month': 'm',
+    'Months': 'm',
+    'Month': 'm',
+    'MONTHS': 'm',
+    'MONTH': 'm',
+    'MMMM': 'm',
+    'MMM': 'm',
+    'MM': 'm',
+    'weekday': 'e',
+    'WEEKDAY': 'e',
+    'ee': 'e',
+    'EE': 'e',
+    'ddd': 'e',
+    'days': 'd',
+    'day': 'd',
+    'Days': 'd',
+    'Day': 'd',
+    'DAYS': 'd',
+    'DAY': 'd',
+    'DD': 'd',
+    'dd': 'd',
+    'hours': 'h',
+    'hour': 'h',
+    'Hours': 'h',
+    'Hour': 'h',
+    'HOURS': 'h',
+    'HOUR': 'h',
+    'HH': 'h',
+    'hr': 'h',
+    'hh': 'h',
+    'minutes': 'i',
+    'minute': 'i',
+    'Minutes': 'i',
+    'Minute': 'i',
+    'MINUTES': 'i',
+    'MINUTE': 'i',
+    'II': 'i',
+    'ii': 'i',
+    'mn': 'i',
+    'mm': 'i',
+    'min': 'i',
+    'SS': 's',
+    'ss': 's',
+    'seconds': 's',
+    'second': 's',
+    'Seconds': 's',
+    'Second': 's',
+    'SECONDS': 's',
+    'SECOND': 's',
+    'sec': 's',
+    'WW': 'w',
+    'Y': 'y',
+    'y': 'y',
+    'M': 'm',
+    'm': 'm',
+    'e': 'e',
+    'E': 'e',
+    'D': 'd',
+    'd': 'd',
+    'H': 'h',
+    'h': 'h',
+    'n': 'i',
+    'i': 'i',
+    's': 's',
+    'S': 's',
+    'W': 'w',
+    'w': 'w'
+};
+const unitsMap = {
+    'y': 'Year',
+    'm': 'Month',
+    'd': 'Date',
+    'w': 'Week',
+    'h': 'Hours',
+    'i': 'Minutes',
+    's': 'Seconds'
+};
+const formatsMap = {
+    'y': 'YYYY',
+    'm': 'MM',
+    'd': 'DD',
+    'e': 'EE',
+    'w': 'WW',
+    'h': 'HH',
+    'i': 'II',
+    's': 'SS'
+};
+export { units, unitsCorrespondence, unitsMap, formatsMap };

package/dist/dt.d.ts

@@ -2,7 +2,7 @@ import bbnDtDateTime from './dt/classes/dateTime.js';
 import parse from './dt/functions/parse.js';
 import guessFormat from './dt/functions/guessFormat.js';
 declare const dt: {
-    (value: any, inputFormat?: null | String, cls?: "auto" | "zoned" | "dateTime" | "date" | "time" | "yearMonth" | "monthDay"): bbnDtDateTime | import("./dt/classes/zoned.js").default | import("./dt/classes/date.js").default | import("./dt/classes/time.js").default | import("./dt/classes/yearMonth.js").default | import("./dt/classes/monthDay.js").default;
+    (value: any, inputFormat?: null | String, cls?: "auto" | "zoned" | "dateTime" | "date" | "time" | "yearMonth" | "monthDay"): import("./dt/classes/zoned.js").default | import("./dt/classes/date.js").default | import("./dt/classes/time.js").default | import("./dt/classes/yearMonth.js").default | import("./dt/classes/monthDay.js").default | bbnDtDateTime;
     locales: any;
     parse: typeof parse;
     guessFormat: typeof guessFormat;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bbn/bbn",
-  "version": "2.0.62",
+  "version": "2.0.64",
   "description": "Javascript toolkit",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",