@belonguniverseai/react-sdk 0.1.5 → 0.1.7

package/dist/component/index-Dips44uG.js

@@ -0,0 +1,2208 @@
+globalThis.process = globalThis.process || { env: {} };
+globalThis.global = globalThis.global || globalThis;
+var c;
+(function(r) {
+  r[r.AM = 0] = "AM", r[r.PM = 1] = "PM";
+})(c || (c = {}));
+var f;
+(function(r) {
+  r[r.SUNDAY = 0] = "SUNDAY", r[r.MONDAY = 1] = "MONDAY", r[r.TUESDAY = 2] = "TUESDAY", r[r.WEDNESDAY = 3] = "WEDNESDAY", r[r.THURSDAY = 4] = "THURSDAY", r[r.FRIDAY = 5] = "FRIDAY", r[r.SATURDAY = 6] = "SATURDAY";
+})(f || (f = {}));
+var p;
+(function(r) {
+  r[r.JANUARY = 1] = "JANUARY", r[r.FEBRUARY = 2] = "FEBRUARY", r[r.MARCH = 3] = "MARCH", r[r.APRIL = 4] = "APRIL", r[r.MAY = 5] = "MAY", r[r.JUNE = 6] = "JUNE", r[r.JULY = 7] = "JULY", r[r.AUGUST = 8] = "AUGUST", r[r.SEPTEMBER = 9] = "SEPTEMBER", r[r.OCTOBER = 10] = "OCTOBER", r[r.NOVEMBER = 11] = "NOVEMBER", r[r.DECEMBER = 12] = "DECEMBER";
+})(p || (p = {}));
+function P(r, e) {
+  r.assign("day", e.getDate()), r.assign("month", e.getMonth() + 1), r.assign("year", e.getFullYear());
+}
+function ve(r, e) {
+  r.assign("hour", e.getHours()), r.assign("minute", e.getMinutes()), r.assign("second", e.getSeconds()), r.assign("millisecond", e.getMilliseconds()), r.assign("meridiem", e.getHours() < 12 ? c.AM : c.PM);
+}
+function N(r, e) {
+  r.imply("day", e.getDate()), r.imply("month", e.getMonth() + 1), r.imply("year", e.getFullYear());
+}
+function S(r, e) {
+  r.imply("hour", e.getHours()), r.imply("minute", e.getMinutes()), r.imply("second", e.getSeconds()), r.imply("millisecond", e.getMilliseconds()), r.imply("meridiem", e.getHours() < 12 ? c.AM : c.PM);
+}
+const at = {
+  ACDT: 630,
+  ACST: 570,
+  ADT: -180,
+  AEDT: 660,
+  AEST: 600,
+  AFT: 270,
+  AKDT: -480,
+  AKST: -540,
+  ALMT: 360,
+  AMST: -180,
+  AMT: -240,
+  ANAST: 720,
+  ANAT: 720,
+  AQTT: 300,
+  ART: -180,
+  AST: -240,
+  AWDT: 540,
+  AWST: 480,
+  AZOST: 0,
+  AZOT: -60,
+  AZST: 300,
+  AZT: 240,
+  BNT: 480,
+  BOT: -240,
+  BRST: -120,
+  BRT: -180,
+  BST: 60,
+  BTT: 360,
+  CAST: 480,
+  CAT: 120,
+  CCT: 390,
+  CDT: -300,
+  CEST: 120,
+  CET: {
+    timezoneOffsetDuringDst: 120,
+    timezoneOffsetNonDst: 60,
+    dstStart: (r) => me(r, p.MARCH, f.SUNDAY, 2),
+    dstEnd: (r) => me(r, p.OCTOBER, f.SUNDAY, 3)
+  },
+  CHADT: 825,
+  CHAST: 765,
+  CKT: -600,
+  CLST: -180,
+  CLT: -240,
+  COT: -300,
+  CST: -360,
+  CT: {
+    timezoneOffsetDuringDst: -300,
+    timezoneOffsetNonDst: -360,
+    dstStart: (r) => R(r, p.MARCH, f.SUNDAY, 2, 2),
+    dstEnd: (r) => R(r, p.NOVEMBER, f.SUNDAY, 1, 2)
+  },
+  CVT: -60,
+  CXT: 420,
+  ChST: 600,
+  DAVT: 420,
+  EASST: -300,
+  EAST: -360,
+  EAT: 180,
+  ECT: -300,
+  EDT: -240,
+  EEST: 180,
+  EET: 120,
+  EGST: 0,
+  EGT: -60,
+  EST: -300,
+  ET: {
+    timezoneOffsetDuringDst: -240,
+    timezoneOffsetNonDst: -300,
+    dstStart: (r) => R(r, p.MARCH, f.SUNDAY, 2, 2),
+    dstEnd: (r) => R(r, p.NOVEMBER, f.SUNDAY, 1, 2)
+  },
+  FJST: 780,
+  FJT: 720,
+  FKST: -180,
+  FKT: -240,
+  FNT: -120,
+  GALT: -360,
+  GAMT: -540,
+  GET: 240,
+  GFT: -180,
+  GILT: 720,
+  GMT: 0,
+  GST: 240,
+  GYT: -240,
+  HAA: -180,
+  HAC: -300,
+  HADT: -540,
+  HAE: -240,
+  HAP: -420,
+  HAR: -360,
+  HAST: -600,
+  HAT: -90,
+  HAY: -480,
+  HKT: 480,
+  HLV: -210,
+  HNA: -240,
+  HNC: -360,
+  HNE: -300,
+  HNP: -480,
+  HNR: -420,
+  HNT: -150,
+  HNY: -540,
+  HOVT: 420,
+  ICT: 420,
+  IDT: 180,
+  IOT: 360,
+  IRDT: 270,
+  IRKST: 540,
+  IRKT: 540,
+  IRST: 210,
+  IST: 330,
+  JST: 540,
+  KGT: 360,
+  KRAST: 480,
+  KRAT: 480,
+  KST: 540,
+  KUYT: 240,
+  LHDT: 660,
+  LHST: 630,
+  LINT: 840,
+  MAGST: 720,
+  MAGT: 720,
+  MART: -510,
+  MAWT: 300,
+  MDT: -360,
+  MESZ: 120,
+  MEZ: 60,
+  MHT: 720,
+  MMT: 390,
+  MSD: 240,
+  MSK: 180,
+  MST: -420,
+  MT: {
+    timezoneOffsetDuringDst: -360,
+    timezoneOffsetNonDst: -420,
+    dstStart: (r) => R(r, p.MARCH, f.SUNDAY, 2, 2),
+    dstEnd: (r) => R(r, p.NOVEMBER, f.SUNDAY, 1, 2)
+  },
+  MUT: 240,
+  MVT: 300,
+  MYT: 480,
+  NCT: 660,
+  NDT: -90,
+  NFT: 690,
+  NOVST: 420,
+  NOVT: 360,
+  NPT: 345,
+  NST: -150,
+  NUT: -660,
+  NZDT: 780,
+  NZST: 720,
+  OMSST: 420,
+  OMST: 420,
+  PDT: -420,
+  PET: -300,
+  PETST: 720,
+  PETT: 720,
+  PGT: 600,
+  PHOT: 780,
+  PHT: 480,
+  PKT: 300,
+  PMDT: -120,
+  PMST: -180,
+  PONT: 660,
+  PST: -480,
+  PT: {
+    timezoneOffsetDuringDst: -420,
+    timezoneOffsetNonDst: -480,
+    dstStart: (r) => R(r, p.MARCH, f.SUNDAY, 2, 2),
+    dstEnd: (r) => R(r, p.NOVEMBER, f.SUNDAY, 1, 2)
+  },
+  PWT: 540,
+  PYST: -180,
+  PYT: -240,
+  RET: 240,
+  SAMT: 240,
+  SAST: 120,
+  SBT: 660,
+  SCT: 240,
+  SGT: 480,
+  SRT: -180,
+  SST: -660,
+  TAHT: -600,
+  TFT: 300,
+  TJT: 300,
+  TKT: 780,
+  TLT: 540,
+  TMT: 300,
+  TVT: 720,
+  ULAT: 480,
+  UTC: 0,
+  UYST: -120,
+  UYT: -180,
+  UZT: 300,
+  VET: -210,
+  VLAST: 660,
+  VLAT: 660,
+  VUT: 660,
+  WAST: 120,
+  WAT: 60,
+  WEST: 60,
+  WESZ: 60,
+  WET: 0,
+  WEZ: 0,
+  WFT: 720,
+  WGST: -120,
+  WGT: -180,
+  WIB: 420,
+  WIT: 540,
+  WITA: 480,
+  WST: 780,
+  WT: 0,
+  YAKST: 600,
+  YAKT: 600,
+  YAPT: 600,
+  YEKST: 360,
+  YEKT: 360
+};
+function R(r, e, t, n, s = 0) {
+  let i = 0, a = 0;
+  for (; a < n; )
+    i++, new Date(r, e - 1, i).getDay() === t && a++;
+  return new Date(r, e - 1, i, s);
+}
+function me(r, e, t, n = 0) {
+  const s = t === 0 ? 7 : t, i = new Date(r, e - 1 + 1, 1, 12), a = i.getDay() === 0 ? 7 : i.getDay();
+  let o;
+  return a === s ? o = 7 : a < s ? o = 7 + a - s : o = a - s, i.setDate(i.getDate() - o), new Date(r, e - 1, i.getDate(), n);
+}
+function ze(r, e, t = {}) {
+  if (r == null)
+    return null;
+  if (typeof r == "number")
+    return r;
+  const n = t[r] ?? at[r];
+  return n == null ? null : typeof n == "number" ? n : e == null ? null : e > n.dstStart(e.getFullYear()) && !(e > n.dstEnd(e.getFullYear())) ? n.timezoneOffsetDuringDst : n.timezoneOffsetNonDst;
+}
+const ot = {
+  day: 0,
+  second: 0,
+  millisecond: 0
+};
+function T(r, e) {
+  let t = new Date(r);
+  if (e.y && (e.year = e.y, delete e.y), e.mo && (e.month = e.mo, delete e.mo), e.M && (e.month = e.M, delete e.M), e.w && (e.week = e.w, delete e.w), e.d && (e.day = e.d, delete e.d), e.h && (e.hour = e.h, delete e.h), e.m && (e.minute = e.m, delete e.m), e.s && (e.second = e.s, delete e.s), e.ms && (e.millisecond = e.ms, delete e.ms), "year" in e) {
+    const n = Math.floor(e.year);
+    t.setFullYear(t.getFullYear() + n);
+    const s = e.year - n;
+    s > 0 && (e.month = e?.month ?? 0, e.month += s * 12);
+  }
+  if ("quarter" in e) {
+    const n = Math.floor(e.quarter);
+    t.setMonth(t.getMonth() + n * 3);
+  }
+  if ("month" in e) {
+    const n = Math.floor(e.month);
+    t.setMonth(t.getMonth() + n);
+    const s = e.month - n;
+    s > 0 && (e.week = e?.week ?? 0, e.week += s * 4);
+  }
+  if ("week" in e) {
+    const n = Math.floor(e.week);
+    t.setDate(t.getDate() + n * 7);
+    const s = e.week - n;
+    s > 0 && (e.day = e?.day ?? 0, e.day += Math.round(s * 7));
+  }
+  if ("day" in e) {
+    const n = Math.floor(e.day);
+    t.setDate(t.getDate() + n);
+    const s = e.day - n;
+    s > 0 && (e.hour = e?.hour ?? 0, e.hour += Math.round(s * 24));
+  }
+  if ("hour" in e) {
+    const n = Math.floor(e.hour);
+    t.setHours(t.getHours() + n);
+    const s = e.hour - n;
+    s > 0 && (e.minute = e?.minute ?? 0, e.minute += Math.round(s * 60));
+  }
+  if ("minute" in e) {
+    const n = Math.floor(e.minute);
+    t.setMinutes(t.getMinutes() + n);
+    const s = e.minute - n;
+    s > 0 && (e.second = e?.second ?? 0, e.second += Math.round(s * 60));
+  }
+  if ("second" in e) {
+    const n = Math.floor(e.second);
+    t.setSeconds(t.getSeconds() + n);
+    const s = e.second - n;
+    s > 0 && (e.millisecond = e?.millisecond ?? 0, e.millisecond += Math.round(s * 1e3));
+  }
+  if ("millisecond" in e) {
+    const n = Math.floor(e.millisecond);
+    t.setMilliseconds(t.getMilliseconds() + n);
+  }
+  return t;
+}
+function k(r) {
+  const e = {};
+  for (const t in r)
+    e[t] = -r[t];
+  return e;
+}
+class E {
+  instant;
+  timezoneOffset;
+  constructor(e, t) {
+    this.instant = e ?? /* @__PURE__ */ new Date(), this.timezoneOffset = t ?? null;
+  }
+  static fromDate(e) {
+    return new E(e);
+  }
+  static fromInput(e, t) {
+    if (e instanceof Date)
+      return E.fromDate(e);
+    const n = e?.instant ?? /* @__PURE__ */ new Date(), s = ze(e?.timezone, n, t);
+    return new E(n, s);
+  }
+  getDateWithAdjustedTimezone() {
+    const e = new Date(this.instant);
+    return this.timezoneOffset !== null && e.setMinutes(e.getMinutes() - this.getSystemTimezoneAdjustmentMinute(this.instant)), e;
+  }
+  getSystemTimezoneAdjustmentMinute(e, t) {
+    e || (e = /* @__PURE__ */ new Date());
+    const n = -e.getTimezoneOffset(), s = t ?? this.timezoneOffset ?? n;
+    return n - s;
+  }
+  getTimezoneOffset() {
+    return this.timezoneOffset ?? -this.instant.getTimezoneOffset();
+  }
+}
+class d {
+  knownValues;
+  impliedValues;
+  reference;
+  _tags = /* @__PURE__ */ new Set();
+  constructor(e, t) {
+    if (this.reference = e, this.knownValues = {}, this.impliedValues = {}, t)
+      for (const s in t)
+        this.knownValues[s] = t[s];
+    const n = e.getDateWithAdjustedTimezone();
+    this.imply("day", n.getDate()), this.imply("month", n.getMonth() + 1), this.imply("year", n.getFullYear()), this.imply("hour", 12), this.imply("minute", 0), this.imply("second", 0), this.imply("millisecond", 0);
+  }
+  static createRelativeFromReference(e, t = ot) {
+    let n = T(e.getDateWithAdjustedTimezone(), t);
+    const s = new d(e);
+    return s.addTag("result/relativeDate"), "hour" in t || "minute" in t || "second" in t || "millisecond" in t ? (s.addTag("result/relativeDateAndTime"), ve(s, n), P(s, n), s.assign("timezoneOffset", e.getTimezoneOffset())) : (S(s, n), s.imply("timezoneOffset", e.getTimezoneOffset()), "day" in t ? (s.assign("day", n.getDate()), s.assign("month", n.getMonth() + 1), s.assign("year", n.getFullYear()), s.assign("weekday", n.getDay())) : "week" in t ? (s.assign("day", n.getDate()), s.assign("month", n.getMonth() + 1), s.assign("year", n.getFullYear()), s.imply("weekday", n.getDay())) : (s.imply("day", n.getDate()), "month" in t ? (s.assign("month", n.getMonth() + 1), s.assign("year", n.getFullYear())) : (s.imply("month", n.getMonth() + 1), "year" in t ? s.assign("year", n.getFullYear()) : s.imply("year", n.getFullYear())))), s;
+  }
+  get(e) {
+    return e in this.knownValues ? this.knownValues[e] : e in this.impliedValues ? this.impliedValues[e] : null;
+  }
+  isCertain(e) {
+    return e in this.knownValues;
+  }
+  getCertainComponents() {
+    return Object.keys(this.knownValues);
+  }
+  imply(e, t) {
+    return e in this.knownValues ? this : (this.impliedValues[e] = t, this);
+  }
+  assign(e, t) {
+    return this.knownValues[e] = t, delete this.impliedValues[e], this;
+  }
+  addDurationAsImplied(e) {
+    const t = this.dateWithoutTimezoneAdjustment(), n = T(t, e);
+    return ("day" in e || "week" in e || "month" in e || "year" in e) && (this.delete(["day", "weekday", "month", "year"]), this.imply("day", n.getDate()), this.imply("weekday", n.getDay()), this.imply("month", n.getMonth() + 1), this.imply("year", n.getFullYear())), ("second" in e || "minute" in e || "hour" in e) && (this.delete(["second", "minute", "hour"]), this.imply("second", n.getSeconds()), this.imply("minute", n.getMinutes()), this.imply("hour", n.getHours())), this;
+  }
+  delete(e) {
+    typeof e == "string" && (e = [e]);
+    for (const t of e)
+      delete this.knownValues[t], delete this.impliedValues[t];
+  }
+  clone() {
+    const e = new d(this.reference);
+    e.knownValues = {}, e.impliedValues = {};
+    for (const t in this.knownValues)
+      e.knownValues[t] = this.knownValues[t];
+    for (const t in this.impliedValues)
+      e.impliedValues[t] = this.impliedValues[t];
+    return e;
+  }
+  isOnlyDate() {
+    return !this.isCertain("hour") && !this.isCertain("minute") && !this.isCertain("second");
+  }
+  isOnlyTime() {
+    return !this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month") && !this.isCertain("year");
+  }
+  isOnlyWeekdayComponent() {
+    return this.isCertain("weekday") && !this.isCertain("day") && !this.isCertain("month");
+  }
+  isDateWithUnknownYear() {
+    return this.isCertain("month") && !this.isCertain("year");
+  }
+  isValidDate() {
+    const e = new Date(Date.UTC(this.get("year"), this.get("month") - 1, this.get("day"), this.get("hour"), this.get("minute"), this.get("second"), this.get("millisecond")));
+    return e.setUTCFullYear(this.get("year")), !(e.getUTCFullYear() !== this.get("year") || e.getUTCMonth() !== this.get("month") - 1 || e.getUTCDate() !== this.get("day") || this.get("hour") != null && e.getUTCHours() != this.get("hour") || this.get("minute") != null && e.getUTCMinutes() != this.get("minute"));
+  }
+  toString() {
+    return `[ParsingComponents {
+            tags: ${JSON.stringify(Array.from(this._tags).sort())}, 
+            knownValues: ${JSON.stringify(this.knownValues)}, 
+            impliedValues: ${JSON.stringify(this.impliedValues)}}, 
+            reference: ${JSON.stringify(this.reference)}]`;
+  }
+  date() {
+    const e = this.get("timezoneOffset") ?? this.reference.timezoneOffset;
+    if (e == null)
+      return this.dateWithoutTimezoneAdjustment();
+    const t = new Date(Date.UTC(this.get("year"), this.get("month") - 1, this.get("day"), this.get("hour"), this.get("minute"), this.get("second"), this.get("millisecond")));
+    return t.setUTCFullYear(this.get("year")), new Date(t.getTime() - e * 6e4);
+  }
+  addTag(e) {
+    return this._tags.add(e), this;
+  }
+  addTags(e) {
+    for (const t of e)
+      this._tags.add(t);
+    return this;
+  }
+  tags() {
+    return new Set(this._tags);
+  }
+  dateWithoutTimezoneAdjustment() {
+    const e = new Date(this.get("year"), this.get("month") - 1, this.get("day"), this.get("hour"), this.get("minute"), this.get("second"), this.get("millisecond"));
+    return e.setFullYear(this.get("year")), e;
+  }
+}
+class D {
+  refDate;
+  index;
+  text;
+  reference;
+  start;
+  end;
+  constructor(e, t, n, s, i) {
+    this.reference = e, this.refDate = e.instant, this.index = t, this.text = n, this.start = s || new d(e), this.end = i;
+  }
+  clone() {
+    const e = new D(this.reference, this.index, this.text);
+    return e.start = this.start ? this.start.clone() : null, e.end = this.end ? this.end.clone() : null, e;
+  }
+  date() {
+    return this.start.date();
+  }
+  addTag(e) {
+    return this.start.addTag(e), this.end && this.end.addTag(e), this;
+  }
+  addTags(e) {
+    return this.start.addTags(e), this.end && this.end.addTags(e), this;
+  }
+  tags() {
+    const e = new Set(this.start.tags());
+    if (this.end)
+      for (const t of this.end.tags())
+        e.add(t);
+    return e;
+  }
+  toString() {
+    const e = Array.from(this.tags()).sort();
+    return `[ParsingResult {index: ${this.index}, text: '${this.text}', tags: ${JSON.stringify(e)} ...}]`;
+  }
+}
+function Q(r, e, t = "\\s{0,5},?\\s{0,5}") {
+  const n = e.replace(/\((?!\?)/g, "(?:");
+  return `${r}${n}(?:${t}${n}){0,10}`;
+}
+function lt(r) {
+  let e;
+  return r instanceof Array ? e = [...r] : r instanceof Map ? e = Array.from(r.keys()) : e = Object.keys(r), e;
+}
+function h(r) {
+  return `(?:${lt(r).sort((t, n) => n.length - t.length).join("|").replace(/\./g, "\\.")})`;
+}
+function Be(r) {
+  return r < 100 && (r > 50 ? r = r + 1900 : r = r + 2e3), r;
+}
+function M(r, e, t) {
+  let n = new Date(r);
+  n.setMonth(t - 1), n.setDate(e);
+  const s = T(n, { year: 1 }), i = T(n, { year: -1 });
+  return Math.abs(s.getTime() - r.getTime()) < Math.abs(n.getTime() - r.getTime()) ? n = s : Math.abs(i.getTime() - r.getTime()) < Math.abs(n.getTime() - r.getTime()) && (n = i), n.getFullYear();
+}
+const K = {
+  sunday: 0,
+  sun: 0,
+  "sun.": 0,
+  monday: 1,
+  mon: 1,
+  "mon.": 1,
+  tuesday: 2,
+  tue: 2,
+  "tue.": 2,
+  wednesday: 3,
+  wed: 3,
+  "wed.": 3,
+  thursday: 4,
+  thurs: 4,
+  "thurs.": 4,
+  thur: 4,
+  "thur.": 4,
+  thu: 4,
+  "thu.": 4,
+  friday: 5,
+  fri: 5,
+  "fri.": 5,
+  saturday: 6,
+  sat: 6,
+  "sat.": 6
+}, Le = {
+  january: 1,
+  february: 2,
+  march: 3,
+  april: 4,
+  may: 5,
+  june: 6,
+  july: 7,
+  august: 8,
+  september: 9,
+  october: 10,
+  november: 11,
+  december: 12
+}, w = {
+  ...Le,
+  jan: 1,
+  "jan.": 1,
+  feb: 2,
+  "feb.": 2,
+  mar: 3,
+  "mar.": 3,
+  apr: 4,
+  "apr.": 4,
+  jun: 6,
+  "jun.": 6,
+  jul: 7,
+  "jul.": 7,
+  aug: 8,
+  "aug.": 8,
+  sep: 9,
+  "sep.": 9,
+  sept: 9,
+  "sept.": 9,
+  oct: 10,
+  "oct.": 10,
+  nov: 11,
+  "nov.": 11,
+  dec: 12,
+  "dec.": 12
+}, Z = {
+  one: 1,
+  two: 2,
+  three: 3,
+  four: 4,
+  five: 5,
+  six: 6,
+  seven: 7,
+  eight: 8,
+  nine: 9,
+  ten: 10,
+  eleven: 11,
+  twelve: 12
+}, q = {
+  first: 1,
+  second: 2,
+  third: 3,
+  fourth: 4,
+  fifth: 5,
+  sixth: 6,
+  seventh: 7,
+  eighth: 8,
+  ninth: 9,
+  tenth: 10,
+  eleventh: 11,
+  twelfth: 12,
+  thirteenth: 13,
+  fourteenth: 14,
+  fifteenth: 15,
+  sixteenth: 16,
+  seventeenth: 17,
+  eighteenth: 18,
+  nineteenth: 19,
+  twentieth: 20,
+  "twenty first": 21,
+  "twenty-first": 21,
+  "twenty second": 22,
+  "twenty-second": 22,
+  "twenty third": 23,
+  "twenty-third": 23,
+  "twenty fourth": 24,
+  "twenty-fourth": 24,
+  "twenty fifth": 25,
+  "twenty-fifth": 25,
+  "twenty sixth": 26,
+  "twenty-sixth": 26,
+  "twenty seventh": 27,
+  "twenty-seventh": 27,
+  "twenty eighth": 28,
+  "twenty-eighth": 28,
+  "twenty ninth": 29,
+  "twenty-ninth": 29,
+  thirtieth: 30,
+  "thirty first": 31,
+  "thirty-first": 31
+}, He = {
+  second: "second",
+  seconds: "second",
+  minute: "minute",
+  minutes: "minute",
+  hour: "hour",
+  hours: "hour",
+  day: "day",
+  days: "day",
+  week: "week",
+  weeks: "week",
+  month: "month",
+  months: "month",
+  quarter: "quarter",
+  quarters: "quarter",
+  year: "year",
+  years: "year"
+}, G = {
+  s: "second",
+  sec: "second",
+  second: "second",
+  seconds: "second",
+  m: "minute",
+  min: "minute",
+  mins: "minute",
+  minute: "minute",
+  minutes: "minute",
+  h: "hour",
+  hr: "hour",
+  hrs: "hour",
+  hour: "hour",
+  hours: "hour",
+  d: "day",
+  day: "day",
+  days: "day",
+  w: "week",
+  week: "week",
+  weeks: "week",
+  mo: "month",
+  mon: "month",
+  mos: "month",
+  month: "month",
+  months: "month",
+  qtr: "quarter",
+  quarter: "quarter",
+  quarters: "quarter",
+  y: "year",
+  yr: "year",
+  year: "year",
+  years: "year",
+  ...He
+}, je = `(?:${h(Z)}|[0-9]+|[0-9]+\\.[0-9]+|half(?:\\s{0,2}an?)?|an?\\b(?:\\s{0,2}few)?|few|several|the|a?\\s{0,2}couple\\s{0,2}(?:of)?)`;
+function ct(r) {
+  const e = r.toLowerCase();
+  return Z[e] !== void 0 ? Z[e] : e === "a" || e === "an" || e == "the" ? 1 : e.match(/few/) ? 3 : e.match(/half/) ? 0.5 : e.match(/couple/) ? 2 : e.match(/several/) ? 7 : parseFloat(e);
+}
+const F = `(?:${h(q)}|[0-9]{1,2}(?:st|nd|rd|th)?)`;
+function W(r) {
+  let e = r.toLowerCase();
+  return q[e] !== void 0 ? q[e] : (e = e.replace(/(?:st|nd|rd|th)$/i, ""), parseInt(e));
+}
+const v = "(?:[1-9][0-9]{0,3}\\s{0,2}(?:BE|AD|BC|BCE|CE)|[1-9][0-9]{3}|[5-9][0-9]|2[0-5])";
+function _(r) {
+  if (/BE/i.test(r))
+    return r = r.replace(/BE/i, ""), parseInt(r) - 543;
+  if (/BCE?/i.test(r))
+    return r = r.replace(/BCE?/i, ""), -parseInt(r);
+  if (/(AD|CE)/i.test(r))
+    return r = r.replace(/(AD|CE)/i, ""), parseInt(r);
+  const e = parseInt(r);
+  return Be(e);
+}
+const Ve = `(${je})\\s{0,3}(${h(G)})`, he = new RegExp(Ve, "i"), ut = `(${je})\\s{0,3}(${h(He)})`, Ke = "\\s{0,5},?(?:\\s*and)?\\s{0,5}", U = Q("(?:(?:about|around)\\s{0,3})?", Ve, Ke), z = Q("(?:(?:about|around)\\s{0,3})?", ut, Ke);
+function $(r) {
+  const e = {};
+  let t = r, n = he.exec(t);
+  for (; n; )
+    dt(e, n), t = t.substring(n[0].length).trim(), n = he.exec(t);
+  return Object.keys(e).length == 0 ? null : e;
+}
+function dt(r, e) {
+  if (e[0].match(/^[a-zA-Z]+$/))
+    return;
+  const t = ct(e[1]), n = G[e[2].toLowerCase()];
+  r[n] = t;
+}
+class g {
+  innerPatternHasChange(e, t) {
+    return this.innerPattern(e) !== t;
+  }
+  patternLeftBoundary() {
+    return "(\\W|^)";
+  }
+  cachedInnerPattern = null;
+  cachedPattern = null;
+  pattern(e) {
+    return this.cachedInnerPattern && !this.innerPatternHasChange(e, this.cachedInnerPattern) ? this.cachedPattern : (this.cachedInnerPattern = this.innerPattern(e), this.cachedPattern = new RegExp(`${this.patternLeftBoundary()}${this.cachedInnerPattern.source}`, this.cachedInnerPattern.flags), this.cachedPattern);
+  }
+  extract(e, t) {
+    const n = t[1] ?? "";
+    t.index = t.index + n.length, t[0] = t[0].substring(n.length);
+    for (let s = 2; s < t.length; s++)
+      t[s - 1] = t[s];
+    return this.innerExtract(e, t);
+  }
+}
+const ft = new RegExp(`(?:(?:within|in|for)\\s*)?(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${U})(?=\\W|$)`, "i"), gt = new RegExp(`(?:within|in|for)\\s*(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${U})(?=\\W|$)`, "i"), mt = new RegExp(`(?:within|in|for)\\s*(?:(?:about|around|roughly|approximately|just)\\s*(?:~\\s*)?)?(${z})(?=\\W|$)`, "i");
+class ht extends g {
+  strictMode;
+  constructor(e) {
+    super(), this.strictMode = e;
+  }
+  innerPattern(e) {
+    return this.strictMode ? mt : e.option.forwardDate ? ft : gt;
+  }
+  innerExtract(e, t) {
+    if (t[0].match(/^for\s*the\s*\w+/))
+      return null;
+    const n = $(t[1]);
+    return n ? d.createRelativeFromReference(e.reference, n) : null;
+  }
+}
+const Tt = new RegExp(`(?:on\\s{0,3})?(${F})(?:\\s{0,3}(?:to|\\-|\\–|until|through|till)\\s{0,3}(${F}))?(?:-|/|\\s{0,3}(?:of)?\\s{0,3})(${h(w)})(?:(?:-|/|,?\\s{0,3})(${v}(?!\\w)))?(?=\\W|$)`, "i"), Te = 1, ye = 2, yt = 3, pe = 4;
+class pt extends g {
+  innerPattern() {
+    return Tt;
+  }
+  innerExtract(e, t) {
+    const n = e.createParsingResult(t.index, t[0]), s = w[t[yt].toLowerCase()], i = W(t[Te]);
+    if (i > 31)
+      return t.index = t.index + t[Te].length, null;
+    if (n.start.assign("month", s), n.start.assign("day", i), t[pe]) {
+      const a = _(t[pe]);
+      n.start.assign("year", a);
+    } else {
+      const a = M(e.refDate, i, s);
+      n.start.imply("year", a);
+    }
+    if (t[ye]) {
+      const a = W(t[ye]);
+      n.end = n.start.clone(), n.end.assign("day", a);
+    }
+    return n;
+  }
+}
+const Et = new RegExp(`(${h(w)})(?:-|/|\\s*,?\\s*)(${F})(?!\\s*(?:am|pm))\\s*(?:(?:to|\\-)\\s*(${F})\\s*)?(?:(?:-|/|\\s*,\\s*|\\s+)(${v}))?(?=\\W|$)(?!\\:\\d)`, "i"), wt = 1, Ee = 2, L = 3, H = 4;
+class Pt extends g {
+  shouldSkipYearLikeDate;
+  constructor(e) {
+    super(), this.shouldSkipYearLikeDate = e;
+  }
+  innerPattern() {
+    return Et;
+  }
+  innerExtract(e, t) {
+    const n = w[t[wt].toLowerCase()], s = W(t[Ee]);
+    if (s > 31 || this.shouldSkipYearLikeDate && !t[L] && !t[H] && t[Ee].match(/^2[0-5]$/))
+      return null;
+    const i = e.createParsingComponents({
+      day: s,
+      month: n
+    }).addTag("parser/ENMonthNameMiddleEndianParser");
+    if (t[H]) {
+      const l = _(t[H]);
+      i.assign("year", l);
+    } else {
+      const l = M(e.refDate, s, n);
+      i.imply("year", l);
+    }
+    if (!t[L])
+      return i;
+    const a = W(t[L]), o = e.createParsingResult(t.index, t[0]);
+    return o.start = i, o.end = i.clone(), o.end.assign("day", a), o;
+  }
+}
+const Dt = new RegExp(`((?:in)\\s*)?(${h(w)})\\s*(?:(?:,|-|of)?\\s*(${v})?)?(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`, "i"), Rt = 1, At = 2, we = 3;
+class xt extends g {
+  innerPattern() {
+    return Dt;
+  }
+  innerExtract(e, t) {
+    const n = t[At].toLowerCase();
+    if (t[0].length <= 3 && !Le[n])
+      return null;
+    const s = e.createParsingResult(t.index + (t[Rt] || "").length, t.index + t[0].length);
+    s.start.imply("day", 1), s.start.addTag("parser/ENMonthNameParser");
+    const i = w[n];
+    if (s.start.assign("month", i), t[we]) {
+      const a = _(t[we]);
+      s.start.assign("year", a);
+    } else {
+      const a = M(e.refDate, 1, i);
+      s.start.imply("year", a);
+    }
+    return s;
+  }
+}
+const Nt = new RegExp(`([0-9]{4})[-\\.\\/\\s](?:(${h(w)})|([0-9]{1,2}))[-\\.\\/\\s]([0-9]{1,2})(?=\\W|$)`, "i"), Ot = 1, Mt = 2, Pe = 3, $t = 4;
+class Ct extends g {
+  strictMonthDateOrder;
+  constructor(e) {
+    super(), this.strictMonthDateOrder = e;
+  }
+  innerPattern() {
+    return Nt;
+  }
+  innerExtract(e, t) {
+    const n = parseInt(t[Ot]);
+    let s = parseInt(t[$t]), i = t[Pe] ? parseInt(t[Pe]) : w[t[Mt].toLowerCase()];
+    if (i < 1 || i > 12) {
+      if (this.strictMonthDateOrder)
+        return null;
+      s >= 1 && s <= 12 && ([i, s] = [s, i]);
+    }
+    return s < 1 || s > 31 ? null : {
+      day: s,
+      month: i,
+      year: n
+    };
+  }
+}
+const St = "(?:[1-9][0-9]{0,3}\\s{0,2}(?:BE|AD|BC|BCE|CE)|[1-9][0-9]{3})", _t = new RegExp(`(${St})(?:\\s*[-.\\/,]?\\s*|\\s+of\\s+)(${h(w)})(?=[^\\s\\w]|\\s+[^0-9]|\\s+$|$)`, "i"), Ut = 1, It = 2;
+class bt extends g {
+  innerPattern() {
+    return _t;
+  }
+  innerExtract(e, t) {
+    const n = _(t[Ut]), s = t[It].toLowerCase(), i = w[s], a = e.createParsingResult(t.index, t[0]);
+    return a.start.imply("day", 1), a.start.assign("month", i), a.start.assign("year", n), a.start.addTag("parser/ENYearMonthNameParser"), a;
+  }
+}
+const Yt = new RegExp("([0-9]|0[1-9]|1[012])/([0-9]{4})", "i"), Ft = 1, Wt = 2;
+class kt extends g {
+  innerPattern() {
+    return Yt;
+  }
+  innerExtract(e, t) {
+    const n = parseInt(t[Wt]), s = parseInt(t[Ft]);
+    return e.createParsingComponents().imply("day", 1).assign("month", s).assign("year", n);
+  }
+}
+function Gt(r, e, t, n) {
+  return new RegExp(`${r}${e}(\\d{1,4})(?:(?:\\.|:|：)(\\d{1,2})(?:(?::|：)(\\d{2})(?:\\.(\\d{1,6}))?)?)?(?:\\s*(a\\.m\\.|p\\.m\\.|am?|pm?))?${t}`, n);
+}
+function vt(r, e) {
+  return new RegExp(`^(${r})(\\d{1,4})(?:(?:\\.|\\:|\\：)(\\d{1,2})(?:(?:\\.|\\:|\\：)(\\d{1,2})(?:\\.(\\d{1,6}))?)?)?(?:\\s*(a\\.m\\.|p\\.m\\.|am?|pm?))?${e}`, "i");
+}
+const j = 2, A = 3, b = 4, Y = 5, x = 6;
+class ee {
+  strictMode;
+  constructor(e = !1) {
+    this.strictMode = e;
+  }
+  patternFlags() {
+    return "i";
+  }
+  primaryPatternLeftBoundary() {
+    return "(^|\\s|T|\\b)";
+  }
+  primarySuffix() {
+    return "(?!/)(?=\\W|$)";
+  }
+  followingSuffix() {
+    return "(?!/)(?=\\W|$)";
+  }
+  pattern(e) {
+    return this.getPrimaryTimePatternThroughCache();
+  }
+  extract(e, t) {
+    const n = this.extractPrimaryTimeComponents(e, t);
+    if (!n)
+      return t[0].match(/^\d{4}/) ? (t.index += 4, null) : (t.index += t[0].length, null);
+    const s = t.index + t[1].length, i = t[0].substring(t[1].length), a = e.createParsingResult(s, i, n);
+    t.index += t[0].length;
+    const o = e.text.substring(t.index), u = this.getFollowingTimePatternThroughCache().exec(o);
+    return i.match(/^\d{3,4}/) && u && (u[0].match(/^\s*([+-])\s*\d{2,4}$/) || u[0].match(/^\s*([+-])\s*\d{2}\W\d{2}/)) ? null : !u || u[0].match(/^\s*([+-])\s*\d{3,4}$/) ? this.checkAndReturnWithoutFollowingPattern(a) : (a.end = this.extractFollowingTimeComponents(e, u, a), a.end && (a.text += u[0]), this.checkAndReturnWithFollowingPattern(a));
+  }
+  extractPrimaryTimeComponents(e, t, n = !1) {
+    const s = e.createParsingComponents();
+    let i = 0, a = null, o = parseInt(t[j]);
+    if (o > 100) {
+      if (t[j].length == 4 && t[A] == null && !t[x] || this.strictMode || t[A] != null)
+        return null;
+      i = o % 100, o = Math.floor(o / 100);
+    }
+    if (o > 24)
+      return null;
+    if (t[A] != null) {
+      if (t[A].length == 1 && !t[x])
+        return null;
+      i = parseInt(t[A]);
+    }
+    if (i >= 60)
+      return null;
+    if (o > 12 && (a = c.PM), t[x] != null) {
+      if (o > 12)
+        return null;
+      const l = t[x][0].toLowerCase();
+      l == "a" && (a = c.AM, o == 12 && (o = 0)), l == "p" && (a = c.PM, o != 12 && (o += 12));
+    }
+    if (s.assign("hour", o), s.assign("minute", i), a !== null ? s.assign("meridiem", a) : o < 12 ? s.imply("meridiem", c.AM) : s.imply("meridiem", c.PM), t[Y] != null) {
+      const l = parseInt(t[Y].substring(0, 3));
+      if (l >= 1e3)
+        return null;
+      s.assign("millisecond", l);
+    }
+    if (t[b] != null) {
+      const l = parseInt(t[b]);
+      if (l >= 60)
+        return null;
+      s.assign("second", l);
+    }
+    return s;
+  }
+  extractFollowingTimeComponents(e, t, n) {
+    const s = e.createParsingComponents();
+    if (t[Y] != null) {
+      const l = parseInt(t[Y].substring(0, 3));
+      if (l >= 1e3)
+        return null;
+      s.assign("millisecond", l);
+    }
+    if (t[b] != null) {
+      const l = parseInt(t[b]);
+      if (l >= 60)
+        return null;
+      s.assign("second", l);
+    }
+    let i = parseInt(t[j]), a = 0, o = -1;
+    if (t[A] != null ? a = parseInt(t[A]) : i > 100 && (a = i % 100, i = Math.floor(i / 100)), a >= 60 || i > 24)
+      return null;
+    if (i >= 12 && (o = c.PM), t[x] != null) {
+      if (i > 12)
+        return null;
+      const l = t[x][0].toLowerCase();
+      l == "a" && (o = c.AM, i == 12 && (i = 0, s.isCertain("day") || s.imply("day", s.get("day") + 1))), l == "p" && (o = c.PM, i != 12 && (i += 12)), n.start.isCertain("meridiem") || (o == c.AM ? (n.start.imply("meridiem", c.AM), n.start.get("hour") == 12 && n.start.assign("hour", 0)) : (n.start.imply("meridiem", c.PM), n.start.get("hour") != 12 && n.start.assign("hour", n.start.get("hour") + 12)));
+    }
+    return s.assign("hour", i), s.assign("minute", a), o >= 0 ? s.assign("meridiem", o) : n.start.isCertain("meridiem") && n.start.get("hour") > 12 ? n.start.get("hour") - 12 > i ? s.imply("meridiem", c.AM) : i <= 12 && (s.assign("hour", i + 12), s.assign("meridiem", c.PM)) : i > 12 ? s.imply("meridiem", c.PM) : i <= 12 && s.imply("meridiem", c.AM), s.date().getTime() < n.start.date().getTime() && s.imply("day", s.get("day") + 1), s;
+  }
+  checkAndReturnWithoutFollowingPattern(e) {
+    if (e.text.match(/^\d$/) || e.text.match(/^\d\d\d+$/) || e.text.match(/\d[apAP]$/))
+      return null;
+    const t = e.text.match(/[^\d:.](\d[\d.]+)$/);
+    if (t) {
+      const n = t[1];
+      if (this.strictMode || n.includes(".") && !n.match(/\d(\.\d{2})+$/) || parseInt(n) > 24)
+        return null;
+    }
+    return e;
+  }
+  checkAndReturnWithFollowingPattern(e) {
+    if (e.text.match(/^\d+-\d+$/))
+      return null;
+    const t = e.text.match(/[^\d:.](\d[\d.]+)\s*-\s*(\d[\d.]+)$/);
+    if (t) {
+      if (this.strictMode)
+        return null;
+      const n = t[1], s = t[2];
+      if (s.includes(".") && !s.match(/\d(\.\d{2})+$/))
+        return null;
+      const i = parseInt(s), a = parseInt(n);
+      if (i > 24 || a > 24)
+        return null;
+    }
+    return e;
+  }
+  cachedPrimaryPrefix = null;
+  cachedPrimarySuffix = null;
+  cachedPrimaryTimePattern = null;
+  getPrimaryTimePatternThroughCache() {
+    const e = this.primaryPrefix(), t = this.primarySuffix();
+    return this.cachedPrimaryPrefix === e && this.cachedPrimarySuffix === t ? this.cachedPrimaryTimePattern : (this.cachedPrimaryTimePattern = Gt(this.primaryPatternLeftBoundary(), e, t, this.patternFlags()), this.cachedPrimaryPrefix = e, this.cachedPrimarySuffix = t, this.cachedPrimaryTimePattern);
+  }
+  cachedFollowingPhase = null;
+  cachedFollowingSuffix = null;
+  cachedFollowingTimePatten = null;
+  getFollowingTimePatternThroughCache() {
+    const e = this.followingPhase(), t = this.followingSuffix();
+    return this.cachedFollowingPhase === e && this.cachedFollowingSuffix === t ? this.cachedFollowingTimePatten : (this.cachedFollowingTimePatten = vt(e, t), this.cachedFollowingPhase = e, this.cachedFollowingSuffix = t, this.cachedFollowingTimePatten);
+  }
+}
+class zt extends ee {
+  constructor(e) {
+    super(e);
+  }
+  followingPhase() {
+    return "\\s*(?:\\-|\\–|\\~|\\〜|to|until|through|till|\\?)\\s*";
+  }
+  primaryPrefix() {
+    return "(?:(?:at|from)\\s*)??";
+  }
+  primarySuffix() {
+    return "(?:\\s*(?:o\\W*clock|at\\s*night|in\\s*the\\s*(?:morning|afternoon)))?(?!/)(?=\\W|$)";
+  }
+  extractPrimaryTimeComponents(e, t) {
+    const n = super.extractPrimaryTimeComponents(e, t);
+    if (!n)
+      return n;
+    if (t[0].endsWith("night")) {
+      const s = n.get("hour");
+      s >= 6 && s < 12 ? (n.assign("hour", n.get("hour") + 12), n.assign("meridiem", c.PM)) : s < 6 && n.assign("meridiem", c.AM);
+    }
+    if (t[0].endsWith("afternoon")) {
+      n.assign("meridiem", c.PM);
+      const s = n.get("hour");
+      s >= 0 && s <= 6 && n.assign("hour", n.get("hour") + 12);
+    }
+    return t[0].endsWith("morning") && (n.assign("meridiem", c.AM), n.get("hour") < 12 && n.assign("hour", n.get("hour"))), n.addTag("parser/ENTimeExpressionParser");
+  }
+  extractFollowingTimeComponents(e, t, n) {
+    const s = super.extractFollowingTimeComponents(e, t, n);
+    return s && s.addTag("parser/ENTimeExpressionParser"), s;
+  }
+}
+const Bt = new RegExp(`(${U})\\s{0,5}(?:ago|before|earlier)(?=\\W|$)`, "i"), Lt = new RegExp(`(${z})\\s{0,5}(?:ago|before|earlier)(?=\\W|$)`, "i");
+class Ht extends g {
+  strictMode;
+  constructor(e) {
+    super(), this.strictMode = e;
+  }
+  innerPattern() {
+    return this.strictMode ? Lt : Bt;
+  }
+  innerExtract(e, t) {
+    const n = $(t[1]);
+    return n ? d.createRelativeFromReference(e.reference, k(n)) : null;
+  }
+}
+const jt = new RegExp(`(${U})\\s{0,5}(?:later|after|from now|henceforth|forward|out)(?=(?:\\W|$))`, "i"), Vt = new RegExp(`(${z})\\s{0,5}(later|after|from now)(?=\\W|$)`, "i"), Kt = 1;
+class Zt extends g {
+  strictMode;
+  constructor(e) {
+    super(), this.strictMode = e;
+  }
+  innerPattern() {
+    return this.strictMode ? Vt : jt;
+  }
+  innerExtract(e, t) {
+    const n = $(t[Kt]);
+    return n ? d.createRelativeFromReference(e.reference, n) : null;
+  }
+}
+class Ze {
+  refine(e, t) {
+    return t.filter((n) => this.isValid(e, n));
+  }
+}
+class I {
+  refine(e, t) {
+    if (t.length < 2)
+      return t;
+    const n = [];
+    let s = t[0], i = null;
+    for (let a = 1; a < t.length; a++) {
+      i = t[a];
+      const o = e.text.substring(s.index + s.text.length, i.index);
+      if (!this.shouldMergeResults(o, s, i, e))
+        n.push(s), s = i;
+      else {
+        const l = s, u = i, m = this.mergeResults(o, l, u, e);
+        e.debug(() => {
+          console.log(`${this.constructor.name} merged ${l} and ${u} into ${m}`);
+        }), s = m;
+      }
+    }
+    return s != null && n.push(s), n;
+  }
+}
+class te extends I {
+  shouldMergeResults(e, t, n) {
+    return !t.end && !n.end && e.match(this.patternBetween()) != null;
+  }
+  mergeResults(e, t, n) {
+    if (!t.start.isOnlyWeekdayComponent() && !n.start.isOnlyWeekdayComponent() && (n.start.getCertainComponents().forEach((i) => {
+      t.start.isCertain(i) || t.start.imply(i, n.start.get(i));
+    }), t.start.getCertainComponents().forEach((i) => {
+      n.start.isCertain(i) || n.start.imply(i, t.start.get(i));
+    })), t.start.date() > n.start.date()) {
+      let i = t.start.date(), a = n.start.date();
+      n.start.isOnlyWeekdayComponent() && T(a, { day: 7 }) > i ? (a = T(a, { day: 7 }), n.start.imply("day", a.getDate()), n.start.imply("month", a.getMonth() + 1), n.start.imply("year", a.getFullYear())) : t.start.isOnlyWeekdayComponent() && T(i, { day: -7 }) < a ? (i = T(i, { day: -7 }), t.start.imply("day", i.getDate()), t.start.imply("month", i.getMonth() + 1), t.start.imply("year", i.getFullYear())) : n.start.isDateWithUnknownYear() && T(a, { year: 1 }) > i ? (a = T(a, { year: 1 }), n.start.imply("year", a.getFullYear())) : t.start.isDateWithUnknownYear() && T(i, { year: -1 }) < a ? (i = T(i, { year: -1 }), t.start.imply("year", i.getFullYear())) : [n, t] = [t, n];
+    }
+    const s = t.clone();
+    return s.start = t.start, s.end = n.start, s.index = Math.min(t.index, n.index), t.index < n.index ? s.text = t.text + e + n.text : s.text = n.text + e + t.text, s;
+  }
+}
+class qt extends te {
+  patternBetween() {
+    return /^\s*(to|-|–|until|through|till)\s*$/i;
+  }
+}
+function De(r, e) {
+  const t = r.clone(), n = r.start, s = e.start;
+  if (t.start = Re(n, s), r.end != null || e.end != null) {
+    const i = r.end == null ? r.start : r.end, a = e.end == null ? e.start : e.end, o = Re(i, a);
+    if (r.end == null && o.date().getTime() < t.start.date().getTime()) {
+      const l = new Date(o.date().getTime());
+      l.setDate(l.getDate() + 1), o.isCertain("day") ? P(o, l) : N(o, l);
+    }
+    t.end = o;
+  }
+  return t;
+}
+function Re(r, e) {
+  const t = r.clone();
+  e.isCertain("hour") ? (t.assign("hour", e.get("hour")), t.assign("minute", e.get("minute")), e.isCertain("second") ? (t.assign("second", e.get("second")), e.isCertain("millisecond") ? t.assign("millisecond", e.get("millisecond")) : t.imply("millisecond", e.get("millisecond"))) : (t.imply("second", e.get("second")), t.imply("millisecond", e.get("millisecond")))) : (t.imply("hour", e.get("hour")), t.imply("minute", e.get("minute")), t.imply("second", e.get("second")), t.imply("millisecond", e.get("millisecond"))), e.isCertain("timezoneOffset") && t.assign("timezoneOffset", e.get("timezoneOffset"));
+  const n = r.get("meridiem") != null && (r.isCertain("meridiem") || Array.from(r.tags()).some((s) => s.startsWith("casualReference/")));
+  return e.isCertain("meridiem") ? t.assign("meridiem", e.get("meridiem")) : e.get("meridiem") != null && !n && t.imply("meridiem", e.get("meridiem")), t.get("meridiem") == c.PM && t.get("hour") < 12 && (e.isCertain("hour") ? t.assign("hour", t.get("hour") + 12) : t.imply("hour", t.get("hour") + 12)), t.addTags(r.tags()), t.addTags(e.tags()), t;
+}
+class ne extends I {
+  shouldMergeResults(e, t, n) {
+    return (t.start.isOnlyDate() && n.start.isOnlyTime() || n.start.isOnlyDate() && t.start.isOnlyTime()) && e.match(this.patternBetween()) != null;
+  }
+  mergeResults(e, t, n) {
+    const s = t.start.isOnlyDate() ? De(t, n) : De(n, t);
+    return s.index = t.index, s.text = t.text + e + n.text, s;
+  }
+}
+class Ae extends ne {
+  patternBetween() {
+    return new RegExp("^\\s*(T|at|after|before|on|of|,|-|\\.|∙|:)?\\s*$");
+  }
+}
+const Jt = new RegExp("^\\s*,?\\s*\\(?([A-Z]{2,4})\\)?(?=\\W|$)", "i");
+class Xt {
+  timezoneOverrides;
+  constructor(e) {
+    this.timezoneOverrides = e;
+  }
+  refine(e, t) {
+    const n = e.option.timezones ?? {};
+    return t.forEach((s) => {
+      const i = e.text.substring(s.index + s.text.length), a = Jt.exec(i);
+      if (!a)
+        return;
+      const o = a[1].toUpperCase(), l = s.start.date() ?? s.refDate ?? /* @__PURE__ */ new Date(), u = { ...this.timezoneOverrides, ...n }, m = ze(o, l, u);
+      if (m == null)
+        return;
+      e.debug(() => {
+        console.log(`Extracting timezone: '${o}' into: ${m} for: ${s.start}`);
+      });
+      const C = s.start.get("timezoneOffset");
+      C !== null && m != C && (s.start.isCertain("timezoneOffset") || o != a[1]) || s.start.isOnlyDate() && o != a[1] || (s.text += a[0], s.start.isCertain("timezoneOffset") || s.start.assign("timezoneOffset", m), s.end != null && !s.end.isCertain("timezoneOffset") && s.end.assign("timezoneOffset", m));
+    }), t;
+  }
+}
+const Qt = new RegExp("^\\s*(?:\\(?(?:GMT|UTC)\\s?)?([+-])(\\d{1,2})(?::?(\\d{2}))?\\)?", "i"), en = 1, tn = 2, nn = 3;
+class sn {
+  refine(e, t) {
+    return t.forEach(function(n) {
+      if (n.start.isCertain("timezoneOffset"))
+        return;
+      const s = e.text.substring(n.index + n.text.length), i = Qt.exec(s);
+      if (!i)
+        return;
+      e.debug(() => {
+        console.log(`Extracting timezone: '${i[0]}' into : ${n}`);
+      });
+      const a = parseInt(i[tn]), o = parseInt(i[nn] || "0");
+      let l = a * 60 + o;
+      l > 840 || (i[en] === "-" && (l = -l), n.end != null && n.end.assign("timezoneOffset", l), n.start.assign("timezoneOffset", l), n.text += i[0]);
+    }), t;
+  }
+}
+class J {
+  refine(e, t) {
+    if (t.length < 2)
+      return t;
+    const n = [];
+    let s = t[0];
+    for (let i = 1; i < t.length; i++) {
+      const a = t[i];
+      if (a.index >= s.index + s.text.length) {
+        n.push(s), s = a;
+        continue;
+      }
+      let o = null, l = null;
+      a.text.length > s.text.length ? (o = a, l = s) : (o = s, l = a), e.debug(() => {
+        console.log(`${this.constructor.name} remove ${l} by ${o}`);
+      }), s = o;
+    }
+    return s != null && n.push(s), n;
+  }
+}
+function se(r, e, t) {
+  const n = r.getDateWithAdjustedTimezone(), s = rn(n, e, t);
+  let i = new d(r);
+  return i = i.addDurationAsImplied({ day: s }), i.assign("weekday", e), i;
+}
+function rn(r, e, t) {
+  const n = r.getDay();
+  switch (t) {
+    case "this":
+      return O(r, e);
+    case "last":
+      return qe(r, e);
+    case "next":
+      return n == f.SUNDAY ? e == f.SUNDAY ? 7 : e : n == f.SATURDAY ? e == f.SATURDAY ? 7 : e == f.SUNDAY ? 8 : 1 + e : e < n && e != f.SUNDAY ? O(r, e) : O(r, e) + 7;
+  }
+  return an(r, e);
+}
+function an(r, e) {
+  const t = qe(r, e), n = O(r, e);
+  return n < -t ? n : t;
+}
+function O(r, e) {
+  const t = r.getDay();
+  let n = e - t;
+  return n < 0 && (n += 7), n;
+}
+function qe(r, e) {
+  const t = r.getDay();
+  let n = e - t;
+  return n >= 0 && (n -= 7), n;
+}
+class on {
+  refine(e, t) {
+    return e.option.forwardDate && t.forEach((n) => {
+      let s = e.reference.getDateWithAdjustedTimezone();
+      if (n.start.isOnlyTime() && e.reference.instant > n.start.date()) {
+        const i = e.reference.getDateWithAdjustedTimezone(), a = new Date(i);
+        a.setDate(a.getDate() + 1), N(n.start, a), e.debug(() => {
+          console.log(`${this.constructor.name} adjusted ${n} time from the ref date (${i}) to the following day (${a})`);
+        }), n.end && n.end.isOnlyTime() && (N(n.end, a), n.start.date() > n.end.date() && (a.setDate(a.getDate() + 1), N(n.end, a)));
+      }
+      if (n.start.isOnlyWeekdayComponent() && s > n.start.date()) {
+        let i = O(s, n.start.get("weekday")) || 7;
+        const a = T(s, { day: i });
+        if (N(n.start, a), e.debug(() => {
+          console.log(`${this.constructor.name} adjusted ${n} weekday (${n.start})`);
+        }), n.end && n.start.date() > n.end.date()) {
+          let o = O(s, n.start.get("weekday")) || 7;
+          const l = T(s, { day: o });
+          N(n.end, l), e.debug(() => {
+            console.log(`${this.constructor.name} adjusted ${n} weekday (${n.end})`);
+          });
+        }
+      }
+      if (n.start.isDateWithUnknownYear() && s > n.start.date())
+        for (let i = 0; i < 3 && s > n.start.date(); i++)
+          n.start.imply("year", n.start.get("year") + 1), e.debug(() => {
+            console.log(`${this.constructor.name} adjusted ${n} year (${n.start})`);
+          }), n.end && !n.end.isCertain("year") && (n.end.imply("year", n.end.get("year") + 1), e.debug(() => {
+            console.log(`${this.constructor.name} adjusted ${n} month (${n.start})`);
+          }));
+    }), t;
+  }
+}
+class ln extends Ze {
+  strictMode;
+  constructor(e) {
+    super(), this.strictMode = e;
+  }
+  isValid(e, t) {
+    return t.text.replace(" ", "").match(/^\d*(\.\d*)?$/) ? (e.debug(() => {
+      console.log(`Removing unlikely result '${t.text}'`);
+    }), !1) : t.start.isValidDate() ? t.end && !t.end.isValidDate() ? (e.debug(() => {
+      console.log(`Removing invalid result: ${t} (${t.end})`);
+    }), !1) : this.strictMode ? this.isStrictModeValid(e, t) : !0 : (e.debug(() => {
+      console.log(`Removing invalid result: ${t} (${t.start})`);
+    }), !1);
+  }
+  isStrictModeValid(e, t) {
+    return t.start.isOnlyWeekdayComponent() ? (e.debug(() => {
+      console.log(`(Strict) Removing weekday only component: ${t} (${t.end})`);
+    }), !1) : !0;
+  }
+}
+const cn = new RegExp("([0-9]{4})\\-([0-9]{1,2})\\-([0-9]{1,2})(?:T([0-9]{1,2}):([0-9]{1,2})(?::([0-9]{1,2})(?:\\.(\\d{1,4}))?)?(Z|([+-]\\d{2}):?(\\d{2})?)?)?(?=\\W|$)", "i"), un = 1, dn = 2, fn = 3, xe = 4, gn = 5, Ne = 6, Oe = 7, mn = 8, Me = 9, $e = 10;
+class hn extends g {
+  innerPattern() {
+    return cn;
+  }
+  innerExtract(e, t) {
+    const n = e.createParsingComponents({
+      year: parseInt(t[un]),
+      month: parseInt(t[dn]),
+      day: parseInt(t[fn])
+    });
+    if (t[xe] != null && (n.assign("hour", parseInt(t[xe])), n.assign("minute", parseInt(t[gn])), t[Ne] != null && n.assign("second", parseInt(t[Ne])), t[Oe] != null && n.assign("millisecond", parseInt(t[Oe])), t[mn] != null)) {
+      let s = 0;
+      if (t[Me]) {
+        const i = parseInt(t[Me]);
+        let a = 0;
+        t[$e] != null && (a = parseInt(t[$e])), s = i * 60, s < 0 ? s -= a : s += a;
+      }
+      n.assign("timezoneOffset", s);
+    }
+    return n.addTag("parser/ISOFormatParser");
+  }
+}
+class Tn extends I {
+  mergeResults(e, t, n) {
+    const s = n.clone();
+    return s.index = t.index, s.text = t.text + e + s.text, s.start.assign("weekday", t.start.get("weekday")), s.end && s.end.assign("weekday", t.start.get("weekday")), s;
+  }
+  shouldMergeResults(e, t, n) {
+    return t.start.isOnlyWeekdayComponent() && !t.start.isCertain("hour") && n.start.isCertain("day") && e.match(/^,?\s*$/) != null;
+  }
+}
+function re(r, e = !1) {
+  return r.parsers.unshift(new hn()), r.refiners.unshift(new Tn()), r.refiners.unshift(new sn()), r.refiners.unshift(new J()), r.refiners.push(new Xt()), r.refiners.push(new J()), r.refiners.push(new on()), r.refiners.push(new ln(e)), r;
+}
+function ie(r) {
+  const e = r.getDateWithAdjustedTimezone(), t = new d(r, {});
+  return P(t, e), ve(t, e), t.assign("timezoneOffset", r.getTimezoneOffset()), t.addTag("casualReference/now"), t;
+}
+function ae(r) {
+  const e = r.getDateWithAdjustedTimezone(), t = new d(r, {});
+  return P(t, e), S(t, e), t.delete("meridiem"), t.addTag("casualReference/today"), t;
+}
+function oe(r) {
+  return yn(r).addTag("casualReference/yesterday");
+}
+function le(r) {
+  return ce(r, 1).addTag("casualReference/tomorrow");
+}
+function yn(r, e) {
+  return ce(r, -1);
+}
+function ce(r, e) {
+  const t = r.getDateWithAdjustedTimezone(), n = new d(r, {}), s = new Date(t.getTime());
+  return s.setDate(s.getDate() + e), P(n, s), S(n, s), n.delete("meridiem"), n;
+}
+function pn(r, e = 22) {
+  const t = r.getDateWithAdjustedTimezone(), n = new d(r, {});
+  return P(n, t), n.imply("hour", e), n.imply("meridiem", c.PM), n.addTag("casualReference/tonight"), n;
+}
+function En(r, e = 20) {
+  const t = new d(r, {});
+  return t.imply("meridiem", c.PM), t.imply("hour", e), t.addTag("casualReference/evening"), t;
+}
+function wn(r) {
+  const e = new d(r, {});
+  return r.getDateWithAdjustedTimezone().getHours() > 2 && e.addDurationAsImplied({ day: 1 }), e.assign("hour", 0), e.imply("minute", 0), e.imply("second", 0), e.imply("millisecond", 0), e.addTag("casualReference/midnight"), e;
+}
+function Pn(r, e = 6) {
+  const t = new d(r, {});
+  return t.imply("meridiem", c.AM), t.imply("hour", e), t.imply("minute", 0), t.imply("second", 0), t.imply("millisecond", 0), t.addTag("casualReference/morning"), t;
+}
+function Dn(r, e = 15) {
+  const t = new d(r, {});
+  return t.imply("meridiem", c.PM), t.imply("hour", e), t.imply("minute", 0), t.imply("second", 0), t.imply("millisecond", 0), t.addTag("casualReference/afternoon"), t;
+}
+function Rn(r) {
+  const e = new d(r, {});
+  return e.imply("meridiem", c.AM), e.assign("hour", 12), e.imply("minute", 0), e.imply("second", 0), e.imply("millisecond", 0), e.addTag("casualReference/noon"), e;
+}
+const An = /(now|today|tonight|tomorrow|overmorrow|tmr|tmrw|yesterday|last\s*night)(?=\W|$)/i;
+class xn extends g {
+  innerPattern(e) {
+    return An;
+  }
+  innerExtract(e, t) {
+    let n = e.refDate;
+    const s = t[0].toLowerCase();
+    let i = e.createParsingComponents();
+    switch (s) {
+      case "now":
+        i = ie(e.reference);
+        break;
+      case "today":
+        i = ae(e.reference);
+        break;
+      case "yesterday":
+        i = oe(e.reference);
+        break;
+      case "tomorrow":
+      case "tmr":
+      case "tmrw":
+        i = le(e.reference);
+        break;
+      case "tonight":
+        i = pn(e.reference);
+        break;
+      case "overmorrow":
+        i = ce(e.reference, 2);
+        break;
+      default:
+        if (s.match(/last\s*night/)) {
+          if (n.getHours() > 6) {
+            const a = new Date(n.getTime());
+            a.setDate(a.getDate() - 1), n = a;
+          }
+          P(i, n), i.imply("hour", 0);
+        }
+        break;
+    }
+    return i.addTag("parser/ENCasualDateParser"), i;
+  }
+}
+const Nn = /(?:this)?\s{0,3}(morning|afternoon|evening|night|midnight|midday|noon)(?=\W|$)/i;
+class On extends g {
+  innerPattern() {
+    return Nn;
+  }
+  innerExtract(e, t) {
+    let n = null;
+    switch (t[1].toLowerCase()) {
+      case "afternoon":
+        n = Dn(e.reference);
+        break;
+      case "evening":
+      case "night":
+        n = En(e.reference);
+        break;
+      case "midnight":
+        n = wn(e.reference);
+        break;
+      case "morning":
+        n = Pn(e.reference);
+        break;
+      case "noon":
+      case "midday":
+        n = Rn(e.reference);
+        break;
+    }
+    return n && n.addTag("parser/ENCasualTimeParser"), n;
+  }
+}
+const Mn = new RegExp(`(?:(?:\\,|\\(|\\（)\\s*)?(?:on\\s*?)?(?:(this|last|past|next)\\s*)?(${h(K)}|weekend|weekday)(?:\\s*(?:\\,|\\)|\\）))?(?:\\s*(?:of\\s*)?(this|last|past|next)\\s*week)?(?=\\W|$)`, "i"), $n = 1, Cn = 2, Sn = 3;
+class _n extends g {
+  innerPattern() {
+    return Mn;
+  }
+  innerExtract(e, t) {
+    const n = t[$n], s = t[Sn];
+    let i = n || s;
+    i = i || "", i = i.toLowerCase();
+    let a = null;
+    i == "last" || i == "past" ? a = "last" : i == "next" ? a = "next" : i == "this" && (a = "this");
+    const o = t[Cn].toLowerCase();
+    let l;
+    if (K[o] !== void 0)
+      l = K[o];
+    else if (o == "weekend")
+      l = a == "last" ? f.SUNDAY : f.SATURDAY;
+    else if (o == "weekday") {
+      const u = e.reference.getDateWithAdjustedTimezone().getDay();
+      u == f.SUNDAY || u == f.SATURDAY ? l = a == "last" ? f.FRIDAY : f.MONDAY : (l = u - 1, l = a == "last" ? l - 1 : l + 1, l = l % 5 + 1);
+    } else
+      return null;
+    return se(e.reference, l, a);
+  }
+}
+const Un = new RegExp(`(this|last|past|next|after\\s*this)\\s*(${h(G)})(?=\\s*)(?=\\W|$)`, "i"), In = 1, bn = 2;
+class Yn extends g {
+  innerPattern() {
+    return Un;
+  }
+  innerExtract(e, t) {
+    const n = t[In].toLowerCase(), s = t[bn].toLowerCase(), i = G[s];
+    if (n == "next" || n.startsWith("after")) {
+      const l = {};
+      return l[i] = 1, d.createRelativeFromReference(e.reference, l);
+    }
+    if (n == "last" || n == "past") {
+      const l = {};
+      return l[i] = -1, d.createRelativeFromReference(e.reference, l);
+    }
+    const a = e.createParsingComponents();
+    let o = new Date(e.reference.instant.getTime());
+    return s.match(/week/i) ? (o.setDate(o.getDate() - o.getDay()), a.imply("day", o.getDate()), a.imply("month", o.getMonth() + 1), a.imply("year", o.getFullYear())) : s.match(/month/i) ? (o.setDate(1), a.imply("day", o.getDate()), a.assign("year", o.getFullYear()), a.assign("month", o.getMonth() + 1)) : s.match(/year/i) && (o.setDate(1), o.setMonth(0), a.imply("day", o.getDate()), a.imply("month", o.getMonth() + 1), a.assign("year", o.getFullYear())), a;
+  }
+}
+const Fn = new RegExp("([^\\d]|^)([0-3]{0,1}[0-9]{1})[\\/\\.\\-]([0-3]{0,1}[0-9]{1})(?:[\\/\\.\\-]([0-9]{4}|[0-9]{2}))?(\\W|$)", "i"), Wn = 1, kn = 5, Ce = 2, Se = 3, V = 4;
+class ue {
+  groupNumberMonth;
+  groupNumberDay;
+  constructor(e) {
+    this.groupNumberMonth = e ? Se : Ce, this.groupNumberDay = e ? Ce : Se;
+  }
+  pattern() {
+    return Fn;
+  }
+  extract(e, t) {
+    const n = t.index + t[Wn].length, s = t.index + t[0].length - t[kn].length;
+    if (n > 0 && e.text.substring(0, n).match("\\d/?$") || s < e.text.length && e.text.substring(s).match("^/?\\d"))
+      return;
+    const i = e.text.substring(n, s);
+    if (i.match(/^\d\.\d$/) || i.match(/^\d\.\d{1,2}\.\d{1,2}\s*$/) || !t[V] && i.indexOf("/") < 0)
+      return;
+    const a = e.createParsingResult(n, i);
+    let o = parseInt(t[this.groupNumberMonth]), l = parseInt(t[this.groupNumberDay]);
+    if ((o < 1 || o > 12) && o > 12)
+      if (l >= 1 && l <= 12 && o <= 31)
+        [l, o] = [o, l];
+      else
+        return null;
+    if (l < 1 || l > 31)
+      return null;
+    if (a.start.assign("day", l), a.start.assign("month", o), t[V]) {
+      const u = parseInt(t[V]), m = Be(u);
+      a.start.assign("year", m);
+    } else {
+      const u = M(e.refDate, l, o);
+      a.start.imply("year", u);
+    }
+    return a.addTag("parser/SlashDateFormatParser");
+  }
+}
+const Gn = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${U})(?=\\W|$)`, "i"), vn = new RegExp(`(this|last|past|next|after|\\+|-)\\s*(${z})(?=\\W|$)`, "i");
+class zn extends g {
+  allowAbbreviations;
+  constructor(e = !0) {
+    super(), this.allowAbbreviations = e;
+  }
+  innerPattern() {
+    return this.allowAbbreviations ? Gn : vn;
+  }
+  innerExtract(e, t) {
+    const n = t[1].toLowerCase();
+    let s = $(t[2]);
+    if (!s)
+      return null;
+    switch (n) {
+      case "last":
+      case "past":
+      case "-":
+        s = k(s);
+        break;
+    }
+    return d.createRelativeFromReference(e.reference, s);
+  }
+}
+function Bn(r) {
+  return r.text.match(/^[+-]/i) != null;
+}
+function _e(r) {
+  return r.text.match(/^-/i) != null;
+}
+class Ln extends I {
+  shouldMergeResults(e, t, n) {
+    return e.match(/^\s*$/i) ? Bn(n) || _e(n) : !1;
+  }
+  mergeResults(e, t, n, s) {
+    let i = $(n.text);
+    _e(n) && (i = k(i));
+    const a = d.createRelativeFromReference(E.fromDate(t.start.date()), i);
+    return new D(t.reference, t.index, `${t.text}${e}${n.text}`, a);
+  }
+}
+function Ue(r) {
+  return r.text.match(/\s+(before|from)$/i) != null;
+}
+function Hn(r) {
+  return r.text.match(/\s+(after|since)$/i) != null;
+}
+class jn extends I {
+  patternBetween() {
+    return /^\s*$/i;
+  }
+  shouldMergeResults(e, t, n) {
+    return !e.match(this.patternBetween()) || !Ue(t) && !Hn(t) ? !1 : !!n.start.get("day") && !!n.start.get("month") && !!n.start.get("year");
+  }
+  mergeResults(e, t, n) {
+    let s = $(t.text);
+    Ue(t) && (s = k(s));
+    const i = d.createRelativeFromReference(E.fromDate(n.start.date()), s);
+    return new D(n.reference, t.index, `${t.text}${e}${n.text}`, i);
+  }
+}
+const Vn = new RegExp(`^\\s*(${v})`, "i"), Kn = 1;
+class Zn {
+  refine(e, t) {
+    return t.forEach(function(n) {
+      if (!n.start.isDateWithUnknownYear())
+        return;
+      const s = e.text.substring(n.index + n.text.length), i = Vn.exec(s);
+      if (!i || i[0].trim().length <= 3)
+        return;
+      e.debug(() => {
+        console.log(`Extracting year: '${i[0]}' into : ${n}`);
+      });
+      const a = _(i[Kn]);
+      n.end != null && n.end.assign("year", a), n.start.assign("year", a), n.text += i[0];
+    }), t;
+  }
+}
+class qn extends Ze {
+  constructor() {
+    super();
+  }
+  isValid(e, t) {
+    const n = t.text.trim();
+    return n === e.text.trim() ? !0 : n.toLowerCase() === "may" && !e.text.substring(0, t.index).trim().match(/\b(in)$/i) ? (e.debug(() => {
+      console.log(`Removing unlikely result: ${t}`);
+    }), !1) : n.toLowerCase().endsWith("the second") ? (e.text.substring(t.index + t.text.length).trim().length > 0 && e.debug(() => {
+      console.log(`Removing unlikely result: ${t}`);
+    }), !1) : !0;
+  }
+}
+class Je {
+  createCasualConfiguration(e = !1) {
+    const t = this.createConfiguration(!1, e);
+    return t.parsers.push(new xn()), t.parsers.push(new On()), t.parsers.push(new xt()), t.parsers.push(new Yn()), t.parsers.push(new zn()), t.refiners.push(new qn()), t;
+  }
+  createConfiguration(e = !0, t = !1) {
+    const n = re({
+      parsers: [
+        new ue(t),
+        new ht(e),
+        new pt(),
+        new Pt(t),
+        new _n(),
+        new kt(),
+        new zt(e),
+        new Ht(e),
+        new Zt(e),
+        new bt()
+      ],
+      refiners: [new Ae()]
+    }, e);
+    return n.parsers.unshift(new Ct(e)), n.refiners.unshift(new jn()), n.refiners.unshift(new Ln()), n.refiners.unshift(new J()), n.refiners.push(new Ae()), n.refiners.push(new Zn()), n.refiners.push(new qt()), n;
+  }
+}
+class y {
+  parsers;
+  refiners;
+  defaultConfig = new Je();
+  constructor(e) {
+    e = e || this.defaultConfig.createCasualConfiguration(), this.parsers = [...e.parsers], this.refiners = [...e.refiners];
+  }
+  clone() {
+    return new y({
+      parsers: [...this.parsers],
+      refiners: [...this.refiners]
+    });
+  }
+  parseDate(e, t, n) {
+    const s = this.parse(e, t, n);
+    return s.length > 0 ? s[0].start.date() : null;
+  }
+  parse(e, t, n) {
+    const s = new Jn(e, t, n);
+    let i = [];
+    return this.parsers.forEach((a) => {
+      const o = y.executeParser(s, a);
+      i = i.concat(o);
+    }), i.sort((a, o) => a.index - o.index), this.refiners.forEach(function(a) {
+      i = a.refine(s, i);
+    }), i;
+  }
+  static executeParser(e, t) {
+    const n = [], s = t.pattern(e), i = e.text;
+    let a = e.text, o = s.exec(a);
+    for (; o; ) {
+      const l = o.index + i.length - a.length;
+      o.index = l;
+      const u = t.extract(e, o);
+      if (!u) {
+        a = i.substring(o.index + 1), o = s.exec(a);
+        continue;
+      }
+      let m = null;
+      u instanceof D ? m = u : u instanceof d ? (m = e.createParsingResult(o.index, o[0]), m.start = u) : m = e.createParsingResult(o.index, o[0], u);
+      const C = m.index, ge = m.text;
+      e.debug(() => console.log(`${t.constructor.name} extracted (at index=${C}) '${ge}'`)), n.push(m), a = i.substring(C + ge.length), o = s.exec(a);
+    }
+    return n;
+  }
+}
+class Jn {
+  text;
+  option;
+  reference;
+  refDate;
+  constructor(e, t, n) {
+    this.text = e, this.option = n ?? {}, this.reference = E.fromInput(t, this.option.timezones), this.refDate = this.reference.instant;
+  }
+  createParsingComponents(e) {
+    return e instanceof d ? e : new d(this.reference, e);
+  }
+  createParsingResult(e, t, n, s) {
+    const i = typeof t == "string" ? t : this.text.substring(e, t), a = n ? this.createParsingComponents(n) : null, o = s ? this.createParsingComponents(s) : null;
+    return new D(this.reference, e, i, a, o);
+  }
+  debug(e) {
+    this.option.debug && (this.option.debug instanceof Function ? this.option.debug(e) : this.option.debug.debug(e));
+  }
+}
+const B = new Je(), Xn = new y(B.createCasualConfiguration(!1));
+new y(B.createConfiguration(!0, !1));
+new y(B.createCasualConfiguration(!0));
+const Fs = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Chrono: y,
+  get Meridiem() {
+    return c;
+  },
+  ParsingComponents: d,
+  ParsingResult: D,
+  ReferenceWithTimezone: E,
+  get Weekday() {
+    return f;
+  },
+  casual: Xn,
+  configuration: B
+}, Symbol.toStringTag, { value: "Module" })), Xe = {
+  domingo: 0,
+  dom: 0,
+  segunda: 1,
+  "segunda-feira": 1,
+  seg: 1,
+  terça: 2,
+  "terça-feira": 2,
+  ter: 2,
+  quarta: 3,
+  "quarta-feira": 3,
+  qua: 3,
+  quinta: 4,
+  "quinta-feira": 4,
+  qui: 4,
+  sexta: 5,
+  "sexta-feira": 5,
+  sex: 5,
+  sábado: 6,
+  sabado: 6,
+  sab: 6
+}, Qe = {
+  janeiro: 1,
+  jan: 1,
+  "jan.": 1,
+  fevereiro: 2,
+  fev: 2,
+  "fev.": 2,
+  março: 3,
+  mar: 3,
+  "mar.": 3,
+  abril: 4,
+  abr: 4,
+  "abr.": 4,
+  maio: 5,
+  mai: 5,
+  "mai.": 5,
+  junho: 6,
+  jun: 6,
+  "jun.": 6,
+  julho: 7,
+  jul: 7,
+  "jul.": 7,
+  agosto: 8,
+  ago: 8,
+  "ago.": 8,
+  setembro: 9,
+  set: 9,
+  "set.": 9,
+  outubro: 10,
+  out: 10,
+  "out.": 10,
+  novembro: 11,
+  nov: 11,
+  "nov.": 11,
+  dezembro: 12,
+  dez: 12,
+  "dez.": 12
+}, Qn = "[0-9]{1,4}(?![^\\s]\\d)(?:\\s*[a|d]\\.?\\s*c\\.?|\\s*a\\.?\\s*d\\.?)?";
+function es(r) {
+  if (r.match(/^[0-9]{1,4}$/)) {
+    let e = parseInt(r);
+    return e < 100 && (e > 50 ? e = e + 1900 : e = e + 2e3), e;
+  }
+  return r.match(/a\.?\s*c\.?/i) ? (r = r.replace(/a\.?\s*c\.?/i, ""), -parseInt(r)) : parseInt(r);
+}
+const ts = new RegExp(`(?:(?:\\,|\\(|\\（)\\s*)?(?:(este|esta|passado|pr[oó]ximo)\\s*)?(${h(Xe)})(?:\\s*(?:\\,|\\)|\\）))?(?:\\s*(este|esta|passado|pr[óo]ximo)\\s*semana)?(?=\\W|\\d|$)`, "i"), ns = 1, ss = 2, rs = 3;
+class is extends g {
+  innerPattern() {
+    return ts;
+  }
+  innerExtract(e, t) {
+    const n = t[ss].toLowerCase(), s = Xe[n];
+    if (s === void 0)
+      return null;
+    const i = t[ns], a = t[rs];
+    let o = i || a || "";
+    o = o.toLowerCase();
+    let l = null;
+    return o == "passado" ? l = "this" : o == "próximo" || o == "proximo" ? l = "next" : o == "este" && (l = "this"), se(e.reference, s, l);
+  }
+}
+class as extends ee {
+  primaryPrefix() {
+    return "(?:(?:ao?|às?|das|da|de|do)\\s*)?";
+  }
+  followingPhase() {
+    return "\\s*(?:\\-|\\–|\\~|\\〜|a(?:o)?|\\?)\\s*";
+  }
+}
+class os extends ne {
+  patternBetween() {
+    return new RegExp("^\\s*(?:,|à)?\\s*$");
+  }
+}
+class ls extends te {
+  patternBetween() {
+    return /^\s*(?:-)\s*$/i;
+  }
+}
+const cs = new RegExp(`([0-9]{1,2})(?:º|ª|°)?(?:\\s*(?:desde|de|\\-|\\–|ao?|\\s)\\s*([0-9]{1,2})(?:º|ª|°)?)?\\s*(?:de)?\\s*(?:-|/|\\s*(?:de|,)?\\s*)(${h(Qe)})(?:\\s*(?:de|,)?\\s*(${Qn}))?(?=\\W|$)`, "i"), Ie = 1, be = 2, us = 3, Ye = 4;
+class ds extends g {
+  innerPattern() {
+    return cs;
+  }
+  innerExtract(e, t) {
+    const n = e.createParsingResult(t.index, t[0]), s = Qe[t[us].toLowerCase()], i = parseInt(t[Ie]);
+    if (i > 31)
+      return t.index = t.index + t[Ie].length, null;
+    if (n.start.assign("month", s), n.start.assign("day", i), t[Ye]) {
+      const a = es(t[Ye]);
+      n.start.assign("year", a);
+    } else {
+      const a = M(e.refDate, i, s);
+      n.start.imply("year", a);
+    }
+    if (t[be]) {
+      const a = parseInt(t[be]);
+      n.end = n.start.clone(), n.end.assign("day", a);
+    }
+    return n;
+  }
+}
+class fs extends g {
+  innerPattern(e) {
+    return /(agora|hoje|amanha|amanhã|ontem)(?=\W|$)/i;
+  }
+  innerExtract(e, t) {
+    const n = t[0].toLowerCase(), s = e.createParsingComponents();
+    switch (n) {
+      case "agora":
+        return ie(e.reference);
+      case "hoje":
+        return ae(e.reference);
+      case "amanha":
+      case "amanhã":
+        return le(e.reference);
+      case "ontem":
+        return oe(e.reference);
+    }
+    return s;
+  }
+}
+class gs extends g {
+  innerPattern() {
+    return /(?:esta\s*)?(manha|manhã|tarde|meia-noite|meio-dia|noite)(?=\W|$)/i;
+  }
+  innerExtract(e, t) {
+    const n = e.refDate, s = e.createParsingComponents();
+    switch (t[1].toLowerCase()) {
+      case "tarde":
+        s.imply("meridiem", c.PM), s.imply("hour", 15), s.addTag("casualReference/afternoon");
+        break;
+      case "noite":
+        s.imply("meridiem", c.PM), s.imply("hour", 22), s.addTag("casualReference/evening");
+        break;
+      case "manha":
+      case "manhã":
+        s.imply("meridiem", c.AM), s.imply("hour", 6), s.addTag("casualReference/morning");
+        break;
+      case "meia-noite":
+        const i = new Date(n.getTime());
+        i.setDate(i.getDate() + 1), P(s, i), S(s, i), s.imply("hour", 0), s.imply("minute", 0), s.imply("second", 0), s.addTag("casualReference/midnight");
+        break;
+      case "meio-dia":
+        s.imply("meridiem", c.AM), s.imply("hour", 12), s.addTag("casualReference/noon");
+        break;
+    }
+    return s;
+  }
+}
+const ms = new y(et());
+new y(de(!0));
+function et(r = !0) {
+  const e = de(!1, r);
+  return e.parsers.push(new fs()), e.parsers.push(new gs()), e;
+}
+function de(r = !0, e = !0) {
+  return re({
+    parsers: [
+      new ue(e),
+      new is(),
+      new as(),
+      new ds()
+    ],
+    refiners: [new os(), new ls()]
+  }, r);
+}
+const Ws = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Chrono: y,
+  get Meridiem() {
+    return c;
+  },
+  ParsingComponents: d,
+  ParsingResult: D,
+  ReferenceWithTimezone: E,
+  get Weekday() {
+    return f;
+  },
+  casual: ms,
+  createCasualConfiguration: et,
+  createConfiguration: de
+}, Symbol.toStringTag, { value: "Module" })), tt = {
+  domingo: 0,
+  dom: 0,
+  lunes: 1,
+  lun: 1,
+  martes: 2,
+  mar: 2,
+  miércoles: 3,
+  miercoles: 3,
+  mié: 3,
+  mie: 3,
+  jueves: 4,
+  jue: 4,
+  viernes: 5,
+  vie: 5,
+  sábado: 6,
+  sabado: 6,
+  sáb: 6,
+  sab: 6
+}, nt = {
+  enero: 1,
+  ene: 1,
+  "ene.": 1,
+  febrero: 2,
+  feb: 2,
+  "feb.": 2,
+  marzo: 3,
+  mar: 3,
+  "mar.": 3,
+  abril: 4,
+  abr: 4,
+  "abr.": 4,
+  mayo: 5,
+  may: 5,
+  "may.": 5,
+  junio: 6,
+  jun: 6,
+  "jun.": 6,
+  julio: 7,
+  jul: 7,
+  "jul.": 7,
+  agosto: 8,
+  ago: 8,
+  "ago.": 8,
+  septiembre: 9,
+  setiembre: 9,
+  sep: 9,
+  "sep.": 9,
+  octubre: 10,
+  oct: 10,
+  "oct.": 10,
+  noviembre: 11,
+  nov: 11,
+  "nov.": 11,
+  diciembre: 12,
+  dic: 12,
+  "dic.": 12
+}, X = {
+  uno: 1,
+  dos: 2,
+  tres: 3,
+  cuatro: 4,
+  cinco: 5,
+  seis: 6,
+  siete: 7,
+  ocho: 8,
+  nueve: 9,
+  diez: 10,
+  once: 11,
+  doce: 12,
+  trece: 13
+}, st = {
+  sec: "second",
+  segundo: "second",
+  segundos: "second",
+  min: "minute",
+  mins: "minute",
+  minuto: "minute",
+  minutos: "minute",
+  h: "hour",
+  hr: "hour",
+  hrs: "hour",
+  hora: "hour",
+  horas: "hour",
+  día: "day",
+  días: "day",
+  semana: "week",
+  semanas: "week",
+  mes: "month",
+  meses: "month",
+  cuarto: "quarter",
+  cuartos: "quarter",
+  año: "year",
+  años: "year"
+}, hs = `(?:${h(X)}|[0-9]+|[0-9]+\\.[0-9]+|un?|uno?|una?|algunos?|unos?|demi-?)`;
+function Ts(r) {
+  const e = r.toLowerCase();
+  return X[e] !== void 0 ? X[e] : e === "un" || e === "una" || e === "uno" ? 1 : e.match(/algunos?/) || e.match(/unos?/) ? 3 : e.match(/media?/) ? 0.5 : parseFloat(e);
+}
+const ys = "[0-9]{1,4}(?![^\\s]\\d)(?:\\s*[a|d]\\.?\\s*c\\.?|\\s*a\\.?\\s*d\\.?)?";
+function ps(r) {
+  if (r.match(/^[0-9]{1,4}$/)) {
+    let e = parseInt(r);
+    return e < 100 && (e > 50 ? e = e + 1900 : e = e + 2e3), e;
+  }
+  return r.match(/a\.?\s*c\.?/i) ? (r = r.replace(/a\.?\s*c\.?/i, ""), -parseInt(r)) : parseInt(r);
+}
+const rt = `(${hs})\\s{0,5}(${h(st)})\\s{0,5}`, Fe = new RegExp(rt, "i"), Es = Q("", rt);
+function ws(r) {
+  const e = {};
+  let t = r, n = Fe.exec(t);
+  for (; n; )
+    Ps(e, n), t = t.substring(n[0].length), n = Fe.exec(t);
+  return e;
+}
+function Ps(r, e) {
+  const t = Ts(e[1]), n = st[e[2].toLowerCase()];
+  r[n] = t;
+}
+const Ds = new RegExp(`(?:(?:\\,|\\(|\\（)\\s*)?(?:(este|esta|pasado|pr[oó]ximo)\\s*)?(${h(tt)})(?:\\s*(?:\\,|\\)|\\）))?(?:\\s*(este|esta|pasado|pr[óo]ximo)\\s*semana)?(?=\\W|\\d|$)`, "i"), Rs = 1, As = 2, xs = 3;
+class Ns extends g {
+  innerPattern() {
+    return Ds;
+  }
+  innerExtract(e, t) {
+    const n = t[As].toLowerCase(), s = tt[n];
+    if (s === void 0)
+      return null;
+    const i = t[Rs], a = t[xs];
+    let o = i || a || "";
+    o = o.toLowerCase();
+    let l = null;
+    return o == "pasado" ? l = "this" : o == "próximo" || o == "proximo" ? l = "next" : o == "este" && (l = "this"), se(e.reference, s, l);
+  }
+}
+class Os extends ee {
+  primaryPrefix() {
+    return "(?:(?:aslas|deslas|las?|al?|de|del)\\s*)?";
+  }
+  followingPhase() {
+    return "\\s*(?:\\-|\\–|\\~|\\〜|a(?:l)?|\\?)\\s*";
+  }
+}
+class Ms extends ne {
+  patternBetween() {
+    return new RegExp("^\\s*(?:,|de|aslas|a)?\\s*$");
+  }
+}
+class $s extends te {
+  patternBetween() {
+    return /^\s*(?:-)\s*$/i;
+  }
+}
+const Cs = new RegExp(`([0-9]{1,2})(?:º|ª|°)?(?:\\s*(?:desde|de|\\-|\\–|ao?|\\s)\\s*([0-9]{1,2})(?:º|ª|°)?)?\\s*(?:de)?\\s*(?:-|/|\\s*(?:de|,)?\\s*)(${h(nt)})(?:\\s*(?:de|,)?\\s*(${ys}))?(?=\\W|$)`, "i"), We = 1, ke = 2, Ss = 3, Ge = 4;
+class _s extends g {
+  innerPattern() {
+    return Cs;
+  }
+  innerExtract(e, t) {
+    const n = e.createParsingResult(t.index, t[0]), s = nt[t[Ss].toLowerCase()], i = parseInt(t[We]);
+    if (i > 31)
+      return t.index = t.index + t[We].length, null;
+    if (n.start.assign("month", s), n.start.assign("day", i), t[Ge]) {
+      const a = ps(t[Ge]);
+      n.start.assign("year", a);
+    } else {
+      const a = M(e.refDate, i, s);
+      n.start.imply("year", a);
+    }
+    if (t[ke]) {
+      const a = parseInt(t[ke]);
+      n.end = n.start.clone(), n.end.assign("day", a);
+    }
+    return n;
+  }
+}
+class Us extends g {
+  innerPattern(e) {
+    return /(ahora|hoy|mañana|ayer)(?=\W|$)/i;
+  }
+  innerExtract(e, t) {
+    const n = t[0].toLowerCase(), s = e.createParsingComponents();
+    switch (n) {
+      case "ahora":
+        return ie(e.reference);
+      case "hoy":
+        return ae(e.reference);
+      case "mañana":
+        return le(e.reference);
+      case "ayer":
+        return oe(e.reference);
+    }
+    return s;
+  }
+}
+class Is extends g {
+  innerPattern() {
+    return /(?:esta\s*)?(mañana|tarde|medianoche|mediodia|mediodía|noche)(?=\W|$)/i;
+  }
+  innerExtract(e, t) {
+    const n = e.refDate, s = e.createParsingComponents();
+    switch (t[1].toLowerCase()) {
+      case "tarde":
+        s.imply("meridiem", c.PM), s.imply("hour", 15), s.addTag("casualReference/afternoon");
+        break;
+      case "noche":
+        s.imply("meridiem", c.PM), s.imply("hour", 22), s.addTag("casualReference/evening");
+        break;
+      case "mañana":
+        s.imply("meridiem", c.AM), s.imply("hour", 6), s.addTag("casualReference/morning");
+        break;
+      case "medianoche":
+        const i = new Date(n.getTime());
+        i.setDate(i.getDate() + 1), P(s, i), S(s, i), s.imply("hour", 0), s.imply("minute", 0), s.imply("second", 0), s.addTag("casualReference/midnight");
+        break;
+      case "mediodia":
+      case "mediodía":
+        s.imply("meridiem", c.AM), s.imply("hour", 12), s.addTag("casualReference/noon");
+        break;
+    }
+    return s;
+  }
+}
+class bs extends g {
+  innerPattern() {
+    return new RegExp(`(?:en|por|durante|de|dentro de)\\s*(${Es})(?=\\W|$)`, "i");
+  }
+  innerExtract(e, t) {
+    const n = ws(t[1]);
+    return d.createRelativeFromReference(e.reference, n);
+  }
+}
+const Ys = new y(it());
+new y(fe(!0));
+function it(r = !0) {
+  const e = fe(!1, r);
+  return e.parsers.push(new Us()), e.parsers.push(new Is()), e;
+}
+function fe(r = !0, e = !0) {
+  return re({
+    parsers: [
+      new ue(e),
+      new Ns(),
+      new Os(),
+      new _s(),
+      new bs()
+    ],
+    refiners: [new Ms(), new $s()]
+  }, r);
+}
+const ks = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Chrono: y,
+  get Meridiem() {
+    return c;
+  },
+  ParsingComponents: d,
+  ParsingResult: D,
+  ReferenceWithTimezone: E,
+  get Weekday() {
+    return f;
+  },
+  casual: Ys,
+  createCasualConfiguration: it,
+  createConfiguration: fe
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  y as Chrono,
+  c as Meridiem,
+  d as ParsingComponents,
+  Jn as ParsingContext,
+  D as ParsingResult,
+  E as ReferenceWithTimezone,
+  f as Weekday,
+  Fs as en,
+  ks as es,
+  Ws as pt
+};
+//# sourceMappingURL=index-Dips44uG.js.map