@uplynk/lynk-design 1.19.0 → 1.19.2

package/dist/chunks/chunk.WOUY7XVX.js

@@ -0,0 +1,983 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk.O6LH3WX2.js";
+
+// src/internal/utils/date/utils.ts
+var padNumber = (number, size) => {
+  let s = `${Math.abs(number)}`;
+  while (s.length < size) {
+    s = `0${s}`;
+  }
+  return `${number < 0 ? "-" : ""}${s}`;
+};
+var throwInvalidValue = (value) => {
+  throw new Error(`Invalid value provided: '${value}'`);
+};
+var getInvalidFormatError = (format5) => {
+  return `Invalid format provided: '${format5}'`;
+};
+var getInvalidValueError = (value) => {
+  return `Invalid value provided: '${value}'`;
+};
+var getInvalidUnitError = (unit) => {
+  return `Invalid unit provided: '${unit}'`;
+};
+
+// src/internal/utils/date/date.ts
+var yyyy_REGEXP = /^-?\d+$/;
+var yyyyMM_REGEXP = /^-?\d+-(0[1-9]|1[0-2])$/;
+var yyyyMMdd_REGEXP = /^-?\d+-(0[1-9]|1[0-2])-(0[1-9]|1[0-9]|2[0-9]|3[0-1])$/;
+var padYear = (year) => padNumber(year, year >= 0 ? 4 : 6);
+var padMonth = (month) => padNumber(month + 1, 2);
+var padDay = (day) => padNumber(day, 2);
+var toSegment = (value, isUTC = false) => {
+  if (value instanceof Date) {
+    const year = isUTC ? value.getUTCFullYear() : value.getFullYear();
+    const month = isUTC ? value.getUTCMonth() : value.getMonth();
+    const day = isUTC ? value.getUTCDate() : value.getDate();
+    return { year, month, day };
+  }
+  const split2 = value.split("-");
+  if (value.startsWith("-")) {
+    split2.shift();
+    split2[0] = `-${split2[0]}`;
+  }
+  return {
+    year: Number(split2[0]),
+    month: Number(split2[1]) - 1 || 0,
+    day: Number(split2[2]) || 1
+  };
+};
+var formatDate = (value, format5, isUTC) => {
+  const segment = value instanceof Date ? toSegment(value, isUTC) : value;
+  switch (format5) {
+    case "yyyy" /* yyyy */:
+      return `${padYear(segment.year)}`;
+    case "yyyy-MM" /* yyyyMM */:
+      return `${padYear(segment.year)}-${padMonth(segment.month)}`;
+    case "yyyy-MM-dd" /* yyyyMMdd */:
+      return `${padYear(segment.year)}-${padMonth(segment.month)}-${padDay(segment.day)}`;
+    default:
+      throw new Error(getInvalidFormatError(format5));
+  }
+};
+var format = (value, dateFormat = "yyyy-MM-dd" /* yyyyMMdd */) => formatDate(value, dateFormat, false);
+var utcFormat = (value, dateTimeFormat = "yyyy-MM-dd" /* yyyyMMdd */) => formatDate(value, dateTimeFormat, true);
+var getFormat = (value) => {
+  if (yyyyMMdd_REGEXP.test(value)) {
+    return "yyyy-MM-dd" /* yyyyMMdd */;
+  }
+  if (yyyyMM_REGEXP.test(value)) {
+    return "yyyy-MM" /* yyyyMM */;
+  }
+  if (yyyy_REGEXP.test(value)) {
+    return "yyyy" /* yyyy */;
+  }
+  return null;
+};
+var isValid = (value, inputFormat) => {
+  const detectedFormat = inputFormat || getFormat(value);
+  if (detectedFormat === "yyyy" /* yyyy */) {
+    return yyyy_REGEXP.test(value);
+  } else if (detectedFormat === "yyyy-MM" /* yyyyMM */) {
+    return yyyyMM_REGEXP.test(value);
+  } else if (detectedFormat === "yyyy-MM-dd" /* yyyyMMdd */ && yyyyMMdd_REGEXP.test(value)) {
+    const segment = toSegment(value);
+    return segment.day <= getDaysInMonth(segment.year, segment.month);
+  }
+  return false;
+};
+var parseDate = (value, isUTC) => {
+  let segment;
+  if (typeof value === "string") {
+    const valid = isValid(value);
+    if (!valid) {
+      return new Date(Number.NaN);
+    }
+    segment = toSegment(value, isUTC);
+  } else {
+    segment = value;
+  }
+  let date;
+  if (isUTC) {
+    date = /* @__PURE__ */ new Date(0);
+    date.setUTCFullYear(segment.year, segment.month, segment.day);
+    date.setUTCHours(0, 0, 0, 0);
+  } else {
+    date = /* @__PURE__ */ new Date();
+    date.setFullYear(segment.year, segment.month, segment.day);
+    date.setHours(0, 0, 0, 0);
+  }
+  return date;
+};
+var parse = (value) => parseDate(value, false);
+var utcParse = (value) => parseDate(value, true);
+var getDaysInMonth = (year, month) => {
+  const lastDayOfMonth = utcParse({ year, month: month + 1, day: 0 });
+  return lastDayOfMonth.getUTCDate();
+};
+
+// src/internal/utils/date/timestamps.ts
+var HOURS_OF_NOON = 12;
+var YEARS_IN_CENTURY = 100;
+var MONTHS_IN_YEAR = 12;
+var HOURS_IN_DAY = 24;
+var MINUTES_IN_HOUR = 60;
+var SECONDS_IN_MINUTE = 60;
+var SECONDS_IN_HOUR = SECONDS_IN_MINUTE * MINUTES_IN_HOUR;
+var SECONDS_IN_DAY = SECONDS_IN_HOUR * HOURS_IN_DAY;
+var MILLISECONDS_IN_SECOND = 1e3;
+var MILLISECONDS_IN_MINUTE = MILLISECONDS_IN_SECOND * SECONDS_IN_MINUTE;
+var MILLISECONDS_IN_HOUR = MILLISECONDS_IN_MINUTE * MINUTES_IN_HOUR;
+var MILLISECONDS_IN_DAY = MILLISECONDS_IN_HOUR * HOURS_IN_DAY;
+var DAYS_IN_WEEK = 7;
+
+// src/internal/utils/date/time.ts
+var HHmm_REGEXP = /^([0-1][0-9]|2[0-3]):([0-5][0-9])$/;
+var HHmmss_REGEXP = /^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$/;
+var HHmmssSSS_REGEXP = /^([0-1][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])\.([0-9][0-9][0-9])$/;
+var padHour = (hour) => padNumber(hour, 2);
+var padMinute = (minute) => padNumber(minute, 2);
+var padSecond = (second) => padNumber(second, 2);
+var padMillisecond = (millisecond) => padNumber(millisecond, 3);
+var getFormat2 = (value) => {
+  if (HHmmssSSS_REGEXP.test(value)) {
+    return "HH:mm:ss.SSS" /* HHmmssSSS */;
+  }
+  if (HHmmss_REGEXP.test(value)) {
+    return "HH:mm:ss" /* HHmmss */;
+  }
+  if (HHmm_REGEXP.test(value)) {
+    return "HH:mm" /* HHmm */;
+  }
+  return null;
+};
+var isValid2 = (value, format5) => {
+  const detectedFormat = format5 || getFormat2(value);
+  switch (detectedFormat) {
+    case "HH:mm:ss" /* HHmmss */:
+      return HHmmss_REGEXP.test(value);
+    case "HH:mm:ss.SSS" /* HHmmssSSS */:
+      return HHmmssSSS_REGEXP.test(value);
+    case "HH:mm" /* HHmm */:
+      return HHmm_REGEXP.test(value);
+  }
+  return false;
+};
+var toSegment2 = (value, isUTC = false) => {
+  if (value instanceof Date) {
+    const hours = isUTC ? value.getUTCHours() : value.getHours();
+    const minutes = isUTC ? value.getUTCMinutes() : value.getMinutes();
+    const seconds = isUTC ? value.getUTCSeconds() : value.getSeconds();
+    const milliseconds = isUTC ? value.getUTCMilliseconds() : value.getMilliseconds();
+    return { hours, minutes, seconds, milliseconds };
+  }
+  const msSplit = value.split(".");
+  const split2 = (msSplit[0] || "").split(":");
+  return {
+    hours: Number(split2[0]) || 0,
+    minutes: Number(split2[1]) || 0,
+    seconds: Number(split2[2]) || 0,
+    milliseconds: Number(msSplit[1]) || 0
+  };
+};
+var formatTime = (value, format5, isUTC) => {
+  const segment = value instanceof Date ? toSegment2(value, isUTC) : value;
+  switch (format5) {
+    case "HH:mm:ss" /* HHmmss */:
+      return `${padHour(segment.hours)}:${padMinute(segment.minutes)}:${padSecond(segment.seconds || 0)}`;
+    case "HH:mm:ss.SSS" /* HHmmssSSS */:
+      return `${padHour(segment.hours)}:${padMinute(segment.minutes)}:${padSecond(
+        segment.seconds || 0
+      )}.${padMillisecond(segment.milliseconds || 0)}`;
+    case "HH:mm" /* HHmm */:
+      return `${padHour(segment.hours)}:${padMinute(segment.minutes)}`;
+  }
+  throw new Error(getInvalidFormatError(format5));
+};
+var format2 = (value, dateFormat = "HH:mm" /* HHmm */) => formatTime(value, dateFormat, false);
+var utcFormat2 = (value, dateTimeFormat = "HH:mm" /* HHmm */) => formatTime(value, dateTimeFormat, true);
+var parseTime = (value, isUTC) => {
+  let segment;
+  if (typeof value === "string") {
+    const valid = isValid2(value);
+    if (!valid) {
+      return new Date(Number.NaN);
+    }
+    segment = toSegment2(value, isUTC);
+  } else {
+    segment = value;
+  }
+  let date;
+  if (isUTC) {
+    date = /* @__PURE__ */ new Date(0);
+    date.setUTCHours(segment.hours, segment.minutes, segment.seconds, segment.milliseconds);
+  } else {
+    date = /* @__PURE__ */ new Date();
+    date.setHours(segment.hours, segment.minutes, segment.seconds, segment.milliseconds);
+  }
+  return date;
+};
+var parse2 = (value) => parseTime(value, false);
+var utcParse2 = (value) => parseTime(value, true);
+
+// src/internal/utils/date/datetime.ts
+var split = (value) => {
+  const dateTimeSplit = value.split("T");
+  return {
+    date: dateTimeSplit[0],
+    time: dateTimeSplit[1]
+  };
+};
+var getFormat3 = (value) => {
+  const { date, time } = split(value);
+  if (!date || !time || !isValid(date, "yyyy-MM-dd" /* yyyyMMdd */) || !isValid2(time)) {
+    return null;
+  }
+  const timeFormat = getFormat2(time);
+  switch (timeFormat) {
+    case "HH:mm:ss.SSS" /* HHmmssSSS */:
+      return "yyyy-MM-dd'T'HH:mm:ss.SSS" /* yyyMMddTHHmmssSSS */;
+    case "HH:mm:ss" /* HHmmss */:
+      return "yyyy-MM-dd'T'HH:mm:ss" /* yyyMMddTHHmmss */;
+    default:
+      return "yyyy-MM-dd'T'HH:mm" /* yyyMMddTHHmm */;
+  }
+};
+var isValid3 = (value, format5) => {
+  const { date, time } = split(value);
+  if (!date || !time || !isValid(date, "yyyy-MM-dd" /* yyyyMMdd */) || !isValid2(time)) {
+    return false;
+  }
+  const timeFormat = getFormat2(time);
+  const defaultFormat = getFormat3(value);
+  return timeFormat === "HH:mm" /* HHmm */ && defaultFormat === "yyyy-MM-dd'T'HH:mm" /* yyyMMddTHHmm */ || timeFormat === "HH:mm:ss" /* HHmmss */ && defaultFormat === "yyyy-MM-dd'T'HH:mm:ss" /* yyyMMddTHHmmss */ || timeFormat === "HH:mm:ss.SSS" /* HHmmssSSS */ && format5 === "yyyy-MM-dd'T'HH:mm:ss.SSS" /* yyyMMddTHHmmssSSS */;
+};
+var toSegment3 = (value, isUTC = false) => {
+  let date = value;
+  let time = value;
+  if (typeof value === "string") {
+    const valueSplit = split(value);
+    date = valueSplit.date;
+    time = valueSplit.time;
+  }
+  return __spreadValues(__spreadValues({}, toSegment(date, isUTC)), toSegment2(time, isUTC));
+};
+var formatDateTime = (value, format5, isUTC) => {
+  const segment = value instanceof Date ? toSegment3(value, isUTC) : value;
+  const dateSegment = {
+    year: segment.year,
+    month: segment.month,
+    day: segment.day
+  };
+  const timeSegment = {
+    hours: segment.hours,
+    minutes: segment.minutes,
+    seconds: segment.seconds,
+    milliseconds: segment.milliseconds
+  };
+  const dateFormat = "yyyy-MM-dd" /* yyyyMMdd */;
+  const date = isUTC ? utcFormat(dateSegment, dateFormat) : format(dateSegment, dateFormat);
+  let timeFormat;
+  switch (format5) {
+    case "yyyy-MM-dd'T'HH:mm:ss.SSS" /* yyyMMddTHHmmssSSS */:
+      timeFormat = "HH:mm:ss.SSS" /* HHmmssSSS */;
+      break;
+    case "yyyy-MM-dd'T'HH:mm:ss" /* yyyMMddTHHmmss */:
+      timeFormat = "HH:mm:ss" /* HHmmss */;
+      break;
+    case "yyyy-MM-dd'T'HH:mm" /* yyyMMddTHHmm */:
+      timeFormat = "HH:mm" /* HHmm */;
+      break;
+    default:
+      throw new Error(getInvalidFormatError(format5));
+  }
+  const time = isUTC ? utcFormat2(timeSegment, timeFormat) : format2(timeSegment, timeFormat);
+  return `${date}T${time}`;
+};
+var format3 = (value, dateFormat = "yyyy-MM-dd'T'HH:mm" /* yyyMMddTHHmm */) => formatDateTime(value, dateFormat, false);
+var utcFormat3 = (value, dateTimeFormat = "yyyy-MM-dd'T'HH:mm" /* yyyMMddTHHmm */) => formatDateTime(value, dateTimeFormat, true);
+var parseDateTime = (value, isUTC) => {
+  let parsedValue;
+  if (typeof value === "string") {
+    const valid = isValid3(value);
+    if (!valid) {
+      return new Date(Number.NaN);
+    }
+    parsedValue = toSegment3(value, isUTC);
+  } else {
+    parsedValue = value;
+  }
+  let date;
+  if (isUTC) {
+    date = /* @__PURE__ */ new Date(0);
+    date.setUTCFullYear(parsedValue.year, parsedValue.month, parsedValue.day);
+    date.setUTCHours(parsedValue.hours, parsedValue.minutes, parsedValue.seconds, parsedValue.milliseconds);
+  } else {
+    date = /* @__PURE__ */ new Date();
+    date.setFullYear(parsedValue.year, parsedValue.month, parsedValue.day);
+    date.setHours(parsedValue.hours, parsedValue.minutes, parsedValue.seconds, parsedValue.milliseconds);
+  }
+  return date;
+};
+var parse3 = (value) => parseDateTime(value, false);
+var utcParse3 = (value) => parseDateTime(value, true);
+
+// src/internal/utils/date/shared.ts
+var isTime = (value) => {
+  if (typeof value === "string") {
+    return isValid2(value);
+  }
+  return value.year === void 0 && value.month === void 0 && value.day === void 0 && value.hours !== void 0 && value.minutes !== void 0;
+};
+var isDate = (value) => {
+  if (typeof value === "string") {
+    return isValid(value);
+  }
+  return value.year !== void 0 && value.month !== void 0 && value.day !== void 0 && value.hours === void 0 && value.minutes === void 0 && value.seconds === void 0 && value.milliseconds === void 0;
+};
+var isDateTime = (value) => {
+  if (typeof value === "string") {
+    return isValid3(value);
+  }
+  return value.year !== void 0 && value.month !== void 0 && value.day !== void 0 && value.hours !== void 0 && value.minutes !== void 0;
+};
+var toSegment4 = (value, isUTC = false) => {
+  if (value instanceof Date) {
+    return toSegment3(value, isUTC);
+  }
+  if (isTime(value)) {
+    return toSegment2(value, isUTC);
+  }
+  if (isDate(value)) {
+    return toSegment(value, isUTC);
+  }
+  if (isDateTime(value)) {
+    return toSegment3(value, isUTC);
+  }
+  throw new Error(getInvalidValueError(value));
+};
+var formatAll = (value, isUTC, format5 = "yyyy-MM-dd'T'HH:mm" /* yyyMMddTHHmm */) => {
+  let segment;
+  if (value instanceof Date) {
+    segment = toSegment4(value, isUTC);
+  } else {
+    segment = value;
+  }
+  const { year = 0, month = 0, day = 0, hours = 0, minutes = 0, seconds = 0, milliseconds = 0 } = segment;
+  const dateTimeSegment = { year, month, day, hours, minutes, seconds, milliseconds };
+  switch (format5) {
+    case "yyyy-MM-dd'T'HH:mm" /* yyyMMddTHHmm */:
+    case "yyyy-MM-dd'T'HH:mm:ss" /* yyyMMddTHHmmss */:
+    case "yyyy-MM-dd'T'HH:mm:ss.SSS" /* yyyMMddTHHmmssSSS */:
+      return isUTC ? utcFormat3(dateTimeSegment, format5) : format3(dateTimeSegment, format5);
+    case "HH:mm" /* HHmm */:
+    case "HH:mm:ss" /* HHmmss */:
+    case "HH:mm:ss.SSS" /* HHmmssSSS */: {
+      const timeSegment = { hours, minutes, seconds, milliseconds };
+      return isUTC ? utcFormat2(timeSegment, format5) : format2(timeSegment, format5);
+    }
+    case "yyyy-MM-dd" /* yyyyMMdd */:
+    case "yyyy-MM" /* yyyyMM */:
+    case "yyyy" /* yyyy */: {
+      const dateSegment = { year, month, day };
+      return isUTC ? utcFormat(dateSegment, format5) : format(dateSegment, format5);
+    }
+  }
+  throw new Error(getInvalidFormatError(format5));
+};
+var format4 = (value, dateFormat = "yyyy-MM-dd'T'HH:mm" /* yyyMMddTHHmm */) => formatAll(value, false, dateFormat);
+var utcFormat4 = (value, dateTimeFormat = "yyyy-MM-dd'T'HH:mm" /* yyyMMddTHHmm */) => formatAll(value, true, dateTimeFormat);
+var parseAll = (value, isUTC) => {
+  let segment;
+  if (typeof value === "string") {
+    segment = toSegment4(value, isUTC);
+  } else {
+    segment = value;
+  }
+  const { year = 0, month = 0, day = 0, hours = 0, minutes = 0, seconds = 0, milliseconds = 0 } = segment;
+  if (isTime(segment)) {
+    const timeSegment = { hours, minutes, seconds, milliseconds };
+    return isUTC ? utcParse2(timeSegment) : parse2(timeSegment);
+  }
+  if (isDate(segment)) {
+    const dateSegment = { year, month, day };
+    return isUTC ? utcParse(dateSegment) : parse(dateSegment);
+  }
+  if (isDateTime(segment)) {
+    const dateTimeSegment = { year, month, day, hours, minutes, seconds, milliseconds };
+    return isUTC ? utcParse3(dateTimeSegment) : parse3(dateTimeSegment);
+  }
+  return new Date(Number.NaN);
+};
+var utcParse4 = (value) => parseAll(value, true);
+var getFormat4 = (value) => {
+  if (isValid2(value)) {
+    return getFormat2(value);
+  }
+  if (isValid(value)) {
+    return getFormat(value);
+  }
+  if (isValid3(value)) {
+    return getFormat3(value);
+  }
+  return null;
+};
+var isAfter = (value, compare) => {
+  const date = utcParse4(value);
+  const compareDate = utcParse4(compare);
+  return date.getTime() > compareDate.getTime();
+};
+var isBefore = (value, compare) => {
+  const date = utcParse4(value);
+  const compareDate = utcParse4(compare);
+  return date.getTime() < compareDate.getTime();
+};
+var isSameDay = (value, compare) => {
+  const valueSegment = toSegment4(value);
+  const compareSegment = toSegment4(compare);
+  return valueSegment.year === compareSegment.year && valueSegment.month === compareSegment.month && valueSegment.day === compareSegment.day;
+};
+var isToday = (value) => {
+  const today = format4(/* @__PURE__ */ new Date());
+  return isSameDay(value, today);
+};
+var addUnit = (value, unit, amount) => {
+  if (!amount) {
+    return value;
+  }
+  const valueFormat = getFormat4(value);
+  if (!valueFormat) {
+    throw new Error(getInvalidValueError(value));
+  }
+  let date = utcParse4(value);
+  switch (unit) {
+    case "year":
+      date.setUTCFullYear(date.getUTCFullYear() + amount);
+      break;
+    case "month": {
+      const dayOfMonth = date.getUTCDate();
+      const endOfDesiredMonth = new Date(date.getTime());
+      endOfDesiredMonth.setUTCMonth(date.getUTCMonth() + amount + 1, 0);
+      const daysInMonth = endOfDesiredMonth.getUTCDate();
+      if (dayOfMonth >= daysInMonth) {
+        date = endOfDesiredMonth;
+      } else {
+        date.setUTCFullYear(endOfDesiredMonth.getUTCFullYear(), endOfDesiredMonth.getUTCMonth(), dayOfMonth);
+      }
+      break;
+    }
+    case "day":
+      date.setUTCDate(date.getUTCDate() + amount);
+      break;
+    case "hour":
+      date.setUTCHours(date.getUTCHours() + amount);
+      break;
+    case "minute":
+      date.setUTCMinutes(date.getUTCMinutes() + amount);
+      break;
+    case "second":
+      date.setUTCSeconds(date.getUTCSeconds() + amount);
+      break;
+    case "millisecond":
+      date.setUTCMilliseconds(date.getUTCMilliseconds() + amount);
+      break;
+    default:
+      throw new Error(getInvalidUnitError(unit));
+  }
+  return utcFormat4(date, valueFormat);
+};
+
+// src/internal/utils/date/Locale.ts
+var YYYY = "(\\d{1,4})";
+var YY = "(\\d{2})";
+var MM = "([1-9]{1}|0[1-9]|1[0-2])";
+var DD = "([1-9]{1}|0[1-9]|1\\d{1}|2\\d{1}|3[0-1])";
+var H23 = "(\\d{1}|[0-1]\\d{1}|2[0-3])";
+var H12 = "([1-9]{1}|0[1-9]|1[0-2])";
+var H24 = "([1-9]{1}|0[1-9]|1\\d{1}|2[0-4])";
+var H11 = "(\\d{1}|0\\d{1}|1[0-1])";
+var mm = "(\\d{1}|[0-5]\\d{1})";
+var ss = "(\\d{1}|[0-5]\\d{1})";
+var S = "(\\d{1})";
+var SS = "(\\d{2})";
+var SSS = "(\\d{3})";
+var TwoDigit = "2-digit";
+var Numeric = "numeric";
+var regExpEscape = (str) => str.replace(/([^\w\s])/g, "\\$1").replace(/\s/g, "\\s");
+var escapeList = (list) => {
+  return `(${[...new Set(list.map((item) => item.name))].map((item) => regExpEscape(item)).join("|")})`;
+};
+var Locale = class _Locale {
+  /**
+   * Create the Locale object
+   * @param formatter Date time format
+   */
+  constructor(formatter) {
+    this._regExp = null;
+    this._monthNames = null;
+    this._weekdayNames = null;
+    this._periodNames = null;
+    this._eraNames = null;
+    this._parts = null;
+    this._resolvedFormat = null;
+    var _a;
+    if (!(formatter instanceof Intl.DateTimeFormat)) {
+      throw new Error(
+        "Invalid constructor parameters provided. formatter should be an instance of Intl.DateTimeFormat"
+      );
+    }
+    this.formatter = formatter;
+    this.options = formatter.resolvedOptions();
+    const options = this.options;
+    this.hourCycle = this.resolveHourCycle(options);
+    const extendedOptions = options;
+    this.fractionalSecondDigits = (_a = extendedOptions.fractionalSecondDigits) != null ? _a : 0;
+    if (options.calendar !== "gregory") {
+      throw new Error(
+        'Only Gregorian calendar is supported. Specify calendar option for locale, e.g. "th-u-ca-gregory"'
+      );
+    }
+    if (options.numberingSystem !== "latn") {
+      throw new Error(
+        'Only Latin symbols supported. Specify calendar option for numbering symbols, e.g. "ar-u-nu-latn"'
+      );
+    }
+    if (options.timeZone !== "UTC") {
+      throw new Error("Only UTC timezone supported. Specify `timeZone: 'UTC'` in formatter options.");
+    }
+  }
+  /**
+   * Construct Locale object from options
+   * @param options Format options
+   * @param [locales] Locale or the default locale
+   * @returns Locale object
+   */
+  static fromOptions(options, locales) {
+    const format5 = new Intl.DateTimeFormat(locales, __spreadProps(__spreadValues({}, options), {
+      calendar: "gregory",
+      // Force Gregorian calendar
+      numberingSystem: "latn",
+      // Force Latin numbering system
+      timeZoneName: void 0,
+      // Timezones are not supported
+      timeZone: "UTC"
+      // must be provided as all calculations are done in UTC
+    }));
+    return new _Locale(format5);
+  }
+  /**
+   * Hour cycle is not supported in older browsers. Therefore keep the default
+   * @param options Format options
+   * @return hourCycle
+   */
+  resolveHourCycle(options) {
+    const extendedOptions = options;
+    if (extendedOptions.hourCycle) {
+      return extendedOptions.hourCycle;
+    }
+    return options.hour12 ? "h12" : "h23";
+  }
+  /**
+   * Get months names for the specified formatter
+   * @returns names Month names
+   */
+  formatMonthNames() {
+    const monthsNames = [];
+    for (let value = 0; value < MONTHS_IN_YEAR; value += 1) {
+      const date = Date.UTC(2018, value, 1);
+      const monthPart = this.formatter.formatToParts(date).find((part) => part.type === "month");
+      if (monthPart) {
+        monthsNames.push({
+          value,
+          name: monthPart.value.toLowerCase()
+        });
+      }
+    }
+    return monthsNames;
+  }
+  /**
+   * Get weekday names for the specified formatter
+   * @returns names Weekday names
+   */
+  formatWeekdayNames() {
+    const weekdayNames = [];
+    for (let value = 0; value < DAYS_IN_WEEK; value += 1) {
+      const date = Date.UTC(2018, 0, value);
+      const weekdayPart = this.formatter.formatToParts(date).find((part) => part.type === "weekday");
+      if (weekdayPart) {
+        weekdayNames.push({
+          value,
+          name: weekdayPart.value.toLowerCase()
+        });
+      }
+    }
+    return weekdayNames;
+  }
+  /**
+   * Get period names for the specified formatter
+   * @returns names Period names
+   */
+  formatPeriodNames() {
+    const periodNames = [];
+    for (let i = 0; i < HOURS_IN_DAY; i += 1) {
+      const date = Date.UTC(2018, 0, 1, i);
+      const parts = this.formatter.formatToParts(date);
+      const dayPeriodPart = parts.find((part) => part.type === "dayPeriod");
+      const hourPart = parts.find((part) => part.type === "hour");
+      if (hourPart && dayPeriodPart) {
+        periodNames.push({
+          value: Number(hourPart.value),
+          name: dayPeriodPart.value.toLowerCase()
+        });
+      }
+    }
+    return periodNames;
+  }
+  /**
+   * Get period names for the specified formatter
+   * @returns names Period names
+   */
+  formatEraNames() {
+    const eraNames = [];
+    const dates = [utcParse4("-0001-01-01").getTime(), Date.UTC(2018, 0, 1)];
+    for (let i = 0; i <= 1; i += 1) {
+      const value = dates[i];
+      const era = this.formatter.formatToParts(value).find((part) => part.type === "era");
+      if (era) {
+        eraNames.push({
+          value,
+          name: era.value.toLowerCase()
+        });
+      }
+    }
+    return eraNames;
+  }
+  /**
+   * Get regular expression for the format
+   */
+  get regExp() {
+    if (this._regExp) {
+      this._regExp.lastIndex = 0;
+      return this._regExp;
+    }
+    const parts = this.parts;
+    let str = "";
+    for (const part of parts) {
+      switch (part.type) {
+        case "year":
+          str += this.yearRegExp;
+          break;
+        case "month":
+          str += this.monthRegExp;
+          break;
+        case "day":
+          str += this.dayRegExp;
+          break;
+        case "hour":
+          str += this.hourRegExp;
+          break;
+        case "minute":
+          str += this.minuteRegExp;
+          break;
+        case "second":
+          str += this.secondRegExp;
+          break;
+        case "fractionalSecond":
+          str += this.fractionalSecondRegExp;
+          break;
+        case "weekday":
+          str += this.weekdayRegExp;
+          break;
+        case "dayPeriod":
+          str += this.dayPeriodRegExp;
+          break;
+        case "literal":
+          str += this.getLiteralRegExp(part.value);
+          break;
+        case "era":
+          str += this.eraRegExp;
+          break;
+        case "timeZoneName":
+          throw new Error("Parsing timezones is ambiguous. Make sure that `timeZoneName` option is not provided");
+        default:
+          throw new Error("Unknown format provided");
+      }
+    }
+    this._regExp = new RegExp(`^${str}$`, "i");
+    return this._regExp;
+  }
+  get yearRegExp() {
+    return this.options.year === TwoDigit ? YY : YYYY;
+  }
+  get monthRegExp() {
+    const options = this.options;
+    if (options.month === TwoDigit || options.month === Numeric) {
+      return MM;
+    }
+    return escapeList(this.monthNames);
+  }
+  get dayRegExp() {
+    return DD;
+  }
+  get hourRegExp() {
+    switch (this.hourCycle) {
+      case "h12":
+        return H12;
+      case "h11":
+        return H11;
+      case "h24":
+        return H24;
+      default:
+        return H23;
+    }
+  }
+  get minuteRegExp() {
+    return mm;
+  }
+  get secondRegExp() {
+    return ss;
+  }
+  get fractionalSecondRegExp() {
+    const ms = this.fractionalSecondDigits;
+    if (ms === 1) {
+      return S;
+    } else if (ms === 2) {
+      return SS;
+    }
+    return SSS;
+  }
+  get weekdayRegExp() {
+    return escapeList(this.weekdayNames);
+  }
+  get dayPeriodRegExp() {
+    return escapeList(this.periodNames);
+  }
+  getLiteralRegExp(literal) {
+    return `(${regExpEscape(literal.toLowerCase())})`;
+  }
+  get eraRegExp() {
+    return escapeList(this.eraNames);
+  }
+  /**
+   * Get month names
+   */
+  get monthNames() {
+    if (this._monthNames) {
+      return this._monthNames;
+    }
+    this._monthNames = this.formatMonthNames();
+    return this._monthNames;
+  }
+  /**
+   * Get weekday names
+   */
+  get weekdayNames() {
+    if (this._weekdayNames) {
+      return this._weekdayNames;
+    }
+    this._weekdayNames = this.formatWeekdayNames();
+    return this._weekdayNames;
+  }
+  /**
+   * Get period names
+   */
+  get periodNames() {
+    if (this._periodNames) {
+      return this._periodNames;
+    }
+    this._periodNames = this.formatPeriodNames();
+    return this._periodNames;
+  }
+  /**
+   * Get era names
+   */
+  get eraNames() {
+    if (this._eraNames) {
+      return this._eraNames;
+    }
+    this._eraNames = this.formatEraNames();
+    return this._eraNames;
+  }
+  /**
+   * Get parts for formatter
+   */
+  get parts() {
+    if (this._parts) {
+      return this._parts;
+    }
+    this._parts = this.formatter.formatToParts(Date.UTC(2018, 0, 1));
+    return this._parts;
+  }
+  /**
+   * Get resolved ISO string format
+   */
+  get isoFormat() {
+    if (this._resolvedFormat) {
+      return this._resolvedFormat;
+    }
+    const options = this.options;
+    const extendedOptions = options;
+    const day = options.day !== void 0 || extendedOptions.dateStyle !== void 0;
+    const month = day || options.month !== void 0;
+    const year = day || month || options.year !== void 0;
+    const millisecond = extendedOptions.fractionalSecondDigits !== void 0;
+    const second = millisecond || options.second !== void 0 || extendedOptions.timeStyle === "full" || extendedOptions.timeStyle === "long" || extendedOptions.timeStyle === "medium";
+    const minute = second || options.minute !== void 0 || extendedOptions.timeStyle === "short";
+    const hour = minute || options.hour !== void 0;
+    if (hour && !year) {
+      this._resolvedFormat = millisecond ? "HH:mm:ss.SSS" /* HHmmssSSS */ : second ? "HH:mm:ss" /* HHmmss */ : "HH:mm" /* HHmm */;
+    } else if (year && !hour) {
+      this._resolvedFormat = day ? "yyyy-MM-dd" /* yyyyMMdd */ : month ? "yyyy-MM" /* yyyyMM */ : "yyyy" /* yyyy */;
+    } else {
+      this._resolvedFormat = millisecond ? "yyyy-MM-dd'T'HH:mm:ss.SSS" /* yyyMMddTHHmmssSSS */ : second ? "yyyy-MM-dd'T'HH:mm:ss" /* yyyMMddTHHmmss */ : "yyyy-MM-dd'T'HH:mm" /* yyyMMddTHHmm */;
+    }
+    return this._resolvedFormat;
+  }
+  /**
+   * Try to parse localised date string into ISO date/time/datetime string
+   * Throw an error if value is invalid
+   * @param value Localised date
+   * @param [referenceDate=0] Reference UTC date or time to resolve ambiguous strings.
+   * @returns ISO date/time/datetime string
+   */
+  parse(value, referenceDate = 0) {
+    const refDate = typeof referenceDate === "string" ? utcParse4(referenceDate) : new Date(referenceDate);
+    const formattedReferenceDate = utcParse4(utcFormat4(refDate, this.isoFormat));
+    const trimmedValue = value.trim();
+    const regExp = this.regExp;
+    const matches = regExp.exec(value);
+    if (!trimmedValue || matches === null) {
+      throwInvalidValue(trimmedValue);
+    }
+    const options = this.options;
+    const parts = this.parts;
+    let year = formattedReferenceDate.getUTCFullYear();
+    let month = formattedReferenceDate.getUTCMonth();
+    let day = formattedReferenceDate.getUTCDay();
+    let hours = formattedReferenceDate.getUTCHours();
+    let minutes = formattedReferenceDate.getUTCMinutes();
+    let seconds = formattedReferenceDate.getUTCSeconds();
+    let milliseconds = formattedReferenceDate.getUTCMilliseconds();
+    let weekDay = "";
+    let referenceDay = Number.NaN;
+    let dayPeriod = "";
+    let era = -1;
+    for (let i = 0; i < parts.length; i += 1) {
+      const part = parts[i];
+      const match = matches[i + 1].toLowerCase();
+      switch (part.type) {
+        case "year":
+          year = Number(match);
+          break;
+        case "month":
+          if (options.month === Numeric || options.month === TwoDigit) {
+            month = Number(match) - 1;
+          } else {
+            const monthItem = this.monthNames.find((item) => item.name === match);
+            if (monthItem) {
+              month = monthItem.value;
+            }
+          }
+          break;
+        case "day":
+          referenceDay = Number(match);
+          break;
+        case "weekday":
+          weekDay = match;
+          break;
+        case "hour":
+          hours = Number(match);
+          break;
+        case "minute":
+          minutes = Number(match);
+          break;
+        case "second":
+          seconds = Number(match);
+          break;
+        case "fractionalSecond":
+          milliseconds = Number(match);
+          break;
+        case "dayPeriod":
+          dayPeriod = match;
+          break;
+        case "era":
+          era = this.eraNames.findIndex((item) => item.name === match);
+          break;
+      }
+    }
+    if (options.year === TwoDigit) {
+      const referenceYear = formattedReferenceDate.getUTCFullYear();
+      year = referenceYear - referenceYear % YEARS_IN_CENTURY + year;
+    }
+    if (era === 0) {
+      year = year * -1 + 1;
+    }
+    if (options.hour12) {
+      hours = this.periodNames.findIndex((period, index) => {
+        let periodName = period.name;
+        if (index === HOURS_OF_NOON && (minutes !== 0 || seconds !== 0)) {
+          periodName = this.periodNames[index + 1].name;
+        }
+        return periodName === dayPeriod && period.value === hours;
+      });
+      if (hours === -1) {
+        throwInvalidValue(trimmedValue);
+      }
+    } else if (this.hourCycle === "h24") {
+      hours = hours === HOURS_IN_DAY ? 0 : hours;
+    }
+    if (!weekDay && !Number.isNaN(referenceDay)) {
+      day = referenceDay;
+    } else if (weekDay && Number.isNaN(referenceDay)) {
+      referenceDay = 1;
+      let utcWeekDay = utcParse4({ year, month, day: referenceDay }).getUTCDay();
+      for (let i = 0; i < DAYS_IN_WEEK; i += 1) {
+        if (this.weekdayNames.find((item) => item.name === weekDay && item.value === utcWeekDay)) {
+          break;
+        }
+        utcWeekDay += 1;
+        referenceDay += 1;
+      }
+    } else if (weekDay && !Number.isNaN(referenceDay)) {
+      day = referenceDay;
+      const utcWeekDay = utcParse4({ year, month, day }).getUTCDay();
+      if (!this.weekdayNames.some((item) => item.name === weekDay && item.value === utcWeekDay)) {
+        throwInvalidValue(trimmedValue);
+      }
+    }
+    const date = utcFormat4(
+      {
+        year,
+        month,
+        day,
+        hours,
+        minutes,
+        seconds,
+        milliseconds
+      },
+      this.isoFormat
+    );
+    if (!getFormat4(date)) {
+      throwInvalidValue(trimmedValue);
+    }
+    return date;
+  }
+};
+
+export {
+  toSegment,
+  utcFormat,
+  utcParse,
+  getDaysInMonth,
+  isValid2 as isValid,
+  toSegment2,
+  format2 as format,
+  parse2 as parse,
+  isAfter,
+  isBefore,
+  isToday,
+  addUnit,
+  Locale
+};