@bbn/bbn 2.0.50 → 2.0.52

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

@@ -0,0 +1,6 @@
+import { Temporal } from 'temporal-polyfill';
+export default class bbnDtDate {
+    #private;
+    constructor(y?: any, m?: number, d?: number);
+    get value(): Temporal.PlainDate;
+}

package/dist/dt/classes/date.js

@@ -0,0 +1,42 @@
+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 _bbnDtDate_value;
+import { Temporal } from 'temporal-polyfill';
+class bbnDtDate {
+    constructor(y, m, d) {
+        _bbnDtDate_value.set(this, void 0);
+        if (!y) {
+            __classPrivateFieldSet(this, _bbnDtDate_value, Temporal.PlainDate.from(Temporal.Now.plainDateISO()), "f");
+        }
+        else if (m === undefined) {
+            if (y instanceof Temporal.PlainDate) {
+                __classPrivateFieldSet(this, _bbnDtDate_value, y, "f");
+            }
+            else if (y instanceof Date) {
+                __classPrivateFieldSet(this, _bbnDtDate_value, new Temporal.PlainDate(y.getFullYear(), y.getMonth() + 1, y.getDate()), "f");
+            }
+            else if (typeof y === 'number') {
+                const d = new Date(y);
+                __classPrivateFieldSet(this, _bbnDtDate_value, new Temporal.PlainDate(d.getFullYear(), d.getMonth() + 1, d.getDate()), "f");
+            }
+            else {
+                throw new Error('Invalid value for bbnDtDateTime');
+            }
+        }
+    }
+    get value() {
+        return __classPrivateFieldGet(this, _bbnDtDate_value, "f");
+    }
+}
+_bbnDtDate_value = new WeakMap();
+export default bbnDtDate;
+;

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

@@ -1,6 +1,6 @@
 import { Temporal } from 'temporal-polyfill';
 export default class bbnDtDateTime {
     #private;
-    constructor(y: number, m: number, d: number, h: number, i: number, s: number, ms?: number);
+    constructor(y?: any, m?: number, d?: number, h?: number, i?: number, s?: number, ms?: number);
     get value(): Temporal.PlainDateTime;
 }

package/dist/dt/classes/dateTime.js

@@ -12,9 +12,29 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _bbnDtDateTime_value;
 import { Temporal } from 'temporal-polyfill';
 class bbnDtDateTime {
-    constructor(y, m, d, h, i, s, ms = 0) {
+    constructor(y, m, d, h, i, s, ms) {
         _bbnDtDateTime_value.set(this, void 0);
-        __classPrivateFieldSet(this, _bbnDtDateTime_value, new Temporal.PlainDateTime(y, m, d, h, i, s, ms), "f");
+        if (!y) {
+            __classPrivateFieldSet(this, _bbnDtDateTime_value, Temporal.PlainDateTime.from(Temporal.Now.plainDateISO()), "f");
+        }
+        else if (m === undefined) {
+            if (y instanceof Temporal.PlainDateTime) {
+                __classPrivateFieldSet(this, _bbnDtDateTime_value, y, "f");
+            }
+            else if (y instanceof Date) {
+                __classPrivateFieldSet(this, _bbnDtDateTime_value, new Temporal.PlainDateTime(y.getFullYear(), y.getMonth() + 1, y.getDate(), y.getHours(), y.getMinutes(), y.getSeconds(), y.getMilliseconds()), "f");
+            }
+            else if (typeof y === 'number') {
+                const d = new Date(y);
+                __classPrivateFieldSet(this, _bbnDtDateTime_value, new Temporal.PlainDateTime(d.getFullYear(), d.getMonth() + 1, d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds()), "f");
+            }
+            else {
+                throw new Error('Invalid value for bbnDtDateTime');
+            }
+        }
+        else {
+            __classPrivateFieldSet(this, _bbnDtDateTime_value, new Temporal.PlainDateTime(y, m, d || 1, h || 0, i || 0, s || 0, ms || 0), "f");
+        }
     }
     get value() {
         return __classPrivateFieldGet(this, _bbnDtDateTime_value, "f");

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

@@ -0,0 +1,6 @@
+import { Temporal } from 'temporal-polyfill';
+export default class bbnDtMonthDay {
+    #private;
+    constructor(m?: any, d?: number);
+    get value(): Temporal.PlainMonthDay;
+}

package/dist/dt/classes/monthDay.js

@@ -0,0 +1,46 @@
+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 _bbnDtMonthDay_value;
+import { Temporal } from 'temporal-polyfill';
+class bbnDtMonthDay {
+    constructor(m, d) {
+        _bbnDtMonthDay_value.set(this, void 0);
+        if (!m) {
+            const d = new Date();
+            __classPrivateFieldSet(this, _bbnDtMonthDay_value, new Temporal.PlainMonthDay(d.getMonth() + 1, d.getDate()), "f");
+        }
+        else if (d === undefined) {
+            if (m instanceof Temporal.PlainMonthDay) {
+                __classPrivateFieldSet(this, _bbnDtMonthDay_value, m, "f");
+            }
+            else if (m instanceof Date) {
+                __classPrivateFieldSet(this, _bbnDtMonthDay_value, new Temporal.PlainMonthDay(m.getMonth() + 1, m.getDate()), "f");
+            }
+            else if (typeof m === 'number') {
+                const d = new Date(m);
+                __classPrivateFieldSet(this, _bbnDtMonthDay_value, new Temporal.PlainMonthDay(d.getMonth() + 1, d.getDate()), "f");
+            }
+            else {
+                throw new Error('Invalid value for bbnDtDateTime');
+            }
+        }
+        else {
+            __classPrivateFieldSet(this, _bbnDtMonthDay_value, new Temporal.PlainMonthDay(m, d), "f");
+        }
+    }
+    get value() {
+        return __classPrivateFieldGet(this, _bbnDtMonthDay_value, "f");
+    }
+}
+_bbnDtMonthDay_value = new WeakMap();
+export default bbnDtMonthDay;
+;

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

@@ -0,0 +1,6 @@
+import { Temporal } from 'temporal-polyfill';
+export default class bbnDtTime {
+    #private;
+    constructor(h?: any, i?: number, s?: number, ms?: number);
+    get value(): Temporal.PlainTime;
+}

package/dist/dt/classes/time.js

@@ -0,0 +1,48 @@
+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 _bbnDtTime_value;
+import { Temporal } from 'temporal-polyfill';
+class bbnDtTime {
+    constructor(h, i, s, ms) {
+        _bbnDtTime_value.set(this, void 0);
+        if (!h) {
+            const d = new Date();
+            __classPrivateFieldSet(this, _bbnDtTime_value, new Temporal.PlainTime(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds() * 1000000), "f");
+        }
+        else if (h === undefined) {
+            if (h instanceof Temporal.PlainTime) {
+                __classPrivateFieldSet(this, _bbnDtTime_value, h, "f");
+            }
+            else if (h instanceof Date) {
+                __classPrivateFieldSet(this, _bbnDtTime_value, new Temporal.PlainTime(h.getHours(), h.getMinutes(), h.getSeconds(), h.getMilliseconds() * 1000000), "f");
+            }
+            else if (typeof h === 'number') {
+                if (i !== undefined) {
+                    __classPrivateFieldSet(this, _bbnDtTime_value, new Temporal.PlainTime(h, i, s || 0, ms || 0), "f");
+                }
+                else {
+                    const d = new Date(h);
+                    __classPrivateFieldSet(this, _bbnDtTime_value, new Temporal.PlainTime(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds() * 1000000), "f");
+                }
+            }
+            else {
+                throw new Error('Invalid value for bbnDtDateTime');
+            }
+        }
+    }
+    get value() {
+        return __classPrivateFieldGet(this, _bbnDtTime_value, "f");
+    }
+}
+_bbnDtTime_value = new WeakMap();
+export default bbnDtTime;
+;

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

@@ -0,0 +1,6 @@
+import { Temporal } from 'temporal-polyfill';
+export default class bbnDtYearMonth {
+    #private;
+    constructor(y?: any, m?: number);
+    get value(): Temporal.PlainYearMonth;
+}

package/dist/dt/classes/yearMonth.js

@@ -0,0 +1,43 @@
+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 _bbnDtYearMonth_value;
+import { Temporal } from 'temporal-polyfill';
+class bbnDtYearMonth {
+    constructor(y, m) {
+        _bbnDtYearMonth_value.set(this, void 0);
+        if (!y) {
+            const d = new Date();
+            __classPrivateFieldSet(this, _bbnDtYearMonth_value, new Temporal.PlainYearMonth(d.getFullYear(), d.getMonth() + 1), "f");
+        }
+        else if (m === undefined) {
+            if (y instanceof Temporal.PlainYearMonth) {
+                __classPrivateFieldSet(this, _bbnDtYearMonth_value, y, "f");
+            }
+            else if (y instanceof Date) {
+                __classPrivateFieldSet(this, _bbnDtYearMonth_value, new Temporal.PlainYearMonth(y.getFullYear(), y.getMonth() + 1), "f");
+            }
+            else if (typeof m === 'number') {
+                const d = new Date(m);
+                __classPrivateFieldSet(this, _bbnDtYearMonth_value, new Temporal.PlainYearMonth(d.getFullYear(), d.getMonth() + 1), "f");
+            }
+            else {
+                throw new Error('Invalid value for bbnDtDateTime');
+            }
+        }
+    }
+    get value() {
+        return __classPrivateFieldGet(this, _bbnDtYearMonth_value, "f");
+    }
+}
+_bbnDtYearMonth_value = new WeakMap();
+export default bbnDtYearMonth;
+;

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

@@ -0,0 +1,6 @@
+import { Temporal } from 'temporal-polyfill';
+export default class bbnDtZoned {
+    #private;
+    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

@@ -0,0 +1,47 @@
+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 _bbnDtZoned_value;
+import { Temporal } from 'temporal-polyfill';
+import fromJsDate from '../functions/fromJsDate.js';
+class bbnDtZoned {
+    constructor(z, y, m, d, h, i, s, ms) {
+        _bbnDtZoned_value.set(this, void 0);
+        if (!z) {
+            const date = new Date();
+            __classPrivateFieldSet(this, _bbnDtZoned_value, new Temporal.ZonedDateTime(BigInt(date.getTime() * 1000000), Intl.DateTimeFormat().resolvedOptions().timeZone), "f");
+        }
+        else if (y === undefined) {
+            if (z instanceof Temporal.ZonedDateTime) {
+                __classPrivateFieldSet(this, _bbnDtZoned_value, z, "f");
+            }
+            else if (z instanceof Date) {
+                __classPrivateFieldSet(this, _bbnDtZoned_value, fromJsDate(z, true), "f");
+            }
+            else if (typeof z === 'number') {
+                const d = new Date(z);
+                __classPrivateFieldSet(this, _bbnDtZoned_value, fromJsDate(d, true), "f");
+            }
+            else {
+                throw new Error('Invalid value for bbnDtZoned');
+            }
+        }
+        else {
+            const dt = new Temporal.PlainDateTime(y, m, d || 1, h || 0, i || 0, s || 0, ms || 0);
+            __classPrivateFieldSet(this, _bbnDtZoned_value, dt.toZonedDateTime(z || Temporal.Now.timeZoneId()), "f");
+        }
+    }
+    get value() {
+        return __classPrivateFieldGet(this, _bbnDtZoned_value, "f");
+    }
+}
+_bbnDtZoned_value = new WeakMap();
+export default bbnDtZoned;

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

@@ -0,0 +1,7 @@
+import { Temporal } from 'temporal-polyfill';
+/**
+ * Convert a JS Date into:
+ *  - Temporal.Instant  (if hasZone=true)
+ *  - Temporal.PlainDate (if hasZone=false)
+ */
+export default function fromJsDate(date: Date, hasZone?: boolean, timeZone?: string): Temporal.ZonedDateTime | Temporal.PlainDateTime;

package/dist/dt/functions/fromJsDate.js

@@ -0,0 +1,12 @@
+import { Temporal } from 'temporal-polyfill';
+/**
+ * Convert a JS Date into:
+ *  - Temporal.Instant  (if hasZone=true)
+ *  - Temporal.PlainDate (if hasZone=false)
+ */
+export default function fromJsDate(date, hasZone = false, timeZone = Temporal.Now.timeZoneId()) {
+    const T = Temporal;
+    const instant = T.Instant.fromEpochMilliseconds(date.getTime());
+    const zdt = instant.toZonedDateTimeISO(timeZone);
+    return hasZone ? zdt : zdt.toPlainDateTime();
+}

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

@@ -1,7 +1,12 @@
-import { Temporal } from 'temporal-polyfill';
-export default function parse(input: string, format: string | string[], locale?: {
+import bbnDtZoned from '../classes/zoned.js';
+import bbnDtDateTime from '../classes/dateTime.js';
+import bbnDtDate from '../classes/date.js';
+import bbnDtTime from '../classes/time.js';
+import bbnDtYearMonth from '../classes/yearMonth.js';
+import bbnDtMonthDay from '../classes/monthDay.js';
+export default function parse(input: string, format: string | string[], cls?: 'auto' | 'zoned' | 'dateTime' | 'date' | 'time' | 'yearMonth' | 'monthDay', locale?: {
     monthsLong?: string[];
     monthsShort?: string[];
     weekdaysLong?: string[];
     weekdaysShort?: string[];
-}): Temporal.Instant | Temporal.PlainDateTime | Temporal.PlainDate | Temporal.PlainTime | Temporal.PlainYearMonth | Temporal.PlainMonthDay;
+}): bbnDtZoned | bbnDtDateTime | bbnDtDate | bbnDtTime | bbnDtYearMonth | bbnDtMonthDay;

package/dist/dt/functions/parse.js

@@ -1,4 +1,10 @@
 import buildLocaleFromIntl from './buildLocaleFromIntl.js';
+import bbnDtZoned from '../classes/zoned.js';
+import bbnDtDateTime from '../classes/dateTime.js';
+import bbnDtDate from '../classes/date.js';
+import bbnDtTime from '../classes/time.js';
+import bbnDtYearMonth from '../classes/yearMonth.js';
+import bbnDtMonthDay from '../classes/monthDay.js';
 const lc = function (str, localeCode) {
     try {
         return localeCode ? str.toLocaleLowerCase(localeCode) : str.toLowerCase();
@@ -7,7 +13,7 @@ const lc = function (str, localeCode) {
         return str.toLowerCase();
     }
 };
-export default function parse(input, format, locale) {
+export default function parse(input, format, cls = 'auto', locale) {
     var _a, _b, _c, _d, _e, _f;
     buildLocaleFromIntl();
     const TemporalAny = globalThis.Temporal;
@@ -443,7 +449,7 @@ export default function parse(input, format, locale) {
             }
         }
     ];
-    function parseWithFormat(fmt) {
+    function parseWithFormat(fmt, cls = 'auto') {
         var _a;
         const ctx = {
             year: 1970,
@@ -461,6 +467,13 @@ export default function parse(input, format, locale) {
             hasSecond: false,
             hasMs: false
         };
+        const isClsAuto = cls === 'auto';
+        const isClsZoned = cls.toLowerCase() === 'zoned';
+        const isClsDateTime = cls.toLowerCase() === 'datetime';
+        const isClsDate = cls.toLowerCase() === 'date';
+        const isClsTime = cls.toLowerCase() === 'time';
+        const isClsYearMonth = cls.toLowerCase() === 'yearmonth';
+        const isClsMonthDay = cls.toLowerCase() === 'monthday';
         const tokenSpecs = makeTokenSpecs();
         const tokensByLength = [...tokenSpecs].sort((a, b) => b.token.length - a.token.length);
         let pattern = '';
@@ -546,8 +559,8 @@ export default function parse(input, format, locale) {
         const hasMonthDayOnly = !ctx.hasYear && ctx.hasMonth && ctx.hasDay;
         const hasTime = ctx.hasHour || ctx.hasMinute || ctx.hasSecond || ctx.hasMs;
         const hasZone = ctx.timeZone != null || ctx.offsetMinutes != null;
-        // ---------- 1) If timezone (Z or z) → Instant ----------
-        if (hasZone) {
+        // ---------- 1) If timezone (Z or z) → Zoned ----------
+        if (isClsZoned || (hasZone && isClsAuto)) {
             let pdt;
             try {
                 pdt = new T.PlainDateTime(ctx.year, ctx.month, ctx.day, ctx.hour, ctx.minute, ctx.second, ctx.ms * 1000000);
@@ -558,33 +571,38 @@ export default function parse(input, format, locale) {
             if (ctx.timeZone) {
                 const tz = T.TimeZone.from(ctx.timeZone);
                 const zdt = pdt.toZonedDateTime(tz);
-                return zdt.toInstant();
+                return new bbnDtZoned(zdt);
             }
             const utcMs = Date.UTC(ctx.year, ctx.month - 1, ctx.day, ctx.hour, ctx.minute, ctx.second, ctx.ms);
             const epochMs = utcMs - ((_a = ctx.offsetMinutes) !== null && _a !== void 0 ? _a : 0) * 60000;
-            return T.Instant.fromEpochMilliseconds(epochMs);
+            return new bbnDtZoned(T.Instant.fromEpochMilliseconds(epochMs).toZonedDateTimeISO(T.Now.timeZoneId()));
         }
         // ---------- 2) No timezone: decide which Plain* type ----------
-        if (hasDate && hasTime) {
+        if (isClsDateTime || (isClsAuto && hasDate && hasTime)) {
             if (!hasFullDate) {
                 throw new Error('PlainDateTime requires year, month and day');
             }
-            return new T.PlainDateTime(ctx.year, ctx.month, ctx.day, ctx.hour, ctx.minute, ctx.second, ctx.ms * 1000000);
+            const d = new T.PlainDateTime(ctx.year, ctx.month, ctx.day, ctx.hour, ctx.minute, ctx.second, ctx.ms * 1000000);
+            return new bbnDtDateTime(d);
         }
-        if (hasDate && !hasTime) {
-            if (hasFullDate) {
-                return new T.PlainDate(ctx.year, ctx.month, ctx.day);
+        if (isClsDate || isClsYearMonth || isClsMonthDay || (isClsAuto && hasDate && !hasTime)) {
+            if (isClsDate && hasFullDate) {
+                const d = new T.PlainDate(ctx.year, ctx.month, ctx.day);
+                return new bbnDtDate(d);
             }
-            if (hasYearMonthOnly) {
-                return new T.PlainYearMonth(ctx.year, ctx.month);
+            if (isClsYearMonth && hasYearMonthOnly) {
+                const d = new T.PlainYearMonth(ctx.year, ctx.month);
+                return new bbnDtYearMonth(d);
             }
-            if (hasMonthDayOnly) {
-                return new T.PlainMonthDay(ctx.month, ctx.day, 1972);
+            if (isClsMonthDay && hasMonthDayOnly) {
+                const d = new T.PlainMonthDay(ctx.month, ctx.day, 1972);
+                return new bbnDtMonthDay(d);
             }
             throw new Error('Not enough date components for a known Temporal type');
         }
-        if (!hasDate && hasTime) {
-            return new T.PlainTime(ctx.hour, ctx.minute, ctx.second, ctx.ms * 1000000);
+        if (isClsTime || (isClsAuto && !hasDate && hasTime)) {
+            const d = new T.PlainTime(ctx.hour, ctx.minute, ctx.second, ctx.ms * 1000000);
+            return new bbnDtTime(d);
         }
         throw new Error('No date or time information found in input');
     }
@@ -592,7 +610,7 @@ export default function parse(input, format, locale) {
         let lastError = null;
         for (const fmt of format) {
             try {
-                return parseWithFormat(fmt);
+                return parseWithFormat(fmt, cls);
             }
             catch (e) {
                 lastError = e;
@@ -600,6 +618,6 @@ export default function parse(input, format, locale) {
         }
         throw lastError !== null && lastError !== void 0 ? lastError : new Error('No format matched');
     }
-    return parseWithFormat(format);
+    return parseWithFormat(format, cls);
 }
 ;

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): bbnDtDateTime;
+    (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;
     locales: any;
     parse: typeof parse;
     guessFormat: typeof guessFormat;

package/dist/dt.js

@@ -1,7 +1,5 @@
 import bbnDtDateTime from './dt/classes/dateTime.js';
 import _ from './_.js';
-import isDate from './fn/type/isDate.js';
-import isPrimitive from './fn/type/isPrimitive.js';
 import parse from './dt/functions/parse.js';
 import guessFormat from './dt/functions/guessFormat.js';
 const patterns = [
@@ -192,39 +190,32 @@ const unitsCorrespondence = {
     'W': 'w',
     'w': 'w'
 };
-const dt = (value, inputFormat = null) => {
-    let v;
+const dt = (value, inputFormat = null, cls = 'auto') => {
     if (!value) {
-        const d = new Date();
-        return new bbnDtDateTime(d.getFullYear(), d.getMonth() + 1, d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+        return new bbnDtDateTime();
     }
     if (typeof value === 'string') {
         if (inputFormat) {
-            v = parse(value, inputFormat);
+            return parse(value, inputFormat, cls);
         }
         else {
             const format = guessFormat(value);
             if (format) {
-                v = parse(value, format);
+                return parse(value, format, cls);
             }
             else {
                 throw new Error(_('Could not guess the date format for value: %s', value));
             }
         }
     }
-    else {
-        if (typeof value === 'number') {
-            const d = new Date(value);
-            v = new bbnDtDateTime(d.getFullYear(), d.getMonth() + 1, d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
-        }
-        else if (isDate(value)) {
-            const d = value;
-            v = new bbnDtDateTime(d.getFullYear(), d.getMonth() + 1, d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
-        }
-        else if (isPrimitive(value)) {
-            throw new Error(_('Invalid date value: %s', value));
-        }
+    if (typeof value === 'number') {
+        return new bbnDtDateTime(value);
+    }
+    else if (value instanceof Date) {
+        const d = value;
+        return new bbnDtDateTime(d.getFullYear(), d.getMonth() + 1, d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
     }
+    throw new Error(_('Invalid date value: %s', value));
 };
 dt.locales = Object.create(null);
 dt.parse = parse;

package/package.json

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