bn-calendar 1.2.0 → 1.2.2

package/dist/index.cjs

@@ -1 +1,1102 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require(`./convert-3jw8Rx7e.cjs`);function t(t){let n=e.r(t);return n?n%4==0&&n%100!=0||n%400==0:!1}const n=864e5,r=Object.freeze({"revised-2019":{normal:[31,31,31,31,31,31,30,30,30,30,29,30],leap:[31,31,31,31,31,31,30,30,30,30,30,30]},"revised-1966":{normal:[31,31,31,31,31,30,30,30,30,30,30,30],leap:[31,31,31,31,31,30,30,30,30,30,31,30]}}),i=Object.freeze([{bn:`গ্রীষ্ম`,en:`Grisma (Summer)`},{bn:`বর্ষা`,en:`Barsa (Monsoon)`},{bn:`শরৎ`,en:`Sarat (Autumn)`},{bn:`হেমন্ত`,en:`Hemanta (Late-Autumn)`},{bn:`শীত`,en:`Shhit (Winter)`},{bn:`বসন্ত`,en:`Basanta (Spring)`}]),a=Object.freeze([{bn:`রবিবার`,en:`Robibar (Sunday)`,short:`র`},{bn:`সোমবার`,en:`Shombar (Monday)`,short:`সো`},{bn:`মঙ্গলবার`,en:`Mongolbar (Tuesday)`,short:`ম`},{bn:`বুধবার`,en:`Budhbar (Wednesday)`,short:`বু`},{bn:`বৃহস্পতিবার`,en:`Brihoshpotibar (Thursday)`,short:`বৃ`},{bn:`শুক্রবার`,en:`Shukrobar (Friday)`,short:`শু`},{bn:`শনিবার`,en:`Shonibar (Saturday)`,short:`শ`}]),o=Object.freeze([{bn:`বৈশাখ`,en:`Boishakh`,short:`বৈ`},{bn:`জ্যৈষ্ঠ`,en:`Joishtho`,short:`জ্য`},{bn:`আষাঢ়`,en:`Asharh`,short:`আ`},{bn:`শ্রাবণ`,en:`Srabon`,short:`শ্রা`},{bn:`ভাদ্র`,en:`Bhadro`,short:`ভা`},{bn:`আশ্বিন`,en:`Ashwin`,short:`আ`},{bn:`কার্তিক`,en:`Kartik`,short:`কা`},{bn:`অগ্রহায়ণ`,en:`Ogrohayon`,short:`অ`},{bn:`পৌষ`,en:`Poush`,short:`পৌ`},{bn:`মাঘ`,en:`Magh`,short:`মা`},{bn:`ফাল্গুন`,en:`Falgun`,short:`ফা`},{bn:`চৈত্র`,en:`Choitro`,short:`চৈ`}]),s=Object.freeze([`YYYY`,`YY`,`yyyy`,`yy`]),c=Object.freeze([`M`,`MM`,`mmm`,`mmmm`]),l=Object.freeze([`DD`,`D`,`Do`]),u=Object.freeze([`d`,`dd`,`ddd`]),d=Object.freeze([`H`,`HH`,`hh`,`h`]),f=Object.freeze([`mm`,`m`]),p=Object.freeze([`ss`,`s`]),m=Object.freeze([`ms`,`mss`]),h=Object.freeze([`a`,`A`]),g=Object.freeze([`Z`,`ZZ`,`S`,`SS`]),_=Object.freeze([...s,...c,...u,...l,...d,...f,...p,...m,...h,...g].sort((e,t)=>t.length-e.length));function v(e,t){let n=RegExp(`^(${_.join(`|`)})`),r=``,i=0;for(;i<e.length;){if(e[i]===`[`){let t=e.indexOf(`]`,i);if(t!==-1){r+=e.slice(i+1,t),i=t+1;continue}}let a=n.exec(e.slice(i));a?(r+=t[a[0]]??a[0],i+=a[0].length):(r+=e[i],i++)}return r}function y(e,n,r){return r===`revised-1966`?e%4==2:t(n)}function b(e,t){let n=i[Math.floor(e/2)];return t===`en`?n.en:n.bn}function x(e){let t=e.getMonth();return{gy:e.getFullYear(),$gm:t,gm:t+1,gd:e.getDate(),wd:e.getDay()}}function S(e){let{gy:t,gm:n,gd:r}=x(e);return n<4||n===4&&r<14?t-1:t}function C(e){return S(e)-593}function w(e){let{gy:t,$gm:n,gd:r}=x(e);return Date.UTC(t,n,r)}function T(e){return Math.floor((w(e)-Date.UTC(S(e),3,14))/n)}function E(e,t){let n=t??`revised-2019`,i=y(C(e),e.getFullYear(),n)?r?.[n].leap:r?.[n].normal,a=T(e),o=0;for(;a>=i[o];)a-=i[o],o++;return{days:a,monthIdx:o}}function D(e,t=2){return e.padStart(t,`০`)}var O=class t{variant;year;month;date;gregorian;weekDay;isoWeekDay;constructor(n,r,i,a){this.variant=this.#r(n,r,i,a);let o=n instanceof Date?n:new Date(e.i(n)&&!t.isBanglaDateString(n)||e.c(n)&&!t.isBanglaYearEn(n)?n:Date.now());isNaN(o.getTime())&&(o=new Date);let{year:s,month:c,monthDate:l}=this.#i(o),u=t.isBanglaYear(n)?e.t(n):e.c(n)&&t.isBanglaYearEn(n)?n:s,d=t.isBanglaMonth(r)?e.t(r):t.isBanglaMonthEn(r)?r:c,f=t.isBanglaDate(i)?e.t(i):t.isBanglaDateEn(i)?i:l;if(t.isBanglaDateString(n)){let t=n.replace(/['"]/g,``).split(`-`);u=e.t(t[0]),d=e.t(t[1]),f=e.t(t[2])}let{gregYear:p}=this.#e(u,d),{bnMonthTable:m}=this.#t(p,u),h=m[d-1];f>h&&(f-=h,d===12?(d=1,u+=1):d+=1),this.year={bn:e.n(u),en:u},this.month={bn:e.n(d),en:d},this.date={bn:e.n(f),en:f};let{gy:g,gm:_,gd:v,wd:y}=x(this.toDate());this.gregorian={year:g,month:_,date:v},this.weekDay=y,this.isoWeekDay=y===0?7:y}[Symbol.toPrimitive](e){return e===`number`?this.valueOf():this.toJSON()}get[Symbol.toStringTag](){return this.toJSON()}valueOf(){return this.toDate().getTime()}toJSON(){let{year:e,month:t,date:n}=this;return`${D(e.bn,4)}-${D(t.bn)}-${D(n.bn)}`}isLeapYear(){let{gregYear:e}=this.#e();return this.#t(e).isBnLeapYear}toDate(){let{baseGregYear:e,gregYear:t}=this.#e(),{bnMonthTable:r}=this.#t(t),i=Date.UTC(e,3,13),a=this.date.en;for(let e=0;e<this.month.en-1;e++)a+=r[e];return new Date(a*n+i)}getSeasonName(e){return b(this.month.en-1,e)}getMonthName(e){let t=o[this.month.en-1];return e===`en`?t.en:t.bn}getDayName(e){let t=a[this.weekDay];return e===`en`?t.en:t.bn}addDays(e){let n=this.toDate();return new t(n.setDate(n.getDate()+e),{variant:this.variant})}addWeeks(e){let n=this.toDate();return new t(n.setDate(n.getDate()+e*7),{variant:this.variant})}addMonths(e,n=!0){if(n){let n=this.toDate();return new t(n.setMonth(n.getMonth()+e),{variant:this.variant})}else{let{variant:t,year:n,month:r,date:i}=this,a=r.en+e,o=n.en;for(;a>12;)a-=12,o+=1;for(;a<1;)a+=12,--o;return this.#n(o,a,i.en,t)}}addYears(e,n=!0){let{variant:r,year:i,month:a,date:o}=this,s=i.en+e;return n?new t(s,a.en,o.en,{variant:r}):this.#n(s,a.en,o.en,r)}startOfMonth(){let{year:e,month:n,variant:r}=this;return new t(e.en,n.en,1,{variant:r})}endOfMonth(){let{year:e,month:n,variant:r}=this;return new t(e.en,n.en,this.daysInMonth(),{variant:r})}startOfYear(){let{year:e,variant:n}=this;return new t(e.en,1,1,{variant:n})}endOfYear(){let{year:e,variant:n}=this;return new t(e.en,12,30,{variant:n})}daysInMonth(e){let{gregYear:t}=this.#e(),{bnMonthTable:n}=this.#t(t);return n[(e??this.month.en)-1]}toString(){return this.#a(`bn`)}toStringEn(){return this.#a(`en`)}format(e){let{year:t,month:n,date:r,weekDay:i}=this,s=this.getSeasonName(),c=o[n.en-1],l=a[i],u=D(t.bn,4),d={YYYY:u,YY:u.slice(-2),yyyy:u,yy:u.slice(-2),M:n.bn,MM:D(n.bn),mmm:c.short,mmmm:c.bn,d:l.short,dd:l.bn.replace(`বার`,``),ddd:l.bn,D:r.bn,DD:D(r.bn),Do:r.bn,S:s,SS:s+`কাল`};return v(e||`ddd, DD mmmm (SS), YYYY বঙ্গাব্দ`,d)}#e(e,t){let n=(e??this.year.en)+593;return{baseGregYear:n,gregYear:(t??this.month.en)>10?n+1:n}}#t(e,t){let n=y(t??this.year.en,e,this.variant);return{bnMonthTable:n?r?.[this.variant].leap:r?.[this.variant].normal,isBnLeapYear:n}}#n(e,n,r,i){let{gregYear:a}=this.#e(e,n),{bnMonthTable:o}=this.#t(a,e);return new t(e,n,Math.min(r,o[n-1]),{variant:i})}#r(e,t,n,r){return this.$hasVariantConfig(e)?e.variant:this.$hasVariantConfig(t)?t.variant:this.$hasVariantConfig(n)?n.variant:this.$hasVariantConfig(r)?r.variant:`revised-2019`}#i(e){let t=C(e),{days:n,monthIdx:r}=E(e,this.variant);return{year:t,month:r+1,monthDate:n+1}}#a(e=`bn`){let{year:t,date:n}=this;return`${this.getDayName(e)}, ${n[e]} ${this.getMonthName(e)}, ${t[e]} [${this.getSeasonName(e)}]`}$hasVariantConfig(t){return e.a(t,[`variant`])&&e.s(t.variant)&&(t.variant===`revised-1966`||t.variant===`revised-2019`)}static isBanglaYear(t){return e.s(t)&&/^(?:০{0,3}[১-৯][০-৯]{0,3}|০)$/.test(t.trim())}static isBanglaYearEn(t){return e.o(t)&&t>=0&&t<=9999}static isBanglaMonth(t){return e.s(t)&&/^(?:০?[১-৯]|১০|১১|১২)$/.test(t.trim())}static isBanglaMonthEn(t){return e.o(t)&&t>=1&&t<=12}static isBanglaDate(t){return e.s(t)&&/^(?:০?[১-৯]|[১২][০-৯]|৩০|৩১)$/.test(t.trim())}static isBanglaDateEn(t){return e.o(t)&&t>=1&&t<=31}static isBanglaDateString(n){if(e.s(n)&&n.includes(`-`)){let[e,r,i]=n.replace(/['"]/g,``).split(`-`);return t.isBanglaYear(e)&&t.isBanglaMonth(r)&&t.isBanglaDate(i)}return!1}};exports.BanglaCalendar=O,exports.BnCalendar=O,exports.Bongabdo=O;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_convert = require('./convert-BetQIRvF.cjs');
+
+//#region node_modules/.pnpm/nhb-toolbox@4.30.1/node_modules/nhb-toolbox/dist/esm/date/guards.js
+function isLeapYear(year) {
+	const $year = require_convert.normalizeNumber(year);
+	return $year ? $year % 4 === 0 && $year % 100 !== 0 || $year % 400 === 0 : false;
+}
+
+//#endregion
+//#region src/constants.ts
+/** Milliseconds per day */
+const MS_PER_DAY = 864e5;
+/** Bangla month days table for different variants */
+const BN_MONTH_TABLES = /* @__PURE__ */ Object.freeze({
+	"revised-2019": {
+		normal: [
+			31,
+			31,
+			31,
+			31,
+			31,
+			31,
+			30,
+			30,
+			30,
+			30,
+			29,
+			30
+		],
+		leap: [
+			31,
+			31,
+			31,
+			31,
+			31,
+			31,
+			30,
+			30,
+			30,
+			30,
+			30,
+			30
+		]
+	},
+	"revised-1966": {
+		normal: [
+			31,
+			31,
+			31,
+			31,
+			31,
+			30,
+			30,
+			30,
+			30,
+			30,
+			30,
+			30
+		],
+		leap: [
+			31,
+			31,
+			31,
+			31,
+			31,
+			30,
+			30,
+			30,
+			30,
+			30,
+			31,
+			30
+		]
+	}
+});
+/** List of Bangla season names in Bangla and English */
+const BN_SEASONS = /* @__PURE__ */ Object.freeze([
+	{
+		bn: "গ্রীষ্ম",
+		en: "Grisma (Summer)"
+	},
+	{
+		bn: "বর্ষা",
+		en: "Barsa (Monsoon)"
+	},
+	{
+		bn: "শরৎ",
+		en: "Sarat (Autumn)"
+	},
+	{
+		bn: "হেমন্ত",
+		en: "Hemanta (Late-Autumn)"
+	},
+	{
+		bn: "শীত",
+		en: "Shhit (Winter)"
+	},
+	{
+		bn: "বসন্ত",
+		en: "Basanta (Spring)"
+	}
+]);
+/** List of Bangla day names in Bangla and English */
+const BN_DAYS = /* @__PURE__ */ Object.freeze([
+	{
+		bn: "রবিবার",
+		en: "Robibar (Sunday)",
+		short: "র"
+	},
+	{
+		bn: "সোমবার",
+		en: "Shombar (Monday)",
+		short: "সো"
+	},
+	{
+		bn: "মঙ্গলবার",
+		en: "Mongolbar (Tuesday)",
+		short: "ম"
+	},
+	{
+		bn: "বুধবার",
+		en: "Budhbar (Wednesday)",
+		short: "বু"
+	},
+	{
+		bn: "বৃহস্পতিবার",
+		en: "Brihoshpotibar (Thursday)",
+		short: "বৃ"
+	},
+	{
+		bn: "শুক্রবার",
+		en: "Shukrobar (Friday)",
+		short: "শু"
+	},
+	{
+		bn: "শনিবার",
+		en: "Shonibar (Saturday)",
+		short: "শ"
+	}
+]);
+/** List of Bangla month names in Bangla and English */
+const BN_MONTHS = /* @__PURE__ */ Object.freeze([
+	{
+		bn: "বৈশাখ",
+		en: "Boishakh",
+		short: "বৈ"
+	},
+	{
+		bn: "জ্যৈষ্ঠ",
+		en: "Joishtho",
+		short: "জ্য"
+	},
+	{
+		bn: "আষাঢ়",
+		en: "Asharh",
+		short: "আ"
+	},
+	{
+		bn: "শ্রাবণ",
+		en: "Srabon",
+		short: "শ্রা"
+	},
+	{
+		bn: "ভাদ্র",
+		en: "Bhadro",
+		short: "ভা"
+	},
+	{
+		bn: "আশ্বিন",
+		en: "Ashwin",
+		short: "আ"
+	},
+	{
+		bn: "কার্তিক",
+		en: "Kartik",
+		short: "কা"
+	},
+	{
+		bn: "অগ্রহায়ণ",
+		en: "Ogrohayon",
+		short: "অ"
+	},
+	{
+		bn: "পৌষ",
+		en: "Poush",
+		short: "পৌ"
+	},
+	{
+		bn: "মাঘ",
+		en: "Magh",
+		short: "মা"
+	},
+	{
+		bn: "ফাল্গুন",
+		en: "Falgun",
+		short: "ফা"
+	},
+	{
+		bn: "চৈত্র",
+		en: "Choitro",
+		short: "চৈ"
+	}
+]);
+const YEAR_FORMATS = /* @__PURE__ */ Object.freeze([
+	"YYYY",
+	"YY",
+	"yyyy",
+	"yy"
+]);
+const MONTH_FORMATS = /* @__PURE__ */ Object.freeze([
+	"M",
+	"MM",
+	"mmm",
+	"mmmm"
+]);
+const DATE_FORMATS = /* @__PURE__ */ Object.freeze([
+	"DD",
+	"D",
+	"Do"
+]);
+const DAY_FORMATS = /* @__PURE__ */ Object.freeze([
+	"d",
+	"dd",
+	"ddd"
+]);
+const HOUR_FORMATS = /* @__PURE__ */ Object.freeze([
+	"H",
+	"HH",
+	"hh",
+	"h"
+]);
+const MINUTE_FORMATS = /* @__PURE__ */ Object.freeze(["mm", "m"]);
+const SECOND_FORMATS = /* @__PURE__ */ Object.freeze(["ss", "s"]);
+const MILLISECOND_FORMATS = /* @__PURE__ */ Object.freeze(["ms", "mss"]);
+const TIME_FORMATS = /* @__PURE__ */ Object.freeze(["a", "A"]);
+const EXTRA_FORMATS = /* @__PURE__ */ Object.freeze([
+	"Z",
+	"ZZ",
+	"S",
+	"SS"
+]);
+const SORTED_TIME_FORMATS = /* @__PURE__ */ Object.freeze([
+	...YEAR_FORMATS,
+	...MONTH_FORMATS,
+	...DAY_FORMATS,
+	...DATE_FORMATS,
+	...HOUR_FORMATS,
+	...MINUTE_FORMATS,
+	...SECOND_FORMATS,
+	...MILLISECOND_FORMATS,
+	...TIME_FORMATS,
+	...EXTRA_FORMATS
+].sort((a, b) => b.length - a.length));
+
+//#endregion
+//#region src/helpers.ts
+/** Core formatting logic shared by `formatDate` and `Chronos`, `BanglaCalendar` classes */
+function _formatDateCore(format, dateComponents) {
+	const tokenRegex = new RegExp(`^(${SORTED_TIME_FORMATS.join("|")})`);
+	let result = "";
+	let i = 0;
+	while (i < format.length) {
+		if (format[i] === "[") {
+			const end = format.indexOf("]", i);
+			if (end !== -1) {
+				result += format.slice(i + 1, end);
+				i = end + 1;
+				continue;
+			}
+		}
+		const match = tokenRegex.exec(format.slice(i));
+		if (match) {
+			result += dateComponents[match[0]] ?? match[0];
+			i += match[0].length;
+		} else {
+			result += format[i];
+			i++;
+		}
+	}
+	return result;
+}
+/** Check whether a Bangla year is leap by Gregorian and Bangla years and calendar variant */
+function _isBnLeapYear(by, gy, v) {
+	return v === "revised-1966" ? by % 4 === 2 : isLeapYear(gy);
+}
+/** Get Bangla season name by month index (`0-11`) */
+function _getBnSeason(month, locale) {
+	const season = BN_SEASONS[Math.floor(month / 2)];
+	return locale === "en" ? season.en : season.bn;
+}
+/** Extract selective unit values from {@link Date} object */
+function _extractDateUnits(date) {
+	const month = date.getMonth();
+	return {
+		gy: date.getFullYear(),
+		$gm: month,
+		gm: month + 1,
+		gd: date.getDate(),
+		wd: date.getDay()
+	};
+}
+/** Get Gregorian base year from {@link Date} object for Bangla year */
+function _getGregBaseYear(date) {
+	const { gy, gm, gd } = _extractDateUnits(date);
+	return gm < 4 || gm === 4 && gd < 14 ? gy - 1 : gy;
+}
+/** Get Bangla year from {@link Date} object */
+function _getBnYear(date) {
+	return _getGregBaseYear(date) - 593;
+}
+/** Get timestamp in milliseconds between midnight, January 1, 1970 (UTC) and the specified {@link Date} object */
+function _getUtcTs(date) {
+	const { gy, $gm, gd } = _extractDateUnits(date);
+	return Date.UTC(gy, $gm, gd);
+}
+/** Get number of days elapsed since midnight April 14, 1970 (UTC) for specific {@link Date} */
+function _getElapsedDays(date) {
+	return Math.floor((_getUtcTs(date) - Date.UTC(_getGregBaseYear(date), 3, 14)) / MS_PER_DAY);
+}
+/** Get number of days elapsed since midnight April 14, 1970 (UTC) and month index for specific `Date` and Bangla calendar variant */
+function _bnDaysMonthIdx(date, variant) {
+	const v = variant ?? "revised-2019";
+	const table = _isBnLeapYear(_getBnYear(date), date.getFullYear(), v) ? BN_MONTH_TABLES?.[v].leap : BN_MONTH_TABLES?.[v].normal;
+	let days = _getElapsedDays(date);
+	let monthIdx = 0;
+	while (days >= table[monthIdx]) {
+		days -= table[monthIdx];
+		monthIdx++;
+	}
+	return {
+		days,
+		monthIdx
+	};
+}
+/**
+* Pad at the start of a string with Bangla zero (`'০'`)
+* @param str String to pad with
+* @param length Maximum length to pad, default is `2`
+* @returns The padded string
+*/
+function _padShunno(str, length = 2) {
+	return str.padStart(length, "০");
+}
+
+//#endregion
+//#region src/BanglaCalendar.ts
+/**
+* @class Represents a date in the Bangla calendar system with support for different variants.
+*      - This class provides functionality to create, manipulate, convert dates between the Bangla and Gregorian calendar systems.
+*      - It supports two Bangla calendar variants: `'revised-2019'` (default) and `'revised-1966'`.
+*
+* @example
+* // Create from current date
+* const today = new BanglaCalendar();
+*
+* // Create from Bangla date string (Bangla digit)
+* const date0 = new BanglaCalendar('১৪৩২-১১-০৮');
+*
+* // Create from Gregorian date
+* const date1 = new BanglaCalendar('2023-04-14'); // Latin digit
+* const date2 = new BanglaCalendar(new Date('2023-04-14')); // Date object
+*
+* // Create with specific Bangla date using Latin digits
+* const date3 = new BanglaCalendar(1430, 1, 1);
+*
+* // Create with specific Bangla date using Bangla digits
+* const date4 = new BanglaCalendar('১৪৩০', '১', '১');
+*
+* // Create with specific variant
+* const date5 = new BanglaCalendar('১৪৩০', '১', '১', { variant: 'revised-1966' });
+*
+* @remarks
+* - The Bangla calendar year starts on `April 14th (১ বৈশাখ)` in the Gregorian calendar.
+* - The class automatically handles leap years according to the selected variant.
+*/
+var BanglaCalendar = class BanglaCalendar {
+	/** Bangla calendar variant */
+	variant;
+	/** Bangla year */
+	year;
+	/** Bangla month */
+	month;
+	/** Bangla day of the month */
+	date;
+	/** Gregorian equivalent of the current bangla date */
+	gregorian;
+	/** Gets the day of the week (0-6, where 0 is Sunday (রবিবার)). */
+	weekDay;
+	/** Gets ISO weekday: 1 = Monday, 7 = Sunday */
+	isoWeekDay;
+	/** * Creates a `BanglaCalendar` instance based on given parameter(s) */
+	constructor(dateBnYrOrCfg, bnMonthOrCfg, bnDateOrCfg, config) {
+		this.variant = this.#processVariants(dateBnYrOrCfg, bnMonthOrCfg, bnDateOrCfg, config);
+		let date = dateBnYrOrCfg instanceof Date ? dateBnYrOrCfg : new Date(require_convert.isDateString(dateBnYrOrCfg) && !BanglaCalendar.isBanglaDateString(dateBnYrOrCfg) ? dateBnYrOrCfg : require_convert.isNumber(dateBnYrOrCfg) && !BanglaCalendar.isBanglaYearEn(dateBnYrOrCfg) ? dateBnYrOrCfg : Date.now());
+		if (isNaN(date.getTime())) date = /* @__PURE__ */ new Date();
+		const { year, month, monthDate } = this.#processDate(date);
+		let bnYear = BanglaCalendar.isBanglaYear(dateBnYrOrCfg) ? require_convert.banglaToDigit(dateBnYrOrCfg) : require_convert.isNumber(dateBnYrOrCfg) && BanglaCalendar.isBanglaYearEn(dateBnYrOrCfg) ? dateBnYrOrCfg : year;
+		let bnMonth = BanglaCalendar.isBanglaMonth(bnMonthOrCfg) ? require_convert.banglaToDigit(bnMonthOrCfg) : BanglaCalendar.isBanglaMonthEn(bnMonthOrCfg) ? bnMonthOrCfg : month;
+		let bnDate = BanglaCalendar.isBanglaDate(bnDateOrCfg) ? require_convert.banglaToDigit(bnDateOrCfg) : BanglaCalendar.isBanglaDateEn(bnDateOrCfg) ? bnDateOrCfg : monthDate;
+		if (BanglaCalendar.isBanglaDateString(dateBnYrOrCfg)) {
+			const parts = dateBnYrOrCfg.replace(/['"]/g, "").split("-");
+			bnYear = require_convert.banglaToDigit(parts[0]);
+			bnMonth = require_convert.banglaToDigit(parts[1]);
+			bnDate = require_convert.banglaToDigit(parts[2]);
+		}
+		const { gregYear } = this.#processGregYear(bnYear, bnMonth);
+		const { bnMonthTable } = this.#getBnMonthTableLeap(gregYear, bnYear);
+		const monthRange = bnMonthTable[bnMonth - 1];
+		if (bnDate > monthRange) {
+			bnDate -= monthRange;
+			if (bnMonth === 12) {
+				bnMonth = 1;
+				bnYear += 1;
+			} else bnMonth += 1;
+		}
+		this.year = {
+			bn: require_convert.digitToBangla(bnYear),
+			en: bnYear
+		};
+		this.month = {
+			bn: require_convert.digitToBangla(bnMonth),
+			en: bnMonth
+		};
+		this.date = {
+			bn: require_convert.digitToBangla(bnDate),
+			en: bnDate
+		};
+		const { gy, gm, gd, wd } = _extractDateUnits(this.toDate());
+		this.gregorian = {
+			year: gy,
+			month: gm,
+			date: gd
+		};
+		this.weekDay = wd;
+		this.isoWeekDay = wd === 0 ? 7 : wd;
+	}
+	[Symbol.toPrimitive](hint) {
+		if (hint === "number") return this.valueOf();
+		return this.toJSON();
+	}
+	get [Symbol.toStringTag]() {
+		return this.toJSON();
+	}
+	/**
+	* @instance Get timestamp in milliseconds for the current date.
+	* @remarks
+	* - Converts the current Bangla date to a Gregorian {@link Date} using {@link toDate()}.
+	* - Returns the Unix timestamp (in milliseconds) of the converted date.
+	* - The time component is normalized to midnight UTC during the conversion process.
+	*/
+	valueOf() {
+		return this.toDate().getTime();
+	}
+	/**
+	* @instance Returns a string representation of the Bangla date in ISO-like format (YYYY-MM-DD with Bangla digits).
+	*
+	* @returns Bangla date string in the format: "YYYY-MM-DD" (e.g., "১৪৩০-০১-০১")
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('2023-04-14');
+	* console.log(bnCal.toJSON()); // "১৪৩০-০১-০১"
+	*
+	* @remarks
+	* - This method is automatically called by {@link JSON.stringify()} method
+	* - Output follows the pattern: `"বছর-মাস-দিন"` with zero-padded Bangla digits
+	* - Month and date are padded to 2 digits, year to 4 digits
+	*/
+	toJSON() {
+		const { year, month, date } = this;
+		return `${_padShunno(year.bn, 4)}-${_padShunno(month.bn)}-${_padShunno(date.bn)}`;
+	}
+	/**
+	* * Checks if the current Bangla year is a leap year.
+	*
+	* @returns `true` if the year is a leap year, `false` otherwise
+	*
+	* @example
+	* const date = new BanglaCalendar(1430, 1, 1);
+	* const isLeap = date.isLeapYear(); // false
+	*
+	* @remarks
+	* - Leap year determination depends on the selected calendar variant.
+	* - The `'revised-2019'` and `'revised-1966'` variants have different leap year rules.
+	*   - **Revised-2019**: Leap year is determined by the associated Gregorian year's leap rule:
+	*     - A year is a leap year if it is divisible by 4, but not divisible by 100, unless it is also divisible by 400.
+	*   - **Revised-1966**: Leap year is determined solely by the Bangla year (`bnYear % 4 === 2`), no Gregorian rule applies.
+	*/
+	isLeapYear() {
+		const { gregYear } = this.#processGregYear();
+		return this.#getBnMonthTableLeap(gregYear).isBnLeapYear;
+	}
+	/**
+	* * Converts the Bangla calendar date to a JS {@link Date} object.
+	*
+	* @returns Gregorian Date object equivalent to the Bangla date
+	*
+	* @example
+	* const bnDate = new BanglaCalendar('১৪৩০', '১', '১');
+	* const gregorianDate = bnDate.toDate(); // Date for April 14, 2023
+	* console.log(gregorianDate.toISOString()); // 2023-04-14T00:00:00.000Z
+	*
+	* @remarks
+	* - The conversion takes into account the calendar variant and leap year rules.
+	* - Time component is always set to `00:00:00` in UTC.
+	*/
+	toDate() {
+		const { baseGregYear, gregYear } = this.#processGregYear();
+		const { bnMonthTable } = this.#getBnMonthTableLeap(gregYear);
+		const epoch = Date.UTC(baseGregYear, 3, 13);
+		let days = this.date.en;
+		for (let i = 0; i < this.month.en - 1; i++) days += bnMonthTable[i];
+		return new Date(days * MS_PER_DAY + epoch);
+	}
+	/**
+	* @instance Gets the Bangla season name for the current date.
+	*
+	* @param locale - Output locale ('bn' for Bengali, 'en' for English)
+	* @returns Name of the season in the specified locale
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('2023-04-14');
+	* bnCal.getSeasonName(); // Returns: 'গ্রীষ্ম'
+	* bnCal.getSeasonName('en'); // Returns: 'Grisma (Summer)'
+	*
+	* @remarks
+	* Bangla calendar is traditionally divided into 6 seasons (ঋতু):
+	* - গ্রীষ্ম (Summer): Mid-April to Mid-June
+	* - বর্ষা (Monsoon): Mid-June to Mid-August
+	* - শরৎ (Autumn): Mid-August to Mid-October
+	* - হেমন্ত (Late Autumn): Mid-October to Mid-December
+	* - শীত (Winter): Mid-December to Mid-February
+	* - বসন্ত (Spring): Mid-February to Mid-April
+	*/
+	getSeasonName(locale) {
+		return _getBnSeason(this.month.en - 1, locale);
+	}
+	/**
+	* @instance Gets the Bangla name of the month for the current date.
+	*
+	* @param locale - Output locale ('bn' for Bengali, 'en' for English)
+	* @returns Name of the month in the specified locale
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('2023-04-14');
+	* bnCal.getMonthName(); // Returns: 'বৈশাখ'
+	* bnCal.getMonthName('en'); // Returns: 'Boishakh'
+	*
+	* @remarks
+	* - Month names follow traditional Bengali naming conventions.
+	* - English names are transliterated versions of the Bengali names.
+	* - Month determination may vary slightly between calendar variants near month boundaries.
+	*/
+	getMonthName(locale) {
+		const MONTH = BN_MONTHS[this.month.en - 1];
+		return locale === "en" ? MONTH.en : MONTH.bn;
+	}
+	/**
+	* @instance Gets the Bangla name of the weekday for the current date.
+	*
+	* @param locale - Output locale ('bn' for Bengali, 'en' for English)
+	* @returns Name of the weekday in the specified locale
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('2023-04-14'); // Friday
+	* bnCal.getDayName(); // Returns: 'শুক্রবার'
+	* bnCal.getDayName('en'); // Returns: 'Shukrobar (Friday)'
+	*
+	* @remarks
+	* - Weekday names follow the standard Bengali naming convention ending with 'বার'.
+	* - English names are the Latin transliterations of the Bangla names with standard English weekday names.
+	*/
+	getDayName(locale) {
+		const DAY = BN_DAYS[this.weekDay];
+		return locale === "en" ? DAY.en : DAY.bn;
+	}
+	/**
+	* @instance Adds days to the current Bangla date.
+	*
+	* @param days - Number of days to add (can be negative to subtract days)
+	* @returns New `BanglaCalendar` instance with the adjusted date
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('১৪৩০', '১', '১'); // ১ বৈশাখ ১৪৩০
+	*
+	* // Add days
+	* bnCal.addDays(7); // Returns: ৮ বৈশাখ ১৪৩০
+	*
+	* // Subtract days
+	* bnCal.addDays(-3); // Returns: ২৮ চৈত্র ১৪২৯
+	*
+	* // Add days crossing month boundary
+	* bnCal.addDays(35); // Returns: ৫ জ্যৈষ্ঠ ১৪৩০
+	*
+	* // Add days crossing year boundary
+	* const lateDate = new BanglaCalendar('১৪৩০', '১২', '২৫');
+	* lateDate.addDays(10); // Returns: ৫ বৈশাখ ১৪৩১
+	*
+	* @remarks
+	* - The resulting instance preserves the calendar variant of the original
+	* - Handles month and year transitions automatically
+	* - Accounts for varying month lengths and leap years
+	* - Time component remains at midnight UTC in the Gregorian conversion (using {@link BanglaCalendar.toDate()} method)
+	* - Negative values subtract days from the current date
+	*/
+	addDays(days) {
+		const date = this.toDate();
+		return new BanglaCalendar(date.setDate(date.getDate() + days), { variant: this.variant });
+	}
+	/**
+	* @instance Adds weeks to the current Bangla date.
+	*
+	* @param weeks - Number of weeks to add (can be negative to subtract weeks)
+	* @returns New `BanglaCalendar` instance with the adjusted date
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('১৪৩০', '১', '১'); // ১ বৈশাখ ১৪৩০
+	*
+	* // Add weeks
+	* bnCal.addWeeks(2); // Returns: ১৫ বৈশাখ ১৪৩০
+	*
+	* // Subtract weeks
+	* bnCal.addWeeks(-1); // Returns: ২৪ চৈত্র ১৪২৯
+	*
+	* // Add weeks crossing month boundary
+	* bnCal.addWeeks(5); // Returns: ৫ জ্যৈষ্ঠ ১৪৩০
+	*
+	* @remarks
+	* - Each week is treated as 7 days
+	* - The resulting instance preserves the calendar variant of the original
+	* - Handles month and year transitions automatically
+	* - Time component remains at midnight UTC in the Gregorian conversion (using {@link BanglaCalendar.toDate()} method)
+	* - Negative values subtract weeks from the current date
+	* - Useful for scheduling recurring weekly events
+	*/
+	addWeeks(weeks) {
+		const date = this.toDate();
+		return new BanglaCalendar(date.setDate(date.getDate() + weeks * 7), { variant: this.variant });
+	}
+	/**
+	* @instance Adds months to the current Bangla date.
+	*
+	* @param months - Number of months to add (can be negative to subtract months)
+	* @param overflow - If `true`, allows date overflow to next month when day doesn't exist;
+	*                   if `false`, clamps to last day of target month (default: `true`)
+	* @returns New `BanglaCalendar` instance with the adjusted date
+	*
+	* @example
+	* // Normal case: day exists in target month
+	* const normal = new BanglaCalendar('১৪৩০', '২', '১৫');
+	* normal.addMonths(1); // Returns: ১৫ আষাঢ় ১৪৩০
+	* normal.addMonths(1, false); // Returns: ১৫ আষাঢ় ১৪৩০ (same behavior for both)
+	*
+	* // Edge case: day does not exist in target month
+	* const edgeCase = new BanglaCalendar('১৪৩০', '৬', '৩১'); // ৩১ আশ্বিন ১৪৩০
+	*
+	* // With overflow (default): 31st doesn't exist in কার্তিক (30 days)
+	* edgeCase.addMonths(1); // Returns: ১ অগ্রহায়ণ ১৪৩০ (overflows to next month)
+	*
+	* // Without overflow: clamps to last day of target month
+	* edgeCase.addMonths(1, false); // Returns: ৩০ কার্তিক ১৪৩০ (clamped)
+	*
+	* // Subtract months
+	* edgeCase.addMonths(-1); // Returns: ১ আশ্বিন ১৪৩০
+	* edgeCase.addMonths(-1, false); // Returns: ৩১ ভাদ্র ১৪৩০
+	*
+	* @remarks
+	* - When `overflow=true` (default):
+	*   Follows JavaScript {@link Date} behavior where invalid dates overflow to the next month (e.g., ৩১ আশ্বিন + 1 month → ১ অগ্রহায়ণ)
+	* - When `overflow=false`:
+	*   Clamps to the last valid day of the target month (e.g., ৩১ আশ্বিন + 1 month → ৩০ কার্তিক)
+	* - The resulting instance preserves the calendar variant of the original
+	* - Handles year transitions automatically
+	* - Time component remains at midnight UTC in the Gregorian conversion (using {@link BanglaCalendar.toDate()} method)
+	* - Negative values subtract months from the current date
+	*/
+	addMonths(months, overflow = true) {
+		if (overflow) {
+			const current = this.toDate();
+			return new BanglaCalendar(current.setMonth(current.getMonth() + months), { variant: this.variant });
+		} else {
+			const { variant, year, month, date } = this;
+			let targetMonth = month.en + months;
+			let targetYear = year.en;
+			while (targetMonth > 12) {
+				targetMonth -= 12;
+				targetYear += 1;
+			}
+			while (targetMonth < 1) {
+				targetMonth += 12;
+				targetYear -= 1;
+			}
+			return this.#getClampedBnCal(targetYear, targetMonth, date.en, variant);
+		}
+	}
+	/**
+	* @instance Adds years to the current Bangla date.
+	*
+	* @param years - Number of years to add (can be negative to subtract years)
+	* @param overflow - If `true`, allows date overflow when day doesn't exist in target year;
+	*                   if `false`, clamps to last valid day of month (default: `true`)
+	* @returns New `BanglaCalendar` instance with the adjusted date
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('১৪৩০', '১', '১৫'); // ১৫ বৈশাখ ১৪৩০
+	*
+	* // Add years
+	* bnCal.addYears(1); // Returns: ১৫ বৈশাখ ১৪৩১
+	*
+	* // Subtract years
+	* bnCal.addYears(-1); // Returns: ১৫ বৈশাখ ১৪২৯
+	*
+	* // Multiple years
+	* bnCal.addYears(5); // Returns: ১৫ বৈশাখ ১৪৩৫
+	*
+	* // Edge case: day adjustment for ফাল্গুন (accounting leap year)
+	* const leapDay = new BanglaCalendar('১৪৩১', '১১', '৩০'); // ১৪৩১ is a leap year
+	* leapDay.addYears(1, false); // Returns: ২৯ ফাল্গুন ১৪৩২ (non-leap years have 29 days in ফাল্গুন)
+	*
+	* @remarks
+	* - The resulting instance preserves the calendar variant of the original
+	* - Negative values subtract years from the current date
+	* - Year addition follows Bangla calendar years
+	* - Time component remains at midnight UTC in the Gregorian conversion (using {@link BanglaCalendar.toDate()} method)
+	* - The month and day generally remain the same unless affected by leap year rules
+	*/
+	addYears(years, overflow = true) {
+		const { variant, year, month, date } = this;
+		const targetYear = year.en + years;
+		if (overflow) return new BanglaCalendar(targetYear, month.en, date.en, { variant });
+		else return this.#getClampedBnCal(targetYear, month.en, date.en, variant);
+	}
+	/**
+	* @instance Gets a new `BanglaCalendar` instance representing the first day of the current month.
+	*
+	* @returns A `BanglaCalendar` instance set to the 1st day of the current month
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('১৪৩০', '৫', '১৫');
+	* const startOfMonth = bnCal.startOfMonth(); // Returns: ১ জ্যৈষ্ঠ ১৪৩০
+	*
+	* @remarks
+	* - The resulting instance preserves the calendar variant of the original
+	* - Useful for date range calculations and month-based operations
+	* - Time component remains at midnight UTC in the Gregorian conversion (using {@link BanglaCalendar.toDate()} method)
+	*/
+	startOfMonth() {
+		const { year, month, variant } = this;
+		return new BanglaCalendar(year.en, month.en, 1, { variant });
+	}
+	/**
+	* @instance Gets a new `BanglaCalendar` instance representing the last day of the current month.
+	*
+	* @returns A `BanglaCalendar` instance set to the last day of the current month
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('১৪৩০', '৫', '১৫');
+	* const endOfMonth = bnCal.endOfMonth(); // Returns: ৩১ জ্যৈষ্ঠ ১৪৩০ (or 30 for some months)
+	*
+	* @remarks
+	* - The resulting instance preserves the calendar variant of the original
+	* - Accounts for month length variations (29/30/31 days) including leap years
+	* - Time component remains at midnight UTC in the Gregorian conversion (using {@link BanglaCalendar.toDate()} method)
+	*/
+	endOfMonth() {
+		const { year, month, variant } = this;
+		return new BanglaCalendar(year.en, month.en, this.daysInMonth(), { variant });
+	}
+	/**
+	* @instance Gets a new `BanglaCalendar` instance representing the first day of the current year (১ বৈশাখ).
+	*
+	* @returns A `BanglaCalendar` instance set to ১ বৈশাখ of the current year
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('১৪৩০', '৫', '১৫');
+	* const startOfYear = bnCal.startOfYear(); // Returns: ১ বৈশাখ ১৪৩০
+	*
+	* @remarks
+	* - The resulting instance preserves the calendar variant of the original
+	* - Always returns the 1st day of the 1st month (বৈশাখ)
+	* - Time component remains at midnight UTC in the Gregorian conversion (using {@link BanglaCalendar.toDate()} method)
+	*/
+	startOfYear() {
+		const { year, variant } = this;
+		return new BanglaCalendar(year.en, 1, 1, { variant });
+	}
+	/**
+	* @instance Gets a new `BanglaCalendar` instance representing the last day of the current year (৩০ চৈত্র).
+	*
+	* @returns A `BanglaCalendar` instance set to ৩০ চৈত্র of the current year
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('১৪৩০', '৫', '১৫');
+	* const endOfYear = bnCal.endOfYear(); // Returns: ৩০ চৈত্র ১৪৩০
+	*
+	* @remarks
+	* - The resulting instance preserves the calendar variant of the original
+	* - Always returns the 30th day of the 12th month (চৈত্র)
+	* - Time component remains at midnight UTC in the Gregorian conversion (using {@link BanglaCalendar.toDate()} method)
+	*/
+	endOfYear() {
+		const { year, variant } = this;
+		return new BanglaCalendar(year.en, 12, 30, { variant });
+	}
+	/**
+	* @instance Gets the number of days in a Bangla month.
+	*
+	* @param month - Optional Bangla month (1-12 in Latin digits)
+	* @returns Number of days in the specified month (29, 30, or 31)
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('১৪৩০', '১', '১');
+	*
+	* // Get days in current month
+	* bnCal.daysInMonth(); // Returns: 31 (বৈশাখ has 31 days)
+	*
+	* // Get days in specific month
+	* bnCal.daysInMonth(2); // Returns: 31 (জ্যৈষ্ঠ has 31 days)
+	* bnCal.daysInMonth(12); // Returns: 30 (চৈত্র has 30 days)
+	*
+	* @remarks
+	* - The method accounts for the selected calendar variant when determining leap years
+	* - If no month is provided, uses the current instance's month
+	* - In the 'revised-2019' variant, leap years follow Gregorian leap rules
+	* - In the 'revised-1966' variant, leap years occur when `bnYear % 4 === 2`
+	*/
+	daysInMonth(month) {
+		const { gregYear } = this.#processGregYear();
+		const { bnMonthTable } = this.#getBnMonthTableLeap(gregYear);
+		return bnMonthTable[(month ?? this.month.en) - 1];
+	}
+	/**
+	* @instance Returns a string representation of the Bangla date in Bengali format.
+	*
+	* @returns Bangla date string in the format: "শুক্রবার, ১৫ জ্যৈষ্ঠ, ১৪৩০ [গ্রীষ্ম]"
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('2023-04-14');
+	* console.log(bnCal.toString()); // "শুক্রবার, ১ বৈশাখ, ১৪৩০ [গ্রীষ্ম]"
+	*
+	* @remarks
+	* - Equivalent to calling {@link toStringEn()} with 'bn' locale
+	* - Format includes day name, date, month name, year, and season in brackets
+	* - Uses Bengali digits and Bengali month/day names
+	*/
+	toString() {
+		return this.#toString("bn");
+	}
+	/**
+	* @instance Returns a string representation of the Bangla date in English/Latin format.
+	*
+	* @returns Bangla date string in the format: "Shukrobar (Friday), 15 Joishtho, 1430 [Grisma (Summer)]"
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('2023-04-14');
+	* console.log(bnCal.toStringEn()); // "Shukrobar (Friday), 1 Boishakh, 1430 [Grisma (Summer)]"
+	*
+	* @remarks
+	* - Equivalent to calling {@link toString()} with 'en' locale
+	* - Format includes transliterated day name (with English equivalent), date, transliterated month and season name, and year.
+	* - Uses Latin digits and transliterated Bengali names
+	*/
+	toStringEn() {
+		return this.#toString("en");
+	}
+	/**
+	* @instance Formats the current date as a Bangla calendar date string (no time) using customizable tokens.
+	*
+	* @param format - Format string using tokens (default: `'ddd, DD mmmm (SS), YYYY বঙ্গাব্দ'`)
+	* @returns Formatted Bangla date string according to the specified format
+	*
+	* @example
+	* const bnCal = new BanglaCalendar('2023-04-14');
+	*
+	* bnCal.format();
+	* // Returns: 'শুক্রবার, বৈশাখ ০১ (গ্রীষ্মকাল), ১৪৩০ বঙ্গাব্দ'
+	*
+	* bnCal.format('YYYY-MM-DD');
+	* // Returns: '১৪৩০-০১-০১'
+	*
+	* bnCal.format('mmmm DD, YYYY');
+	* // Returns: 'বৈশাখ ০১, ১৪৩০'
+	*
+	* @remarks
+	* - **Important:** Does not allow time formatting tokens!
+	* - Supported format tokens include: `YYYY`, `YY`, `mmmm`, `mmm`, `MM`, `M`, `DD`, `D`, `dd`, `ddd`, `Do`, `SS` and `S`.
+	*   - **Year**: `YYYY/yyyy` (full year), `YY/yy` (last 2 digits)
+	*   - **Month**: `M/MM`(padded), `mmm` (short name), `mmmm` (full name)
+	*   - **Day**: `D/DD`(padded), Do (results same as cardinal for Bangla dates)
+	*   - **Weekday**: `d` (short), `dd` (without 'বার'), `ddd` (full)
+	*   - **Season**: `S` (season), `SS` (season with 'কাল' suffix)
+	* - To output raw text (i.e., not interpreted as a date token), wrap it in square brackets.
+	* - For example, `[আজ] ddd` results in `আজ রবিবার`, and `[year ]YYYY` results in `year ২০২৫`.
+	* - *Any token not wrapped in brackets will be parsed and replaced with its corresponding date component.*
+	*/
+	format(format) {
+		const { year, month, date, weekDay } = this;
+		const seasonName = this.getSeasonName();
+		const M_NAME = BN_MONTHS[month.en - 1];
+		const D_NAME = BN_DAYS[weekDay];
+		const paddedYear = _padShunno(year.bn, 4);
+		const dateComponents = {
+			YYYY: paddedYear,
+			YY: paddedYear.slice(-2),
+			yyyy: paddedYear,
+			yy: paddedYear.slice(-2),
+			M: month.bn,
+			MM: _padShunno(month.bn),
+			mmm: M_NAME.short,
+			mmmm: M_NAME.bn,
+			d: D_NAME.short,
+			dd: D_NAME.bn.replace("বার", ""),
+			ddd: D_NAME.bn,
+			D: date.bn,
+			DD: _padShunno(date.bn),
+			Do: date.bn,
+			S: seasonName,
+			SS: seasonName + "কাল"
+		};
+		return _formatDateCore(format || "ddd, DD mmmm (SS), YYYY বঙ্গাব্দ", dateComponents);
+	}
+	/** Process Gregorian base year and calculated year from optional Bangla year and month */
+	#processGregYear(bnYear, bnMonth) {
+		const baseGregYear = (bnYear ?? this.year.en) + 593;
+		return {
+			baseGregYear,
+			gregYear: (bnMonth ?? this.month.en) > 10 ? baseGregYear + 1 : baseGregYear
+		};
+	}
+	/** Get the Bangla month table and leap year flag based on calendar variant */
+	#getBnMonthTableLeap(gregYear, bnYear) {
+		const isBnLeapYear = _isBnLeapYear(bnYear ?? this.year.en, gregYear, this.variant);
+		return {
+			bnMonthTable: isBnLeapYear ? BN_MONTH_TABLES?.[this.variant].leap : BN_MONTH_TABLES?.[this.variant].normal,
+			isBnLeapYear
+		};
+	}
+	/**
+	* @internal Get new `BanglaCalendar` instance with clamped date
+	* @param tyBn - Target Bangla year
+	* @param tmBn - Target Bangla month
+	* @param cdBn - Current Bangla date of the month
+	* @param variant - Calendar variant to preserve
+	* @returns New `BanglaCalendar` instance with date clamped to valid range
+	*
+	* @remarks
+	* - Clamps the date to not exceed the number of days in the target month
+	* - Used internally for non-overflow date arithmetic
+	* - Ensures dates like ৩১ don't become invalid in months with only 30 days
+	*/
+	#getClampedBnCal(tyBn, tmBn, cdBn, variant) {
+		const { gregYear } = this.#processGregYear(tyBn, tmBn);
+		const { bnMonthTable } = this.#getBnMonthTableLeap(gregYear, tyBn);
+		return new BanglaCalendar(tyBn, tmBn, Math.min(cdBn, bnMonthTable[tmBn - 1]), { variant });
+	}
+	/** Process variant from the config */
+	#processVariants(v1, v2, v3, v4) {
+		return this.$hasVariantConfig(v1) ? v1.variant : this.$hasVariantConfig(v2) ? v2.variant : this.$hasVariantConfig(v3) ? v3.variant : this.$hasVariantConfig(v4) ? v4.variant : "revised-2019";
+	}
+	/** Process {@link Date} and extract Bangla year, month and dates in both Bangla and Latin */
+	#processDate(date) {
+		const bnYear = _getBnYear(date);
+		const { days, monthIdx } = _bnDaysMonthIdx(date, this.variant);
+		return {
+			year: bnYear,
+			month: monthIdx + 1,
+			monthDate: days + 1
+		};
+	}
+	/** Convert to human readable string either in `bn` or `en` locale */
+	#toString(lcl = "bn") {
+		const { year, date } = this;
+		return `${this.getDayName(lcl)}, ${date[lcl]} ${this.getMonthName(lcl)}, ${year[lcl]} [${this.getSeasonName(lcl)}]`;
+	}
+	/**
+	* @static Check if a value is a configuration object that contains a valid {@link variant}
+	* @param value Value to check
+	* @returns `true` if the value contains a valid {@link variant} property, `false` otherwise
+	*/
+	$hasVariantConfig(value) {
+		return require_convert.isObjectWithKeys(value, ["variant"]) && require_convert.isNonEmptyString(value.variant) && (value.variant === "revised-1966" || value.variant === "revised-2019");
+	}
+	/**
+	* @static Checks whether a value is a valid Bangla year in Bangla digits (`০–৯৯৯৯`).
+	*
+	* @param value - Value to check. Accepts both zero-padded and non-padded Bangla digits
+	* @returns `true` if the value is a valid Bangla year, `false` otherwise
+	*
+	* @example
+	* BanglaCalendar.isBanglaYear('১৪৩০'); // true
+	* BanglaCalendar.isBanglaYear('০');    // true
+	* BanglaCalendar.isBanglaYear('১০০০০'); // false (too many digits)
+	* BanglaCalendar.isBanglaYear('1430');  // false (Latin digits)
+	*/
+	static isBanglaYear(value) {
+		return require_convert.isNonEmptyString(value) && /^(?:০{0,3}[১-৯][০-৯]{0,3}|০)$/.test(value.trim());
+	}
+	/**
+	* @static Checks whether a value is a valid Bangla year in Latin digits (`0–9999`).
+	*
+	* @param value - Value to check (must be a number)
+	* @returns `true` if the value is a valid Bangla year, `false` otherwise
+	*
+	* @example
+	* BanglaCalendar.isBanglaYearEn(1430);  // true
+	* BanglaCalendar.isBanglaYearEn(0);     // true
+	* BanglaCalendar.isBanglaYearEn(10000); // false
+	* BanglaCalendar.isBanglaYearEn(-1);    // false
+	*/
+	static isBanglaYearEn(value) {
+		return require_convert.isInteger(value) && value >= 0 && value <= 9999;
+	}
+	/**
+	* @static Checks whether a value is a valid Bangla month in Bangla digits (`১–১২`).
+	*
+	* @param value - Value to check. Accepts both zero-padded and non-padded Bangla digits
+	* @returns `true` if the value is a valid Bangla month, `false` otherwise
+	*
+	* @example
+	* BanglaCalendar.isBanglaMonth('১');  // true
+	* BanglaCalendar.isBanglaMonth('১২'); // true
+	* BanglaCalendar.isBanglaMonth('১৩'); // false
+	* BanglaCalendar.isBanglaMonth('0');  // false (Latin digit)
+	*/
+	static isBanglaMonth(value) {
+		return require_convert.isNonEmptyString(value) && /^(?:০?[১-৯]|১০|১১|১২)$/.test(value.trim());
+	}
+	/**
+	* @static Checks whether a value is a valid Bangla month in Latin digits (`1–12`).
+	*
+	* @param value - Value to check
+	* @returns `true` if the value is a valid Bangla month, `false` otherwise
+	*
+	* @example
+	* BanglaCalendar.isBanglaMonthEn(1);  // true
+	* BanglaCalendar.isBanglaMonthEn(12); // true
+	* BanglaCalendar.isBanglaMonthEn(0);  // false
+	* BanglaCalendar.isBanglaMonthEn(13); // false
+	*/
+	static isBanglaMonthEn(value) {
+		return require_convert.isInteger(value) && value >= 1 && value <= 12;
+	}
+	/**
+	* @static Checks whether a value is a valid Bangla date of month in Bangla digits (`১–৩১`).
+	*
+	* @param value - Value to check. Accepts both zero-padded and non-padded Bangla digits
+	* @returns `true` if the value is a valid Bangla date, `false` otherwise
+	*
+	* @example
+	* BanglaCalendar.isBanglaDate('১');   // true
+	* BanglaCalendar.isBanglaDate('৩১');  // true
+	* BanglaCalendar.isBanglaDate('৩২');  // false
+	* BanglaCalendar.isBanglaDate('০');   // false
+	*/
+	static isBanglaDate(value) {
+		return require_convert.isNonEmptyString(value) && /^(?:০?[১-৯]|[১২][০-৯]|৩০|৩১)$/.test(value.trim());
+	}
+	/**
+	* @static Checks whether a value is a valid Bangla date of month in Latin digits (`1–31`).
+	*
+	* @param value - Value to check
+	* @returns `true` if the value is a valid Bangla date, `false` otherwise
+	*
+	* @example
+	* BanglaCalendar.isBanglaDateEn(1);   // true
+	* BanglaCalendar.isBanglaDateEn(31);  // true
+	* BanglaCalendar.isBanglaDateEn(32);  // false
+	* BanglaCalendar.isBanglaDateEn(0);   // false
+	*/
+	static isBanglaDateEn(value) {
+		return require_convert.isInteger(value) && value >= 1 && value <= 31;
+	}
+	/**
+	* @static Checks whether a string follows the Bangla date format pattern (`YYYY-MM-DD` with Bangla digits).
+	*
+	* @param value - String value to check
+	* @returns `true` if the string matches the pattern `"বছর-মাস-দিন"` with Bangla digits, `false` otherwise
+	*
+	* @example
+	* BanglaCalendar.isBanglaDateString('১৪৩০-০১-০১'); // true
+	* BanglaCalendar.isBanglaDateString('1430-01-01'); // false (Latin digits)
+	* BanglaCalendar.isBanglaDateString('১৪৩০-১-১'); // true (single-digit month/date)
+	* BanglaCalendar.isBanglaDateString('১৪৩০-১৩-০১'); // false (invalid month)
+	*
+	* @remarks
+	* - Accepts both zero-padded and non-padded Bangla digits
+	* - Validates year, month, and date components separately
+	* - Year must be `‌০-৯৯৯৯`, month must be `১-১২`, date must be `১-৩১`
+	*/
+	static isBanglaDateString(value) {
+		if (require_convert.isNonEmptyString(value) && value.includes("-")) {
+			const [year, month, date] = value.replace(/['"]/g, "").split("-");
+			return BanglaCalendar.isBanglaYear(year) && BanglaCalendar.isBanglaMonth(month) && BanglaCalendar.isBanglaDate(date);
+		}
+		return false;
+	}
+};
+
+//#endregion
+exports.BanglaCalendar = BanglaCalendar;
+exports.BnCalendar = BanglaCalendar;
+exports.Bongabdo = BanglaCalendar;