@bbn/bbn 2.0.61 → 2.0.63

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,9 @@
 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;
 }

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");

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

@@ -1,6 +1,8 @@
 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;
 }

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");

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

@@ -1,6 +1,9 @@
 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;
 }

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");

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

@@ -1,6 +1,9 @@
 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;
 }

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");

package/dist/dt/functions/buildLocaleFromIntl.js

@@ -3,23 +3,27 @@ import extend from "../../fn/object/extend.js";
  * Build a token pattern (YYYY, MM, DD, dddd, HH, II, SS, A, z) from Intl parts.
  * Uses Intl options to distinguish MMM vs MMMM, ddd vs dddd, etc.
  */
-const partsToPattern = (parts, resolved, requestedOpts) => {
+function partsToPattern(parts, hourCycle, opts) {
     let pattern = '';
-    const hourCycle = resolved.hourCycle;
     const hasDayPeriod = parts.some(p => p.type === 'dayPeriod');
     const is12h = hasDayPeriod || hourCycle === 'h12' || hourCycle === 'h11';
-    const hasYear = !!requestedOpts.year;
-    const hasMonth = !!requestedOpts.month;
-    const hasDay = !!requestedOpts.day;
-    const hasWeekday = !!requestedOpts.weekday;
-    const hasTextMonth = requestedOpts.month === 'short' || requestedOpts.month === 'long';
-    // "Whole numeric date" = year+month+day, all numeric, no weekday, no text month
-    const isWholeNumericDate = hasYear && hasMonth && hasDay && !hasWeekday && !hasTextMonth;
+    const hasWeekday = !!opts.weekday;
+    const hasTextMonth = opts.month === 'short' || opts.month === 'long';
+    // when we *request* year/month/day in "numeric" (not 2-digit, not short),
+    // and all three are present, then we want D/M/YYYY in our mask,
+    // in the locale's order, even if the sample shows "02" / "01".
+    const requestedPureNumericYMD = opts.year === 'numeric' &&
+        opts.month === 'numeric' &&
+        opts.day === 'numeric' &&
+        !hasWeekday &&
+        !hasTextMonth;
     for (const p of parts) {
         switch (p.type) {
             case 'year': {
-                // Keep YY when the locale actually resolved to 2-digit
-                if (resolved.year === '2-digit') {
+                // If you want YY vs YYYY disambiguation you can still
+                // look at opts.year here; I’ll keep it simple:
+                // numeric → YYYY, '2-digit' → YY
+                if (opts.year === '2-digit') {
                     pattern += 'YY';
                 }
                 else {
@@ -28,28 +32,33 @@ const partsToPattern = (parts, resolved, requestedOpts) => {
                 break;
             }
             case 'month': {
-                // textual month
-                if (requestedOpts.month === 'short' || requestedOpts.month === 'long') {
-                    pattern += requestedOpts.month === 'long' ? 'MMMM' : 'MMM';
+                // Textual month first
+                if (opts.month === 'short') {
+                    pattern += 'MMM';
                     break;
                 }
-                if (isWholeNumericDate) {
-                    // whole numeric date → always use M (accepts 1–2 digits)
+                if (opts.month === 'long') {
+                    pattern += 'MMMM';
+                    break;
+                }
+                // 👉 Pure numeric Y-M-D requested: always M
+                if (requestedPureNumericYMD) {
                     pattern += 'M';
                     break;
                 }
-                // other numeric month cases (e.g. year–month or month–day)
+                // Other numeric month cases (year-month, month-day, or 2-digit)
                 if (/^\d+$/.test(p.value)) {
                     pattern += p.value.length === 2 ? 'MM' : 'M';
                 }
                 else {
+                    // should not happen, but be defensive
                     pattern += p.value.length > 3 ? 'MMMM' : 'MMM';
                 }
                 break;
             }
             case 'day': {
-                if (isWholeNumericDate) {
-                    // whole numeric date → always use D (accepts 1–2 digits)
+                // 👉 Pure numeric Y-M-D requested: always D
+                if (requestedPureNumericYMD) {
                     pattern += 'D';
                     break;
                 }
@@ -57,10 +66,10 @@ const partsToPattern = (parts, resolved, requestedOpts) => {
                 break;
             }
             case 'weekday': {
-                if (requestedOpts.weekday === 'short' || requestedOpts.weekday === 'narrow') {
+                if (opts.weekday === 'short' || opts.weekday === 'narrow') {
                     pattern += 'ddd';
                 }
-                else if (requestedOpts.weekday === 'long') {
+                else if (opts.weekday === 'long') {
                     pattern += 'dddd';
                 }
                 else {
@@ -90,20 +99,15 @@ const partsToPattern = (parts, resolved, requestedOpts) => {
                 pattern += 'z';
                 break;
             case 'literal': {
-                if (!p.value) {
+                if (!p.value)
                     break;
-                }
-                // If the literal contains any letter (ASCII or basic Latin-1),
-                // wrap it in [ ... ] so it can't be confused with tokens.
-                // Otherwise (spaces, /, -, :, commas, etc.) keep it raw.
+                // Only wrap *text* literals in [ ... ], not separators like /, -, spaces, etc.
                 const hasLetter = /[A-Za-zÀ-ÖØ-öø-ÿ]/.test(p.value);
                 if (hasLetter) {
-                    // Escape ']' inside the bracketed literal
                     const v = p.value.replace(/]/g, '\\]');
                     pattern += `[${v}]`;
                 }
                 else {
-                    // Non-problematic punctuation/whitespace: just append as-is
                     pattern += p.value;
                 }
                 break;
@@ -114,7 +118,8 @@ const partsToPattern = (parts, resolved, requestedOpts) => {
         }
     }
     return pattern;
-};
+}
+;
 /**
  * Get a curated set of *common* date, time and datetime formats
  * for the given locale, without exploding into thousands of combos.
@@ -162,7 +167,7 @@ const getCommonFormatsForLocale = (lng) => {
         const fmt = new Intl.DateTimeFormat(lng, opts);
         const parts = fmt.formatToParts(sample);
         const resolved = fmt.resolvedOptions();
-        const pattern = partsToPattern(parts, resolved, opts);
+        const pattern = partsToPattern(parts, resolved.hourCycle, opts);
         if (!seenDatePatterns.has(pattern)) {
             seenDatePatterns.add(pattern);
             date.push({
@@ -189,7 +194,7 @@ const getCommonFormatsForLocale = (lng) => {
         const fmt = new Intl.DateTimeFormat(lng, opts);
         const parts = fmt.formatToParts(sample);
         const resolved = fmt.resolvedOptions();
-        const pattern = partsToPattern(parts, resolved, opts);
+        const pattern = partsToPattern(parts, resolved.hourCycle, opts);
         if (!seenTimePatterns.has(pattern)) {
             seenTimePatterns.add(pattern);
             time.push({
@@ -206,7 +211,7 @@ const getCommonFormatsForLocale = (lng) => {
             const fmt = new Intl.DateTimeFormat(lng, opts);
             const parts = fmt.formatToParts(sample);
             const resolved = fmt.resolvedOptions();
-            const pattern = partsToPattern(parts, resolved, opts);
+            const pattern = partsToPattern(parts, resolved.hourCycle, opts);
             if (!seenDateTimePatterns.has(pattern)) {
                 seenDateTimePatterns.add(pattern);
                 datetime.push({

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/functions/guessFormat.js

@@ -30,54 +30,6 @@ const MYSQL_AND_NATIVE_FORMATS = [
     // Tue Oct 29 2024 14:30:00
     'ddd MMM DD YYYY HH:II:SS'
 ];
-const isPureNumericDateFormat = (fmt) => {
-    // Only Y/M/D tokens and literal separators, no time or AM/PM tokens
-    if (/[HhI SAz]/.test(fmt)) {
-        return false;
-    }
-    // Must have year and month and day tokens
-    if (!/[Y]/.test(fmt) || !/[M]/.test(fmt) || !/[D]/.test(fmt)) {
-        return false;
-    }
-    return true;
-};
-const makeRelaxedNumericFormat = (fmt) => {
-    // Relax DD -> D and MM -> M, but don't touch other tokens
-    return fmt.replace(/DD/g, 'D').replace(/MM/g, 'M');
-};
-/**
- * If the format is a pure numeric date like D/M/YYYY or DD/MM/YYYY,
- * and the input clearly uses 2-digit day and 2-digit month (22/11/2022),
- * upgrade to DD/MM/YYYY.
- */
-const normalizeNumericDM = (fmt, input) => {
-    // Only touch "pure numeric date" patterns: D/M/YYYY, DD-MM-YY, etc.
-    // No time tokens, no text months, no weekdays.
-    if (/[HhI SAzM]{2,}|[A-Za-z]/.test(fmt.replace(/[DMY]/g, ''))) {
-        // If there are other letters than D/M/Y (like MMM, ddd), don't touch.
-        // (We only want simple numeric dates)
-        return fmt;
-    }
-    // Quick check: must contain D and M and Y
-    if (!fmt.includes('D') || !fmt.includes('M') || !fmt.includes('Y')) {
-        return fmt;
-    }
-    // Extract numeric chunks from the input: ["22", "11", "2022"] for "22/11/2022"
-    const nums = input.split(/\D+/).filter(Boolean);
-    if (nums.length < 3) {
-        return fmt;
-    }
-    const [dayStr, monthStr] = nums;
-    // Only upgrade if both day and month are exactly 2-digit
-    if (dayStr.length === 2 && monthStr.length === 2) {
-        // Upgrade first D-group to DD and first M-group to MM
-        let out = fmt;
-        out = out.replace(/D+/, 'DD');
-        out = out.replace(/M+/, 'MM');
-        return out;
-    }
-    return fmt;
-};
 export default function guessFormat(input, formats, lng) {
     const str = input.trim();
     if (!str) {
@@ -89,24 +41,11 @@ export default function guessFormat(input, formats, lng) {
             // 1) Try strict format first
             try {
                 parse(str, fmt);
-                return normalizeNumericDM(fmt, str);
+                return fmt;
             }
             catch (_a) {
                 // ignore, we'll maybe try a relaxed version
             }
-            // 2) If it's a pure numeric date pattern, try a relaxed version too
-            if (isPureNumericDateFormat(fmt)) {
-                const relaxed = makeRelaxedNumericFormat(fmt);
-                if (relaxed !== fmt) {
-                    try {
-                        parse(str, relaxed);
-                        return relaxed;
-                    }
-                    catch (_b) {
-                        // still nothing, move on
-                    }
-                }
-            }
         }
         return null;
     };

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 };